'use strict';

if (self.importScripts) {
  self.importScripts('../resources/rs-utils.js');
  self.importScripts('/resources/testharness.js');
}

let ReadableStreamBYOBReader;

test(() => {

  // It's not exposed globally, but we test a few of its properties here.
  ReadableStreamBYOBReader = (new ReadableStream({ type: 'bytes' }))
      .getReader({ mode: 'byob' }).constructor;

}, 'Can get the ReadableStreamBYOBReader constructor indirectly');

test(() => {

  assert_throws(new TypeError(), () => new ReadableStreamBYOBReader('potato'));
  assert_throws(new TypeError(), () => new ReadableStreamBYOBReader({}));
  assert_throws(new TypeError(), () => new ReadableStreamBYOBReader());

}, 'ReadableStreamBYOBReader constructor should get a ReadableStream object as argument');

test(() => {

  const methods = ['cancel', 'constructor', 'read', 'releaseLock'];
  const properties = methods.concat(['closed']).sort();

  const rsReader = new ReadableStreamBYOBReader(new ReadableStream({ type: 'bytes' }));
  const proto = Object.getPrototypeOf(rsReader);

  assert_array_equals(Object.getOwnPropertyNames(proto).sort(), properties);

  for (const m of methods) {
    const propDesc = Object.getOwnPropertyDescriptor(proto, m);
    assert_equals(propDesc.enumerable, false, 'method should be non-enumerable');
    assert_equals(propDesc.configurable, true, 'method should be configurable');
    assert_equals(propDesc.writable, true, 'method should be writable');
    assert_equals(typeof rsReader[m], 'function', 'should have be a method');
    const expectedName = m === 'constructor' ? 'ReadableStreamBYOBReader' : m;
    assert_equals(rsReader[m].name, expectedName, 'method should have the correct name');
  }

  const closedPropDesc = Object.getOwnPropertyDescriptor(proto, 'closed');
  assert_equals(closedPropDesc.enumerable, false, 'closed should be non-enumerable');
  assert_equals(closedPropDesc.configurable, true, 'closed should be configurable');
  assert_not_equals(closedPropDesc.get, undefined, 'closed should have a getter');
  assert_equals(closedPropDesc.set, undefined, 'closed should not have a setter');

  assert_equals(rsReader.cancel.length, 1, 'cancel has 1 parameter');
  assert_not_equals(rsReader.closed, undefined, 'has a non-undefined closed property');
  assert_equals(typeof rsReader.closed.then, 'function', 'closed property is thenable');
  assert_equals(rsReader.constructor.length, 1, 'constructor has 1 parameter');
  assert_equals(rsReader.read.length, 1, 'read has 1 parameter');
  assert_equals(rsReader.releaseLock.length, 0, 'releaseLock has no parameters');

}, 'ReadableStreamBYOBReader instances should have the correct list of properties');

promise_test(t => {

  const rs = new ReadableStream({
    pull(controller) {
      return t.step(() => {
        const byobRequest = controller.byobRequest;

        const methods = ['constructor', 'respond', 'respondWithNewView'];
        const properties = methods.concat(['view']).sort();

        const proto = Object.getPrototypeOf(byobRequest);

        assert_array_equals(Object.getOwnPropertyNames(proto).sort(), properties);

        for (const m of methods) {
          const propDesc = Object.getOwnPropertyDescriptor(proto, m);
          assert_equals(propDesc.enumerable, false, 'method should be non-enumerable');
          assert_equals(propDesc.configurable, true, 'method should be configurable');
          assert_equals(propDesc.writable, true, 'method should be writable');
          assert_equals(typeof byobRequest[m], 'function', 'should have a method');
          const expectedName = m === 'constructor' ? 'ReadableStreamBYOBRequest' : m;
          assert_equals(byobRequest[m].name, expectedName, 'method should have the correct name');
        }

        const viewPropDesc = Object.getOwnPropertyDescriptor(proto, 'view');
        assert_equals(viewPropDesc.enumerable, false, 'view should be non-enumerable');
        assert_equals(viewPropDesc.configurable, true, 'view should be configurable');
        assert_not_equals(viewPropDesc.get, undefined, 'view should have a getter');
        assert_equals(viewPropDesc.set, undefined, 'view should not have a setter');
        assert_not_equals(byobRequest.view, undefined, 'has a non-undefined view property');
        assert_equals(byobRequest.constructor.length, 0, 'constructor has 0 parameters');
        assert_equals(byobRequest.respond.length, 1, 'respond has 1 parameter');
        assert_equals(byobRequest.respondWithNewView.length, 1, 'releaseLock has 1 parameter');

        byobRequest.respond(1);

      });
    },
    type: 'bytes' });
  const reader = rs.getReader({ mode: 'byob' });
  return reader.read(new Uint8Array(1));

}, 'ReadableStreamBYOBRequest instances should have the correct list of properties');

test(() => {

  const methods = ['close', 'constructor', 'enqueue', 'error'];
  const accessors = ['byobRequest', 'desiredSize'];
  const properties = methods.concat(accessors).sort();

  let controller;
  new ReadableStream({
    start(c) {
      controller = c;
    },
    type: 'bytes'
  });
  const proto = Object.getPrototypeOf(controller);

  assert_array_equals(Object.getOwnPropertyNames(proto).sort(), properties);

  for (const m of methods) {
    const propDesc = Object.getOwnPropertyDescriptor(proto, m);
    assert_equals(propDesc.enumerable, false, 'method should be non-enumerable');
    assert_equals(propDesc.configurable, true, 'method should be configurable');
    assert_equals(propDesc.writable, true, 'method should be writable');
    assert_equals(typeof controller[m], 'function', 'should have be a method');
    const expectedName = m === 'constructor' ? 'ReadableByteStreamController' : m;
    assert_equals(controller[m].name, expectedName, 'method should have the correct name');
  }

  for (const a of accessors) {
    const propDesc = Object.getOwnPropertyDescriptor(proto, a);
    assert_equals(propDesc.enumerable, false, `${a} should be non-enumerable`);
    assert_equals(propDesc.configurable, true, `${a} should be configurable`);
    assert_not_equals(propDesc.get, undefined, `${a} should have a getter`);
    assert_equals(propDesc.set, undefined, `${a} should not have a setter`);
  }

  assert_equals(controller.close.length, 0, 'cancel has no parameters');
  assert_equals(controller.constructor.length, 0, 'constructor has no parameters');
  assert_equals(controller.enqueue.length, 1, 'enqueue has 1 parameter');
  assert_equals(controller.error.length, 1, 'releaseLock has 1 parameter');

}, 'ReadableByteStreamController instances should have the correct list of properties');

done();