From: "Saved by Windows Internet Explorer 9"
Subject: 
Date: Wed, 18 May 2011 16:49:23 -0700
MIME-Version: 1.0
Content-Type: multipart/related;
	type="text/html";
	boundary="----=_NextPart_000_0012_01CC157B.8AA06570"
X-MimeOLE: Produced By Microsoft MimeOLE V6.1.7600.16776

This is a multi-part message in MIME format.

------=_NextPart_000_0012_01CC157B.8AA06570
Content-Type: text/html;
	charset="Windows-1252"
Content-Transfer-Encoding: quoted-printable
Content-Location: http://localhost/page_with_css_and_js.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML><HEAD>
<META content=3D"text/html; charset=3Dwindows-1252" =
http-equiv=3DContent-Type><LINK=20
rel=3Dstylesheet type=3Dtext/css =
href=3D"http://localhost/resources/hide_image.css">
<SCRIPT type=3Dtext/javascript=20
src=3D"http://localhost/resources/remove_image_script.js"></SCRIPT>

<SCRIPT>=0A=
    if (window.testRunner) {=0A=
      testRunner.dumpAsText();=0A=
      testRunner.waitUntilDone();=0A=
    }=0A=
  </SCRIPT>

<META name=3DGENERATOR content=3D"MSHTML 9.00.8112.16421"></HEAD>
<BODY onload=3DonLoad()>This page tests that CSS and JavaScript =
resources are=20
retrieved correctly for MHTML files.<BR><BR>There should be only one red =
square=20
below:=20
<DIV id=3DfirstDiv><IMG=20
src=3D"http://localhost/resources/red_square.png"><BR><BR></DIV>
<DIV id=3DsecondDiv>The red square below should be hidden by way of =
CSS.<BR><IMG=20
src=3D"http://localhost/resources/red_square.png"><BR><BR></DIV>
<DIV id=3DthirdDiv>The red square below should be hidden by way of=20
JavaScript.<BR><IMG=20
src=3D"http://localhost/resources/red_square.png"><BR><BR></DIV></BODY><=
/HTML>

------=_NextPart_000_0012_01CC157B.8AA06570
Content-Type: image/png
Content-Transfer-Encoding: base64
Content-Location: http://localhost/resources/red_square.png

iVBORw0KGgoAAAANSUhEUgAAAB4AAAAeCAYAAAA7MK6iAAAAAXNSR0IArs4c6QAAAARnQU1BAACx
jwv8YQUAAAAJcEhZcwAADsQAAA7EAZUrDhsAAACESURBVEhL7ZYxDoAwCEXB2LGTo46ewXj/zXgV
PQKgexP/Ai6l889/6Stp4HtZjYKOiRCpEpfSEIYgJqxNMFTkFUjVXiZhT6qGirwCqdrLJOxJ1VCR
V6A/1XxNc9jqQ6JkpjTU2rwQR+5c4769YCM5zn/BX4PY33Dljb0+JtiTqqEir8ADWEIY6dz7d1cA
AAAASUVORK5CYII=

------=_NextPart_000_0012_01CC157B.8AA06570
Content-Type: text/css;
	charset="iso-8859-1"
Content-Transfer-Encoding: 7bit
Content-Location: http://localhost/resources/hide_image.css

#secondDiv {
	DISPLAY: none
}

------=_NextPart_000_0012_01CC157B.8AA06570
Content-Type: application/octet-stream
Content-Transfer-Encoding: quoted-printable
Content-Location: http://localhost/resources/remove_image_script.js

function onLoad() {=0A=
    divToRemove =3D document.getElementById("thirdDiv");=0A=
    divToRemove.parentNode.removeChild(divToRemove);=0A=
    if (window.testRunner)=0A=
      testRunner.notifyDone();=0A=
}
------=_NextPart_000_0012_01CC157B.8AA06570--
