//**************************************************************************
//
//
//                       National Institute Of Standards and Technology
//                                    DTS Version 1.0
//         
//                                 HTMLElement Interface
//**************************************************************************

function HTMLElement()
{
   var tests = new Array (HTML0001HE(),HTML0002HE(),HTML0003HE(),HTML0004HE(),HTML0005HE(),HTML0006HE(),HTML0007HE(),HTML0008HE(),HTML0009HE(),HTML0010HE(),HTML0011HE(),HTML0012HE(),HTML0013HE(),HTML0014HE(),HTML0015HE(),HTML0016HE(),HTML0017HE(),HTML0018HE(),HTML0019HE(),HTML0020HE(),HTML0021HE(),HTML0022HE(),HTML0023HE(),HTML0024HE(),HTML0025HE(),HTML0026HE(),HTML0027HE(),HTML0028HE(),HTML0029HE(),HTML0030HE(),HTML0031HE(),HTML0032HE(),HTML0033HE(),HTML0034HE(),HTML0035HE(),HTML0036HE(),HTML0037HE(),HTML0038HE(),HTML0039HE(),HTML0040HE(),HTML0041HE(),HTML0042HE(),HTML0043HE(),HTML0044HE(),HTML0045HE(),HTML0046HE(),HTML0047HE(),HTML0048HE(),HTML0049HE(),HTML0050HE(),HTML0051HE(),HTML0052HE(),HTML0053HE(),HTML0054HE(),HTML0055HE(),HTML0056HE(),HTML0057HE(),HTML0058HE(),HTML0059HE(),HTML0060HE(),HTML0061HE(),HTML0062HE(),HTML0063HE(),HTML0064HE(),HTML0065HE(),HTML0066HE(),HTML0067HE(),HTML0068HE(),HTML0069HE(),HTML0070HE(),HTML0071HE(),HTML0072HE(),HTML0073HE(),HTML0074HE(),HTML0075HE(),HTML0076HE(),HTML0077HE(),HTML0078HE(),HTML0079HE(),HTML0080HE(),HTML0081HE(),HTML0082HE(),HTML0083HE(),HTML0084HE(),HTML0085HE(),HTML0086HE(),HTML0087HE(),HTML0088HE(),HTML0089HE(),HTML0090HE(),HTML0091HE(),HTML0092HE(),HTML0093HE(),HTML0094HE(),HTML0095HE(),HTML0096HE(),HTML0097HE(),HTML0098HE(),HTML0099HE(),HTML0100HE(),HTML0101HE(),HTML0102HE(),HTML0103HE(),HTML0104HE(),HTML0105HE(),HTML0106HE(),HTML0107HE(),HTML0108HE(),HTML0109HE(),HTML0110HE(),HTML0111HE(),HTML0112HE(),HTML0113HE(),HTML0114HE(),HTML0115HE(),HTML0116HE(),HTML0117HE(),HTML0118HE(),HTML0119HE(),HTML0120HE(),HTML0121HE(),HTML0122HE(),HTML0123HE(),HTML0124HE(),HTML0125HE(),HTML0126HE(),HTML0127HE(),HTML0128HE(),HTML0129HE(),HTML0130HE(),HTML0131HE(),HTML0132HE(),HTML0133HE(),HTML0134HE(),HTML0135HE(),HTML0136HE(),HTML0137HE(),HTML0138HE(),HTML0139HE(),HTML0140HE(),HTML0141HE(),HTML0142HE(),HTML0143HE(),HTML0144HE(),HTML0145HE());
     return tests;
}

