1 files changed, 239 insertions, 0 deletions
diff --git a/LayoutTests/http/tests/cookies/resources/cookies-test-pre.js b/LayoutTests/http/tests/cookies/resources/cookies-test-pre.js
new file mode 100644
index 0000000..80b0ff1
--- /dev/null
+++ b/LayoutTests/http/tests/cookies/resources/cookies-test-pre.js
@@ -0,0 +1,239 @@
+if (window.layoutTestController)
+    layoutTestController.dumpAsText();
+
+function description(msg)
+{
+    // For MSIE 6 compatibility
+    var span = document.createElement("span");
+    span.innerHTML = '<p>' + msg + '</p><p>On success, you will see a series of "<span class="pass">PASS</span>" messages, followed by "<span class="pass">TEST COMPLETE</span>".</p>';
+    var description = document.getElementById("description");
+    if (description.firstChild)
+        description.replaceChild(span, description.firstChild);
+    else
+        description.appendChild(span);
+}
+
+function debug(msg)
+{
+    var span = document.createElement("span");
+    document.getElementById("console").appendChild(span); // insert it first so XHTML knows the namespace
+    span.innerHTML = msg + '<br />';
+}
+
+function escapeHTML(text)
+{
+    return text.replace(/&/g, "&amp;").replace(/</g, "&lt;");
+}
+
+function testPassed(msg)
+{
+    debug('<span><span class="pass">PASS</span> ' + escapeHTML(msg) + '</span>');
+}
+
+function testFailed(msg)
+{
+    debug('<span><span class="fail">FAIL</span> ' + escapeHTML(msg) + '</span>');
+}
+
+function areArraysEqual(_a, _b)
+{
+    if (_a.length !== _b.length)
+        return false;
+    for (var i = 0; i < _a.length; i++)
+        if (_a[i] !== _b[i])
+            return false;
+    return true;
+}
+
+function isMinusZero(n)
+{
+    // the only way to tell 0 from -0 in JS is the fact that 1/-0 is
+    // -Infinity instead of Infinity
+    return n === 0 && 1/n < 0;
+}
+
+function isResultCorrect(_actual, _expected)
+{
+    if (_expected === 0)
+        return _actual === _expected && (1/_actual) === (1/_expected);
+    if (_actual === _expected)
+        return true;
+    if (typeof(_expected) == "number" && isNaN(_expected))
+        return typeof(_actual) == "number" && isNaN(_actual);
+    if (Object.prototype.toString.call(_expected) == Object.prototype.toString.call([]))
+        return areArraysEqual(_actual, _expected);
+    return false;
+}
+
+function stringify(v)
+{
+    if (v === 0 && 1/v < 0)
+        return "-0";
+    else return "" + v;
+}
+
+function shouldBe(_a, _b)
+{
+    if (typeof _a != "string" || typeof _b != "string")
+        debug("WARN: shouldBe() expects string arguments");
+    var exception;
+    var _av;
+    try {
+        _av = eval(_a);
+    } catch (e) {
+        exception = e;
+    }
+    var _bv = eval(_b);
+
+    if (exception)
+        testFailed(_a + " should be " + _bv + ". Threw exception " + exception);
+    else if (isResultCorrect(_av, _bv))
+        testPassed(_a + " is " + _b);
+    else if (typeof(_av) == typeof(_bv))
+        testFailed(_a + " should be " + _bv + ". Was " + stringify(_av) + ".");
+    else
+        testFailed(_a + " should be " + _bv + " (of type " + typeof _bv + "). Was " + _av + " (of type " + typeof _av + ").");
+}
+
+function shouldBeTrue(_a) { shouldBe(_a, "true"); }
+function shouldBeFalse(_a) { shouldBe(_a, "false"); }
+function shouldBeNaN(_a) { shouldBe(_a, "NaN"); }
+function shouldBeNull(_a) { shouldBe(_a, "null"); }
+
+function shouldBeEqualToString(a, b)
+{
+    var unevaledString = '"' + b.replace(/"/g, "\"") + '"';
+    shouldBe(a, unevaledString);
+}
+
+function shouldBeUndefined(_a)
+{
+    var exception;
+    var _av;
+    try {
+        _av = eval(_a);
+    } catch (e) {
+        exception = e;
+    }
+
+    if (exception)
+        testFailed(_a + " should be undefined. Threw exception " + exception);
+    else if (typeof _av == "undefined")
+        testPassed(_a + " is undefined.");
+    else
+        testFailed(_a + " should be undefined. Was " + _av);
+}
+
+function shouldThrow(_a, _e)
+{
+    var exception;
+    var _av;
+    try {
+        _av = eval(_a);
+    } catch (e) {
+        exception = e;
+    }
+
+    var _ev;
+    if (_e)
+        _ev =  eval(_e);
+
+    if (exception) {
+        if (typeof _e == "undefined" || exception == _ev)
+            testPassed(_a + " threw exception " + exception + ".");
+        else
+            testFailed(_a + " should throw " + (typeof _e == "undefined" ? "an exception" : _ev) + ". Threw exception " + exception + ".");
+    } else if (typeof _av == "undefined")
+        testFailed(_a + " should throw " + (typeof _e == "undefined" ? "an exception" : _ev) + ". Was undefined.");
+    else
+        testFailed(_a + " should throw " + (typeof _e == "undefined" ? "an exception" : _ev) + ". Was " + _av + ".");
+}
+
+var cookies = new Array();
+
+// This method sets the cookies using XMLHttpRequest.
+// We do not set the cookie right away as it is forbidden by the XHR spec.
+// FIXME: Add the possibility to set multiple cookies in a row.
+function setCookies(cookie)
+{
+    try {
+        var xhr = new XMLHttpRequest();
+        xhr.open("GET", "resources/setCookies.cgi", false);
+        xhr.setRequestHeader("SET_COOKIE", cookie);
+        xhr.send(null);
+        if (xhr.status == 200) {
+            // This is to clear them later.
+            cookies.push(cookie);
+            return true;
+        } else
+            return false;
+    } catch (e) {
+        return false;
+    }
+}
+
+// Normalize a cookie string
+function normalizeCookie(cookie)
+{
+    // Split the cookie string, sort it and then put it back together.
+    return cookie.split('; ').sort().join('; ');
+}
+
+// We get the cookies throught an XMLHttpRequest.
+function testCookies(result)
+{
+    var xhr = new XMLHttpRequest();
+    xhr.open("GET", "resources/getCookies.cgi", false);
+    xhr.send(null);
+    var cookie = xhr.getResponseHeader("HTTP_COOKIE") == null ? '"null"' : xhr.getResponseHeader("HTTP_COOKIE");
+
+    // Normalize the cookie strings.
+    result = normalizeCookie(result);
+    cookie = normalizeCookie(cookie);
+    
+    if (cookie === result)
+        testPassed("cookie is '" + cookie + "'.");
+    else
+        testFailed("cookie was '" + cookie + "'. Expected '" + result + "'.");
+}
+
+function clearAllCookies()
+{
+    var cookieString;
+    while (cookieString = document.cookie) {
+        var cookieName = cookieString.substr(0, cookieString.indexOf("=") || cookieString.length());
+        cookies.push(cookieName);
+        clearCookies();
+    }
+}
+
+function clearCookies()
+{
+    if (!cookies.length)
+        return;
+
+    try {
+        var xhr = new XMLHttpRequest();
+        var cookie;
+        // We need to clean one cookie at a time because to be cleared the
+        // cookie must be exactly the same except for the "Max-Age"
+        // and "Expires" fields.
+        while (cookie = cookies.pop()) {
+            xhr.open("GET", "resources/clearCookies.cgi", false);
+            xhr.setRequestHeader("CLEAR_COOKIE", cookie);
+            xhr.send(null);
+        }
+    } catch (e) {
+        debug("Could not clear the cookies expect the following results to fail");
+    }
+}
+
+// This method check one cookie at a time.
+function cookiesShouldBe(cookiesToSet, result)
+{
+    if (!setCookies(cookiesToSet)) {
+        testFailed("could not set cookie(s) " + cookiesToSet);
+        return;
+    }
+    testCookies(result);
+}