if (this.importScripts) {
    importScripts('../../../resources/js-test.js');
    importScripts('shared.js');
}

description("Test structured clone permutations in IndexedDB.");

indexedDBTest(prepareDatabase, startTests);
function prepareDatabase()
{
    db = event.target.result;
    evalAndLog("store = db.createObjectStore('storeName')");
    debug("This index is not used, but evaluating key path on each put() call will exercise (de)serialization:");
    evalAndLog("store.createIndex('indexName', 'dummyKeyPath')");
}

function startTests()
{
    debug("");
    debug("Running tests...");
    var tests_to_run = [
        testUndefined,
        testNull,
        testBoolean,
        testNumber,
        testString,
        testBigInt,
        testBooleanObject,
        testNumberObject,
        testStringObject,
        testBigIntObject,
        testDateObject,
        testRegExpObject,
        testImageData,
        testBlob,
        testFile,
        testFileList,
        testObject,
        testArray,
        testTypedArray,
        testArrays,
        testMap,
        testSet,
        testGeometryTypes,
        testCryptoKey,
        testDOMExceptionObject
    ];

    function nextTest() {
        debug("");
        if (tests_to_run.length) {
            var test = tests_to_run.shift();
            test(nextTest); // When done, call this again.
        } else {
            testBadTypes();
        }
    }
    nextTest();
}

function forEachWithCallback(testFunction, values, callback)
{
    function nextValue() {
        if (values.length) {
            testFunction(values.shift(), nextValue);
        } else {
            callback();
        }
    }

    nextValue();
}

function testValue(value, callback)
{
    // One transaction per test, since some tests require asynchronous
    // operations to verify the result (e.g. via FileReader)
    evalAndLog("transaction = db.transaction('storeName', 'readwrite')");
    transaction.onerror = unexpectedErrorCallback;
    transaction.onabort = unexpectedAbortCallback;
    evalAndLog("store = transaction.objectStore('storeName')");

    self.value = value;
    request = evalAndLog("store.put(value, 'key')");
    request.onerror = unexpectedErrorCallback;
    request.onsuccess = function(e) {
        request = evalAndLog("store.get('key')");
        request.onerror = unexpectedErrorCallback;
        request.onsuccess = function(e) {
            callback(request.result);
        };
    };
}

// Identity testing, sensitive to NaN and -0
function is(x, y) {
    if (x === y) {
        return x !== 0 || 1 / x === 1 / y;
    }
    return x !== x && y !== y;
}

function arrayCompare(a, b) {
    if (a.length !== b.length) {
        return false;
    }
    for (var i = 0; i < a.length; ++i) {
        if (!is(a[i], b[i])) {
            return false;
        }
    }
    return true;
}

function testPrimitiveValue(string, callback)
{
    debug("Testing: " + string);
    var value = eval("value = (" + string + ")");
    test_data = value;
    testValue(test_data, function(result) {
        self.result = result;
        shouldBeTrue("is(test_data, result)");
        callback();
    });
}

function testObjectWithValue(string, callback)
{
    debug("Testing: " + string);
    var value = eval("value = (" + string + ")");
    test_data = value;
    testValue(test_data, function(result) {
        self.result = result;
        shouldBeEqualToString("typeof result", "object");
        shouldBe("Object.prototype.toString.call(result)", "Object.prototype.toString.call(test_data)");
        shouldBeTrue("test_data !== result");
        shouldBe("result.toString()", "test_data.toString()");
        shouldBeTrue("is(test_data.valueOf(), result.valueOf())");
        callback();
    });
}

function testUndefined(callback)
{
    testPrimitiveValue("undefined", callback);
}

function testNull(callback)
{
    testPrimitiveValue("null", callback);
}

function testBoolean(callback)
{
    debug("Testing boolean primitives");
    forEachWithCallback(testPrimitiveValue, ["true", "false"], callback);
}

function testBooleanObject(callback)
{
    debug("Testing Boolean objects");
    forEachWithCallback(testObjectWithValue, [
        "new Boolean(true)",
        "new Boolean(false)"
    ], callback);
}

