if (self.importScripts) {
  importScripts('../resources/fetch-test-helpers.js');
  importScripts('/streams/resources/rs-utils.js');
}

function isLocked(stream) {
  try {
    var reader = stream.getReader();
    reader.releaseLock();
    return false;
  } catch(e) {
    return true;
  }
}

promise_test(function(test) {
    return fetch('/fetch/resources/doctype.html')
      .then(function(response) {
          // Accessing the body property makes the stream start working.
          var stream = response.body;
          return response.text();
        })
      .then(function(text) {
          assert_equals(text, '<!DOCTYPE html>\n');
        })
    }, 'FetchTextAfterAccessingStreamTest');

promise_test(function(test) {
    var actual = '';
    return fetch('/fetch/resources/doctype.html')
      .then(function(response) {
          r = response;
          return readableStreamToArray(response.body);
        })
      .then(function(chunks) {
          var decoder = new TextDecoder();
          for (var chunk of chunks) {
            actual += decoder.decode(chunk, {stream: true});
          }
          // Put an empty buffer without the stream option to end decoding.
          actual += decoder.decode(new Uint8Array(0));
          assert_equals(actual, '<!DOCTYPE html>\n');
        })
    }, 'FetchStreamTest');

promise_test(function(test) {
    return fetch('/fetch/resources/progressive.php')
      .then(function(response) {
          var p1 = response.text();
          // Because progressive.php takes some time to load, we expect
          // response.text() is not yet completed here.
          var p2 = response.text().then(function() {
              return Promise.reject(new Error('resolved unexpectedly'));
            }, function(e) {
              return e;
            });
          return Promise.all([p1, p2]);
        })
      .then(function(results) {
          assert_equals(results[0].length, 190);
          assert_equals(results[1].name, 'TypeError');
        })
    }, 'FetchTwiceTest');

promise_test(function(test) {
    var response;
    return fetch('/fetch/resources/doctype.html')
      .then(function(res) {
          response = res;
          assert_false(response.bodyUsed);
          var p = response.arrayBuffer();
          assert_true(response.bodyUsed);
          assert_true(isLocked(response.body));
          return p;
        })
      .then(function(b) {
          assert_true(isLocked(response.body));
          assert_equals(b.byteLength, 16);
        })
    }, 'ArrayBufferTest');

promise_test(function(test) {
    var response;
    return fetch('/fetch/resources/doctype.html')
      .then(function(res) {
          response = res;
          assert_false(response.bodyUsed);
          var p = response.blob();
          assert_true(response.bodyUsed);
          assert_true(isLocked(response.body));
          return p;
        })
      .then(function(blob) {
          assert_true(isLocked(response.body));
          assert_equals(blob.size, 16);
          assert_equals(blob.type, 'text/html');
        })
    }, 'BlobTest');

promise_test(function(test) {
    var response;
    return fetch('/fetch/resources/doctype.html')
      .then(function(res) {
          response = res;
          assert_false(response.bodyUsed);
          var p = response.formData();
          assert_true(response.bodyUsed);
          assert_true(isLocked(response.body));
          return p;
        })
      .then(
        unreached_fulfillment(test),
        function(e) {
          assert_true(isLocked(response.body));
          assert_equals(e.name, 'TypeError', 'expected MIME type error');
        })
    }, 'FormDataFailedTest');

promise_test(function(test) {
    var response;
    return fetch('/fetch/resources/doctype.html')
      .then(function(res) {
          response = res;
          assert_false(response.bodyUsed);
          var p = response.json();
          assert_true(response.bodyUsed);
          assert_true(isLocked(response.body));
          return p;
        })
      .then(
        test.unreached_func('json() must fail'),
        function(e) {
          assert_true(isLocked(response.body));
          assert_equals(e.name, 'SyntaxError', 'expected JSON error');
        })
    }, 'JSONFailedTest');

promise_test(function(test) {
    var response;
    return fetch('/fetch/resources/simple.json')
      .then(function(res) {
          response = res;
          assert_false(response.bodyUsed);
          var p = response.json();
          assert_true(response.bodyUsed);
          assert_true(isLocked(response.body));
          return p;
        })
      .then(function(json) {
          assert_true(isLocked(response.body));
          assert_equals(json['a'], 1);
          assert_equals(json['b'], 2);
        })
    }, 'JSONTest');

promise_test(function(test) {
    var response;
    return fetch('/fetch/resources/doctype.html')
      .then(function(res) {
          response = res;
          assert_false(response.bodyUsed);
          var p = response.text();
          assert_true(response.bodyUsed);
          assert_true(isLocked(response.body));
          return p;
        })
      .then(function(text) {
          assert_true(isLocked(response.body));
          assert_equals(text, '<!DOCTYPE html>\n');
        })
    }, 'TextTest');

promise_test(function(test) {
    return fetch('/fetch/resources/non-ascii.txt')
      .then(function(response) {
          assert_false(response.bodyUsed);
          var p = response.text();
          assert_true(response.bodyUsed);
          return p;
        })
      .then(function(text) {
          assert_equals(text, '\u4e2d\u6587 Gem\u00fcse\n');
        })
    }, 'NonAsciiTextTest');

