Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-09-02 11:08:22 +01:00
Code Issues Projects Releases Packages Wiki Activity

Update web-platform-tests to revision 3f3849c5d05f9350fad0b06d3bb3ae30d7e18d14

Browse source
This commit is contained in:
WPT Sync Bot 2019-07-24 10:23:41 +00:00
parent 9a7e2663e8
commit f767403c00
310 changed files with 8134 additions and 895 deletions
Download patch file Download diff file Expand all files Collapse all files

71
tests/wpt/web-platform-tests/cookie-store/cookieListItem_attributes.tentative.https.window.js
View file

@ -1,15 +1,5 @@
'use strict';
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
const kCurrentHostname = (new URL(self.location.href)).hostname;
const kOneDay = 24 * 60 * 60 * 1000;
@ -23,6 +13,9 @@ promise_test(async testCase => {
await cookieStore.delete('cookie-name');
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
@ -33,14 +26,15 @@ promise_test(async testCase => {
assert_equals(cookie.secure, true);
assert_equals(cookie.sameSite, 'strict');
assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'CookieListItem - cookieStore.set defaults with positional name and value');
promise_test(async testCase => {
await cookieStore.delete('cookie-name');
await cookieStore.set({ name: 'cookie-name', value: 'cookie-value' });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
@ -50,8 +44,6 @@ promise_test(async testCase => {
assert_equals(cookie.secure, true);
assert_equals(cookie.sameSite, 'strict');
assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'CookieListItem - cookieStore.set defaults with name and value in options');
promise_test(async testCase => {
@ -59,6 +51,9 @@ promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value',
{ expires: kTenYearsFromNow });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
@ -68,8 +63,6 @@ promise_test(async testCase => {
assert_equals(cookie.secure, true);
assert_equals(cookie.sameSite, 'strict');
assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'CookieListItem - cookieStore.set with expires set to a timestamp 10 ' +
'years in the future');
@ -78,6 +71,9 @@ promise_test(async testCase => {
await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
expires: kTenYearsFromNow });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
@ -87,8 +83,6 @@ promise_test(async testCase => {
assert_equals(cookie.secure, true);
assert_equals(cookie.sameSite, 'strict');
assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'CookieListItem - cookieStore.set with name and value in options and ' +
'expires set to a future timestamp');
@ -97,6 +91,9 @@ promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value',
{ expires: new Date(kTenYearsFromNow) });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
@ -104,8 +101,6 @@ promise_test(async testCase => {
assert_equals(cookie.path, '/');
assert_approx_equals(cookie.expires, kTenYearsFromNow, kOneDay);
assert_equals(cookie.secure, true);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'CookieListItem - cookieStore.set with expires set to a Date 10 ' +
'years in the future');
@ -114,6 +109,9 @@ promise_test(async testCase => {
await cookieStore.set({ name: 'cookie-name', value: 'cookie-value',
expires: new Date(kTenYearsFromNow) });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
@ -123,8 +121,6 @@ promise_test(async testCase => {
assert_equals(cookie.secure, true);
assert_equals(cookie.sameSite, 'strict');
assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'CookieListItem - cookieStore.set with name and value in options and ' +
'expires set to a future Date');
@ -133,6 +129,9 @@ promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value',
{ domain: kCurrentHostname });
testCase.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', domain: kCurrentHostname });
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
@ -142,10 +141,6 @@ promise_test(async testCase => {
assert_equals(cookie.secure, true);
assert_equals(cookie.sameSite, 'strict');
assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
await async_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', domain: kCurrentHostname });
});
}, 'CookieListItem - cookieStore.set with domain set to the current hostname');
promise_test(async testCase => {
@ -157,6 +152,9 @@ promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value',
{ path: currentDirectory });
testCase.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
@ -166,16 +164,15 @@ promise_test(async testCase => {
assert_equals(cookie.secure, true);
assert_equals(cookie.sameSite, 'strict');
assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
await async_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
});
}, 'CookieListItem - cookieStore.set with path set to the current directory');
promise_test(async testCase => {
await cookieStore.delete('cookie-name');
await cookieStore.set('cookie-name', 'cookie-value', { secure: false });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
@ -185,8 +182,6 @@ promise_test(async testCase => {
assert_equals(cookie.secure, false);
assert_equals(cookie.sameSite, 'strict');
assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'CookieListItem - cookieStore.set with secure set to false');
['strict', 'lax', 'unrestricted'].forEach(sameSiteValue => {
@ -195,6 +190,9 @@ promise_test(async testCase => {
await cookieStore.set({
name: 'cookie-name', value: 'cookie-value', sameSite: sameSiteValue });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
@ -204,8 +202,6 @@ promise_test(async testCase => {
assert_equals(cookie.secure, true);
assert_equals(cookie.sameSite, sameSiteValue);
assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, `CookieListItem - cookieStore.set with sameSite set to ${sameSiteValue}`);
promise_test(async testCase => {
@ -213,6 +209,9 @@ promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value',
{ sameSite: sameSiteValue });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
@ -222,8 +221,6 @@ promise_test(async testCase => {
assert_equals(cookie.secure, true);
assert_equals(cookie.sameSite, sameSiteValue);
assert_array_equals(Object.keys(cookie).sort(), kCookieListItemKeys);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'CookieListItem - cookieStore.set with positional name and value and ' +
`sameSite set to ${sameSiteValue}`);
});
});

53
tests/wpt/web-platform-tests/cookie-store/cookieStore_delete_arguments.tentative.https.window.js
View file

@ -1,15 +1,5 @@
'use strict';
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
@ -20,22 +10,24 @@ promise_test(async testCase => {
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await cookieStore.delete({ name: 'cookie-name' });
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie, null);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.delete with name in options');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await cookieStore.delete('cookie-name', { name: 'wrong-cookie-name' });
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie, null);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.delete with name in both positional arguments and options');
promise_test(async testCase => {
@ -43,14 +35,13 @@ promise_test(async testCase => {
const currentDomain = currentUrl.hostname;
await cookieStore.set(
'cookie-name', 'cookie-value', { domain: currentDomain });
testCase.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
});
await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie, null);
await async_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
});
}, 'cookieStore.delete with domain set to the current hostname');
promise_test(async testCase => {
@ -79,14 +70,13 @@ promise_test(async testCase => {
const currentDomain = currentUrl.hostname;
await cookieStore.set(
'cookie-name', 'cookie-value', { domain: currentDomain });
testCase.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
});
await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie, null);
await async_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
});
}, 'cookieStore.delete with name in options and domain set to the current ' +
'hostname');
@ -119,14 +109,13 @@ promise_test(async testCase => {
currentPath.substr(0, currentPath.lastIndexOf('/') + 1);
await cookieStore.set(
'cookie-name', 'cookie-value', { path: currentDirectory });
testCase.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
});
await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie, null);
async_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
});
}, 'cookieStore.delete with path set to the current directory');
promise_test(async testCase => {
@ -137,19 +126,21 @@ promise_test(async testCase => {
const subDirectory = currentDirectory + "subdir/";
await cookieStore.set(
'cookie-name', 'cookie-value', { path: currentDirectory });
testCase.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
});
await cookieStore.delete({ name: 'cookie-name', path: subDirectory });
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
});
}, 'cookieStore.delete with path set to subdirectory of the current directory');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie_attributes = await cookieStore.get('cookie-name');
assert_equals(cookie_attributes.name, 'cookie-name');
@ -158,6 +149,4 @@ promise_test(async testCase => {
await cookieStore.delete(cookie_attributes);
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie, null);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.delete with get result');

15
tests/wpt/web-platform-tests/cookie-store/cookieStore_event_basic.tentative.https.window.js
View file

@ -1,21 +1,14 @@
'use strict';
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
promise_test(async testCase => {
const eventPromise = new Promise((resolve) => {
cookieStore.onchange = resolve;
});
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const event = await eventPromise;
assert_true(event instanceof CookieChangeEvent);
@ -24,6 +17,4 @@ promise_test(async testCase => {
assert_equals(event.changed[0].name, 'cookie-name');
assert_equals(event.changed[0].value, 'cookie-value');
assert_equals(event.deleted.length, 0);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore fires change event for cookie set by cookieStore.set()');

15
tests/wpt/web-platform-tests/cookie-store/cookieStore_event_delete.tenative.https.window.js
View file

@ -1,17 +1,10 @@
'use strict';
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const eventPromise = new Promise((resolve) => {
cookieStore.onchange = resolve;
@ -26,6 +19,4 @@ promise_test(async testCase => {
event.deleted[0].value, undefined,
'Cookie change events for deletions should not have cookie values');
assert_equals(event.changed.length, 0);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore fires change event for cookie deleted by cookieStore.delete()');

15
tests/wpt/web-platform-tests/cookie-store/cookieStore_event_overwrite.tentative.https.window.js
View file

@ -1,17 +1,10 @@
'use strict';
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const eventPromise = new Promise((resolve) => {
cookieStore.onchange = resolve;
@ -26,6 +19,4 @@ promise_test(async testCase => {
assert_equals(event.changed[0].name, 'cookie-name');
assert_equals(event.changed[0].value, 'new-cookie-value');
assert_equals(event.deleted.length, 0);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore fires change event for cookie overwritten by cookieStore.set()');

79
tests/wpt/web-platform-tests/cookie-store/cookieStore_getAll_arguments.tentative.https.window.js
View file

@ -1,18 +1,14 @@
'use strict';
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await cookieStore.set('cookie-name-2', 'cookie-value-2');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name-2');
});
const cookies = await cookieStore.getAll();
cookies.sort((a, b) => a.name.localeCompare(b.name));
@ -21,53 +17,62 @@ promise_test(async testCase => {
assert_equals(cookies[0].value, 'cookie-value');
assert_equals(cookies[1].name, 'cookie-name-2');
assert_equals(cookies[1].value, 'cookie-value-2');
await async_cleanup(() => cookieStore.delete('cookie-name'));
await async_cleanup(() => cookieStore.delete('cookie-name-2'));
}, 'cookieStore.getAll with no arguments');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await cookieStore.set('cookie-name-2', 'cookie-value-2');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name-2');
});
const cookies = await cookieStore.getAll('cookie-name');
assert_equals(cookies.length, 1);
assert_equals(cookies[0].name, 'cookie-name');
assert_equals(cookies[0].value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
await async_cleanup(() => cookieStore.delete('cookie-name-2'));
}, 'cookieStore.getAll with positional name');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await cookieStore.set('cookie-name-2', 'cookie-value-2');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name-2');
});
const cookies = await cookieStore.getAll({ name: 'cookie-name' });
assert_equals(cookies.length, 1);
assert_equals(cookies[0].name, 'cookie-name');
assert_equals(cookies[0].value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
await async_cleanup(() => cookieStore.delete('cookie-name-2'));
}, 'cookieStore.getAll with name in options');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await cookieStore.set('cookie-name-2', 'cookie-value-2');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name-2');
});
const cookies = await cookieStore.getAll('cookie-name',
{ name: 'wrong-cookie-name' });
assert_equals(cookies.length, 1);
assert_equals(cookies[0].name, 'cookie-name');
assert_equals(cookies[0].value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
await async_cleanup(() => cookieStore.delete('cookie-name-2'));
}, 'cookieStore.getAll with name in both positional arguments and options');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookies = await cookieStore.getAll({ name: 'cookie-name',
matchType: 'equals' });
@ -78,53 +83,59 @@ promise_test(async testCase => {
const no_cookies = await cookieStore.getAll(
'cookie-na', { matchType: 'equals' });
assert_equals(no_cookies.length, 0);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.getAll with matchType explicitly set to equals');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await cookieStore.set('cookie-name-2', 'cookie-value-2');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name-2');
});
const cookies = await cookieStore.getAll({ name: 'cookie-name-',
matchType: 'starts-with' });
assert_equals(cookies.length, 1);
assert_equals(cookies[0].name, 'cookie-name-2');
assert_equals(cookies[0].value, 'cookie-value-2');
await async_cleanup(() => cookieStore.delete('cookie-name'));
await async_cleanup(() => cookieStore.delete('cookie-name-2'));
}, 'cookieStore.getAll with matchType set to starts-with');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await cookieStore.set('cookie-name-2', 'cookie-value-2');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name-2');
});
await promise_rejects(testCase, new TypeError(), cookieStore.getAll(
{ name: 'cookie-name', matchType: 'invalid' }));
await async_cleanup(() => cookieStore.delete('cookie-name'));
await async_cleanup(() => cookieStore.delete('cookie-name-2'));
}, 'cookieStore.getAll with invalid matchType');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookies = await cookieStore.getAll({ matchType: 'equals' });
assert_equals(cookies.length, 1);
assert_equals(cookies[0].name, 'cookie-name');
assert_equals(cookies[0].value, 'cookie-value');
async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.getAll with matchType set to equals and missing name');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookies = await cookieStore.getAll({ matchType: 'starts-with' });
assert_equals(cookies.length, 1);
assert_equals(cookies[0].name, 'cookie-name');
assert_equals(cookies[0].value, 'cookie-value');
async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.getAll with matchType set to starts-with and missing name');