function testString(callback)
{
    debug("Testing string primitives");
    forEachWithCallback(testPrimitiveValue, [
        "''",
        "'this is a sample string'",
        "'null(\\0)'"
    ], callback);
}

function testStringObject(callback)
{
    debug("Testing String objects");
    forEachWithCallback(testObjectWithValue, [
        "new String()",
        "new String('this is a sample string')",
        "new String('null(\\0)')"
    ], callback);
}

function testNumber(callback)
{
    debug("Testing number primitives");
    forEachWithCallback(testPrimitiveValue, [
        "NaN",
        "-Infinity",
        "-Number.MAX_VALUE",
        "-0xffffffff",
        "-0x80000000",
        "-0x7fffffff",
        "-1",
        "-Number.MIN_VALUE",
        "-0",
        "0",
        "1",
        "Number.MIN_VALUE",
        "0x7fffffff",
        "0x80000000",
        "0xffffffff",
        "Number.MAX_VALUE",
        "Infinity"
    ], callback);
}

function testNumberObject(callback)
{
    debug("Testing Number objects");
    forEachWithCallback(testObjectWithValue, [
        "new Number(NaN)",
        "new Number(-Infinity)",
        "new Number(-Number.MAX_VALUE)",
        "new Number(-Number.MIN_VALUE)",
        "new Number(-0)",
        "new Number(0)",
        "new Number(Number.MIN_VALUE)",
        "new Number(Number.MAX_VALUE)",
        "new Number(Infinity)"
    ], callback);
}

function testBigInt(callback)
{
    debug("Testing BigInt primitives");
    forEachWithCallback(testPrimitiveValue, [
        "-12345678901234567890n",
        "-1n",
        "0n",
        "1n",
        "12345678901234567890n",
    ], callback);
}

function testBigIntObject(callback)
{
    debug("Testing BigInt objects");
    function testOneBigIntObject(string, callback) {
        debug("Testing BigInt object: " + string);
        var value = eval("value = (" + string + ")");
        test_data = value;
        testValue(test_data, function(result) {
            self.result = result;
            shouldBeEqualToString("typeof result", "bigint");
            shouldBe("test_data.toString()", "result.toString()");
            callback();
        });
    }
    forEachWithCallback(testOneBigIntObject, [
        "BigInt(-12345678901234567890)",
        "BigInt(-1)",
        "BigInt(0)",
        "BigInt(1)",
        "BigInt(-0)",
        "BigInt('0x1fffffffffffff')"
    ], callback);
}

function testDateObject(callback)
{
    debug("Testing Date objects");
    forEachWithCallback(testObjectWithValue, [
        "new Date(-1e13)",
        "new Date(-1e12)",
        "new Date(-1e9)",
        "new Date(-1e6)",
        "new Date(-1e3)",
        "new Date(0)",
        "new Date(1e3)",
        "new Date(1e6)",
        "new Date(1e9)",
        "new Date(1e12)",
        "new Date(1e13)"
    ], callback);
}

function testRegExpObject(callback)
{
    debug("Testing RegExp objects");
    function testRegExp(string, callback) {
        debug("Testing RegExp: " + string);
        var value = eval("value = (" + string + ")");
        test_data = value;
        testValue(test_data, function(result) {
            self.result = result;
            shouldBeTrue("test_data !== result");
            shouldBeEqualToString("Object.prototype.toString.call(result)", "[object RegExp]");
            shouldBe("result.toString()", "test_data.toString()");
            debug("");
            callback();
        });
    }

    forEachWithCallback(testRegExp, [
        "new RegExp()",
        "/abc/",
        "/abc/g",
        "/abc/i",
        "/abc/gi",
        "/abc/m",
        "/abc/mg",
        "/abc/mi",
        "/abc/mgi"
    ], callback);
}