promise_test(function(test) {
    return fetch('/fetch/resources/bom-utf-8.php')
      .then(function(response) { return response.text(); })
      .then(function(text) {
          assert_equals(text, '\u4e09\u6751\u304b\u306a\u5b50',
                        'utf-8 string with BOM is decoded as utf-8 and ' +
                        'BOM is not included in the decoded result.');
        })
    }, 'BOMUTF8Test');

promise_test(function(test) {
    return fetch('/fetch/resources/bom-utf-16le.php')
      .then(function(response) { return response.text(); })
      .then(function(text) {
          assert_equals(text, '\ufffd\ufffd\tNQgK0j0P[',
                        'utf-16le string is decoded as if utf-8 ' +
                        'even if the data has utf-16le BOM.');
        })
    }, 'BOMUTF16LETest');

promise_test(function(test) {
    return fetch('/fetch/resources/bom-utf-16be.php')
      .then(function(response) { return response.text(); })
      .then(function(text) {
          assert_equals(text, '\ufffd\ufffdN\tgQ0K0j[P',
                        'utf-16be string is decoded as if utf-8 ' +
                        'even if the data has utf-16be BOM.');
        })
    }, 'BOMUTF16BETest');

test(t => {
    var req = new Request('/');
    assert_false(req.bodyUsed);
    req.text();
    assert_false(req.bodyUsed);
  }, 'BodyUsedShouldNotBeSetForNullBody');

test(t => {
    var req = new Request('/', {method: 'POST', body: ''});
    assert_false(req.bodyUsed);
    req.text();
    assert_true(req.bodyUsed);
  }, 'BodyUsedShouldBeSetForEmptyBody');

test(t => {
    var res = new Response('');
    assert_false(res.bodyUsed);
    var reader = res.body.getReader();
    assert_false(res.bodyUsed);
    reader.read();
    assert_true(res.bodyUsed);
  }, 'BodyUsedShouldBeSetWhenRead');

test(t => {
    var res = new Response('');
    assert_false(res.bodyUsed);
    var reader = res.body.getReader();
    assert_false(res.bodyUsed);
    reader.cancel();
    assert_true(res.bodyUsed);
  }, 'BodyUsedShouldBeSetWhenCancelled');

promise_test(t => {
    var res = new Response('');
    res.body.cancel();
    return res.arrayBuffer().then(unreached_fulfillment(t), e => {
        assert_equals(e.name, 'TypeError');
      });
  }, 'Used => arrayBuffer');

promise_test(t => {
    var res = new Response('');
    res.body.cancel();
    return res.blob().then(unreached_fulfillment(t), e => {
        assert_equals(e.name, 'TypeError');
      });
  }, 'Used => blob');

promise_test(t => {
    var res = new Response('');
    res.body.cancel();
    return res.formData().then(unreached_fulfillment(t), e => {
        assert_equals(e.name, 'TypeError');
      });
  }, 'Used => formData');

promise_test(t => {
    var res = new Response('');
    res.body.cancel();
    return res.json().then(unreached_fulfillment(t), e => {
        assert_equals(e.name, 'TypeError');
      });
  }, 'Used => json');

promise_test(t => {
    var res = new Response('');
    res.body.cancel();
    return res.text().then(unreached_fulfillment(t), e => {
        assert_equals(e.name, 'TypeError');
      });
  }, 'Used => text');

promise_test(t => {
    var res = new Response('');
    const reader = res.body.getReader();
    return res.arrayBuffer().then(unreached_fulfillment(t), e => {
        // TODO(yhirano): Use finally when it's available. Ditto below.
        reader.releaseLock();
        assert_equals(e.name, 'TypeError');
      });
  }, 'Locked => arrayBuffer');

promise_test(t => {
    var res = new Response('');
    const reader = res.body.getReader();
    return res.blob().then(unreached_fulfillment(t), e => {
        reader.releaseLock();
        assert_equals(e.name, 'TypeError');
      });
  }, 'Locked => blob');

promise_test(t => {
    var res = new Response('');
    const reader = res.body.getReader();
    return res.formData().then(unreached_fulfillment(t), e => {
        reader.releaseLock();
        assert_equals(e.name, 'TypeError');
      });
  }, 'Locked => formData');

promise_test(t => {
    var res = new Response('');
    const reader = res.body.getReader();
    return res.json().then(unreached_fulfillment(t), e => {
        reader.releaseLock();
        assert_equals(e.name, 'TypeError');
      });
  }, 'Locked => json');

promise_test(t => {
    var res = new Response('');
    const reader = res.body.getReader();
    return res.text().then(unreached_fulfillment(t), e => {
        reader.releaseLock();
        assert_equals(e.name, 'TypeError');
      });
  }, 'Locked => text');

promise_test(t => {
    return fetch('/fetch/resources/slow-failure.cgi').then(response => {
        return response.text().then(unreached_fulfillment(t), e => {
            assert_equals(e.name, 'TypeError');
          });
      });
  }, 'streaming error');

done();