Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1581)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: third_party/WebKit/LayoutTests/bindings/sequence-type.html

Issue 2810843002: bindings: Make the sequence conversion code more complaint with WebIDL. (Closed)
Patch Set: Adjust even more tests Created 3 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « no previous file | third_party/WebKit/LayoutTests/crypto/subtle/aes-cbc/generateKey-failures-expected.txt » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: third_party/WebKit/LayoutTests/bindings/sequence-type.html
diff --git a/third_party/WebKit/LayoutTests/bindings/sequence-type.html b/third_party/WebKit/LayoutTests/bindings/sequence-type.html
new file mode 100644
index 0000000000000000000000000000000000000000..c50b3b3f668dc3df710cc8a8b0db0db3d8047c83
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/bindings/sequence-type.html
@@ -0,0 +1,207 @@
+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script>
+ function createIterable(iterations) {
+ return {
+ [Symbol.iterator]() {
+ var i = 0;
+ return {next: () => iterations[i++]};
+ },
+ };
+ }
+
+ test(() => {
+ let sequenceTest = internals.sequenceTest();
+
+ assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(null) },
+ "Converting null to sequence must throw a type error");
+ assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(undefined) },
+ "Converting undefined to sequence must throw a type error");
+ assert_equals(sequenceTest.identityOctetSequenceOrNull(null), null,
+ "Converting null to a nullable sequence works");
+ assert_equals(sequenceTest.identityOctetSequenceOrNull(undefined), null,
+ "Converting undefined to a nullable sequence works");
+ }, "null and undefined conversions");
+
+ test(() => {
+ let sequenceTest = internals.sequenceTest();
+
+ let emptyArray = [];
+ let emptyObject = createIterable([{done: true}]);
+
+ let convertedArray = sequenceTest.identityLongSequence(emptyArray);
+ assert_array_equals(convertedArray, [], "Empty array produces an empty vector");
+ let convertedObject = sequenceTest.identityLongSequence(emptyObject);
+ assert_array_equals(convertedObject, [], "Empty object produces an empty vector");
+ }, "Empty sequences");
+
+ test(() => {
+ let sequenceTest = internals.sequenceTest();
+
+ let obj = createIterable([
+ { done: false, value: 34 },
+ { done: false, value: 42 },
+ { done: true }
+ ]);
+ let convertedObj = sequenceTest.identityLongSequence(obj);
+ assert_array_equals(convertedObj, [34, 42],
+ "'done: true' does not need a value property");
+
+ obj = createIterable([
+ { done: false, value: 34 },
+ { done: false, value: 42 },
+ { done: true, value: 88 }
+ ]);
+ convertedObj = sequenceTest.identityLongSequence(obj);
+ assert_array_equals(convertedObj, [34, 42],
+ "'value' is ignored when 'done' is true");
+
+ obj = createIterable([
+ { done: 0, value: 42 },
+ { done: 1, value: 34 }
+ ]);
+ convertedObj = sequenceTest.identityDoubleSequence(obj);
+ assert_array_equals(convertedObj, [42],
+ "'done' is always converted to a boolean");
+ }, "Iterator stop values");
+
+ test(() => {
+ let sequenceTest = internals.sequenceTest();
+
+ let array = [1, 2];
+ let convertedArray = sequenceTest.identityDoubleSequence(array);
+ assert_not_equals(array, convertedArray);
+ convertedArray.push(42);
+ let convertedArray2 = sequenceTest.identityDoubleSequence(array);
+ assert_equals(array.length, 2);
+ assert_not_equals(convertedArray, convertedArray2);
+ assert_array_equals(convertedArray2, [1, 2]);
+ }, "Sequences are passed by value");
+
+ test(() => {
+ let sequenceTest = internals.sequenceTest();
+
+ let longArray = ['not', 'a', 'long'];
+ longArray[5] = 42;
+ let convertedLongArray = sequenceTest.identityLongSequence(longArray);
+ assert_array_equals(convertedLongArray, [0, 0, 0, 0, 0, 42],
+ "Long array with gaps correctly produces a vector");
+
+ let doubleArray = [34, 42.5];
+ doubleArray[9] = 2; // The elements inbetween are all undefined.
+ assert_throws(new TypeError, () => { sequenceTest.identityDoubleSequence(doubleArray) },
+ "Converting an undefined value to double throws a TypeError and " +
+ "causes the sequence -> C++ conversion to fail");
+
+ let byteStringSequenceSequence = [
+ ["foo"],
+ ["bar"]
+ ];
+ byteStringSequenceSequence[7] = ["baz"];
+ assert_throws(new TypeError, () => {
+ sequenceTest.identityByteStringSequenceSequence(byteStringSequenceSequence);
+ }, "Converting an undefined to a sequence<> throws a TypeError and causes the " +
+ "entire conversion to fail");
+ }, "Arrays with gaps in the elements");
+
+ test(() => {
+ let sequenceTest = internals.sequenceTest();
+
+ assert_throws(new TypeError, () => { sequenceTest.identityLongSequence({}) },
+ "Objects without Symbol.iterator cannot be converted");
+
+ let obj = {
+ [Symbol.iterator]: 42
+ };
+ assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(obj) },
+ "Symbol.iterator must be callable");
+
+ obj = {
+ [Symbol.iterator]() {
+ return 42;
+ }
+ }
+ assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(obj) },
+ "Symbol.iterator must return an object");
+
+ obj = {
+ [Symbol.iterator]() {
+ return {}
+ }
+ }
+ assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(obj) },
+ "Symbol.iterator must return an object with a 'next' callable");
+
+ obj = {
+ [Symbol.iterator]() {
+ return {'next': 42}
+ }
+ }
+ assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(obj) },
+ "Symbol.iterator must return an object with a 'next' callable");
+
+ obj = {
+ [Symbol.iterator]() {
+ return {'next': () => { return 42 }}
+ }
+ }
+ assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(obj) },
+ "'next' must return an object");
+ }, "Invalid iterable protocols");
+
+ test(() => {
+ let sequenceTest = internals.sequenceTest();
+
+ assert_false(sequenceTest.unionReceivedSequence(42),
+ "Passing a double should convert the union to double");
+ assert_false(sequenceTest.unionReceivedSequence(true),
+ "Passing a boolean should convert the union to double");
+ assert_true(sequenceTest.unionReceivedSequence([]),
+ "Passing an empty array should convert the union to a sequence");
+ assert_true(sequenceTest.unionReceivedSequence([34, 42]),
+ "Passing an array should convert the union to a sequence");
+ let obj = createIterable([{done: false, value: 99},
+ {done: false, value: -3.14},
+ {done: true}]);
+ assert_true(sequenceTest.unionReceivedSequence(obj),
+ "Passing an iterable object should convert the union to a sequence");
+ }, "Sequences in unions");
+
+ test(() => {
+ let sequenceTest = internals.sequenceTest();
+
+ let foods = ["Sushi", "Beer"];
+ assert_throws(new TypeError, () => { sequenceTest.identityFoodEnumSequence(foods) },
+ "Invalid enum type must throw a type error");
+
+ foods = createIterable([{done: false, value: "Spaghetti"},
+ {done: false, value: "Bread"},
+ {done: true}]);
+ assert_array_equals(sequenceTest.identityFoodEnumSequence(foods),
+ ["Spaghetti", "Bread"]);
+ }, "Enum sequences");
+
+ test(() => {
+ let sequenceTest = internals.sequenceTest();
+
+ let sequenceCreationFunctions = [
+ (elem) => { return [elem] },
+ (elem) => { return createIterable([{done: false, value: elem},
+ {done: true}]) }
+ ];
+ for (sequenceCreationFunction of sequenceCreationFunctions) {
+ let elem = document.createElement('p');
+ sequenceTest.setElementSequence(sequenceCreationFunction(elem));
+ assert_array_equals(sequenceTest.getElementSequence(), [elem],
+ "The same DOM object was stored in the sequence");
+ assert_not_equals(sequenceTest.getElementSequence()[0],
+ document.createElement('br'),
+ "The same DOM object was stored in the sequence");
+
+ elem = document.createElement('br');
+ assert_not_equals(sequenceTest.getElementSequence()[0], elem,
+ "Changing the original object does not change the sequence value");
+ }
+ }, "Converting DOM object sequences");
+</script>
« no previous file with comments | « no previous file | third_party/WebKit/LayoutTests/crypto/subtle/aes-cbc/generateKey-failures-expected.txt » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698