function testImageData(callback)
{
    debug("Testing ImageData");
    function testImageData(colorSpace, callback) {
        debug(`Testing ImageData: { colorSpace: ${colorSpace} }`);
        evalAndLog("canvas = document.createElement('canvas')");
        evalAndLog("canvas.width = 8");
        evalAndLog("canvas.height = 8");
        evalAndLog(`test_data = canvas.getContext('2d').getImageData(0, 0, 8, 8, { colorSpace: ${colorSpace} })`);

        for (var i = 0; i < 256; ++i) {
            test_data.data[i] = i;
        }

        testValue(test_data, function(result) {
            self.result = result;
            shouldBeTrue("test_data !== result");
            shouldBeEqualToString("Object.prototype.toString.call(result)", "[object ImageData]");
            shouldBe("result.width", "test_data.width");
            shouldBe("result.height", "test_data.height");
            shouldBe("result.data.length", "test_data.data.length");
            shouldBe("result.colorSpace", "test_data.colorSpace");
            if (arrayCompare(test_data.data, result.data)) {
                testPassed("result data matches");
            } else {
                testFailed("result data doesn't match");
            }
            callback();
        });
    }

    forEachWithCallback(testImageData, [
        `"srgb"`,
        `undefined`
    ], callback);
}

function readBlobAsText(blob, callback)
{
    var reader = new FileReader();
    reader.onload = function(e) {
        if (e.target.readyState === FileReader.DONE) {
            callback(e.target.result);
        }
    };
    reader.onerror = function(e) {
        testFailed("Error reading blob as text: " + e);
        finishJSTest();
    };
    reader.readAsText(blob);
}

function checkBlobContents(blob, expected, callback)
{
    readBlobAsText(blob, function(text) {
        self.text = text;
        shouldBeEqualToString("text", expected);
        callback();
    });
}

function compareBlobs(blob1, blob2, callback)
{
    readBlobAsText(blob1, function(text1) {
        readBlobAsText(blob2, function(text2) {
            self.text1 = text1;
            self.text2 = text2;
            shouldBeEqualToString("text2", text1);
            callback();
        });
    });
}

function testBlob(callback)
{
    debug("Testing Blob");
    shouldBeTrue("FileReader != null");
    evalAndLog("test_content = 'This is a test. This is only a test.'");
    evalAndLog("test_data = new Blob([test_content])");
    testValue(test_data, function(result) {
        self.result = result;
        shouldBeTrue("test_data !== result");
        shouldBeEqualToString("Object.prototype.toString.call(result)", "[object Blob]");
        shouldBe("result.size", "test_data.size");
        shouldBe("result.type", "test_data.type");
        checkBlobContents(result, test_content, callback);
    });
}

function compareFiles(file1, file2, callback)
{
    self.file1 = file1;
    self.file2 = file2;
    shouldBeTrue("file1 !== file2");
    shouldBeEqualToString("Object.prototype.toString.call(file1)", "[object File]");
    shouldBeEqualToString("Object.prototype.toString.call(file2)", "[object File]");
    shouldBe("file1.name", "file2.name");
    shouldBe("String(file1.lastModifiedDate)", "String(file2.lastModifiedDate)");
    if (callback) {
        compareBlobs(file1, file2, callback);
    }
}

function testFile(callback)
{
    debug("Testing File");
    evalAndLog("test_content = 'This is a test. This is only a test.'");
    evalAndLog("blob = new Blob([test_content])");
    evalAndLog("test_data = new File([blob], 'fileName')");
    testValue(test_data, function(result) {
        self.result = result;
        compareFiles(result, test_data, callback);
    });
}


function testFileList(callback)
{
    debug("Testing FileList");
    evalAndLog("test_data = document.getElementById('fileInput').files;");
    testValue(test_data, function(result) {
        self.result = result;
        shouldBeTrue("test_data !== result");
        shouldBeEqualToString("Object.prototype.toString.call(result)", "[object FileList]");
        shouldBe("result.length", "test_data.length");
        i = 0;
        function doNext() {
            if (i >= test_data.length) {
                callback();
            } else {
                debug("comparing file[" + i + "]");
                compareFiles(result[i], test_data[i++], doNext);
            }
        }
        doNext();
    });
}