23
tests/wpt/web-platform-tests/cookie-store/cookieStore_getAll_multiple.tentative.https.window.js
View file

@ -1,19 +1,18 @@
'use strict';
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await cookieStore.set('cookie-name-2', 'cookie-value-2');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name-2');
});
await cookieStore.set('cookie-name-3', 'cookie-value-3');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name-3');
});
const cookies = await cookieStore.getAll();
cookies.sort((a, b) => a.name.localeCompare(b.name));
@ -24,8 +23,4 @@ promise_test(async testCase => {
assert_equals(cookies[1].value, 'cookie-value-2');
assert_equals(cookies[2].name, 'cookie-name-3');
assert_equals(cookies[2].value, 'cookie-value-3');
await async_cleanup(() => cookieStore.delete('cookie-name'));
await async_cleanup(() => cookieStore.delete('cookie-name-2'));
await async_cleanup(() => cookieStore.delete('cookie-name-3'));
}, 'cookieStore.getAll returns multiple cookies written by cookieStore.set');

15
tests/wpt/web-platform-tests/cookie-store/cookieStore_getAll_set_basic.tentative.https.window.js
View file

@ -1,22 +1,13 @@
'use strict';
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookies = await cookieStore.getAll('cookie-name');
assert_equals(cookies.length, 1);
assert_equals(cookies[0].name, 'cookie-name');
assert_equals(cookies[0].value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.getAll returns the cookie written by cookieStore.set');

55
tests/wpt/web-platform-tests/cookie-store/cookieStore_get_arguments.tentative.https.window.js
View file

@ -1,56 +1,53 @@
'use strict';
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get();
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.get with no arguments');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.get with positional name');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get({ name: 'cookie-name' });
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.get with name in options');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name',
{ name: 'wrong-cookie-name' });
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.get with name in both positional arguments and options');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get(
'cookie-name', { matchType: 'equals' });
@ -60,46 +57,48 @@ promise_test(async testCase => {
const no_cookie = await cookieStore.get({ name: 'cookie-na',
matchType: 'equals' });
assert_equals(no_cookie, null);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.get with matchType explicitly set to equals');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get({ name: 'cookie-na',
matchType: 'starts-with' });
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.get with matchType set to starts-with');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await promise_rejects(testCase, new TypeError(), cookieStore.get(
{ name: 'cookie-name', matchType: 'invalid' }));
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.get with invalid matchType');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get({ matchType: 'equals' });
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.get with matchType set to equals and missing name');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get({ matchType: 'starts-with' });
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.get with matchType set to starts-with and missing name');

