<!doctype html>
<html>
<head>
<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
<script>
function test()
{
    let options = {
        workInterval: 100,
    };

    function createTaskItems(size = 5) {
        return Array(size).fill("test");
    }

    let suite = InspectorTest.createAsyncSuite("YieldableTask");

    suite.addTestCase({
        name: "ItemsAreProcessedInIterationOrder",
        description: "Check that yieldableTaskWillProcessItem delegate is called on input items in order.",
        test(resolve, reject) {
            let expectedItems = createTaskItems();
            let delegate = {
                yieldableTaskWillProcessItem: (task, item) => {
                    let expectedItem = expectedItems.shift();
                    InspectorTest.expectThat(item === expectedItem, "Item to process should be next expected item.");
                },
                yieldableTaskDidFinish: (task) => {
                    InspectorTest.log("The yieldable task finished.");
                    InspectorTest.expectThat(!task.cancelled, "Task should not be cancelled.");
                    InspectorTest.expectThat(!task.processing, "Task should not be processing.");
                    resolve();
                }
            };

            new WI.YieldableTask(delegate, expectedItems.slice(), options).start();
        }
    });

    suite.addTestCase({
        name: "ProcessedItemsArgumentContainsExpectedItems",
        description: "The list of processed items after a yield should contain the items that were processed by yieldableTaskWillProcessItem.",
        test(resolve, reject) {
            const itemsToProcessBeforeForcingTaskToYield = 10;
            let actualProcessedItems = [];

            let delegate = {
                yieldableTaskWillProcessItem: (task, item) => {
                    actualProcessedItems.push(item);
                    if (actualProcessedItems.length < itemsToProcessBeforeForcingTaskToYield)
                        return;

                    // Busy wait until workInterval is exceeded.
                    let startTime = Date.now();
                    while (Date.now() - startTime <= task.workInterval) {}
                },
                yieldableTaskDidYield: (task, processedItems, elapsedTime) => {
                    InspectorTest.expectThat(itemsToProcessBeforeForcingTaskToYield === processedItems.length, `processedItems argument should contain ${itemsToProcessBeforeForcingTaskToYield} items.`);
                    InspectorTest.expectThat(elapsedTime > 0, "Time to process items before yielding should be greater than zero.");
                    InspectorTest.expectThat(Object.shallowEqual(processedItems, actualProcessedItems), "processedItems argument should contain all items processed since the previous yield.");
                    actualProcessedItems = [];
                },
                yieldableTaskDidFinish: (task) => {
                    InspectorTest.log("Finished processing items.");
                    resolve();
                }
            };

            new WI.YieldableTask(delegate, createTaskItems(40), options).start();
        }
    });

    suite.addTestCase({
        name: "TaskFinishesWhenInterruptedByCancellation",
        description: "Check that a task can be cancelled.",
        test(resolve, reject) {
            let items = createTaskItems(40);
            let delegate = {
                yieldableTaskWillProcessItem: (task, item) => {
                    InspectorTest.log("Process item: " + JSON.stringify(item));
                    task.cancel();
                },
                yieldableTaskDidFinish: (task) => {
                    InspectorTest.log("Finished processing items.");
                    InspectorTest.expectThat(!task.processing, "Task should not be processing.");
                    InspectorTest.expectThat(task.cancelled, "Task should be cancelled.");
                    resolve();
                }
            };

            new WI.YieldableTask(delegate, items, options).start();
        }
    });

    suite.addTestCase({
        name: "ShortTaskCompletesWithoutYielding",
        description: "A task with very few items should run to completion without yielding.",
        test(resolve, reject) {
            let processedItemsCount = 0;

            let delegate = {
                yieldableTaskWillProcessItem: (task, item) => {},
                yieldableTaskDidYield: (task, processedItems, elapsedTime) => { processedItemsCount++; },
                yieldableTaskDidFinish: (task) => {
                    // Note: we expect a fake yield notification when the final item is processed, whether
                    // or not the task actually yielded the run loop.
                    InspectorTest.expectThat(processedItemsCount === 1, "Should process all items without yielding.");
                    InspectorTest.log("Finished processing items.");
                    InspectorTest.expectThat(!task.cancelled, "Task should not be cancelled.");
                    InspectorTest.expectThat(!task.processing, "Task should not be processing.");
                    resolve();
                }
            };

            new WI.YieldableTask(delegate, createTaskItems(50)).start();
        }
    });

    function addTestCaseForIterable(iterable, name) {
        suite.addTestCase({
            name: `ProcessItemsFrom${name}`,
            description: "Check that any iterable object is supported.",
            test(resolve, reject) {
                let delegate = {
                    yieldableTaskWillProcessItem: (task, item) => {
                        InspectorTest.log("Process item: " + JSON.stringify(item));
                    },
                    yieldableTaskDidFinish: (task) => {
                        InspectorTest.log("Finished processing items.");
                        InspectorTest.expectThat(!task.cancelled, "Task should not be cancelled.");
                        InspectorTest.expectThat(!task.processing, "Task should not be processing.");
                        resolve();
                    }
                };

                new WI.YieldableTask(delegate, iterable).start();
            }
        });
    }

    function* gen() {
        let i = 0;
        while (i < 8)
            yield 1 << i++;
    }
    addTestCaseForIterable(gen(), "Generator");

    let map = new Map;
    map.set(1, "one");
    map.set(2, "two");
    map.set(3, "three");
    addTestCaseForIterable(map, "Map");

    let set = new Set;
    set.add(1);
    set.add(2);
    set.add(3);
    addTestCaseForIterable(set, "Set");

    suite.runTestCasesAndFinish();
}
</script>
</head>
<body onload="runTest()">
    <p>Testing WI.YieldableTask.</p>
</body>
</html>