//------------------------ test case HTML-0001HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier. 
//
// Testing approach - Retrieve the "id" attribute from the HEAD element 
//                    of the testing document and examine its value.  It
//                    should be equal to "test-head".
//
// Semantic Requirements: 1
//
// Last modification date - Novebmer 01, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0001HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-HEAD";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0001HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for HEAD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(HEAD);
//
// and access its "id" attribute.
//
      testNode.node.id="TEST-HEAD";
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results 
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0001HE -------------------------
//
//------------------------ test case HTML-0002HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the SUB element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-sub".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0002HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-SUB";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0002HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for SUB element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SUB);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0002HE -------------------------
//
//------------------------ test case HTML-0003HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the SUP element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-sup".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0003HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-SUP";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0003HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for SUP element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SUP);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0003HE -------------------------
//
//------------------------ test case HTML-0004HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the SPAN element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-span".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0004HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-SPAN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0004HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for SPAN element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SPAN);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0004HE -------------------------
//
//------------------------ test case HTML-0005HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the BDO element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-bdo".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0005HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-BDO";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0005HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for BDO element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(BDO);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0005HE -------------------------
//
//------------------------ test case HTML-0006HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the TT element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-TT".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0006HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-TT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0006HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for TT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(TT);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0006HE -------------------------
//
//------------------------ test case HTML-0007HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the I element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-i".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0007HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-I";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0007HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for I element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(I);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0007HE -------------------------
//
//------------------------ test case HTML-0008HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the B element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-b".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0008HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-B";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0008HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for B element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(B);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0008HE -------------------------
//
//------------------------ test case HTML-0009HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the U element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-u".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0009HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-U";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0009HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for U element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(U);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0009HE -------------------------
//
//------------------------ test case HTML-0010HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the S element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-s".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0010HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-S";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0010HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for S element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(S);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0010HE -------------------------
//
//------------------------ test case HTML-0011HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the STRIKE element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-strike".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0011HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-STRIKE";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0011HE");
    results.description = "The \"id\" attribute specifies the "+
                         "element's identifier. (Test for STRIKE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(STRIKE);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0011HE -------------------------