function testArray(callback) 
{
    debug("Testing Array");
    evalAndLog("test_data = []");
    evalAndLog("test_data[0] = 'foo'");
    evalAndLog("test_data[1] = 'bar'");
    evalAndLog("test_data[10] = true");
    evalAndLog("test_data[11] = false");
    evalAndLog("test_data[20] = 123");
    evalAndLog("test_data[21] = 456");
    evalAndLog("test_data[30] = null");

    testValue(test_data, function(result) {
        self.result = result;
        shouldBeTrue("test_data !== result");
        shouldBeTrue("test_data.length === result.length");
        Object.keys(test_data).forEach(
            function(key) {
                shouldBe("test_data[" + key + "]", "result[" + key + "]");
            });
        callback();
    });
}

function testObject(callback) 
{
    debug("Testing Object");
    evalAndLog("test_data = []");
    evalAndLog("test_data[0] = 'foo'");
    evalAndLog("test_data[1] = 'bar'");
    evalAndLog("test_data['a'] = true");
    evalAndLog("test_data['b'] = false");
    evalAndLog("test_data['foo'] = 123");
    evalAndLog("test_data['bar'] = 456");
    evalAndLog("test_data[''] = null");

    testValue(test_data, function(result) {
        self.result = result;
        shouldBeTrue("test_data !== result");
        shouldBeTrue("arrayCompare(Object.keys(result).sort(), Object.keys(test_data).sort())");
        Object.keys(test_data).forEach(
            function(key) {
                shouldBe("test_data[" + JSON.stringify(key) + "]", "result[" + JSON.stringify(key) + "]");
            });
        callback();
    });
}

function testTypedArray(callback) 
{
    debug("Testing TypedArray");
    function testTypedArrayValue(string, callback) {
        evalAndLog("value = " + string);
        test_data = value;
        testValue(test_data, function(result) {
            self.result = result;
            shouldBeTrue("test_data !== result");
            shouldBe("Object.prototype.toString.call(result)", "Object.prototype.toString.call(test_data)");
            shouldBeTrue("test_data.length === result.length");
            for (i = 0; i < test_data.length; ++i) {
                shouldBeTrue("is(test_data[" + i + "], result[" + i + "])");
            }
            callback();
        });
    }

    forEachWithCallback(testTypedArrayValue, [
        "new Uint8Array([])",
        "new Uint8Array([0, 1, 254, 255])",
        "new Uint16Array([0x0000, 0x0001, 0xFFFE, 0xFFFF])",
        "new Uint32Array([0x00000000, 0x00000001, 0xFFFFFFFE, 0xFFFFFFFF])",
        "new Int8Array([0, 1, 254, 255])",
        "new Int16Array([0x0000, 0x0001, 0xFFFE, 0xFFFF])",
        "new Int32Array([0x00000000, 0x00000001, 0xFFFFFFFE, 0xFFFFFFFF])",
        "new Uint8ClampedArray([0, 1, 254, 255])",
        "new Float32Array([-Infinity, -1.5, -1, -0.5, 0, 0.5, 1, 1.5, Infinity, NaN])",
        "new Float64Array([-Infinity, -Number.MAX_VALUE, -Number.MIN_VALUE, 0, Number.MIN_VALUE, Number.MAX_VALUE, Infinity, NaN])",
        "new BigInt64Array([0x7fffffffffffffffn, 1n, 0n, -1n, -0x8000000000000000n])",
        "new BigUint64Array([0n, 0xffffffffffffffffn])",
    ], callback);
}

function testArrays(callback)
{
    debug("Testing Arrays");
    evalAndLog("test_data = []");
    evalAndLog("test_data[0] = []");
    evalAndLog("test_data[1] = [1, 2, 3]");
    evalAndLog("test_data[10] = Object.assign(['foo', 'bar'], {10: true, 11: false, 20: 123, 21: 456, 30: null})");
    evalAndLog("test_data[11] = Object.assign(['foo', 'bar'], {a: true, b: false, foo: 123, bar: 456, '': null})");
    testValue(test_data, function(result) {
        self.result = result;
        shouldBeTrue("test_data !== result");
        shouldBe("typeof test_data", "typeof result");
        shouldBeTrue("test_data.length === result.length");
        Object.keys(test_data).forEach((key) => {
            shouldBeTrue("arrayCompare(test_data[" + key + "], result[" + key + "])");
        });
        callback();
    });
}

