shared-storage/setters.tentative.https.sub.html

<!doctype html>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>

<body>
<script>
'use strict';

promise_test(async t => {
  return promise_rejects_js(t, TypeError, sharedStorage.set());
}, 'sharedStorage.set with 0 argument');

promise_test(async t => {
  return promise_rejects_js(t, TypeError, sharedStorage.set("a"));
}, 'sharedStorage.set with 1 argument');

promise_test(() => {
  return sharedStorage.set("a", "b");
}, 'sharedStorage.set with 2 arguments');

promise_test(() => {
  return sharedStorage.set("a", "b", {ignoreIfPresent: true});
}, 'sharedStorage.set with options');

promise_test(async t => {
  return promise_rejects_js(t, TypeError, sharedStorage.set("a", "b", "c"));
}, 'sharedStorage.set with invalid options');

promise_test(async t => {
  try {
      await sharedStorage.set('', 'b');
  } catch (e) {
    assert_equals(e.name, 'DataError');
    return;
  }
  assert_unreached("did not reject");
}, 'sharedStorage.set with empty key');

promise_test(() => {
  return sharedStorage.append("a", "b");
}, 'sharedStorage.append');

promise_test(() => {
  return sharedStorage.clear();
}, 'sharedStorage.clear');

promise_test(() => {
  return sharedStorage.delete("a");
}, 'sharedStorage.delete');

test(() => {
  try {
    let a = new SharedStorageSetMethod('a');
  } catch (e) {
    assert_equals(e.name, 'TypeError');
    return;
  }
  assert_unreached("did not throw");
}, 'new SharedStorageSetMethod with 1 argument');

test(() => {
  let a = new SharedStorageSetMethod('a', 'b');
}, 'new SharedStorageSetMethod with 2 arguments');

test(() => {
  try {
    let a = new SharedStorageAppendMethod('a');
  } catch (e) {
    assert_equals(e.name, 'TypeError');
    return;
  }
  assert_unreached("did not throw");
}, 'new SharedStorageAppendMethod with 1 argument');

test(() => {
  let a = new SharedStorageAppendMethod('a', 'b');
}, 'new SharedStorageAppendMethod with 2 arguments');

test(() => {
  try {
    let a = new SharedStorageDeleteMethod();
  } catch (e) {
    assert_equals(e.name, 'TypeError');
    return;
  }
  assert_unreached("did not throw");
}, 'new SharedStorageDeleteMethod with no arguments');

test(() => {
  let a = new SharedStorageDeleteMethod('a');
}, 'new SharedStorageDeleteMethod with 1 argument');

test(() => {
  try {
    let a = SharedStorageClearMethod();
  } catch (e) {
    assert_equals(e.name, 'TypeError');
    return;
  }
  assert_unreached("did not throw");
}, 'call SharedStorageClearMethod() as a function');

test(() => {
  let a = new SharedStorageClearMethod();
}, 'new SharedStorageClearMethod with no arguments');

promise_test(() => {
  return sharedStorage.batchUpdate([
    new SharedStorageSetMethod("key0", "value0"),
    new SharedStorageAppendMethod("key1", "value1"),
    new SharedStorageDeleteMethod("key2"),
    new SharedStorageClearMethod()
  ], {withLock: "lock3"});
}, 'sharedStorage.batchUpdate');

promise_test(async t => {
  return promise_rejects_js(t, TypeError, sharedStorage.batchUpdate());
}, 'sharedStorage.batchUpdate without \'methods\' argument');

promise_test(async t => {
  return promise_rejects_js(t, TypeError, sharedStorage.batchUpdate(["123"]));
}, 'sharedStorage.batchUpdate with invalid \'methods\' argument');

</script>
</body>