//**************************************************************************
//
//
//                       National Institute Of Standards and Technology
//                                    DTS Version 1.1
//         
//                              HTMLInputElement Interface
//**************************************************************************

function HTMLInputElement()
{
   var tests = new Array (HTML0001IE(),HTML0002IE(),HTML0003IE(),HTML0004IE(),HTML0005IE(),HTML0006IE(),HTML0007IE(),HTML0008IE(),HTML0009IE(),HTML0010IE(),HTML0011IE(),HTML0012IE(),HTML0013IE(),HTML0014IE(),HTML0015IE(),HTML0016IE(),HTML0017IE(),HTML0018IE(),HTML0019IE(),HTML0020IE(),HTML0021IE(),HTML0022IE());
   return tests;
}

//------------------------ test case HTML-0001IE -------------------------
//
// Testing feature - The "defaultValue" attribute represents the HTML value
//                   of the attribute when the type attribute has the value
//                   "Text", "File" or "Password".
//
// Testing approach - Retrieve the fourth INPUT element of the testing
//                    document and examine its "defaultValue" attribute.
//                    It should be equal to "EARLYMONING".
//
// Semantic Requirements: 1
//
// Last modification date - October 20 , 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0001IE()
 {
   var computedValue = "";
   var expectedValue = "EARLYMORNING";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0001IE");
    results.description = "The \"defaultValue\" attribute represents the "+
                          "HTML value of the attribute when the type "+
                          "attribute has the value \"Text\", \"File\" or "+
                          "\"Password\".";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FOURTH);
//
// Access "defaultValue" attribute.
//
      computedValue = testNode.node.defaultValue;
      computedValue = computedValue.toUpperCase();
//
// Write out results 
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0001IE  ----------------------
//
//------------------------ test case HTML-0002IE -------------------------
//
// Testing feature - The "defaultChecked" attribute represents the HTML
//                   checked attribute of the element when the type 
//                   attribute has the value "Checkbox" or "Radio". 
//
// Testing approach - Retrieve the fourth INPUT element of the testing
//                    document and examine its "defaultChecked" attribute.
//                    It should be equal to true.
//
// Semantic Requirements:2 
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0002IE()
 {
   var computedValue = "";
   var expectedValue = true;
   var results = "";
   var testNode = "";

    results = new testResults("HTML0002IE");
    results.description = "The \"defaultChecked\" attribute represents the HTML "+
                          " checked value when the type has the value "+
                          "\"Radio\" or \"Checkbox\".";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FOURTH);