15
tests/wpt/web-platform-tests/cookie-store/cookieStore_get_delete_basic.tentative.https.window.js
View file

@ -1,20 +1,11 @@
'use strict';
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await cookieStore.delete('cookie-name');
const cookie = await cookieStore.get();
assert_equals(cookie, null);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.get returns null for a cookie deleted by cookieStore.delete');

8
tests/wpt/web-platform-tests/cookie-store/cookieStore_get_set_across_frames.tentative.https.html
View file

@ -19,7 +19,9 @@ promise_test(async t => {
'Precondition not met: cookie store should be empty');
await cookieStore.set('cookie-name', 'cookie-value');
t.add_cleanup(() => cookieStore.delete('cookie-name'));
t.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const frameCookie = await frameCookieStore.get('cookie-name');
assert_equals(frameCookie.value, 'cookie-value');
@ -34,7 +36,9 @@ promise_test(async t => {
'Precondition not met: cookie store should be empty');
await frameCookieStore.set('cookie-name', 'cookie-value');
t.add_cleanup(() => frameCookieStore.delete('cookie-name'));
t.add_cleanup(async () => {
await frameCookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.value, 'cookie-value');

14
tests/wpt/web-platform-tests/cookie-store/cookieStore_get_set_across_origins.tentative.sub.https.html
View file

@ -24,10 +24,9 @@ promise_test(async t => {
name: 'cookie-name',
value: 'cookie-value',
}, kCorsBase);
t.add_cleanup(() => cookieStore.delete({
name: 'cookie-name',
domain: '{{host}}',
}));
t.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', domain: '{{host}}' });
});
await waitForMessage();
const cookies = await cookieStore.getAll();
@ -53,10 +52,9 @@ promise_test(async t => {
opname: 'get-cookie',
name: 'cookie-name',
}, kCorsBase);
t.add_cleanup(() => cookieStore.delete({
name: 'cookie-name',
domain: '{{host}}',
}));
t.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', domain: '{{host}}' });
});
const message = await waitForMessage();