//
//------------------------ test case HTML-0012HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the BIG element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-big".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0012HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-BIG";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0012HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for BIG element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(BIG);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0012HE -------------------------
//
//------------------------ test case HTML-0013HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the SMALL element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-small".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0013HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-SMALL";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0013HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for SMALL element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SMALL);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0013HE -------------------------
//
//------------------------ test case HTML-0014HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the EM element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-em".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0014HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-EM";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0014HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for EM element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(EM);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0014HE -------------------------
//
//------------------------ test case HTML-0015HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the STRONG element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-strong".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0015HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-STRONG";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0015HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for STRONG element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(STRONG);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0015HE -------------------------
//
//------------------------ test case HTML-0016HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the DFN element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-dfn".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0016HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-DFN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0016HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for DFN element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DFN);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0016HE -------------------------
//
//------------------------ test case HTML-0017HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the CODE element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-code".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0017HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-CODE";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0017HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for CODE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CODE);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0017HE -------------------------
//
//------------------------ test case HTML-0018HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the SAMP element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-samp".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0018HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-SAMP";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0018HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for SAMP element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SAMP);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0018HE -------------------------
//
//------------------------ test case HTML-0019HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the KBD element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-kbd".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0019HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-KBD";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0019HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for KBD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(KBD);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0019HE -------------------------
//
//------------------------ test case HTML-0020HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the VAR element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-var".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0020HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-VAR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0020HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for VAR element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(VAR);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0020HE -------------------------
//
//------------------------ test case HTML-0021HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the CITE element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-cite".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0021HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-CITE";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0021HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for CITE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CITE);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0021HE -------------------------
//
//------------------------ test case HTML-0022HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the ACRONYM element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-acronym".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0022HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-ACRONYM";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0022HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for ACRONYM element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ACRONYM);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0022HE -------------------------
//
//------------------------ test case HTML-0023HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the ABBR element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-abbr".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0023HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-ABBR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0023HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for ABBR element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ABBR);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0023HE -------------------------
//
//------------------------ test case HTML-0024HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the DD element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-dd".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0024HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-DD";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0024HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for DD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DD);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0024HE -------------------------
//
//------------------------ test case HTML-0025HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the DT element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-dt".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0025HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-DT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0025HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for DT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DT);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0025HE -------------------------
//
//------------------------ test case HTML-0026HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the NOFRAMES element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-noframes".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0026HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-NOFRAMES";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0026HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for NOFRAMES element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(NOFRAMES);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0026HE -------------------------
//
//------------------------ test case HTML-0027HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the NOSCRIPT element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-noscript".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0027HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-NOSCRIPT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0027HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for NOSCRIPT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(NOSCRIPT);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0027HE -------------------------
//
//------------------------ test case HTML-0028HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the ADDRESS element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-address".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0028HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-ADDRESS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0028HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for ADDRESS element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ADDRESS);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0028HE -------------------------
//
//------------------------ test case HTML-0029HE -----------------------------
//
// Testing feature - The "id" attribute specifies the element's
//                   identifier.
//
// Testing approach - Retrieve the "id" attribute from the CENTER element
//                    of the testing document and examine its value.  It
//                    should be equal to "test-center".
//
// Semantic Requirements: 1
//
// Last modification date - October 14,1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0029HE()
 {
   var computedValue = "";
   var expectedValue = "TEST-CENTER";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0029HE");
    results.description = "The \"id\" attribute specifies the "+
                          "element's identifier. (Test for CENTER element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CENTER);
//
// and access its "id" attribute.
//
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0029HE -------------------------
//
//------------------------   test case HTML-0030HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the HEAD element
//                    of the testing document and examine its value.  It
//                    should be equal to "Head Element".
//
// Semantic Requirements: 2 
//
// Last modification date - November 01, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0030HE()
 {
   var computedValue = "";
   var expectedValue = "HEAD ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0030HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for HEAD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(HEAD);
//
// and access its "title" attribute.
//
      testNode.node.title="HEAD ELEMENT";
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0030HE -------------------------
//
//------------------------   test case HTML-0031HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the SUB element
//                    of the testing document and examine its value.  It
//                    should be equal to "SUB Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0031HE()
 {
   var computedValue = "";
   var expectedValue = "SUB ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0031HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for SUB element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SUB);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0031HE -------------------------
//
//------------------------   test case HTML-0032HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the SUP element
//                    of the testing document and examine its value.  It
//                    should be equal to "SUP Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0032HE()
 {
   var computedValue = "";
   var expectedValue = "SUP ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0032HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for SUP element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SUP);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0032HE -------------------------
//
//------------------------   test case HTML-0033HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the SPAN element
//                    of the testing document and examine its value.  It
//                    should be equal to "span Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0033HE()
 {
   var computedValue = "";
   var expectedValue = "SPAN ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0033HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for SPAN element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SPAN);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0033HE -------------------------
//
//------------------------   test case HTML-0034HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the BDO element
//                    of the testing document and examine its value.  It
//                    should be equal to "bdo Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0034HE()
 {
   var computedValue = "";
   var expectedValue = "BDO ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0034HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for BDO element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(BDO);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0034HE -------------------------
//
//------------------------   test case HTML-0035HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the TT element
//                    of the testing document and examine its value.  It
//                    should be equal to "tt Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0035HE()
 {
   var computedValue = "";
   var expectedValue = "TT ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0035HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for TT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(TT);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0035HE -------------------------
//
//------------------------   test case HTML-0036HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the I element
//                    of the testing document and examine its value.  It
//                    should be equal to "i Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0036HE()
 {
   var computedValue = "";
   var expectedValue = "I ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0036HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for I element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(I);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0036HE -------------------------
//
//------------------------   test case HTML-0037HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the B element
//                    of the testing document and examine its value.  It
//                    should be equal to "B Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0037HE()
 {
   var computedValue = "";
   var expectedValue = "B ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0037HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for B element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(B);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0037HE -------------------------
//
//------------------------   test case HTML-0038HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the U element
//                    of the testing document and examine its value.  It
//                    should be equal to "U Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0038HE()
 {
   var computedValue = "";
   var expectedValue = "U ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0038HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for U element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(U);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0038HE -------------------------
//
//------------------------   test case HTML-0039HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the S element
//                    of the testing document and examine its value.  It
//                    should be equal to "S Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0039HE()
 {
   var computedValue = "";
   var expectedValue = "S ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0039HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for S element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(S);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0039HE -------------------------
//
//------------------------   test case HTML-0040HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the STRIKE element
//                    of the testing document and examine its value.  It
//                    should be equal to "Strike Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0040HE()
 {
   var computedValue = "";
   var expectedValue = "STRIKE ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0040HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for STRIKE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(STRIKE);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0040HE -------------------------
//
//------------------------   test case HTML-0041HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the BIG element
//                    of the testing document and examine its value.  It
//                    should be equal to "Big Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0041HE()
 {
   var computedValue = "";
   var expectedValue = "BIG ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0041HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for BIG element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(BIG);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0041HE -------------------------
//
//------------------------   test case HTML-0042HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the SMALL element
//                    of the testing document and examine its value.  It
//                    should be equal to "Small Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0042HE()
 {
   var computedValue = "";
   var expectedValue = "SMALL ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0042HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for SMALL element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SMALL);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0042HE -------------------------
//
//------------------------   test case HTML-0043HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the EM element
//                    of the testing document and examine its value.  It
//                    should be equal to "EM Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0043HE()
 {
   var computedValue = "";
   var expectedValue = "EM ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0043HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for EM element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(EM);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0043HE -------------------------
//
//------------------------   test case HTML-0044HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the STRONG element
//                    of the testing document and examine its value.  It
//                    should be equal to "Strong Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0044HE()
 {
   var computedValue = "";
   var expectedValue = "STRONG ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0044HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for STRONG element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(STRONG);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0044HE -------------------------
//
//------------------------   test case HTML-0045HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the DFN element
//                    of the testing document and examine its value.  It
//                    should be equal to "DFN Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0045HE()
 {
   var computedValue = "";
   var expectedValue = "DFN ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0045HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for DFN element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DFN);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0045HE -------------------------
//
//------------------------   test case HTML-0046HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the CODE element
//                    of the testing document and examine its value.  It
//                    should be equal to "CODE Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0046HE()
 {
   var computedValue = "";
   var expectedValue = "CODE ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0046HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for CODE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CODE);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0046HE -------------------------
//
//------------------------   test case HTML-0047HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the SAMP element
//                    of the testing document and examine its value.  It
//                    should be equal to "SAMP Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0047HE()
 {
   var computedValue = "";
   var expectedValue = "SAMP ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0047HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for SAMP element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SAMP);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0047HE -------------------------
//
//------------------------   test case HTML-0048HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the KBD element
//                    of the testing document and examine its value.  It
//                    should be equal to "KBD Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0048HE()
 {
   var computedValue = "";
   var expectedValue = "KBD ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0048HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for KBD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(KBD);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0048HE -------------------------
//
//------------------------   test case HTML-0049HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the VAR element
//                    of the testing document and examine its value.  It
//                    should be equal to "VAR Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0049HE()
 {
   var computedValue = "";
   var expectedValue = "VAR ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0049HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for VAR element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(VAR);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0049HE -------------------------
//
//------------------------   test case HTML-0050HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the CITE element
//                    of the testing document and examine its value.  It
//                    should be equal to "CITE Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0050HE()
 {
   var computedValue = "";
   var expectedValue = "CITE ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0050HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for CITE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CITE);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0050HE -------------------------
//
//------------------------   test case HTML-0051HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the ACRONYM element
//                    of the testing document and examine its value.  It
//                    should be equal to "Acronym Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0051HE()
 {
   var computedValue = "";
   var expectedValue = "ACRONYM ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0051HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for ACRONYM element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ACRONYM);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0051HE -------------------------
//
//------------------------   test case HTML-0052HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the ABBR element
//                    of the testing document and examine its value.  It
//                    should be equal to "ABBR Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0052HE()
 {
   var computedValue = "";
   var expectedValue = "ABBR ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0052HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for ABBR element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ABBR);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0052HE -------------------------
//
//------------------------   test case HTML-0053HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the DD element
//                    of the testing document and examine its value.  It
//                    should be equal to "DD Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0053HE()
 {
   var computedValue = "";
   var expectedValue = "DD ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0053HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for DD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DD);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0053HE -------------------------
//
//------------------------   test case HTML-0054HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the DT element
//                    of the testing document and examine its value.  It
//                    should be equal to "DT Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0054HE()
 {
   var computedValue = "";
   var expectedValue = "DT ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0054HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for DT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DT);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0054HE -------------------------
//
//------------------------   test case HTML-0055HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the NOFRAMES element
//                    of the testing document and examine its value.  It
//                    should be equal to "NOFRAMES Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0055HE()
 {
   var computedValue = "";
   var expectedValue = "NOFRAMES ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0055HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for NOFRAMES element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(NOFRAMES);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0055HE -------------------------
//
//------------------------   test case HTML-0056HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the NOSCRIPT element
//                    of the testing document and examine its value.  It
//                    should be equal to "Noscript Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0056HE()
 {
   var computedValue = "";
   var expectedValue = "NOSCRIPT ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0056HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for NOSCRIPT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(NOSCRIPT);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0056HE -------------------------
//
//------------------------   test case HTML-0057HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the ADDRESS element
//                    of the testing document and examine its value.  It
//                    should be equal to "Address Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0057HE()
 {
   var computedValue = "";
   var expectedValue = "ADDRESS ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0057HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for ADDRESS element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ADDRESS);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0047HE -------------------------
//
//------------------------   test case HTML-0058HE   -------------------------
//
// Testing feature - The "title" attribute specifies the element's
//                   advisory title.
//
// Testing approach - Retrieve the "title" attribute from the CENTER element
//                    of the testing document and examine its value.  It
//                    should be equal to "Center Element".
//
// Semantic Requirements: 2
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0058HE()
 {
   var computedValue = "";
   var expectedValue = "CENTER ELEMENT";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0058HE");
    results.description = "The \"title\" attribute specifies the "+
                          "element's advisory title. (Test for CENTER element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CENTER);
//
// and access its "title" attribute.
//
      computedValue = testNode.node.title;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0058HE -------------------------
//
//------------------------   test case HTML-0059HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined 
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the HEAD element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3 
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0059HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0059HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for HEAD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(HEAD);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0059HE -------------------------
//
//------------------------   test case HTML-0060HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the SUB element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0060HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0060HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for SUB element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SUB);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0060HE -------------------------
//
//------------------------   test case HTML-0061HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the SUP element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0061HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0061HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for SUP element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SUP);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0061HE -------------------------
//
//------------------------   test case HTML-0062HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the SPAN element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0062HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0062HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for SPAN element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SPAN);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0062HE -------------------------
//
//------------------------   test case HTML-0063HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the BDO element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0063HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0063HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for BDO element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(BDO);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0063HE -------------------------
//
//------------------------   test case HTML-0064HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the TT element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0064HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0064HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for TT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(TT);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0064HE -------------------------
//
//------------------------   test case HTML-0065HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the I element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0065HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0065HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for I element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(I);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0065HE -------------------------
//
//------------------------   test case HTML-0066HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the B element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0066HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0066HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for B element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(B);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0066HE -------------------------
//
//------------------------   test case HTML-0067HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the U element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0067HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0067HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for U element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(U);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0067HE -------------------------
//
//------------------------   test case HTML-0068HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the S element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0068HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0068HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for S element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(S);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0068HE -------------------------
//
//------------------------   test case HTML-0069HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the STRIKE element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0069HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0069HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for STRIKE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(STRIKE);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0069HE -------------------------
//
//------------------------   test case HTML-0070HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the BIG element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0070HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0070HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for BIG element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(BIG);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0070HE -------------------------
//
//------------------------   test case HTML-0071HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the SMALL element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0071HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0071HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for SMALL element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SMALL);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0071HE -------------------------
//
//------------------------   test case HTML-0072HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the EM element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0072HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0072HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for EM element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(EM);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0072HE -------------------------
//
//------------------------   test case HTML-0073HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the STRONG element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0073HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0073HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for STRONG element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(STRONG);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0073HE -------------------------
//
//------------------------   test case HTML-0074HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the DFN element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0074HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0074HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for DFN element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DFN);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0074HE -------------------------
//
//------------------------   test case HTML-0075HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the CODE element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0075HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0075HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for CODE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CODE);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0075HE -------------------------
//
//------------------------   test case HTML-0076HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the SAMP element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0076HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0076HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for SAMP element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SAMP);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0076HE -------------------------
//
//------------------------   test case HTML-0077HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the KBD element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0077HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0077HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for KBD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(KBD);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0077HE -------------------------
//
//------------------------   test case HTML-0078HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the VAR element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0078HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0078HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for VAR element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(VAR);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0078HE -------------------------
//
//------------------------   test case HTML-0079HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the CITE element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0079HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0079HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for CITE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CITE);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0079HE -------------------------
//
//------------------------   test case HTML-0080HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the ACRONYM element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0080HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0080HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for ACRONYM element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ACRONYM);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0080HE -------------------------
//
//------------------------   test case HTML-0081HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the ABBR element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0081HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0081HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for ABBR element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ABBR);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0081HE -------------------------
//
//------------------------   test case HTML-0082HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the DD element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0082HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0082HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for DD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DD);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0082HE -------------------------
//
//------------------------   test case HTML-0083HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the DT element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0083HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0083HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for DT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DT);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0083HE -------------------------
//
//------------------------   test case HTML-0084HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the NOFRAMES element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0084HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0084HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for NOFRAMES element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(NOFRAMES);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0084HE -------------------------
//
//------------------------   test case HTML-0085HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the NOSCRIPT element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0085HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0085HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for NOSCRIPT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(NOSCRIPT);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0085HE -------------------------
//
//------------------------   test case HTML-0086HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the ADDRESS element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0086HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0086HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for ADDRESS element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ADDRESS);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0086HE -------------------------
//
//------------------------   test case HTML-0087HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the language defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "lang" attribute from the CENTER element
//                    of the testing document and examine its value.  It
//                    should be equal to "en" (English).
//
// Semantic Requirements: 3
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0087HE()
 {
   var computedValue = "";
   var expectedValue = "EN";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0087HE");
    results.description = "The \"lang\" attribute specifies the "+
                          "language code defined in RFC 1766. (Test for CENTER element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CENTER);
//
// and access its "lang" attribute.
//
      computedValue = testNode.node.lang;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0087HE -------------------------
//
//------------------------   test case HTML-0088HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality 
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the HEAD element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4 
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0088HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0088HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for HEAD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(HEAD);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0088HE -------------------------
//
//------------------------   test case HTML-0089HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the SUB element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0089HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0089HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for SUB element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SUB);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0089HE -------------------------
//
//------------------------   test case HTML-0090HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the SUP element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0090HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0090HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for SUP element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SUP);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0090HE -------------------------
//
//------------------------   test case HTML-0091HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the SPAN element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0091HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0091HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for SPAN element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SPAN);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0091HE -------------------------
//
//------------------------   test case HTML-0092HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the BDO element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0092HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0092HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for BDO element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(BDO);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0092HE -------------------------
//
//------------------------   test case HTML-0093HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the TT element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0093HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0093HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for TT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(TT);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0093HE -------------------------
//
//------------------------   test case HTML-0094HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the I element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0094HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0094HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for I element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(I);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0094HE -------------------------
//
//------------------------   test case HTML-0095HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the B element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0095HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0095HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for B element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(B);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0095HE -------------------------
//
//------------------------   test case HTML-0096HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the U element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0096HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0096HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for U element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(U);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0096HE -------------------------
//
//------------------------   test case HTML-0097HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the S element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0097HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0097HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for S element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(S);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0097HE -------------------------
//
//------------------------   test case HTML-0098HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the STRIKE element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0098HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0098HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for STRIKE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(STRIKE);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0098HE -------------------------
//
//------------------------   test case HTML-0099HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the BIG element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0099HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0099HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for BIG element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(BIG);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0099HE -------------------------
//
//------------------------   test case HTML-0100HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the SMALL element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0100HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0100HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for SMALL element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SMALL);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0100HE -------------------------
//
//------------------------   test case HTML-0101HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the EM element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0101HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0101HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for EM element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(EM);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0101HE -------------------------
//
//------------------------   test case HTML-0102HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the STRONG element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0102HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0102HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for STRONG element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(STRONG);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0102HE -------------------------
//
//------------------------   test case HTML-0103HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the DFN element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0103HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0103HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for DFN element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DFN);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0103HE -------------------------
//
//------------------------   test case HTML-0104HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables. (Test for CODE element)";
//
// Testing approach - Retrieve the "dir" attribute from the  element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0104HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0104HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for CODE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CODE);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0104HE -------------------------
//
//------------------------   test case HTML-0105HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the SAMP element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0105HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0105HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for SAMP element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SAMP);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0105HE -------------------------
//
//------------------------   test case HTML-0106HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the KBD element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0106HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0106HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for KBD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(KBD);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0106HE -------------------------
//
//------------------------   test case HTML-0107HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the VAR element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0107HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0107HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for VAR element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(VAR);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0107HE -------------------------
//
//------------------------   test case HTML-0108HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the CITE element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0108HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0108HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for CITE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CITE);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0108HE -------------------------
//
//------------------------   test case HTML-0109HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the ACRONYM element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0109HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0109HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for ACRONYM element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ACRONYM);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0109HE -------------------------
//
//------------------------   test case HTML-0110HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the ABBR element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0110HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0110HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for ABBR element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ABBR);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0110HE -------------------------
//
//------------------------   test case HTML-0111HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the DD element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0111HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0111HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for DD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DD);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0111HE -------------------------
//
//------------------------   test case HTML-0112HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the DT element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0112HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0112HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for DT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DT);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0112HE -------------------------
//
//------------------------   test case HTML-0113HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the NOFRAMES element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0113HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0113HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for NOFRAMES element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(NOFRAMES);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0113HE -------------------------
//
//------------------------   test case HTML-0114HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the NOSCRIPT element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0114HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0114HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for NOSCRIPT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(NOSCRIPT);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0114HE -------------------------
//
//------------------------   test case HTML-0115HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the ADDRESS element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0115HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0115HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for ADDRESS element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ADDRESS);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0115HE -------------------------
//
//------------------------   test case HTML-0116HE   -------------------------
//
// Testing feature - The "lang" attribute specifies the base direction
//                   of directionally neutral text and directionality
//                   of tables.
//
// Testing approach - Retrieve the "dir" attribute from the CENTER element
//                    of the testing document and examine its value.  It
//                    should be equal to "LTR".
//
// Semantic Requirements: 4
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0116HE()
 {
   var computedValue = "";
   var expectedValue = "LTR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0116HE");
    results.description = "The \"dir\" attribute specifies the "+
                          "base direction and the directionality "+
                          "of tables. (Test for CENTER element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CENTER);
//
// and access its "dir" attribute.
//
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0116HE -------------------------
//
//------------------------   test case HTML-0117HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the 
//                    HEAD element of the testing document and examine its 
//                    value.  It should be equal to "head-class".
//
// Semantic Requirements: 5 
//
// Last modification date - November 01, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0117HE()
 {
   var computedValue = "";
   var expectedValue = "HEAD-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0117HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for HEAD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(HEAD);
//
// and access its "className" attribute.
//
      testNode.node.className="HEAD-CLASS";
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0117HE -------------------------
//
//------------------------   test case HTML-0118HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    SUB element of the testing document and examine its
//                    value.  It should be equal to "SUB-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0118HE()
 {
   var computedValue = "";
   var expectedValue = "SUB-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0118HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for SUB element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SUB);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0118HE -------------------------
//
//------------------------   test case HTML-0119HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    SUP element of the testing document and examine its
//                    value.  It should be equal to "sup-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0119HE()
 {
   var computedValue = "";
   var expectedValue = "SUP-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0119HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for SUP element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SUP);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0119HE -------------------------
//
//------------------------   test case HTML-0120HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    SPAN element of the testing document and examine its
//                    value.  It should be equal to "span-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0120HE()
 {
   var computedValue = "";
   var expectedValue = "SPAN-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0120HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for SPAN element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SPAN);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0120HE -------------------------
//
//------------------------   test case HTML-0121HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    BDO element of the testing document and examine its
//                    value.  It should be equal to "BDO-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0121HE()
 {
   var computedValue = "";
   var expectedValue = "BDO-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0121HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for BDO element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(BDO);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0121HE -------------------------
//
//------------------------   test case HTML-0122HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    TT element of the testing document and examine its
//                    value.  It should be equal to "TT-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0122HE()
 {
   var computedValue = "";
   var expectedValue = "TT-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0122HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for TT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(TT);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0122HE -------------------------
//
//------------------------   test case HTML-0123HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    I element of the testing document and examine its
//                    value.  It should be equal to "I-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0123HE()
 {
   var computedValue = "";
   var expectedValue = "I-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0123HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for I element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(I);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0123HE -------------------------
//
//------------------------   test case HTML-0124HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    B element of the testing document and examine its
//                    value.  It should be equal to "B-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0124HE()
 {
   var computedValue = "";
   var expectedValue = "B-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0124HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for B element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(B);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0124HE -------------------------
//
//------------------------   test case HTML-0125HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    U element of the testing document and examine its
//                    value.  It should be equal to "U-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0125HE()
 {
   var computedValue = "";
   var expectedValue = "U-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0125HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for U element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(U);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0125HE -------------------------
//
//------------------------   test case HTML-0126HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    S element of the testing document and examine its
//                    value.  It should be equal to "S-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0126HE()
 {
   var computedValue = "";
   var expectedValue = "S-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0126HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for S element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(S);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0126HE -------------------------
//
//------------------------   test case HTML-0127HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    STRIKE element of the testing document and examine its
//                    value.  It should be equal to "strike-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0127HE()
 {
   var computedValue = "";
   var expectedValue = "STRIKE-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0127HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for STRIKE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(STRIKE);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0127HE -------------------------
//
//------------------------   test case HTML-0128HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    BIG element of the testing document and examine its
//                    value.  It should be equal to "big-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0128HE()
 {
   var computedValue = "";
   var expectedValue = "BIG-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0128HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for BIG element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(BIG);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0128HE -------------------------
//
//------------------------   test case HTML-0129HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    SMALL element of the testing document and examine its
//                    value.  It should be equal to "small-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0129HE()
 {
   var computedValue = "";
   var expectedValue = "SMALL-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0129HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for SMALL element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SMALL);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0129HE -------------------------
//
//------------------------   test case HTML-0130HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    EM element of the testing document and examine its
//                    value.  It should be equal to "em-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0130HE()
 {
   var computedValue = "";
   var expectedValue = "EM-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0130HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for EM element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(EM);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0130HE -------------------------
//
//------------------------   test case HTML-0131HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    STRONG element of the testing document and examine its
//                    value.  It should be equal to "strong-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0131HE()
 {
   var computedValue = "";
   var expectedValue = "STRONG-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0131HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for STRONG element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(STRONG);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0131HE -------------------------
//
//------------------------   test case HTML-0132HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    DFN element of the testing document and examine its
//                    value.  It should be equal to "dfn-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0132HE()
 {
   var computedValue = "";
   var expectedValue = "DFN-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0132HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for DFN element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DFN);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0132HE -------------------------
//
//------------------------   test case HTML-0133HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    CODE element of the testing document and examine its
//                    value.  It should be equal to "code-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0133HE()
 {
   var computedValue = "";
   var expectedValue = "CODE-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0133HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for CODE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CODE);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0133HE -------------------------
//
//------------------------   test case HTML-0134HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    SAMP element of the testing document and examine its
//                    value.  It should be equal to "samp-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0134HE()
 {
   var computedValue = "";
   var expectedValue = "SAMP-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0134HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for SAMP element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(SAMP);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0134HE -------------------------
//
//------------------------   test case HTML-0135HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    KBD element of the testing document and examine its
//                    value.  It should be equal to "kbd-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0135HE()
 {
   var computedValue = "";
   var expectedValue = "KBD-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0135HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for KBD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(KBD);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0135HE -------------------------
//
//------------------------   test case HTML-0136HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    VAR element of the testing document and examine its
//                    value.  It should be equal to "var-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0136HE()
 {
   var computedValue = "";
   var expectedValue = "VAR-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0136HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for VAr element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(VAR);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0136HE -------------------------
//
//------------------------   test case HTML-0137HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    CITE element of the testing document and examine its
//                    value.  It should be equal to "cite-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0137HE()
 {
   var computedValue = "";
   var expectedValue = "CITE-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0137HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for CITE element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CITE);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0137HE -------------------------
//
//------------------------   test case HTML-0138HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    ACRONYM element of the testing document and examine its
//                    value.  It should be equal to "acronym-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0138HE()
 {
   var computedValue = "";
   var expectedValue = "ACRONYM-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0138HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for ACRONYM element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ACRONYM);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0138HE -------------------------
//
//------------------------   test case HTML-0139HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    ABBR element of the testing document and examine its
//                    value.  It should be equal to "abbr-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0139HE()
 {
   var computedValue = "";
   var expectedValue = "ABBR-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0139HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for ABBR element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ABBR);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0139HE -------------------------
//
//------------------------   test case HTML-0140HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    DD element of the testing document and examine its
//                    value.  It should be equal to "dd-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0140HE()
 {
   var computedValue = "";
   var expectedValue = "DD-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0140HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for DD element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DD);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0140HE -------------------------
//
//------------------------   test case HTML-0141HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    DT element of the testing document and examine its
//                    value.  It should be equal to "dt-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0141HE()
 {
   var computedValue = "";
   var expectedValue = "DT-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0141HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for DT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(DT);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0141HE -------------------------
//
//------------------------   test case HTML-0142HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    NOFRAMES element of the testing document and examine its
//                    value.  It should be equal to "noframes-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0142HE()
 {
   var computedValue = "";
   var expectedValue = "NOFRAMES-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0142HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for NOFRAMES element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(NOFRAMES);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0142HE -------------------------
//
//------------------------   test case HTML-0143HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    NOSCRIPT element of the testing document and examine its
//                    value.  It should be equal to "noscript-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0143HE()
 {
   var computedValue = "";
   var expectedValue = "NOSCRIPT-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0143HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for NOSCRIPT element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(NOSCRIPT);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0143HE -------------------------
//
//------------------------   test case HTML-0144HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    ADDRESS element of the testing document and examine its
//                    value.  It should be equal to "address-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0144HE()
 {
   var computedValue = "";
   var expectedValue = "ADDRESS-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0144HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for ADDRESS element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(ADDRESS);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0144HE -------------------------
//
//------------------------   test case HTML-0145HE   -------------------------
//
// Testing feature - The "className" attribute specifies the langusge defined
//                   in RFC 1766.
//
// Testing approach - Retrieve the "class" attribute (by using the "className"
//                    attribute of the HTMLElement interface) from the
//                    CENTER element of the testing document and examine its
//                    value.  It should be equal to "center-class".
//
// Semantic Requirements: 5
//
// Last modification date - October 14, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------

 function HTML0145HE()
 {
   var computedValue = "";
   var expectedValue = "CENTER-CLASS";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0145HE");
    results.description = "The \"className\" attribute specifies the "+
                          "class attribute of the element. (Test for CENTER element)";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(CENTER);
//
// and access its "className" attribute.
//
      computedValue = testNode.node.className;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//------------------------ End test case HTML-0145HE -------------------------