//
// Access "defaultChecked" attribute.
//
      computedValue = testNode.node.defaultChecked;
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0002IE -----------------------
//
//------------------------ test case HTML-0003IE -------------------------
//
// Testing feature - The "form" attribute returns the FORM containing 
//                   this control.
//
// Testing approach - Retrieve the first INPUT element of the testing
//                    document and examine its "form" attribute.
//                    It should be equal to an HTMLFormElement whose name
//                    attribute is "form1".
//
// Semantic Requirements:3 
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0003IE()
 {
   var computedValue = "";
   var expectedValue = "FORM1";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0003IE");
    results.description = "The \"form\" attribute returns the FORM containing "+
                          "this control.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FIRST);
//
// Access "form" attribute.
//
      computedValue = testNode.node.form.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0003IE -----------------------
//
//------------------------ test case HTML-0004IE -------------------------
//
// Testing feature - The "accept" attribute is a comma-seperated list of
//                   content types that a server processing this form will
//                   handle correctly.
//
// Testing approach - Retrieve the nineth INPUT element of the testing
//                    document and examine its "accept" attribute.
//                    It should be equal to "GIF,JPEG".
//
// Semantic Requirements:4 
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0004IE()
 {
   var computedValue = "";
   var expectedValue = "GIF,JPEG";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0004IE");
    results.description = "The \"accept\" attribute is a comma-seperated list "+
                          "of content types that a server processing this  "+
                          "form will handle correctly.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,NINETH);
//
// Access "accept" attribute.
//
      computedValue = testNode.node.accept;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0004IE -----------------------
//
//------------------------ test case HTML-0005IE -------------------------
//
// Testing feature - The "accessKey" attribute is a single character 
//                   access key to give access to the form control.
//
// Testing approach - Retrieve the second INPUT element of the testing
//                    document and examine its "accessKey" attribute.
//                    It should be equal to "c".
//
// Semantic Requirements:5 
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0005IE()
 {
   var computedValue = "";
   var expectedValue = "C";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0005IE");
    results.description = "The \"accessKey\" attribute is a single character "+
                          "access key to give access to the form control.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,SECOND);
//
// Access "accessKey" attribute.
//
      computedValue = testNode.node.accessKey;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0005IE -----------------------
//
//------------------------ test case HTML-0006IE -------------------------
//
// Testing feature - The "align" attribute aligns this object (vertically 
//                   or horizontally) with respect to the surrounding text.
//
// Testing approach - Retrieve the fourth INPUT element of the testing
//                    document and examine its "align" attribute.
//                    It should be equal to "BOTTOM".
//
// Semantic Requirements:6 
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0006IE()
 {
   var computedValue = "";
   var expectedValue = "BOTTOM";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0006IE");
    results.description = "The \"align\" attribute aligns this object "+
                          "(vertically or horizontally) with respect to the "+
                          "surrounding text.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FOURTH);
//
// Access "align" attribute.
//
      computedValue = testNode.node.align;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//----------------------- end test case HTML-0006IE ----------------------
//
//------------------------ test case HTML-0007IE -------------------------
//
// Testing feature - The "alt" attribute alternates text for user agents 
//                   not rendering the normal content of this element.
//
// Testing approach - Retrieve the first INPUT element of the testing
//                    document and examine its "alt" attribute.
//                    It should be equal to "PASSWORD ENTRY".
//
// Semantic Requirements:7 
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0007IE()
 {
   var computedValue = "";
   var expectedValue = "PASSWORD ENTRY";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0007IE");
    results.description = "The \"alt\" attribute alternates text for user "+
                          "agents not rendering the normal content of this"+
                          " Element.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FIRST);
//
// Access "alt" attribute.
//
      computedValue = testNode.node.alt;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0007IE ----------------------
//
//------------------------ test case HTML-0008IE -------------------------
//
// Testing feature - The "checked" attribute represents the current state
//                   of the corresponding form control when type has the 
//                   value "Radio" or "Checkbox".
//
// Testing approach - Retrieve the third INPUT element of the testing
//                    document and examine its "checked" attribute.
//                    It should be equal to "true".
//
// Semantic Requirements:8 
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0008IE()
 {
   var computedValue = "";
   var expectedValue = true;
   var results = "";
   var testNode = "";

    results = new testResults("HTML0008IE");
    results.description = "The \"checked\" attribute represents the current "+
                          " form control when type has the value \"Radio\" or "
                          " \"Checkbox\".";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,THIRD);
//
// Access "checked" attribute.
//
      computedValue = testNode.node.checked;
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0008IE -----------------------
//
//------------------------ test case HTML-0009IE -------------------------
//
// Testing feature - The "disabled" attribute has a TRUE value if it is
//                   explicitly set.
//
// Testing approach - Retrieve the seventh INPUT element of the testing
//                    document and examine its "disabled" attribute.
//                    It should be equal to true.
//
// Semantic Requirements: 9
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0009IE()
 {
   var computedValue = "";
   var expectedValue = true;
   var results = "";
   var testNode = "";

    results = new testResults("HTML0009IE");
    results.description = "The \"disabled\" attribute has a TRUE value if  "+
                          "it is explicitly set.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,SEVENTH);
//
// Access "disabled" attribute.
//
      computedValue = testNode.node.disabled;
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0009IE -----------------------
//
//------------------------ test case HTML-0010IE -------------------------
//
// Testing feature - The "maxLength" attribute is the maximum number of
//                   text characters for text fields, when type has the 
//                   value of "Text" or "Password".
//
// Testing approach - Retrieve the frst INPUT element of the testing
//                    document and examine its "maxLength" attribute.
//                    It should be equal to 5.
//
// Semantic Requirements: 10
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0010IE()
 {
   var computedValue = "";
   var expectedValue = 5;
   var results = "";
   var testNode = "";

    results = new testResults("HTML0010IE");
    results.description = "The \"maxLength\" attribute is the maximum "+
                          "number of text characters for text fields, when "+
                          "type has the value of \"Text\" or \"Password\".";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FIRST);
//
// Access "maxLength" attribute.
//
      computedValue = testNode.node.maxLength
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0010IE -----------------------
//
//------------------------ test case HTML-0011IE -------------------------
//
// Testing feature - The "name" attribute is the form control or object
//                   name when submitted with a form.
//
// Testing approach - Retrieve the first INPUT element of the testing
//                    document and examine its "name" attribute.
//                    It should be equal to "PASSWORD".
//
// Semantic Requirements: 11
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0011IE()
 {
   var computedValue = "";
   var expectedValue = "PASSWORD"
   var results = "";
   var testNode = "";

    results = new testResults("HTML0011IE");
    results.description = "The \"name\" attribute is the from control "+
                          "or object name when submitted with a form.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FIRST);
//
// and access "name" attribute.
//
      computedValue = testNode.node.name;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//----------------------- end test case HTML-0011IE -----------------------
//
//------------------------ test case HTML-00012IE -------------------------
//
// Testing feature - The "readOnly" attribute indicates that this control
//                   is read-only when type has a value of "text" or 
//                   "password" only.
//
// Testing approach - Retrieve the first INPUT element of the testing
//                    document and examine its "readOnly" attribute.
//                    It should be equal to true.
//
// Semantic Requirements: 12
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0012IE()
 {
   var computedValue = "";
   var expectedValue = true;
   var results = "";
   var testNode = "";

    results = new testResults("HTML0012IE");
    results.description = "The \"readOnly\" attribute indicates that this "+
                          "control is read-only when type has a value of "+
                          "\"text\" or \"password\" only.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FIRST);
//
// Access "readOnly" attribute.
//
      computedValue = testNode.node.readOnly;
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0012IE -----------------------
//
//------------------------ test case HTML-0013IE -------------------------
//
// Testing feature - The "size" attribute contains the size information.
//                   Its precise meaning is specific to each type of field.
//
// Testing approach - Retrieve the first INPUT element of the testing
//                    document and examine its "size" attribute.
//                    It should be equal to "25".
//
// Semantic Requirements: 13
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0013IE()
 {
   var computedValue = "";
   var expectedValue = "25";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0013IE");
    results.description = "The \"size\" attribute contains the size "+
                          "information.  Its precise meaning is specific "+
                          "to each type of field.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FIRST);
//
// Access "size" attribute.
//
      computedValue = testNode.node.size;
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0013IE -----------------------
//
//------------------------ test case HTML-0014IE -------------------------
//
// Testing feature - The "src" attribute specifies the location of the
//                   image to decorate the graphical submit button when
//                   the type has the value "Image".
//
// Testing approach - Retrieve the eight INPUT element of the testing
//                    document and examine its "src" attribute.
//                    It should be equal to 
//                    "./PIX/SUBMIT.GIF."
//
// Semantic Requirements: 14
//
// Last modification date - September 21, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0014IE()
 {
   var computedValue = "";
   var expectedValue = "./PIX/SUBMIT.GIF";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0014IE");
    results.description = "The \"src\" attribute specifies the location of "+
                          "the image to decorate the graphical submit "+
                          "button when the type has the value \"Image\".";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,EIGHT);
//
// Access "src" attribute.
//
      computedValue = testNode.node.src;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0014IE -----------------------
//
//------------------------ test case HTML-0015IE -------------------------
//
// Testing feature - The "tabIndex" attribute is an index that represents
//                   the element's position in the tabbing order.
//
// Testing approach - Retrieve the third INPUT element of the testing
//                    document and examine its "tabIndex" attribute.
//                    It should be equal to 9.
//
// Semantic Requirements: 15
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0015IE()
 {
   var computedValue = "";
   var expectedValue = 9;
   var results = "";
   var testNode = "";

    results = new testResults("HTML0015IE");
    results.description = "The \"tabIndex\" attribute is an index that "+
                          "represents the element's position in the "+
                          "tabbing order.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,THIRD);
//
// Access "tabIndex" attribute.
//
      computedValue = testNode.node.tabIndex;
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0015IE -----------------------
//
//------------------------ test case HTML-0016IE -------------------------
//
// Testing feature - The "type" attribute is the type of control created.
//
// Testing approach - Retrieve the first INPUT element of the testing
//                    document and examine its "type" attribute.
//                    It should be equal to "PASSWORD".
//
// Semantic Requirements: 16
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0016IE()
 {
   var computedValue = "";
   var expectedValue = "PASSWORD";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0016IE");
    results.description = "The \"type\" attribute is the type of control "+
                          "created.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FIRST);
//
// Access "type" attribute.
//
      computedValue = testNode.node.type;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0016IE -----------------------
//
//------------------------ test case HTML-0017IE -------------------------
//
// Testing feature - The "useMap" attribute is the used client-side 
//                   image map.
//
// Semantic Requirements: 17
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0017IE()
 {
   var computedValue = "";
   var expectedValue = "#SUBMIT-MAP";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0017IE");
    results.description = "The \"useMap\" attribute is the used client-side "+
                          "image map.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,EIGHT);
//
// and access attribute.
//
      computedValue = testNode.node.useMap;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//---------------------- end test case HTML-0019IE -----------------------
//
//------------------------ test case HTML-0018IE -------------------------
//
// Testing feature - The "value" attribute is the current contents of the
//                   corresponding form control when the type attribute
//                   has the value "Text", "File" or "Password".
//
// Testing approach - Retrieve the second INPUT element of the testing
//                    document and examine its "value" attribute.
//                    It should be equal to "REHIRE".
//
// Semantic Requirements: 18
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0018IE()
 {
   var computedValue = "";
   var expectedValue = "REHIRE";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0018IE");
    results.description = "The \"value\" attribute is the current value of the
                          " corresponding form control when the type "+
                          " has the value \"Text\", \"File\" or \"Password\".";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,SECOND);
//
// Access "value" attribute.
//
      computedValue = testNode.node.value;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//----------------------- end test case HTML-0018IE -------------------------
//
//------------------------  test case HTML-0019IE   -------------------------
//
// Testing feature - The "blur()" method removes keyboard focus from
//                   this element.
//
// Testing approach - Retrieve the first INPUT element from the testing
//                    document and invoke its "blur()" method.  Upon
//                    invocation of this method, the element should become
//                    "blurred".  This should trigger an "onblur" event that
//                    will invoke the "setIdBlur()" function which changes the
//                    element's id attribute to "newId_Blur".  Before the
//                    "blur()" method is invoked, the element is given focus by
//                    invoking its "focus()" method.
//
// Semantic Requirements: 19
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0019IE()
 {
   var computedValue = "";
   var expectedValue = "NEWID_BLUR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0019IE");
    results.description = "The \"blur()\" method removes keyboard focus "+
                          "from this element.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FIRST);
//
// Invoke its "blur()" method 
//
      testNode.node.blur();
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
//      resetHTMLData();
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//----------------------- end test case HTML-0019IE ----------------------
//
//------------------------ test case HTML-0020IE -------------------------
//
// Testing feature - The "focus()" method gives keyboard focus to this
//                   element.
//
// Testing approach - Retrieve the first INPUT element from the testing
//                    document and invoke its "focus()" method.  upon this
//                    method being invoked, focus should be given to
//                    this element.  This should trigger an "onfocus" event
//                    that will invoke the "setDir()" function which changes the
//                    element's dir attribute to to "RTL".
//
// Semantic Requirements:20 
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0020IE()
 {
   var computedValue = "";
   var expectedValue = "RTL";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0020IE");
    results.description = "The \"focus()\" method gives keyboard focus "+
                          "to this element.";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FIRST);
//
// Invoke its "focus()" method.
//
      testNode.node.focus();
      computedValue = testNode.node.dir;
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
//      resetHTMLData();
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//-----------------------  end test case HTML-0020IE ---------------------
//
//------------------------   test case HTML-0021IE   ---------------------
//
// Testing feature - The "select()" method selects the content of the text
//                   area for INPUT elements whose type attribute is set
//                   to "Text", "File" or "Password".
//
// Testing approach - Retrieve the nineth INPUT element from the testing
//                    document and invoke its "select()" method.  upon this
//                    method being invoked, the contents of the text area
//                    should be selected.  This should trigger an "onselect"
//                    event that will invoke the "newTitle()" function which
//                    changes the element's title attribute to "new_title".
//
// Semantic Requirements: 21
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0021IE()
 {
   var computedValue = "";
   var expectedValue = "NEW_TITLE";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0021IE");
    results.description = "The \"select()\" method selects the content of "+
                          "the text area for INPUT elements whose type "+
                          "attribute is set to \"Text\", \"File\" or "+
                          "\"Password\"."; 
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,NINETH);
//
// invoke its "select()" method.
//
      testNode.node.select();
      computedValue = testNode.node.title; 
      computedValue = computedValue.toUpperCase();
//
// Write out results
//
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//----------------------- end test case HTML-0021IE ----------------------
//
//------------------------ test case HTML-0022IE -------------------------
//
// Testing feature - The "click()" method simulates a mouse click for 
//                   INPUT elements whose type attribute is "Button",
//                   "Checkbox", "Radio", "Reset" or "Submit".
//
// Testing approach - Retrieve the fifth INPUT element from the testing
//                    document and invoke its "click()" method.  Upon this
//                    method being invoked, an "onclick" event will be
//                    triggered that will result on the execution of the 
//                    "newId()" function which changes the element's id
//                    attribute to "newid_blur".
//
// Semantic Requirements: 22 
//
// Last modification date - October 20, 1999
//
// Written by: Mark LaRoy Zimmerman
//----------------------------------------------------------------------------
function HTML0022IE()
 {
   var computedValue = "";
   var expectedValue = "NEWID_BLUR";
   var results = "";
   var testNode = "";

    results = new testResults("HTML0022IE");
    results.description = "The \"Click()\" method simulates a mouse click "+
                          "for INPUT elements whose type attribute is "+
                          "\"Button\", \"Checkbox\", \"Radio\", \"Reset\" "+
                          "or \"Submit\".";
//
// Retrieve targeted data.
//
      testNode = new HTMLNodeObject(INPUT,FIFTH);
//
// Invoke "click()" method
//
      testNode.node.click();
      computedValue = testNode.node.id;
      computedValue = computedValue.toUpperCase(); 
//
// Write out results
//
      resetHTMLData();
      results.expected = expectedValue;
      results.actual = computedValue;

    return results;
}
//----------------------- end test case HTML-0022IE ----------------------