15
tests/wpt/web-platform-tests/cookie-store/cookieStore_get_set_basic.tentative.https.window.js
View file

@ -1,21 +1,12 @@
'use strict';
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.get returns the cookie written by cookieStore.set');

108
tests/wpt/web-platform-tests/cookie-store/cookieStore_set_arguments.tentative.https.window.js
View file

@ -1,47 +1,40 @@
'use strict';
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
promise_test(async testCase => {
await cookieStore.delete('cookie-name');
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.set with positional name and value');
promise_test(async testCase => {
await cookieStore.delete('cookie-name');
await cookieStore.set({ name: 'cookie-name', value: 'cookie-value' });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.set with name and value in options');
promise_test(async testCase => {
await cookieStore.delete('cookie-name');
cookieStore.set('cookie-name', 'cookie-value', { name: 'wrong-cookie-name' });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.set with name in both positional arguments and options');
promise_test(async testCase => {
@ -49,11 +42,12 @@ promise_test(async testCase => {
cookieStore.set('cookie-name', 'cookie-value',
{ value: 'wrong-cookie-value' });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.set with value in both positional arguments and options');
promise_test(async testCase => {
@ -63,11 +57,12 @@ promise_test(async testCase => {
await cookieStore.set(
'cookie-name', 'cookie-value', { expires: tenYearsFromNow });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.set with expires set to a future timestamp');
promise_test(async testCase => {
@ -77,10 +72,11 @@ promise_test(async testCase => {
await cookieStore.set(
'cookie-name', 'cookie-value', { expires: tenYearsAgo });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie, null);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.set with expires set to a past timestamp');
promise_test(async testCase => {
@ -90,11 +86,12 @@ promise_test(async testCase => {
await cookieStore.set(
'cookie-name', 'cookie-value', { expires: new Date(tenYearsFromNow) });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.set with expires set to a future Date');
promise_test(async testCase => {
@ -104,10 +101,11 @@ promise_test(async testCase => {
await cookieStore.set(
'cookie-name', 'cookie-value', { expires: new Date(tenYearsAgo) });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie, null);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.set with expires set to a past Date');
promise_test(async testCase => {
@ -117,11 +115,12 @@ promise_test(async testCase => {
await cookieStore.set(
{ name: 'cookie-name', value: 'cookie-value', expires: tenYearsFromNow });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.set with name and value in options and expires in the future');
promise_test(async testCase => {
@ -131,10 +130,11 @@ promise_test(async testCase => {
await cookieStore.set(
{ name: 'cookie-name', value: 'cookie-value', expires: tenYearsAgo });
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie, null);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.set with name and value in options and expires in the past');
promise_test(async testCase => {
@ -144,13 +144,12 @@ promise_test(async testCase => {
await cookieStore.set(
'cookie-name', 'cookie-value', { domain: currentDomain });
testCase.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
});
}, 'cookieStore.set with domain set to the current hostname');
promise_test(async testCase => {
@ -184,8 +183,14 @@ promise_test(async testCase => {
await cookieStore.delete('cookie-name');
await cookieStore.set('cookie-name', 'cookie-value1');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await cookieStore.set('cookie-name', 'cookie-value2',
{ domain: currentDomain });
testCase.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
});
const cookies = await cookieStore.getAll('cookie-name');
assert_equals(cookies.length, 2);
@ -196,11 +201,6 @@ promise_test(async testCase => {
const values = cookies.map((cookie) => cookie.value);
values.sort();
assert_array_equals(values, ['cookie-value1', 'cookie-value2']);
await async_cleanup(async () => {
await cookieStore.delete('cookie-name');
await cookieStore.delete({ name: 'cookie-name', domain: currentDomain });
});
}, 'cookieStore.set default domain is null and differs from current hostname');
promise_test(async testCase => {
@ -212,13 +212,12 @@ promise_test(async testCase => {
await cookieStore.set(
'cookie-name', 'cookie-value', { path: currentDirectory });
testCase.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'cookie-value');
await async_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', path: currentDirectory });
});
}, 'cookieStore.set with path set to the current directory');
promise_test(async testCase => {
@ -232,33 +231,36 @@ promise_test(async testCase => {
await cookieStore.set(
'cookie-name', 'cookie-value', { path: subDirectory });
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie, null);
await async_cleanup(async () => {
testCase.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', path: subDirectory });
});
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie, null);
}, 'cookieStore.set with path set to a subdirectory of the current directory');
promise_test(async testCase => {
await cookieStore.delete('cookie-name');
await cookieStore.set('cookie-name', 'cookie-old-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
await cookieStore.set('cookie-name', 'cookie-new-value', { path: '/' });
testCase.add_cleanup(async () => {
await cookieStore.delete({ name: 'cookie-name', path: '/' });
});
const cookies = await cookieStore.getAll('cookie-name');
assert_equals(cookies.length, 1);
assert_equals(cookies[0].name, 'cookie-name');
assert_equals(cookies[0].value, 'cookie-new-value');
await async_cleanup(async () => {
await cookieStore.delete('cookie-name');
await cookieStore.delete({ name: 'cookie-name', path: '/' });
});
}, 'cookieStore.set default path is /');
promise_test(async testCase => {
await cookieStore.set('cookie-name', 'old-cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const cookie_attributes = await cookieStore.get('cookie-name');
assert_equals(cookie_attributes.name, 'cookie-name');
@ -269,6 +271,4 @@ promise_test(async testCase => {
const cookie = await cookieStore.get('cookie-name');
assert_equals(cookie.name, 'cookie-name');
assert_equals(cookie.value, 'new-cookie-value');
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookieStore.set with get result');

4
tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_cross_origin.tentative.https.sub.html
View file

@ -27,9 +27,7 @@ promise_test(async t => {
name: 'cookie-name',
value: 'cookie-value',
}, kCorsBase);
t.add_cleanup(() => {
cookieStore.delete('cookie-name');
});
t.add_cleanup(async () => { await cookieStore.delete('cookie-name'); });
await waitForMessage();

21
tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions.js
View file

@ -24,16 +24,6 @@ self.addEventListener('install', (event) => {
})());
});
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
// Resolves when the service worker receives the 'activate' event.
const kServiceWorkerActivatedPromise = new Promise(resolve => {
self.addEventListener('activate', event => { resolve(); });
@ -96,8 +86,13 @@ promise_test(async testCase => {
await kServiceWorkerActivatedPromise;
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
testCase.add_cleanup(() => { g_cookie_changes = []; });
await g_cookie_change_received_promise;
testCase.add_cleanup(() => RearmCookieChangeReceivedPromise());
assert_equals(g_cookie_changes.length, 1);
const event = g_cookie_changes[0]
@ -108,12 +103,6 @@ promise_test(async testCase => {
assert_equals(event.deleted.length, 0);
assert_true(event instanceof ExtendableCookieChangeEvent);
assert_true(event instanceof ExtendableEvent);
await async_cleanup(async () => {
await cookieStore.delete('cookie-name');
g_cookie_changes = [];
RearmCookieChangeReceivedPromise();
});
}, 'cookiechange dispatched with cookie change that matches subscription');
done();

15
tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_basic.js
View file

@ -17,16 +17,6 @@ self.addEventListener('install', (event) => {
})());
});
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
// Resolves when the service worker receives the 'activate' event.
const kServiceWorkerActivatedPromise = new Promise(resolve => {
self.addEventListener('activate', event => { resolve(); });
@ -53,6 +43,9 @@ promise_test(async testCase => {
});
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const event = await cookie_change_received_promise;
assert_equals(event.type, 'cookiechange');
@ -62,8 +55,6 @@ promise_test(async testCase => {
assert_equals(event.deleted.length, 0);
assert_true(event instanceof ExtendableCookieChangeEvent);
assert_true(event instanceof ExtendableEvent);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookiechange dispatched with cookie change that matches subscription ' +
'to event handler registered with addEventListener');

10
tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_empty.js
View file

@ -16,16 +16,6 @@ self.addEventListener('install', (event) => {
})());
});
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/w3c/web-platform-tests/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
// Resolves when the service worker receives the 'activate' event.
const kServiceWorkerActivatedPromise = new Promise(resolve => {
self.addEventListener('activate', event => { resolve(); });

15
tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_eventhandler_attribute.js
View file

@ -17,16 +17,6 @@ self.addEventListener('install', (event) => {
})());
});
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/web-platform-tests/wpt/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
// Resolves when the service worker receives the 'activate' event.
const kServiceWorkerActivatedPromise = new Promise(resolve => {
self.addEventListener('activate', event => { resolve(); });
@ -40,6 +30,9 @@ promise_test(async testCase => {
});
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const event = await cookie_change_received_promise;
assert_equals(event.type, 'cookiechange');
@ -49,8 +42,6 @@ promise_test(async testCase => {
assert_equals(event.deleted.length, 0);
assert_true(event instanceof ExtendableCookieChangeEvent);
assert_true(event instanceof ExtendableEvent);
await async_cleanup(() => cookieStore.delete('cookie-name'));
}, 'cookiechange dispatched with cookie change that matches subscription ' +
'to event handler registered with oncookiechange');

21
tests/wpt/web-platform-tests/cookie-store/serviceworker_cookieStore_subscriptions_mismatch.js
View file

@ -17,16 +17,6 @@ self.addEventListener('install', (event) => {
})());
});
// Workaround because add_cleanup doesn't support async functions yet.
// See https://github.com/w3c/web-platform-tests/issues/6075
async function async_cleanup(cleanup_function) {
try {
await cleanup_function();
} catch (e) {
// Errors in cleanup functions shouldn't result in test failures.
}
}
// Resolves when the service worker receives the 'activate' event.
const kServiceWorkerActivatedPromise = new Promise(resolve => {
self.addEventListener('activate', event => { resolve(); });
@ -42,18 +32,19 @@ promise_test(async testCase => {
});
await cookieStore.set('another-cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('another-cookie-name');
});
await cookieStore.set('cookie-name', 'cookie-value');
testCase.add_cleanup(async () => {
await cookieStore.delete('cookie-name');
});
const event = await cookie_change_received_promise;
assert_equals(event.type, 'cookiechange');
assert_equals(event.changed.length, 1);
assert_equals(event.changed[0].name, 'cookie-name');
assert_equals(event.changed[0].value, 'cookie-value');
await async_cleanup(async () => {
await cookieStore.delete('another-cookie-name');
await cookieStore.delete('cookie-name');
});
}, 'cookiechange not dispatched for change that does not match subscription');
done();