<!DOCTYPE html>
<script src='../../resources/testharness.js'></script>
<script src='../../resources/testharnessreport.js'></script>
<script src='resources/streams-utils.js'></script>
<script>
// This is updated till https://github.com/whatwg/streams/commit/4ba861e6f60c248060811830e11271c84b439cc3

function writeArrayToStream(array, writableStream) {
    array.forEach(function(chunk) { writableStream.write(chunk); })
    return writableStream.close();
}

var test1 = async_test('error argument is given to start method');
test1.step(function() {
    var error;
    var ws = new WritableStream({
        start: function(error_) {
            error = error_;
        }
    });

    // Now error the stream after its construction.
    var passedError = new Error('horrible things');
    error(passedError);
    assert_equals(ws.state, 'errored');
    ws.closed.catch(test1.step_func(function(r) {
        assert_equals(r, passedError);
        test1.done();
    }));
});

var test2 = async_test('Underlying sink\'s write won\'t be called until start finishes');
test2.step(function() {
    var expectWriteCall = false;

    var resolveStartPromise;
    var ws = new WritableStream({
        start: function() {
            return new Promise(test2.step_func(function(resolve) { resolveStartPromise = resolve; }));
        },
        write: function(chunk) {
            if (expectWriteCall) {
                assert_equals(chunk, 'a');
                test2.done();
            } else {
                assert_unreached('Unexpected write call');
            }
        },
        close: function() {
            assert_unreached('Unexpected close call');
        }
    });

    ws.write('a');
    assert_equals(ws.state, 'waiting', 'writable stream should be waiting, not ' + ws.state);

    // Wait and see that write won't be called.
    setTimeout(test2.step_func(function() {
        expectWriteCall = true;
        resolveStartPromise();
    }), 200);
});

var test3 = async_test('Underlying sink\'s close won\'t be called until start finishes');
test3.step(function() {
    var expectCloseCall = false;

    var resolveStartPromise;
    var ws = new WritableStream({
        start: function() {
            return new Promise(test3.step_func(function(resolve, reject) { resolveStartPromise = resolve; }));
        },
        write: function(chunk) {
            assert_unreached('Unexpected write call');
        },
        close: function() {
            if (expectCloseCall) {
                test3.done();
            } else {
                assert_unreached('Unexpected close call');
            }
        }
    });
    ws.close('a');
    assert_equals(ws.state, 'closing');

    // Wait and see that write won't be called.
    setTimeout(test3.step_func(function() {
        expectCloseCall = true;
        resolveStartPromise();
    }), 200);
});

var test4 = async_test('Fulfillment value of ws.close() call must be undefined even if the underlying sink returns a non-undefined value');
test4.step(function() {
    var ws = new WritableStream({
        close: function() {
            return 'Hello';
        }
    });

    var closePromise = ws.close('a');
    closePromise.then(test4.step_func(function(value) {
        assert_equals(value, undefined, 'fulfillment value must be undefined');
        test4.done();
    })).catch(test4.step_func(function() {
        assert_unreached('closePromise is rejected');
    }));
});

var test5 = async_test('Underlying sink\'s write or close are never invoked if start throws');
test5.step(function() {
    var passedError = new Error('horrible things');

    try {
        var ws = new WritableStream({
            start: function() {
                throw passedError;
            },
            write: function(chunk) {
                assert_unreached('Unexpected write call');
            },
            close: function() {
                assert_unreached('Unexpected close call');
            }
        });
    } catch (e) {
        assert_equals(e, passedError);
        test5.done();
    }
    assert_unreached('Constructor didn\'t throw');
});

var test6 = async_test('Underlying sink\'s write or close are never invoked if the promise returned by start is rejected');
test6.step(function() {
    var ws = new WritableStream({
        start: function() {
            return Promise.reject();
        },
        write: function(chunk) {
            assert_unreached('Unexpected write call');
        },
        close: function() {
            assert_unreached('Unexpected close call');
        }
    });

    // Wait and see that write or close won't be called.
    setTimeout(test6.step_func(function() {
        test6.done();
    }), 500);
});

test(function() {
    new WritableStream() // WritableStream constructed with no errors.
}, 'WritableStream can be constructed with no arguments');

test(function() {
    var ws = new WritableStream();

    assert_equals(typeof ws.write, 'function', 'has a write method');
    assert_equals(typeof ws.abort, 'function', 'has an abort method');
    assert_equals(typeof ws.close, 'function', 'has a close method');

    assert_equals(ws.state, 'writable', 'state starts out writable');

    assert_true('ready' in ws, 'has a ready property');
    assert_true('then' in ws.ready, 'ready property is a thenable');
    assert_true('closed' in ws, 'has a closed property');
    assert_true('then' in ws.closed, 'closed property is thenable');
}, 'WritableStream instances have the correct methods and properties');

var test7 = async_test('WritableStream with simple input, processed asynchronously');
test7.step(function() {
    var storage;
    var ws = new WritableStream({
        start: function() {
            storage = [];
        },

        write: function(chunk) {
            return new Promise(test7.step_func(function(resolve) {
                setTimeout(test7.step_func(function() {
                    storage.push(chunk);
                    resolve();
                }), 0);
            }));
        },

        close: function() {
            return new Promise(test7.step_func(function(resolve) { setTimeout(test7.step_func(resolve), 0); }));
        }
    });

    var input = [1, 2, 3, 4, 5];
    writeArrayToStream(input, ws).then(
        test7.step_func(function() {
            assert_array_equals(storage, input, 'correct data was relayed to underlying sink');
            test7.done();
        }),
        test7.step_func(function(r) { assert_unreached(r); })
    );
});

var test8 = async_test('WritableStream with simple input, processed synchronously');
test8.step(function() {
    var storage;
    var ws = new WritableStream({
        start: function() {
            storage = [];
        },

        write: function(chunk) {
            storage.push(chunk);
        },
    });

    var input = [1, 2, 3, 4, 5];
    writeArrayToStream(input, ws).then(
        test8.step_func(function() {
            assert_array_equals(storage, input, 'correct data was relayed to underlying sink');
            test8.done();
        }),
        test8.step_func(function(r) { assert_unreached(r); })
    );
});

var test9 = async_test('WritableStream is writable and ready fulfills immediately if the strategy does not apply backpressure');
test9.step(function() {
    var ws = new WritableStream({}, {
        highWaterMark: Infinity,
        size() { return 0; }
    });

    assert_equals(ws.state, 'writable');

    ws.ready.then(test9.step_func(function() {
        test9.done('ready promise was fulfilled');
    }));
});

var test10 = async_test('Fulfillment value of ws.write() call must be undefined even if the underlying sink returns a non-undefined value');
test10.step(function() {
    var ws = new WritableStream({
        write: function() {
            return 'Hello';
        }
    });

    var writePromise = ws.write('a');
    writePromise.then(test10.step_func(function(value) {
        assert_equals(value, undefined, 'fulfillment value must be undefined');
        test10.done();
    })).catch(test10.step_func(function() { assert_unreached('writePromise is rejected'); }));
});
</script>