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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side 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 unified diff | 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 »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 <!DOCTYPE html>
2 <script src="../resources/testharness.js"></script>
3 <script src="../resources/testharnessreport.js"></script>
4 <script>
5 function createIterable(iterations) {
6 return {
7 [Symbol.iterator]() {
8 var i = 0;
9 return {next: () => iterations[i++]};
10 },
11 };
12 }
13
14 test(() => {
15 let sequenceTest = internals.sequenceTest();
16
17 assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(null) },
18 "Converting null to sequence must throw a type error");
19 assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(undefi ned) },
20 "Converting undefined to sequence must throw a type error");
21 assert_equals(sequenceTest.identityOctetSequenceOrNull(null), null,
22 "Converting null to a nullable sequence works");
23 assert_equals(sequenceTest.identityOctetSequenceOrNull(undefined), null,
24 "Converting undefined to a nullable sequence works");
25 }, "null and undefined conversions");
26
27 test(() => {
28 let sequenceTest = internals.sequenceTest();
29
30 let emptyArray = [];
31 let emptyObject = createIterable([{done: true}]);
32
33 let convertedArray = sequenceTest.identityLongSequence(emptyArray);
34 assert_array_equals(convertedArray, [], "Empty array produces an empty vector ");
35 let convertedObject = sequenceTest.identityLongSequence(emptyObject);
36 assert_array_equals(convertedObject, [], "Empty object produces an empty vect or");
37 }, "Empty sequences");
38
39 test(() => {
40 let sequenceTest = internals.sequenceTest();
41
42 let obj = createIterable([
43 { done: false, value: 34 },
44 { done: false, value: 42 },
45 { done: true }
46 ]);
47 let convertedObj = sequenceTest.identityLongSequence(obj);
48 assert_array_equals(convertedObj, [34, 42],
49 "'done: true' does not need a value property");
50
51 obj = createIterable([
52 { done: false, value: 34 },
53 { done: false, value: 42 },
54 { done: true, value: 88 }
55 ]);
56 convertedObj = sequenceTest.identityLongSequence(obj);
57 assert_array_equals(convertedObj, [34, 42],
58 "'value' is ignored when 'done' is true");
59
60 obj = createIterable([
61 { done: 0, value: 42 },
62 { done: 1, value: 34 }
63 ]);
64 convertedObj = sequenceTest.identityDoubleSequence(obj);
65 assert_array_equals(convertedObj, [42],
66 "'done' is always converted to a boolean");
67 }, "Iterator stop values");
68
69 test(() => {
70 let sequenceTest = internals.sequenceTest();
71
72 let array = [1, 2];
73 let convertedArray = sequenceTest.identityDoubleSequence(array);
74 assert_not_equals(array, convertedArray);
75 convertedArray.push(42);
76 let convertedArray2 = sequenceTest.identityDoubleSequence(array);
77 assert_equals(array.length, 2);
78 assert_not_equals(convertedArray, convertedArray2);
79 assert_array_equals(convertedArray2, [1, 2]);
80 }, "Sequences are passed by value");
81
82 test(() => {
83 let sequenceTest = internals.sequenceTest();
84
85 let longArray = ['not', 'a', 'long'];
86 longArray[5] = 42;
87 let convertedLongArray = sequenceTest.identityLongSequence(longArray);
88 assert_array_equals(convertedLongArray, [0, 0, 0, 0, 0, 42],
89 "Long array with gaps correctly produces a vector");
90
91 let doubleArray = [34, 42.5];
92 doubleArray[9] = 2; // The elements inbetween are all undefined.
93 assert_throws(new TypeError, () => { sequenceTest.identityDoubleSequence(doub leArray) },
94 "Converting an undefined value to double throws a TypeError and " +
95 "causes the sequence -> C++ conversion to fail");
96
97 let byteStringSequenceSequence = [
98 ["foo"],
99 ["bar"]
100 ];
101 byteStringSequenceSequence[7] = ["baz"];
102 assert_throws(new TypeError, () => {
103 sequenceTest.identityByteStringSequenceSequence(byteStringSequenceSequence) ;
104 }, "Converting an undefined to a sequence<> throws a TypeError and causes the " +
105 "entire conversion to fail");
106 }, "Arrays with gaps in the elements");
107
108 test(() => {
109 let sequenceTest = internals.sequenceTest();
110
111 assert_throws(new TypeError, () => { sequenceTest.identityLongSequence({}) },
112 "Objects without Symbol.iterator cannot be converted");
113
114 let obj = {
115 [Symbol.iterator]: 42
116 };
117 assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(obj) } ,
118 "Symbol.iterator must be callable");
119
120 obj = {
121 [Symbol.iterator]() {
122 return 42;
123 }
124 }
125 assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(obj) } ,
126 "Symbol.iterator must return an object");
127
128 obj = {
129 [Symbol.iterator]() {
130 return {}
131 }
132 }
133 assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(obj) } ,
134 "Symbol.iterator must return an object with a 'next' callable") ;
135
136 obj = {
137 [Symbol.iterator]() {
138 return {'next': 42}
139 }
140 }
141 assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(obj) } ,
142 "Symbol.iterator must return an object with a 'next' callable") ;
143
144 obj = {
145 [Symbol.iterator]() {
146 return {'next': () => { return 42 }}
147 }
148 }
149 assert_throws(new TypeError, () => { sequenceTest.identityLongSequence(obj) } ,
150 "'next' must return an object");
151 }, "Invalid iterable protocols");
152
153 test(() => {
154 let sequenceTest = internals.sequenceTest();
155
156 assert_false(sequenceTest.unionReceivedSequence(42),
157 "Passing a double should convert the union to double");
158 assert_false(sequenceTest.unionReceivedSequence(true),
159 "Passing a boolean should convert the union to double");
160 assert_true(sequenceTest.unionReceivedSequence([]),
161 "Passing an empty array should convert the union to a sequence");
162 assert_true(sequenceTest.unionReceivedSequence([34, 42]),
163 "Passing an array should convert the union to a sequence");
164 let obj = createIterable([{done: false, value: 99},
165 {done: false, value: -3.14},
166 {done: true}]);
167 assert_true(sequenceTest.unionReceivedSequence(obj),
168 "Passing an iterable object should convert the union to a sequenc e");
169 }, "Sequences in unions");
170
171 test(() => {
172 let sequenceTest = internals.sequenceTest();
173
174 let foods = ["Sushi", "Beer"];
175 assert_throws(new TypeError, () => { sequenceTest.identityFoodEnumSequence(fo ods) },
176 "Invalid enum type must throw a type error");
177
178 foods = createIterable([{done: false, value: "Spaghetti"},
179 {done: false, value: "Bread"},
180 {done: true}]);
181 assert_array_equals(sequenceTest.identityFoodEnumSequence(foods),
182 ["Spaghetti", "Bread"]);
183 }, "Enum sequences");
184
185 test(() => {
186 let sequenceTest = internals.sequenceTest();
187
188 let sequenceCreationFunctions = [
189 (elem) => { return [elem] },
190 (elem) => { return createIterable([{done: false, value: elem},
191 {done: true}]) }
192 ];
193 for (sequenceCreationFunction of sequenceCreationFunctions) {
194 let elem = document.createElement('p');
195 sequenceTest.setElementSequence(sequenceCreationFunction(elem));
196 assert_array_equals(sequenceTest.getElementSequence(), [elem],
197 "The same DOM object was stored in the sequence");
198 assert_not_equals(sequenceTest.getElementSequence()[0],
199 document.createElement('br'),
200 "The same DOM object was stored in the sequence");
201
202 elem = document.createElement('br');
203 assert_not_equals(sequenceTest.getElementSequence()[0], elem,
204 "Changing the original object does not change the sequenc e value");
205 }
206 }, "Converting DOM object sequences");
207 </script>
OLDNEW
« 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