function testMap(callback)
{
    debug("Testing Map");
    evalAndLog("test_data = new Map([[1,2],[3,4]])");
    testValue(test_data, function(result) {
        self.result = result;
        shouldBe("typeof test_data", "typeof result");
        shouldBe("test_data.size", "result.size");
        Object.keys(test_data).forEach((key) => {
            shouldBeTrue("test_data[" + key + "] === result[" + key + "]");
        });
        callback();
    });
}

function testSet(callback)
{
    debug("Testing Set");
    evalAndLog("test_data = new Set([1,2,3,4])");
    testValue(test_data, function(result) {
        self.result = result;
        shouldBe("typeof test_data", "typeof result");
        shouldBe("test_data.size", "result.size");
        for (var element of test_data)
            shouldBeTrue("result.has("+ element +")");
        callback();
    });
}

function testGeometryTypes(callback)
{
    debug("Testing geometry types");
    function testOneGeometryType(string, callback) {
        debug("Testing geometry type: " + string);
        var value = eval("value = (" + string + ")");
        test_data = value;
        testValue(test_data, function(result) {
            self.result = result;
            shouldBeTrue("test_data !== result");
            shouldBeEqualToString("typeof result", "object");
            shouldBe("Object.prototype.toString.call(test_data)", "Object.prototype.toString.call(result)");
            shouldBe("test_data.toString()", "result.toString()");
            callback();
        });
    }
    forEachWithCallback(testOneGeometryType, [
        "new DOMMatrix()",
        "new DOMMatrixReadOnly()",
        "new DOMPoint()",
        "new DOMPointReadOnly()",
        "new DOMRect()",
        "new DOMRectReadOnly()",
        "new DOMQuad()"
    ], callback);
}

function testCryptoKey(callback)
{
    debug("Testing CryptoKey");
    evalAndLog("promise = crypto.subtle.generateKey({ name: 'HMAC', hash: {name: 'SHA-512'}}, true, ['sign', 'verify']);");
    promise.then((test_data) => {
        self.test_data = test_data;
        testValue(test_data, function(result) {
            self.result = result;
            shouldBe("typeof test_data", "typeof result");
            shouldBe("test_data.type", "result.type");
            shouldBe("test_data.extractable", "result.extractable");
            shouldBe("test_data.algorithm.toString()", "result.algorithm.toString()");
            shouldBeTrue("arrayCompare(test_data.usages, result.usages)");
            callback();
        });
    });
}

function testDOMExceptionObject(callback)
{
    debug("Testing DOMException objects");
    function testDOMException(string, callback) {
        debug("Testing: " + string);
        var value = eval("value = (" + string + ")");
        test_data = value;
        testValue(test_data, function(result) {
            self.result = result;
            shouldBeEqualToString("typeof result", "object");
            shouldBe("Object.prototype.toString.call(result)", "Object.prototype.toString.call(test_data)");
            shouldBeTrue("test_data !== result");
            shouldBe("result.toString()", "test_data.toString()");
            callback();
        });
    }

    forEachWithCallback(testDOMException, [
        "new DOMException()",
        "new DOMException(\"message\")",
        "new DOMException(\"message\", \"name\")",
        "new DOMException(\"\", \"\")"
    ], callback);
}

function testBadTypes()
{
    debug("Test types that can't be cloned:");

    evalAndLog("transaction = db.transaction('storeName', 'readwrite')");
    evalAndLog("store = transaction.objectStore('storeName')");
    transaction.onerror = unexpectedErrorCallback;
    transaction.onabort = unexpectedAbortCallback;
    transaction.oncomplete = finishJSTest;

    debug("Testing Error");
    evalAndExpectException("store.put(new Error, 'key')", "DOMException.DATA_CLONE_ERR");
    debug("Testing Function");
    evalAndExpectException("store.put(new Function, 'key')", "DOMException.DATA_CLONE_ERR");

    debug("Testing other host object types");
    evalAndExpectException("store.put(self, 'key')", "DOMException.DATA_CLONE_ERR");
    evalAndExpectException("store.put(document, 'key')", "DOMException.DATA_CLONE_ERR");
    evalAndExpectException("store.put(document.body, 'key')", "DOMException.DATA_CLONE_ERR");
}