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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: runtime/tests/vm/src/byte_array_test.dart

Issue 9958046: Implement {Int,Uint}{8,16,32,64} and Float{32,64} typed arrays. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: add view classes and their tests Created 8 years, 7 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 | Annotate | Revision Log
« runtime/lib/byte_array.dart ('K') | « runtime/lib/byte_array.dart ('k') | runtime/vm/bootstrap_natives.h » ('j') | runtime/vm/dart_api_impl.cc » ('J')
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 class ByteArrayTest {
2 static testInt8Array() {
3 var array = new Int8Array(10);
4 Expect.isTrue(array is List<int>);
5 Expect.equals(10, array.length);
6 Expect.equals(1, array.bytesPerElement());
7 Expect.equals(10, array.lengthInBytes());
8 Expect.listEquals([0, 0, 0, 0, 0,
9 0, 0, 0, 0, 0],
10 array);
11 Expect.throws(() { array[-1] = 0; },
12 (e) { return e is IndexOutOfRangeException; });
13 Expect.throws(() { return array[-1]; },
14 (e) { return e is IndexOutOfRangeException; });
15 Expect.throws(() { array[10]; },
16 (e) { return e is IndexOutOfRangeException; });
17 Expect.throws(() { array[10] = 0; },
18 (e) { return e is IndexOutOfRangeException; });
19 Expect.throws(() { array.add(0); },
20 (e) { return e is UnsupportedOperationException; });
21 Expect.throws(() { array.addAll([0]); },
22 (e) { return e is UnsupportedOperationException; });
23 Expect.throws(() { array.addLast(0); },
24 (e) { return e is UnsupportedOperationException; });
25 Expect.throws(() { array.clear(); },
26 (e) { return e is UnsupportedOperationException; });
27 Expect.throws(() { array.insertRange(0, array.length, 0); },
28 (e) { return e is UnsupportedOperationException; });
29 Expect.throws(() { array.length = 0; },
30 (e) { return e is UnsupportedOperationException; });
31 Expect.throws(() { array.removeLast(); },
32 (e) { return e is UnsupportedOperationException; });
33 Expect.throws(() { array.removeRange(0, array.length - 1); },
34 (e) { return e is UnsupportedOperationException; });
35 for (int i = 0; i < array.length; ++i) {
36 array[i] = 1 + i;
37 }
38 Expect.listEquals([1, 2, 3, 4, 5,
39 6, 7, 8, 9, 10],
40 array);
41 for (int i = 0; i < array.length; ++i) {
42 array[i] = 0x100 + i;
43 }
44 Expect.listEquals([0, 1, 2, 3, 4,
45 5, 6, 7, 8, 9],
46 array);
47 for (int i = 0; i < array.length; ++i) {
48 array[i] = -10 + i;
49 }
50 Expect.listEquals([-10, -9, -8, -7, -6,
51 -5, -4, -3, -2, -1],
52 array);
53 for (int i = 0; i < array.length; ++i) {
54 array[i] = 0x7F - i;
55 }
56 Expect.listEquals([127, 126, 125, 124, 123,
57 122, 121, 120, 119, 118],
58 array);
59 for (int i = 0; i < array.length; ++i) {
60 array[i] = -0x80 + i;
61 }
62 Expect.listEquals([-128, -127, -126, -125, -124,
63 -123, -122, -121, -120, -119],
64 array);
65 for (int i = 0; i < array.length; ++i) {
66 array[i] = i;
67 }
68 var copy = array.getRange(0, array.length);
69 Expect.isFalse(copy === array);
70 Expect.isTrue(copy is Int8Array);
71 Expect.equals(10, copy.length);
72 Expect.listEquals(array, copy);
73 var region = array.getRange(3, array.length - 6);
74 Expect.isTrue(copy is Int8Array);
75 Expect.equals(4, region.length);
76 Expect.listEquals([3, 4, 5, 6], region);
77 array.setRange(3, 4, [-128, 0, 1, 127]);
78 Expect.listEquals([0, 1, 2, -128, 0, 1, 127, 7, 8, 9],
79 array);
80 }
81
82 static testUint8Array() {
83 var array = new Uint8Array(10);
84 Expect.isTrue(array is List<int>);
85 Expect.equals(10, array.length);
86 Expect.equals(1, array.bytesPerElement());
87 Expect.equals(10, array.lengthInBytes());
88 Expect.listEquals([0, 0, 0, 0, 0,
89 0, 0, 0, 0, 0],
90 array);
91 Expect.throws(() { array[-1] = 0; },
92 (e) { return e is IndexOutOfRangeException; });
93 Expect.throws(() { return array[-1]; },
94 (e) { return e is IndexOutOfRangeException; });
95 Expect.throws(() { array[10]; },
96 (e) { return e is IndexOutOfRangeException; });
97 Expect.throws(() { array[10] = 0; },
98 (e) { return e is IndexOutOfRangeException; });
99 Expect.throws(() { array.add(0); },
100 (e) { return e is UnsupportedOperationException; });
101 Expect.throws(() { array.addAll([0]); },
102 (e) { return e is UnsupportedOperationException; });
103 Expect.throws(() { array.addLast(0); },
104 (e) { return e is UnsupportedOperationException; });
105 Expect.throws(() { array.clear(); },
106 (e) { return e is UnsupportedOperationException; });
107 Expect.throws(() { array.insertRange(0, array.length, 0); },
108 (e) { return e is UnsupportedOperationException; });
109 Expect.throws(() { array.length = 0; },
110 (e) { return e is UnsupportedOperationException; });
111 Expect.throws(() { array.removeLast(); },
112 (e) { return e is UnsupportedOperationException; });
113 Expect.throws(() { array.removeRange(0, array.length - 1); },
114 (e) { return e is UnsupportedOperationException; });
115 for (int i = 0; i < array.length; ++i) {
116 array[i] = 1 + i;
117 }
118 Expect.listEquals([1, 2, 3, 4, 5,
119 6, 7, 8, 9, 10],
120 array);
121 for (int i = 0; i < array.length; ++i) {
122 array[i] = 0x100 + i;
123 }
124 Expect.listEquals([0, 1, 2, 3, 4,
125 5, 6, 7, 8, 9],
126 array);
127 for (int i = 0; i < array.length; ++i) {
128 array[i] = 0xFF - i;
129 }
130 Expect.listEquals([0xFF, 0xFE, 0xFD, 0xFC, 0xFB,
131 0xFA, 0xF9, 0xF8, 0xF7, 0xF6],
132 array);
133 for (int i = 0; i < array.length; ++i) {
134 array[i] = i;
135 }
136 var copy = array.getRange(0, array.length);
137 Expect.isFalse(copy === array);
138 Expect.isTrue(copy is Uint8Array);
139 Expect.equals(10, copy.length);
140 Expect.listEquals(array, copy);
141 var region = array.getRange(3, array.length - 6);
142 Expect.isTrue(copy is Uint8Array);
143 Expect.equals(4, region.length);
144 Expect.listEquals([3, 4, 5, 6], region);
145 array.setRange(3, 4, [257, 0, 1, 255]);
146 Expect.listEquals([0, 1, 2, 1, 0, 1, 255, 7, 8, 9],
147 array);
148 }
149
150 static testInt16Array() {
151 var array = new Int16Array(10);
152 Expect.isTrue(array is List<int>);
153 Expect.equals(10, array.length);
154 Expect.equals(2, array.bytesPerElement());
155 Expect.equals(20, array.lengthInBytes());
156 Expect.listEquals([0, 0, 0, 0, 0,
157 0, 0, 0, 0, 0],
158 array);
159 Expect.throws(() { array[-1] = 0; },
160 (e) { return e is IndexOutOfRangeException; });
161 Expect.throws(() { return array[-1]; },
162 (e) { return e is IndexOutOfRangeException; });
163 Expect.throws(() { array[10]; },
164 (e) { return e is IndexOutOfRangeException; });
165 Expect.throws(() { array[10] = 0; },
166 (e) { return e is IndexOutOfRangeException; });
167 Expect.throws(() { array.add(0); },
168 (e) { return e is UnsupportedOperationException; });
169 Expect.throws(() { array.addAll([0]); },
170 (e) { return e is UnsupportedOperationException; });
171 Expect.throws(() { array.addLast(0); },
172 (e) { return e is UnsupportedOperationException; });
173 Expect.throws(() { array.clear(); },
174 (e) { return e is UnsupportedOperationException; });
175 Expect.throws(() { array.insertRange(0, array.length, 0); },
176 (e) { return e is UnsupportedOperationException; });
177 Expect.throws(() { array.length = 0; },
178 (e) { return e is UnsupportedOperationException; });
179 Expect.throws(() { array.removeLast(); },
180 (e) { return e is UnsupportedOperationException; });
181 Expect.throws(() { array.removeRange(0, array.length - 1); },
182 (e) { return e is UnsupportedOperationException; });
183 for (int i = 0; i < array.length; ++i) {
184 array[i] = 1 + i;
185 }
186 Expect.listEquals([1, 2, 3, 4, 5,
187 6, 7, 8, 9, 10],
188 array);
189 for (int i = 0; i < array.length; ++i) {
190 array[i] = 0x10000 + i;
191 }
192 Expect.listEquals([0, 1, 2, 3, 4,
193 5, 6, 7, 8, 9],
194 array);
195 for (int i = 0; i < array.length; ++i) {
196 array[i] = -10 + i;
197 }
198 Expect.listEquals([-10, -9, -8, -7, -6,
199 -5, -4, -3, -2, -1],
200 array);
201 for (int i = 0; i < array.length; ++i) {
202 array[i] = 0x7FFF - i;
203 }
204 Expect.listEquals([0x7FFF, 0x7FFE, 0x7FFD, 0x7FFC, 0x7FFB,
205 0x7FFA, 0x7FF9, 0x7FF8, 0x7FF7, 0x7FF6],
206 array);
207 for (int i = 0; i < array.length; ++i) {
208 array[i] = -0x8000 + i;
209 }
210 Expect.listEquals([-0x8000, -0x7FFF, -0x7FFE, -0x7FFD, -0x7FFC,
211 -0x7FFB, -0x7FFA, -0x7FF9, -0x7FF8, -0x7FF7],
212 array);
213 for (int i = 0; i < array.length; ++i) {
214 array[i] = i;
215 }
216 var copy = array.getRange(0, array.length);
217 Expect.isFalse(copy === array);
218 Expect.isTrue(copy is Int16Array);
219 Expect.equals(10, copy.length);
220 Expect.listEquals(array, copy);
221 var region = array.getRange(3, array.length - 6);
222 Expect.isTrue(copy is Int16Array);
223 Expect.equals(4, region.length);
224 Expect.listEquals([3, 4, 5, 6], region);
225 array.setRange(3, 4, [-32768, 0, 1, 32767]);
226 Expect.listEquals([0, 1, 2, -32768, 0, 1, 32767, 7, 8, 9],
227 array);
228 }
229
230 static testUint16Array() {
231 var array = new Uint16Array(10);
232 Expect.isTrue(array is List<int>);
233 Expect.equals(10, array.length);
234 Expect.equals(2, array.bytesPerElement());
235 Expect.equals(20, array.lengthInBytes());
236 Expect.listEquals([0, 0, 0, 0, 0,
237 0, 0, 0, 0, 0],
238 array);
239 Expect.throws(() { array[-1] = 0; },
240 (e) { return e is IndexOutOfRangeException; });
241 Expect.throws(() { return array[-1]; },
242 (e) { return e is IndexOutOfRangeException; });
243 Expect.throws(() { array[10]; },
244 (e) { return e is IndexOutOfRangeException; });
245 Expect.throws(() { array[10] = 0; },
246 (e) { return e is IndexOutOfRangeException; });
247 Expect.throws(() { array.add(0); },
248 (e) { return e is UnsupportedOperationException; });
249 Expect.throws(() { array.addAll([0]); },
250 (e) { return e is UnsupportedOperationException; });
251 Expect.throws(() { array.addLast(0); },
252 (e) { return e is UnsupportedOperationException; });
253 Expect.throws(() { array.clear(); },
254 (e) { return e is UnsupportedOperationException; });
255 Expect.throws(() { array.insertRange(0, array.length, 0); },
256 (e) { return e is UnsupportedOperationException; });
257 Expect.throws(() { array.length = 0; },
258 (e) { return e is UnsupportedOperationException; });
259 Expect.throws(() { array.removeLast(); },
260 (e) { return e is UnsupportedOperationException; });
261 Expect.throws(() { array.removeRange(0, array.length - 1); },
262 (e) { return e is UnsupportedOperationException; });
263 for (int i = 0; i < array.length; ++i) {
264 array[i] = 1 + i;
265 }
266 Expect.listEquals([1, 2, 3, 4, 5,
267 6, 7, 8, 9, 10],
268 array);
269 for (int i = 0; i < array.length; ++i) {
270 array[i] = 0x10000 + i;
271 }
272 Expect.listEquals([0, 1, 2, 3, 4,
273 5, 6, 7, 8, 9],
274 array);
275 for (int i = 0; i < array.length; ++i) {
276 array[i] = 0xFFFF - i;
277 }
278 Expect.listEquals([0xFFFF, 0xFFFE, 0xFFFD, 0xFFFC, 0xFFFB,
279 0xFFFA, 0xFFF9, 0xFFF8, 0xFFF7, 0xFFF6],
280 array);
281 for (int i = 0; i < array.length; ++i) {
282 array[i] = i;
283 }
284 var copy = array.getRange(0, array.length);
285 Expect.isFalse(copy === array);
286 Expect.isTrue(copy is Uint16Array);
287 Expect.equals(10, copy.length);
288 Expect.listEquals(array, copy);
289 var region = array.getRange(3, array.length - 6);
290 Expect.isTrue(copy is Uint16Array);
291 Expect.equals(4, region.length);
292 Expect.listEquals([3, 4, 5, 6], region);
293 array.setRange(3, 4, [0x10001, 0, 1, 0xFFFF]);
294 Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFF, 7, 8, 9],
295 array);
296 }
297
298 static testInt32Array() {
299 var array = new Int32Array(10);
300 Expect.isTrue(array is List<int>);
301 Expect.equals(10, array.length);
302 Expect.equals(4, array.bytesPerElement());
303 Expect.equals(40, array.lengthInBytes());
304 Expect.listEquals([0, 0, 0, 0, 0,
305 0, 0, 0, 0, 0],
306 array);
307 Expect.throws(() { array[-1] = 0; },
308 (e) { return e is IndexOutOfRangeException; });
309 Expect.throws(() { return array[-1]; },
310 (e) { return e is IndexOutOfRangeException; });
311 Expect.throws(() { array[10]; },
312 (e) { return e is IndexOutOfRangeException; });
313 Expect.throws(() { array[10] = 0; },
314 (e) { return e is IndexOutOfRangeException; });
315 Expect.throws(() { array.add(0); },
316 (e) { return e is UnsupportedOperationException; });
317 Expect.throws(() { array.addAll([0]); },
318 (e) { return e is UnsupportedOperationException; });
319 Expect.throws(() { array.addLast(0); },
320 (e) { return e is UnsupportedOperationException; });
321 Expect.throws(() { array.clear(); },
322 (e) { return e is UnsupportedOperationException; });
323 Expect.throws(() { array.insertRange(0, array.length, 0); },
324 (e) { return e is UnsupportedOperationException; });
325 Expect.throws(() { array.length = 0; },
326 (e) { return e is UnsupportedOperationException; });
327 Expect.throws(() { array.removeLast(); },
328 (e) { return e is UnsupportedOperationException; });
329 Expect.throws(() { array.removeRange(0, array.length - 1); },
330 (e) { return e is UnsupportedOperationException; });
331 for (int i = 0; i < array.length; ++i) {
332 array[i] = 1 + i;
333 }
334 Expect.listEquals([1, 2, 3, 4, 5,
335 6, 7, 8, 9, 10],
336 array);
337 for (int i = 0; i < array.length; ++i) {
338 array[i] = 0x100000000 + i;
339 }
340 Expect.listEquals([0, 1, 2, 3, 4,
341 5, 6, 7, 8, 9],
342 array);
343 for (int i = 0; i < array.length; ++i) {
344 array[i] = -10 + i;
345 }
346 Expect.listEquals([-10, -9, -8, -7, -6,
347 -5, -4, -3, -2, -1],
348 array);
349 for (int i = 0; i < array.length; ++i) {
350 array[i] = 0x7FFFFFFF - i;
351 }
352 Expect.listEquals([0x7FFFFFFF, 0x7FFFFFFE,
353 0x7FFFFFFD, 0x7FFFFFFC,
354 0x7FFFFFFB, 0x7FFFFFFA,
355 0x7FFFFFF9, 0x7FFFFFF8,
356 0x7FFFFFF7, 0x7FFFFFF6],
357 array);
358 for (int i = 0; i < array.length; ++i) {
359 array[i] = -0x80000000 + i;
360 }
361 Expect.listEquals([-0x80000000, -0x7FFFFFFF,
362 -0x7FFFFFFE, -0x7FFFFFFD,
363 -0x7FFFFFFC, -0x7FFFFFFB,
364 -0x7FFFFFFA, -0x7FFFFFF9,
365 -0x7FFFFFF8, -0x7FFFFFF7],
366 array);
367 for (int i = 0; i < array.length; ++i) {
368 array[i] = i;
369 }
370 var copy = array.getRange(0, array.length);
371 Expect.isFalse(copy === array);
372 Expect.isTrue(copy is Int32Array);
373 Expect.equals(10, copy.length);
374 Expect.listEquals(array, copy);
375 var region = array.getRange(3, array.length - 6);
376 Expect.isTrue(copy is Int32Array);
377 Expect.equals(4, region.length);
378 Expect.listEquals([3, 4, 5, 6], region);
379 array.setRange(3, 4, [-0x80000000, 0, 1, 0x7FFFFFFF]);
380 Expect.listEquals([0, 1, 2, -0x80000000, 0, 1, 0x7FFFFFFF, 7, 8, 9],
381 array);
382 }
383
384 static testUint32Array() {
385 var array = new Uint32Array(10);
386 Expect.isTrue(array is List<int>);
387 Expect.equals(10, array.length);
388 Expect.equals(4, array.bytesPerElement());
389 Expect.equals(40, array.lengthInBytes());
390 Expect.listEquals([0, 0, 0, 0, 0,
391 0, 0, 0, 0, 0],
392 array);
393 Expect.throws(() { array[-1] = 0; },
394 (e) { return e is IndexOutOfRangeException; });
395 Expect.throws(() { return array[-1]; },
396 (e) { return e is IndexOutOfRangeException; });
397 Expect.throws(() { array[10]; },
398 (e) { return e is IndexOutOfRangeException; });
399 Expect.throws(() { array[10] = 0; },
400 (e) { return e is IndexOutOfRangeException; });
401 Expect.throws(() { array.add(0); },
402 (e) { return e is UnsupportedOperationException; });
403 Expect.throws(() { array.addAll([0]); },
404 (e) { return e is UnsupportedOperationException; });
405 Expect.throws(() { array.addLast(0); },
406 (e) { return e is UnsupportedOperationException; });
407 Expect.throws(() { array.clear(); },
408 (e) { return e is UnsupportedOperationException; });
409 Expect.throws(() { array.insertRange(0, array.length, 0); },
410 (e) { return e is UnsupportedOperationException; });
411 Expect.throws(() { array.length = 0; },
412 (e) { return e is UnsupportedOperationException; });
413 Expect.throws(() { array.removeLast(); },
414 (e) { return e is UnsupportedOperationException; });
415 Expect.throws(() { array.removeRange(0, array.length - 1); },
416 (e) { return e is UnsupportedOperationException; });
417 for (int i = 0; i < array.length; ++i) {
418 array[i] = 1 + i;
419 }
420 Expect.listEquals([1, 2, 3, 4, 5,
421 6, 7, 8, 9, 10],
422 array);
423 for (int i = 0; i < array.length; ++i) {
424 array[i] = 0x100000000 + i;
425 }
426 Expect.listEquals([0, 1, 2, 3, 4,
427 5, 6, 7, 8, 9],
428 array);
429 for (int i = 0; i < array.length; ++i) {
430 array[i] = 0xFFFFFFFF - i;
431 }
432 Expect.listEquals([0xFFFFFFFF, 0xFFFFFFFE,
433 0xFFFFFFFD, 0xFFFFFFFC,
434 0xFFFFFFFB, 0xFFFFFFFA,
435 0xFFFFFFF9, 0xFFFFFFF8,
436 0xFFFFFFF7, 0xFFFFFFF6],
437 array);
438 for (int i = 0; i < array.length; ++i) {
439 array[i] = i;
440 }
441 var copy = array.getRange(0, array.length);
442 Expect.isFalse(copy === array);
443 Expect.isTrue(copy is Uint32Array);
444 Expect.equals(10, copy.length);
445 Expect.listEquals(array, copy);
446 var region = array.getRange(3, array.length - 6);
447 Expect.isTrue(copy is Uint32Array);
448 Expect.equals(4, region.length);
449 Expect.listEquals([3, 4, 5, 6], region);
450 array.setRange(3, 4, [0x100000001, 0, 1, 0xFFFFFFFF]);
451 Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFFFFFF, 7, 8, 9],
452 array);
453 }
454
455 static testInt64Array() {
456 var array = new Int64Array(10);
457 Expect.isTrue(array is List<int>);
458 Expect.equals(10, array.length);
459 Expect.equals(8, array.bytesPerElement());
460 Expect.equals(80, array.lengthInBytes());
461 Expect.listEquals([0, 0, 0, 0, 0,
462 0, 0, 0, 0, 0],
463 array);
464 Expect.throws(() { array[-1] = 0; },
465 (e) { return e is IndexOutOfRangeException; });
466 Expect.throws(() { return array[-1]; },
467 (e) { return e is IndexOutOfRangeException; });
468 Expect.throws(() { array[10]; },
469 (e) { return e is IndexOutOfRangeException; });
470 Expect.throws(() { array[10] = 0; },
471 (e) { return e is IndexOutOfRangeException; });
472 Expect.throws(() { array.add(0); },
473 (e) { return e is UnsupportedOperationException; });
474 Expect.throws(() { array.addAll([0]); },
475 (e) { return e is UnsupportedOperationException; });
476 Expect.throws(() { array.addLast(0); },
477 (e) { return e is UnsupportedOperationException; });
478 Expect.throws(() { array.clear(); },
479 (e) { return e is UnsupportedOperationException; });
480 Expect.throws(() { array.insertRange(0, array.length, 0); },
481 (e) { return e is UnsupportedOperationException; });
482 Expect.throws(() { array.length = 0; },
483 (e) { return e is UnsupportedOperationException; });
484 Expect.throws(() { array.removeLast(); },
485 (e) { return e is UnsupportedOperationException; });
486 Expect.throws(() { array.removeRange(0, array.length - 1); },
487 (e) { return e is UnsupportedOperationException; });
488 for (int i = 0; i < array.length; ++i) {
489 array[i] = 1 + i;
490 }
491 Expect.listEquals([1, 2, 3, 4, 5,
492 6, 7, 8, 9, 10],
493 array);
494 for (int i = 0; i < array.length; ++i) {
495 array[i] = 0x10000000000000000 + i;
496 }
497 Expect.listEquals([0, 1, 2, 3, 4,
498 5, 6, 7, 8, 9],
499 array);
500 for (int i = 0; i < array.length; ++i) {
501 array[i] = -10 + i;
502 }
503 Expect.listEquals([-10, -9, -8, -7, -6,
504 -5, -4, -3, -2, -1],
505 array);
506 for (int i = 0; i < array.length; ++i) {
507 array[i] = 0x7FFFFFFFFFFFFFFF - i;
508 }
509 Expect.listEquals([0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFE,
510 0x7FFFFFFFFFFFFFFD, 0x7FFFFFFFFFFFFFFC,
511 0x7FFFFFFFFFFFFFFB, 0x7FFFFFFFFFFFFFFA,
512 0x7FFFFFFFFFFFFFF9, 0x7FFFFFFFFFFFFFF8,
513 0x7FFFFFFFFFFFFFF7, 0x7FFFFFFFFFFFFFF6],
514 array);
515 for (int i = 0; i < array.length; ++i) {
516 array[i] = -0x8000000000000000 + i;
517 }
518 Expect.listEquals([-0x8000000000000000, -0x7FFFFFFFFFFFFFFF,
519 -0x7FFFFFFFFFFFFFFE, -0x7FFFFFFFFFFFFFFD,
520 -0x7FFFFFFFFFFFFFFC, -0x7FFFFFFFFFFFFFFB,
521 -0x7FFFFFFFFFFFFFFA, -0x7FFFFFFFFFFFFFF9,
522 -0x7FFFFFFFFFFFFFF8, -0x7FFFFFFFFFFFFFF7],
523 array);
524 for (int i = 0; i < array.length; ++i) {
525 array[i] = i;
526 }
527 var copy = array.getRange(0, array.length);
528 Expect.isFalse(copy === array);
529 Expect.isTrue(copy is Int64Array);
530 Expect.equals(10, copy.length);
531 Expect.listEquals(array, copy);
532 var region = array.getRange(3, array.length - 6);
533 Expect.isTrue(copy is Int64Array);
534 Expect.equals(4, region.length);
535 Expect.listEquals([3, 4, 5, 6], region);
536 array.setRange(3, 4, [-0x8000000000000000, 0, 1, 0x7FFFFFFFFFFFFFFF]);
537 Expect.listEquals([0, 1, 2, -0x8000000000000000, 0,
538 1, 0x7FFFFFFFFFFFFFFF, 7, 8, 9],
539 array);
540 }
541
542 static testUint64Array() {
543 var array = new Uint64Array(10);
544 Expect.isTrue(array is List<int>);
545 Expect.equals(10, array.length);
546 Expect.equals(8, array.bytesPerElement());
547 Expect.equals(80, array.lengthInBytes());
548 Expect.listEquals([0, 0, 0, 0, 0,
549 0, 0, 0, 0, 0],
550 array);
551 Expect.throws(() { array[-1] = 0; },
552 (e) { return e is IndexOutOfRangeException; });
553 Expect.throws(() { return array[-1]; },
554 (e) { return e is IndexOutOfRangeException; });
555 Expect.throws(() { array[10]; },
556 (e) { return e is IndexOutOfRangeException; });
557 Expect.throws(() { array[10] = 0; },
558 (e) { return e is IndexOutOfRangeException; });
559 Expect.throws(() { array.add(0); },
560 (e) { return e is UnsupportedOperationException; });
561 Expect.throws(() { array.addAll([0]); },
562 (e) { return e is UnsupportedOperationException; });
563 Expect.throws(() { array.addLast(0); },
564 (e) { return e is UnsupportedOperationException; });
565 Expect.throws(() { array.clear(); },
566 (e) { return e is UnsupportedOperationException; });
567 Expect.throws(() { array.insertRange(0, array.length, 0); },
568 (e) { return e is UnsupportedOperationException; });
569 Expect.throws(() { array.length = 0; },
570 (e) { return e is UnsupportedOperationException; });
571 Expect.throws(() { array.removeLast(); },
572 (e) { return e is UnsupportedOperationException; });
573 Expect.throws(() { array.removeRange(0, array.length - 1); },
574 (e) { return e is UnsupportedOperationException; });
575 for (int i = 0; i < array.length; ++i) {
576 array[i] = 1 + i;
577 }
578 Expect.listEquals([1, 2, 3, 4, 5,
579 6, 7, 8, 9, 10],
580 array);
581 for (int i = 0; i < array.length; ++i) {
582 array[i] = 0x10000000000000000 + i;
583 }
584 Expect.listEquals([0, 1, 2, 3, 4,
585 5, 6, 7, 8, 9],
586 array);
587 for (int i = 0; i < array.length; ++i) {
588 array[i] = 0xFFFFFFFFFFFFFFFF - i;
589 }
590 Expect.listEquals([0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFE,
591 0xFFFFFFFFFFFFFFFD, 0xFFFFFFFFFFFFFFFC,
592 0xFFFFFFFFFFFFFFFB, 0xFFFFFFFFFFFFFFFA,
593 0xFFFFFFFFFFFFFFF9, 0xFFFFFFFFFFFFFFF8,
594 0xFFFFFFFFFFFFFFF7, 0xFFFFFFFFFFFFFFF6],
595 array);
596 for (int i = 0; i < array.length; ++i) {
597 array[i] = i;
598 }
599 var copy = array.getRange(0, array.length);
600 Expect.isFalse(copy === array);
601 Expect.isTrue(copy is Uint64Array);
602 Expect.equals(10, copy.length);
603 Expect.listEquals(array, copy);
604 var region = array.getRange(3, array.length - 6);
605 Expect.isTrue(copy is Uint64Array);
606 Expect.equals(4, region.length);
607 Expect.listEquals([3, 4, 5, 6], region);
608 array.setRange(3, 4, [0x10000000000000001, 0, 1, 0xFFFFFFFFFFFFFFFF]);
609 Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFFFFFFFFFFFFFF, 7, 8, 9],
610 array);
611 }
612
613 static testFloat32Array() {
614 var array = new Float32Array(10);
615 Expect.isTrue(array is List<double>);
616 Expect.equals(10, array.length);
617 Expect.equals(4, array.bytesPerElement());
618 Expect.equals(40, array.lengthInBytes());
619 Expect.listEquals([0.0, 0.0, 0.0, 0.0, 0.0,
620 0.0, 0.0, 0.0, 0.0, 0.0],
621 array);
622 Expect.throws(() { array[-1] = 0.0; },
623 (e) { return e is IndexOutOfRangeException; });
624 Expect.throws(() { return array[-1]; },
625 (e) { return e is IndexOutOfRangeException; });
626 Expect.throws(() { array[10]; },
627 (e) { return e is IndexOutOfRangeException; });
628 Expect.throws(() { array[10] = 0.0; },
629 (e) { return e is IndexOutOfRangeException; });
630 Expect.throws(() { array.add(0.0); },
631 (e) { return e is UnsupportedOperationException; });
632 Expect.throws(() { array.addAll([0]); },
633 (e) { return e is UnsupportedOperationException; });
634 Expect.throws(() { array.addLast(0.0); },
635 (e) { return e is UnsupportedOperationException; });
636 Expect.throws(() { array.clear(); },
637 (e) { return e is UnsupportedOperationException; });
638 Expect.throws(() { array.insertRange(0, array.length, 0.0); },
639 (e) { return e is UnsupportedOperationException; });
640 Expect.throws(() { array.length = 0; },
641 (e) { return e is UnsupportedOperationException; });
642 Expect.throws(() { array.removeLast(); },
643 (e) { return e is UnsupportedOperationException; });
644 Expect.throws(() { array.removeRange(0, array.length - 1); },
645 (e) { return e is UnsupportedOperationException; });
646 for (int i = 0; i < array.length; ++i) {
647 array[i] = 1.0 + i;
648 }
649 Expect.listEquals([1.0, 2.0, 3.0, 4.0, 5.0,
650 6.0, 7.0, 8.0, 9.0, 10.0],
651 array);
652 // TODO: min, max, and round
653 for (int i = 0; i < array.length; ++i) {
654 array[i] = i * 1.0;
655 }
656 var copy = array.getRange(0, array.length);
657 Expect.isFalse(copy === array);
658 Expect.isTrue(copy is Float32Array);
659 Expect.equals(10, copy.length);
660 Expect.listEquals(array, copy);
661 var region = array.getRange(3, array.length - 6);
662 Expect.isTrue(copy is Float32Array);
663 Expect.equals(4, region.length);
664 Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
665 array.setRange(3, 4, [double.NEGATIVE_INFINITY, 0.0, 1.0, double.INFINITY]);
666 Expect.listEquals([0.0, 1.0, 2.0, double.NEGATIVE_INFINITY, 0.0,
667 1.0, double.INFINITY, 7.0, 8.0, 9.0],
668 array);
669 }
670
671 static testFloat64Array() {
672 var array = new Float64Array(10);
673 Expect.isTrue(array is List<double>);
674 Expect.equals(10, array.length);
675 Expect.equals(8, array.bytesPerElement());
676 Expect.equals(80, array.lengthInBytes());
677 Expect.listEquals([0.0, 0.0, 0.0, 0.0, 0.0,
678 0.0, 0.0, 0.0, 0.0, 0.0],
679 array);
680 Expect.throws(() { array[-1] = 0.0; },
681 (e) { return e is IndexOutOfRangeException; });
682 Expect.throws(() { return array[-1]; },
683 (e) { return e is IndexOutOfRangeException; });
684 Expect.throws(() { array[10]; },
685 (e) { return e is IndexOutOfRangeException; });
686 Expect.throws(() { array[10] = 0.0; },
687 (e) { return e is IndexOutOfRangeException; });
688 Expect.throws(() { array.add(0.0); },
689 (e) { return e is UnsupportedOperationException; });
690 Expect.throws(() { array.addAll([0]); },
691 (e) { return e is UnsupportedOperationException; });
692 Expect.throws(() { array.addLast(0.0); },
693 (e) { return e is UnsupportedOperationException; });
694 Expect.throws(() { array.clear(); },
695 (e) { return e is UnsupportedOperationException; });
696 Expect.throws(() { array.insertRange(0, array.length, 0.0); },
697 (e) { return e is UnsupportedOperationException; });
698 Expect.throws(() { array.length = 0; },
699 (e) { return e is UnsupportedOperationException; });
700 Expect.throws(() { array.removeLast(); },
701 (e) { return e is UnsupportedOperationException; });
702 Expect.throws(() { array.removeRange(0, array.length - 1); },
703 (e) { return e is UnsupportedOperationException; });
704 for (int i = 0; i < array.length; ++i) {
705 array[i] = 1.0 + i;
706 }
707 Expect.listEquals([1.0, 2.0, 3.0, 4.0, 5.0,
708 6.0, 7.0, 8.0, 9.0, 10.0],
709 array);
710 // TODO: min, max
711 for (int i = 0; i < array.length; ++i) {
712 array[i] = i * 1.0;
713 }
714 var copy = array.getRange(0, array.length);
715 Expect.isFalse(copy === array);
716 Expect.isTrue(copy is Float64Array);
717 Expect.equals(10, copy.length);
718 Expect.listEquals(array, copy);
719 var region = array.getRange(3, array.length - 6);
720 Expect.isTrue(copy is Float64Array);
721 Expect.equals(4, region.length);
722 Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
723 array.setRange(3, 4, [double.NEGATIVE_INFINITY, 0.0, 1.0, double.INFINITY]);
724 Expect.listEquals([0.0, 1.0, 2.0, double.NEGATIVE_INFINITY, 0.0,
725 1.0, double.INFINITY, 7.0, 8.0, 9.0],
726 array);
727 }
728
729 static testByteArray() {
730 var array = new Uint8Array(8);
731 Expect.equals(8, array.length);
732 Expect.equals(8, array.lengthInBytes());
733 var byte_array = array.asByteArray(0, array.lengthInBytes());
734 Expect.equals(8, byte_array.lengthInBytes());
735 Expect.throws(() { byte_array.getInt8(-1); },
736 (e) { return e is IndexOutOfRangeException; });
737 Expect.throws(() { byte_array.getUint8(-1); },
738 (e) { return e is IndexOutOfRangeException; });
739 Expect.throws(() { byte_array.getInt16(-1); },
740 (e) { return e is IndexOutOfRangeException; });
741 Expect.throws(() { byte_array.getUint16(-1); },
742 (e) { return e is IndexOutOfRangeException; });
743 Expect.throws(() { byte_array.getInt32(-1); },
744 (e) { return e is IndexOutOfRangeException; });
745 Expect.throws(() { byte_array.getUint32(-1); },
746 (e) { return e is IndexOutOfRangeException; });
747 Expect.throws(() { byte_array.getInt64(-1); },
748 (e) { return e is IndexOutOfRangeException; });
749 Expect.throws(() { byte_array.getUint64(-1); },
750 (e) { return e is IndexOutOfRangeException; });
751 Expect.throws(() { byte_array.getFloat32(-1); },
752 (e) { return e is IndexOutOfRangeException; });
753 Expect.throws(() { byte_array.getFloat64(-1); },
754 (e) { return e is IndexOutOfRangeException; });
755 Expect.throws(() { byte_array.setInt8(-1, 0); },
756 (e) { return e is IndexOutOfRangeException; });
757 Expect.throws(() { byte_array.setUint8(-1, 0); },
758 (e) { return e is IndexOutOfRangeException; });
759 Expect.throws(() { byte_array.setInt16(-1, 0); },
760 (e) { return e is IndexOutOfRangeException; });
761 Expect.throws(() { byte_array.setUint16(-1, 0); },
762 (e) { return e is IndexOutOfRangeException; });
763 Expect.throws(() { byte_array.setInt32(-1, 0); },
764 (e) { return e is IndexOutOfRangeException; });
765 Expect.throws(() { byte_array.setUint32(-1, 0); },
766 (e) { return e is IndexOutOfRangeException; });
767 Expect.throws(() { byte_array.setInt64(-1, 0); },
768 (e) { return e is IndexOutOfRangeException; });
769 Expect.throws(() { byte_array.setUint64(-1, 0); },
770 (e) { return e is IndexOutOfRangeException; });
771 Expect.throws(() { byte_array.setFloat32(-1, 0.0); },
772 (e) { return e is IndexOutOfRangeException; });
773 Expect.throws(() { byte_array.setFloat64(-1, 0.0); },
774 (e) { return e is IndexOutOfRangeException; });
775 Expect.throws(() { byte_array.getInt8(8); },
776 (e) { return e is IndexOutOfRangeException; });
777 Expect.throws(() { byte_array.getUint8(8); },
778 (e) { return e is IndexOutOfRangeException; });
779 Expect.throws(() { byte_array.getInt16(8); },
780 (e) { return e is IndexOutOfRangeException; });
781 Expect.throws(() { byte_array.getUint16(8); },
782 (e) { return e is IndexOutOfRangeException; });
783 Expect.throws(() { byte_array.getInt32(8); },
784 (e) { return e is IndexOutOfRangeException; });
785 Expect.throws(() { byte_array.getUint32(8); },
786 (e) { return e is IndexOutOfRangeException; });
787 Expect.throws(() { byte_array.getInt64(8); },
788 (e) { return e is IndexOutOfRangeException; });
789 Expect.throws(() { byte_array.getUint64(8); },
790 (e) { return e is IndexOutOfRangeException; });
791 Expect.throws(() { byte_array.getFloat32(8); },
792 (e) { return e is IndexOutOfRangeException; });
793 Expect.throws(() { byte_array.getFloat64(8); },
794 (e) { return e is IndexOutOfRangeException; });
795 Expect.throws(() { byte_array.setInt8(8, 0); },
796 (e) { return e is IndexOutOfRangeException; });
797 Expect.throws(() { byte_array.setUint8(8, 0); },
798 (e) { return e is IndexOutOfRangeException; });
799 Expect.throws(() { byte_array.setInt16(8, 0); },
800 (e) { return e is IndexOutOfRangeException; });
801 Expect.throws(() { byte_array.setUint16(8, 0); },
802 (e) { return e is IndexOutOfRangeException; });
803 Expect.throws(() { byte_array.setInt32(8, 0); },
804 (e) { return e is IndexOutOfRangeException; });
805 Expect.throws(() { byte_array.setUint32(8, 0); },
806 (e) { return e is IndexOutOfRangeException; });
807 Expect.throws(() { byte_array.setInt64(8, 0); },
808 (e) { return e is IndexOutOfRangeException; });
809 Expect.throws(() { byte_array.setUint64(8, 0); },
810 (e) { return e is IndexOutOfRangeException; });
811 Expect.throws(() { byte_array.setFloat32(8, 0.0); },
812 (e) { return e is IndexOutOfRangeException; });
813 Expect.throws(() { byte_array.setFloat64(8, 0.0); },
814 (e) { return e is IndexOutOfRangeException; });
815 Expect.equals(0, byte_array.getInt8(0));
816 Expect.equals(0, byte_array.getUint8(0));
817 Expect.equals(0, byte_array.getInt16(0));
818 Expect.equals(0, byte_array.getUint16(0));
819 Expect.equals(0, byte_array.getInt32(0));
820 Expect.equals(0, byte_array.getUint32(0));
821 Expect.equals(0, byte_array.getInt64(0));
822 Expect.equals(0, byte_array.getUint64(0));
823 Expect.equals(0.0, byte_array.getFloat32(0));
824 Expect.equals(0.0, byte_array.getFloat64(0));
825 for (int i = 0; i < array.length; ++i) {
826 array[i] = 0xFF;
827 }
828 Expect.equals(-1, byte_array.getInt8(0));
829 Expect.equals(0xFF, byte_array.getUint8(0));
830 Expect.equals(-1, byte_array.getInt16(0));
831 Expect.equals(0xFFFF, byte_array.getUint16(0));
832 Expect.equals(-1, byte_array.getInt32(0));
833 Expect.equals(0xFFFFFFFF, byte_array.getUint32(0));
834 Expect.equals(-1, byte_array.getInt64(0));
835 Expect.equals(0xFFFFFFFFFFFFFFFF, byte_array.getUint64(0));
836 Expect.isTrue(byte_array.getFloat32(0).isNaN());
837 Expect.isTrue(byte_array.getFloat64(0).isNaN());
838 for (int i = 0; i < array.length; ++i) {
839 array[i] = 0xFF - i;
840 }
841 byte_array.setUint32(0, 0xBF800000);
842 Expect.equals(0, byte_array.getInt8(0));
843 Expect.equals(0, byte_array.getInt8(1));
844 Expect.equals(-128, byte_array.getInt8(2));
845 Expect.equals(-65, byte_array.getInt8(3));
846 Expect.equals(-5, byte_array.getInt8(4));
847 Expect.equals(-6, byte_array.getInt8(5));
848 Expect.equals(-7, byte_array.getInt8(6));
849 Expect.equals(-8, byte_array.getInt8(7));
850 Expect.equals(0x00, byte_array.getUint8(0));
851 Expect.equals(0x00, byte_array.getUint8(1));
852 Expect.equals(0x80, byte_array.getUint8(2));
853 Expect.equals(0xBF, byte_array.getUint8(3));
854 Expect.equals(0xFB, byte_array.getUint8(4));
855 Expect.equals(0xFA, byte_array.getUint8(5));
856 Expect.equals(0xF9, byte_array.getUint8(6));
857 Expect.equals(0xF8, byte_array.getUint8(7));
858 Expect.equals(0, byte_array.getInt16(0));
859 Expect.equals(-16512, byte_array.getInt16(2));
860 Expect.equals(-1285, byte_array.getInt16(4));
861 Expect.equals(-1799, byte_array.getInt16(6));
862 Expect.equals(0x0000, byte_array.getUint16(0));
863 Expect.equals(0xBF80, byte_array.getUint16(2));
864 Expect.equals(0xFAFB, byte_array.getUint16(4));
865 Expect.equals(0xF8F9, byte_array.getUint16(6));
866 Expect.equals(-1082130432, byte_array.getInt32(0));
867 Expect.equals(0xBF800000, byte_array.getUint32(0));
868 Expect.equals(-506097523945897984, byte_array.getInt64(0));
869 Expect.equals(0xF8F9FAFBBF800000, byte_array.getUint64(0));
870 Expect.equals(-1.0, byte_array.getFloat32(0));
871 // TODO: byte_array.getFloat64(0)
872 }
873
874 static testInt8ArrayView() {
875 var array = new Uint8Array(12);
876 Expect.equals(12, array.length);
877 Expect.equals(1, array.bytesPerElement());
878 Expect.equals(12, array.lengthInBytes());
879 for (int i = 0; i < array.length; ++i) {
880 array[i] = 0xFF;
881 }
882 Expect.throws(() { new Int8Array.view(array.asByteArray(), -1); },
883 (e) { return e is IndexOutOfRangeException; });
884 Expect.throws(() { new Int8Array.view(array.asByteArray(), 0, -1); },
885 (e) { return e is IndexOutOfRangeException; });
886 Expect.throws(() { new Int8Array.view(array.asByteArray(),
887 array.length); },
888 (e) { return e is IndexOutOfRangeException; });
889 Expect.throws(() { new Int8Array.view(array.asByteArray(),
890 0, array.length + 1); },
891 (e) { return e is IndexOutOfRangeException; });
892 Expect.throws(() { new Int8Array.view(array.asByteArray(),
893 array.length - 1, 2); },
894 (e) { return e is IndexOutOfRangeException; });
895 var view = new Int8Array.view(array.asByteArray(), 1, array.length - 2);
896 Expect.isTrue(view is List<int>);
897 Expect.isTrue(view is Int8Array);
898 Expect.equals(10, view.length);
899 Expect.equals(1, view.bytesPerElement());
900 Expect.equals(10, view.lengthInBytes());
901 Expect.listEquals([-1, -1, -1, -1, -1,
902 -1, -1, -1, -1, -1],
903 view);
904 Expect.throws(() { view[-1] = 0; },
905 (e) { return e is IndexOutOfRangeException; });
906 Expect.throws(() { return view[-1]; },
907 (e) { return e is IndexOutOfRangeException; });
908 Expect.throws(() { view[view.length]; },
909 (e) { return e is IndexOutOfRangeException; });
910 Expect.throws(() { view[10] = 0; },
911 (e) { return e is IndexOutOfRangeException; });
912 Expect.throws(() { view.add(0); },
913 (e) { return e is UnsupportedOperationException; });
914 Expect.throws(() { view.addAll([0]); },
915 (e) { return e is UnsupportedOperationException; });
916 Expect.throws(() { view.addLast(0); },
917 (e) { return e is UnsupportedOperationException; });
918 Expect.throws(() { view.clear(); },
919 (e) { return e is UnsupportedOperationException; });
920 Expect.throws(() { view.insertRange(0, view.length, 0); },
921 (e) { return e is UnsupportedOperationException; });
922 Expect.throws(() { view.length = 0; },
923 (e) { return e is UnsupportedOperationException; });
924 Expect.throws(() { view.removeLast(); },
925 (e) { return e is UnsupportedOperationException; });
926 Expect.throws(() { view.removeRange(0, view.length - 1); },
927 (e) { return e is UnsupportedOperationException; });
928 for (int i = 0; i < view.length; ++i) {
929 view[i] = 1 + i;
930 }
931 Expect.listEquals([1, 2, 3, 4, 5,
932 6, 7, 8, 9, 10],
933 view);
934 Expect.listEquals([0xFF, 1, 2, 3, 4, 5,
935 6, 7, 8, 9, 10, 0xFF],
936 array);
937 for (int i = 0; i < view.length; ++i) {
938 view[i] = 0x100 + i;
939 }
940 Expect.listEquals([0, 1, 2, 3, 4,
941 5, 6, 7, 8, 9],
942 view);
943 Expect.listEquals([0xFF, 0, 1, 2, 3, 4,
944 5, 6, 7, 8, 9, 0xFF],
945 array);
946 for (int i = 0; i < view.length; ++i) {
947 view[i] = -10 + i;
948 }
949 Expect.listEquals([-10, -9, -8, -7, -6,
950 -5, -4, -3, -2, -1],
951 view);
952 Expect.listEquals([0xFF, 0xF6, 0xF7, 0xF8, 0xF9, 0xFA,
953 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0xFF],
954 array);
955 for (int i = 0; i < view.length; ++i) {
956 view[i] = 0x7F - i;
957 }
958 Expect.listEquals([127, 126, 125, 124, 123,
959 122, 121, 120, 119, 118],
960 view);
961 Expect.listEquals([0xFF, 127, 126, 125, 124, 123,
962 122, 121, 120, 119, 118, 0xFF],
963 array);
964 for (int i = 0; i < view.length; ++i) {
965 view[i] = -0x80 + i;
966 }
967 Expect.listEquals([-128, -127, -126, -125, -124,
968 -123, -122, -121, -120, -119],
969 view);
970 Expect.listEquals([0xFF, 0x80, 0x81, 0x82, 0x83, 0x84,
971 0x85, 0x86, 0x87, 0x88, 0x89, 0xFF],
972 array);
973 for (int i = 0; i < view.length; ++i) {
974 view[i] = i;
975 }
976 var copy = view.getRange(0, view.length);
977 Expect.isFalse(copy === view);
978 Expect.isTrue(copy is Int8Array);
979 Expect.equals(10, copy.length);
980 Expect.listEquals(view, copy);
981 var region = view.getRange(3, view.length - 6);
982 Expect.isTrue(copy is Int8Array);
983 Expect.equals(4, region.length);
984 Expect.listEquals([3, 4, 5, 6], region);
985 view.setRange(3, 4, [-128, 0, 1, 127]);
986 Expect.listEquals([0, 1, 2, -128, 0, 1, 127, 7, 8, 9],
987 view);
988 Expect.listEquals([0xFF, 0, 1, 2, 128, 0, 1, 127, 7, 8, 9, 0xFF],
989 array);
990 }
991
992 static testUint8ArrayView() {
993 var array = new Int8Array(12);
994 Expect.isTrue(array is List<int>);
995 Expect.equals(12, array.length);
996 Expect.equals(1, array.bytesPerElement());
997 Expect.equals(12, array.lengthInBytes());
998 for (int i = 0; i < array.length; ++i) {
999 array[i] = -1;
1000 }
1001 Expect.throws(() { new Uint8Array.view(array.asByteArray(), -1); },
1002 (e) { return e is IndexOutOfRangeException; });
1003 Expect.throws(() { new Uint8Array.view(array.asByteArray(), 0, -1); },
1004 (e) { return e is IndexOutOfRangeException; });
1005 Expect.throws(() { new Uint8Array.view(array.asByteArray(),
1006 array.length); },
1007 (e) { return e is IndexOutOfRangeException; });
1008 Expect.throws(() { new Uint8Array.view(array.asByteArray(),
1009 0, array.length + 1); },
1010 (e) { return e is IndexOutOfRangeException; });
1011 Expect.throws(() { new Uint8Array.view(array.asByteArray(),
1012 array.length - 1, 2); },
1013 (e) { return e is IndexOutOfRangeException; });
1014 var view = new Uint8Array.view(array.asByteArray(), 1, array.length - 2);
1015 Expect.isTrue(view is List<int>);
1016 Expect.isTrue(view is Uint8Array);
1017 Expect.equals(10, view.length);
1018 Expect.equals(1, view.bytesPerElement());
1019 Expect.equals(10, view.lengthInBytes());
1020 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1021 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
1022 view);
1023 Expect.throws(() { view[-1] = 0; },
1024 (e) { return e is IndexOutOfRangeException; });
1025 Expect.throws(() { return view[-1]; },
1026 (e) { return e is IndexOutOfRangeException; });
1027 Expect.throws(() { view[view.length]; },
1028 (e) { return e is IndexOutOfRangeException; });
1029 Expect.throws(() { view[view.length] = 0; },
1030 (e) { return e is IndexOutOfRangeException; });
1031 Expect.throws(() { view.add(0); },
1032 (e) { return e is UnsupportedOperationException; });
1033 Expect.throws(() { view.addAll([0]); },
1034 (e) { return e is UnsupportedOperationException; });
1035 Expect.throws(() { view.addLast(0); },
1036 (e) { return e is UnsupportedOperationException; });
1037 Expect.throws(() { view.clear(); },
1038 (e) { return e is UnsupportedOperationException; });
1039 Expect.throws(() { view.insertRange(0, view.length, 0); },
1040 (e) { return e is UnsupportedOperationException; });
1041 Expect.throws(() { view.length = 0; },
1042 (e) { return e is UnsupportedOperationException; });
1043 Expect.throws(() { view.removeLast(); },
1044 (e) { return e is UnsupportedOperationException; });
1045 Expect.throws(() { view.removeRange(0, view.length - 1); },
1046 (e) { return e is UnsupportedOperationException; });
1047 for (int i = 0; i < view.length; ++i) {
1048 view[i] = 1 + i;
1049 }
1050 Expect.listEquals([1, 2, 3, 4, 5,
1051 6, 7, 8, 9, 10],
1052 view);
1053 Expect.listEquals([-1, 1, 2, 3, 4, 5,
1054 6, 7, 8, 9, 10, -1],
1055 array);
1056 for (int i = 0; i < view.length; ++i) {
1057 view[i] = 0x100 + i;
1058 }
1059 Expect.listEquals([0, 1, 2, 3, 4,
1060 5, 6, 7, 8, 9],
1061 view);
1062 Expect.listEquals([-1, 0, 1, 2, 3, 4,
1063 5, 6, 7, 8, 9, -1],
1064 array);
1065 for (int i = 0; i < view.length; ++i) {
1066 view[i] = 0xFF - i;
1067 }
1068 Expect.listEquals([0xFF, 0xFE, 0xFD, 0xFC, 0xFB,
1069 0xFA, 0xF9, 0xF8, 0xF7, 0xF6],
1070 view);
1071 Expect.listEquals([-1, -1, -2, -3, -4, -5,
1072 -6, -7, -8, -9, -10, -1],
1073 array);
1074 for (int i = 0; i < view.length; ++i) {
1075 view[i] = i;
1076 }
1077 var copy = view.getRange(0, view.length);
1078 Expect.isFalse(copy === view);
1079 Expect.isTrue(copy is Uint8Array);
1080 Expect.equals(10, copy.length);
1081 Expect.listEquals(view, copy);
1082 var region = view.getRange(3, view.length - 6);
1083 Expect.isTrue(copy is Uint8Array);
1084 Expect.equals(4, region.length);
1085 Expect.listEquals([3, 4, 5, 6], region);
1086 view.setRange(3, 4, [257, 0, 1, 255]);
1087 Expect.listEquals([0, 1, 2, 1, 0, 1, 255, 7, 8, 9],
1088 view);
1089 }
1090
1091 static testInt16ArrayView() {
1092 var array = new Uint8Array(24);
1093 Expect.equals(24, array.length);
1094 Expect.equals(1, array.bytesPerElement());
1095 Expect.equals(24, array.lengthInBytes());
1096 for (int i = 0; i < array.length; ++i) {
1097 array[i] = 0xFF;
1098 }
1099 Expect.throws(() { new Int16Array.view(array.asByteArray(), -1); },
1100 (e) { return e is IndexOutOfRangeException; });
1101 Expect.throws(() { new Int16Array.view(array.asByteArray(), 0, -1); },
1102 (e) { return e is IndexOutOfRangeException; });
1103 Expect.throws(() { new Int16Array.view(array.asByteArray(),
1104 array.length); },
1105 (e) { return e is IndexOutOfRangeException; });
1106 Expect.throws(() { new Int16Array.view(array.asByteArray(),
1107 0, array.length + 1); },
1108 (e) { return e is IndexOutOfRangeException; });
1109 Expect.throws(() { new Int16Array.view(array.asByteArray(),
1110 array.length - 1, 2); },
1111 (e) { return e is IndexOutOfRangeException; });
1112 var view = new Int16Array.view(array.asByteArray(), 2, 10);
1113 Expect.isTrue(view is List<int>);
1114 Expect.isTrue(view is Int16Array);
1115 Expect.equals(10, view.length);
1116 Expect.equals(2, view.bytesPerElement());
1117 Expect.equals(20, view.lengthInBytes());
1118 Expect.listEquals([-1, -1, -1, -1, -1,
1119 -1, -1, -1, -1, -1],
1120 view);
1121 Expect.throws(() { view[-1] = 0; },
1122 (e) { return e is IndexOutOfRangeException; });
1123 Expect.throws(() { return view[-1]; },
1124 (e) { return e is IndexOutOfRangeException; });
1125 Expect.throws(() { view[view.length]; },
1126 (e) { return e is IndexOutOfRangeException; });
1127 Expect.throws(() { view[10] = 0; },
1128 (e) { return e is IndexOutOfRangeException; });
1129 Expect.throws(() { view.add(0); },
1130 (e) { return e is UnsupportedOperationException; });
1131 Expect.throws(() { view.addAll([0]); },
1132 (e) { return e is UnsupportedOperationException; });
1133 Expect.throws(() { view.addLast(0); },
1134 (e) { return e is UnsupportedOperationException; });
1135 Expect.throws(() { view.clear(); },
1136 (e) { return e is UnsupportedOperationException; });
1137 Expect.throws(() { view.insertRange(0, view.length, 0); },
1138 (e) { return e is UnsupportedOperationException; });
1139 Expect.throws(() { view.length = 0; },
1140 (e) { return e is UnsupportedOperationException; });
1141 Expect.throws(() { view.removeLast(); },
1142 (e) { return e is UnsupportedOperationException; });
1143 Expect.throws(() { view.removeRange(0, view.length - 1); },
1144 (e) { return e is UnsupportedOperationException; });
1145 for (int i = 0; i < view.length; ++i) {
1146 view[i] = 1 + i;
1147 }
1148 Expect.listEquals([1, 2, 3, 4, 5,
1149 6, 7, 8, 9, 10],
1150 view);
1151 Expect.listEquals([0xFF, 0xFF, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00,
1152 0x04, 0x00, 0x05, 0x00, 0x06, 0x00, 0x07, 0x00,
1153 0x08, 0x00, 0x09, 0x00, 0x0A, 0x00, 0xFF, 0xFF],
1154 array);
1155 for (int i = 0; i < view.length; ++i) {
1156 view[i] = 0x10000 + i;
1157 }
1158 Expect.listEquals([0, 1, 2, 3, 4,
1159 5, 6, 7, 8, 9],
1160 view);
1161 Expect.listEquals([0xFF, 0xFF, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00,
1162 0x03, 0x00, 0x04, 0x00, 0x05, 0x00, 0x06, 0x00,
1163 0x07, 0x00, 0x08, 0x00, 0x09, 0x00, 0xFF, 0xFF],
1164 array);
1165 for (int i = 0; i < view.length; ++i) {
1166 view[i] = -10 + i;
1167 }
1168 Expect.listEquals([-10, -9, -8, -7, -6,
1169 -5, -4, -3, -2, -1],
1170 view);
1171 Expect.listEquals([0xFF, 0xFF, 0xF6, 0xFF, 0xF7, 0xFF, 0xF8, 0xFF,
1172 0xF9, 0xFF, 0xFA, 0xFF, 0xFB, 0xFF, 0xFC, 0xFF,
1173 0xFD, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
1174 array);
1175 for (int i = 0; i < view.length; ++i) {
1176 view[i] = 0x7FFF - i;
1177 }
1178 Expect.listEquals([0x7FFF, 0x7FFE, 0x7FFD, 0x7FFC, 0x7FFB,
1179 0x7FFA, 0x7FF9, 0x7FF8, 0x7FF7, 0x7FF6],
1180 view);
1181 Expect.listEquals([0xFF, 0xFF, 0xFF, 0x7F, 0xFE, 0x7F, 0xFD, 0x7F,
1182 0xFC, 0x7F, 0xFB, 0x7F, 0xFA, 0x7F, 0xF9, 0x7F,
1183 0xF8, 0x7F, 0xF7, 0x7F, 0xF6, 0x7F, 0xFF, 0xFF],
1184 array);
1185 for (int i = 0; i < view.length; ++i) {
1186 view[i] = -0x8000 + i;
1187 }
1188 Expect.listEquals([-0x8000, -0x7FFF, -0x7FFE, -0x7FFD, -0x7FFC,
1189 -0x7FFB, -0x7FFA, -0x7FF9, -0x7FF8, -0x7FF7],
1190 view);
1191 Expect.listEquals([0xFF, 0xFF, 0x00, 0x80, 0x01, 0x80, 0x02, 0x80,
1192 0x03, 0x80, 0x04, 0x80, 0x05, 0x80, 0x06, 0x80,
1193 0x07, 0x80, 0x08, 0x80, 0x09, 0x80, 0xFF, 0xFF],
1194 array);
1195 for (int i = 0; i < view.length; ++i) {
1196 view[i] = i;
1197 }
1198 var copy = view.getRange(0, view.length);
1199 Expect.isFalse(copy === view);
1200 Expect.isTrue(copy is Int16Array);
1201 Expect.equals(10, copy.length);
1202 Expect.listEquals(view, copy);
1203 var region = view.getRange(3, view.length - 6);
1204 Expect.isTrue(copy is Int16Array);
1205 Expect.equals(4, region.length);
1206 Expect.listEquals([3, 4, 5, 6], region);
1207 view.setRange(3, 4, [-32768, 0, 1, 32767]);
1208 Expect.listEquals([0, 1, 2, -32768, 0, 1, 32767, 7, 8, 9],
1209 view);
1210 Expect.listEquals([0xFF, 0xFF, 0x00, 0x00, 0x01, 0x00, 0x02, 0x00,
1211 0x00, 0x80, 0x00, 0x00, 0x01, 0x00, 0xFF, 0x7F,
1212 0x07, 0x00, 0x08, 0x00, 0x09, 0x00, 0xFF, 0xFF],
1213 array);
1214 }
1215
1216 static testUint16ArrayView() {
1217 var array = new Int8Array(24);
1218 Expect.isTrue(array is List<int>);
1219 Expect.equals(24, array.length);
1220 Expect.equals(1, array.bytesPerElement());
1221 Expect.equals(24, array.lengthInBytes());
1222 for (int i = 0; i < array.length; ++i) {
1223 array[i] = -1;
1224 }
1225 Expect.throws(() { new Uint16Array.view(array.asByteArray(), -1); },
1226 (e) { return e is IndexOutOfRangeException; });
1227 Expect.throws(() { new Uint16Array.view(array.asByteArray(), 0, -1); },
1228 (e) { return e is IndexOutOfRangeException; });
1229 Expect.throws(() { new Uint16Array.view(array.asByteArray(),
1230 array.length); },
1231 (e) { return e is IndexOutOfRangeException; });
1232 Expect.throws(() { new Uint16Array.view(array.asByteArray(),
1233 0, array.length + 1); },
1234 (e) { return e is IndexOutOfRangeException; });
1235 Expect.throws(() { new Uint16Array.view(array.asByteArray(),
1236 array.length - 1, 2); },
1237 (e) { return e is IndexOutOfRangeException; });
1238 var view = new Uint16Array.view(array.asByteArray(), 2, 10);
1239 Expect.isTrue(view is List<int>);
1240 Expect.isTrue(view is Uint16Array);
1241 Expect.equals(10, view.length);
1242 Expect.equals(2, view.bytesPerElement());
1243 Expect.equals(20, view.lengthInBytes());
1244 Expect.listEquals([0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
1245 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF],
1246 view);
1247 Expect.throws(() { view[-1] = 0; },
1248 (e) { return e is IndexOutOfRangeException; });
1249 Expect.throws(() { return view[-1]; },
1250 (e) { return e is IndexOutOfRangeException; });
1251 Expect.throws(() { view[view.length]; },
1252 (e) { return e is IndexOutOfRangeException; });
1253 Expect.throws(() { view[view.length] = 0; },
1254 (e) { return e is IndexOutOfRangeException; });
1255 Expect.throws(() { view.add(0); },
1256 (e) { return e is UnsupportedOperationException; });
1257 Expect.throws(() { view.addAll([0]); },
1258 (e) { return e is UnsupportedOperationException; });
1259 Expect.throws(() { view.addLast(0); },
1260 (e) { return e is UnsupportedOperationException; });
1261 Expect.throws(() { view.clear(); },
1262 (e) { return e is UnsupportedOperationException; });
1263 Expect.throws(() { view.insertRange(0, view.length, 0); },
1264 (e) { return e is UnsupportedOperationException; });
1265 Expect.throws(() { view.length = 0; },
1266 (e) { return e is UnsupportedOperationException; });
1267 Expect.throws(() { view.removeLast(); },
1268 (e) { return e is UnsupportedOperationException; });
1269 Expect.throws(() { view.removeRange(0, view.length - 1); },
1270 (e) { return e is UnsupportedOperationException; });
1271 for (int i = 0; i < view.length; ++i) {
1272 view[i] = 1 + i;
1273 }
1274 Expect.listEquals([1, 2, 3, 4, 5,
1275 6, 7, 8, 9, 10],
1276 view);
1277 Expect.listEquals([-1, -1, 1, 0, 2, 0, 3, 0, 4, 0, 5, 0,
1278 6, 0, 7, 0, 8, 0, 9, 0, 10, 0, -1, -1],
1279 array);
1280 for (int i = 0; i < view.length; ++i) {
1281 view[i] = 0x10000 + i;
1282 }
1283 Expect.listEquals([0, 1, 2, 3, 4,
1284 5, 6, 7, 8, 9],
1285 view);
1286 Expect.listEquals([-1, -1, 0, 0, 1, 0, 2, 0, 3, 0, 4, 0,
1287 5, 0, 6, 0, 7, 0, 8, 0, 9, 0, -1, -1],
1288 array);
1289 for (int i = 0; i < view.length; ++i) {
1290 view[i] = 0xFFFF - i;
1291 }
1292 Expect.listEquals([0xFFFF, 0xFFFE, 0xFFFD, 0xFFFC, 0xFFFB,
1293 0xFFFA, 0xFFF9, 0xFFF8, 0xFFF7, 0xFFF6],
1294 view);
1295 Expect.listEquals([-1, -1, -1, -1, -2, -1, -3, -1,
1296 -4, -1, -5, -1, -6, -1, -7, -1,
1297 -8, -1, -9, -1, -10, -1, -1, -1],
1298 array);
1299 for (int i = 0; i < view.length; ++i) {
1300 view[i] = i;
1301 }
1302 var copy = view.getRange(0, view.length);
1303 Expect.isFalse(copy === view);
1304 Expect.isTrue(copy is Uint16Array);
1305 Expect.equals(10, copy.length);
1306 Expect.listEquals(view, copy);
1307 var region = view.getRange(3, view.length - 6);
1308 Expect.isTrue(copy is Uint16Array);
1309 Expect.equals(4, region.length);
1310 Expect.listEquals([3, 4, 5, 6], region);
1311 view.setRange(3, 4, [0x10001, 0, 1, 0xFFFF]);
1312 Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFF, 7, 8, 9],
1313 view);
1314 Expect.listEquals([-1, -1, 0, 0, 1, 0, 2, 0,
1315 1, 0, 0, 0, 1, 0, -1, -1,
1316 7, 0, 8, 0, 9, 0, -1, -1],
1317 array);
1318 }
1319
1320 static testInt32ArrayView() {
1321 var array = new Uint8Array(48);
1322 Expect.equals(48, array.length);
1323 Expect.equals(1, array.bytesPerElement());
1324 Expect.equals(48, array.lengthInBytes());
1325 for (int i = 0; i < array.length; ++i) {
1326 array[i] = 0xFF;
1327 }
1328 Expect.throws(() { new Int32Array.view(array.asByteArray(), -1); },
1329 (e) { return e is IndexOutOfRangeException; });
1330 Expect.throws(() { new Int32Array.view(array.asByteArray(), 0, -1); },
1331 (e) { return e is IndexOutOfRangeException; });
1332 Expect.throws(() { new Int32Array.view(array.asByteArray(),
1333 array.length); },
1334 (e) { return e is IndexOutOfRangeException; });
1335 Expect.throws(() { new Int32Array.view(array.asByteArray(),
1336 0, array.length + 1); },
1337 (e) { return e is IndexOutOfRangeException; });
1338 Expect.throws(() { new Int32Array.view(array.asByteArray(),
1339 array.length - 1, 2); },
1340 (e) { return e is IndexOutOfRangeException; });
1341 var view = new Int32Array.view(array.asByteArray(), 4, 10);
1342 Expect.isTrue(view is List<int>);
1343 Expect.isTrue(view is Int32Array);
1344 Expect.equals(10, view.length);
1345 Expect.equals(4, view.bytesPerElement());
1346 Expect.equals(40, view.lengthInBytes());
1347 Expect.listEquals([-1, -1, -1, -1, -1,
1348 -1, -1, -1, -1, -1],
1349 view);
1350 Expect.throws(() { view[-1] = 0; },
1351 (e) { return e is IndexOutOfRangeException; });
1352 Expect.throws(() { return view[-1]; },
1353 (e) { return e is IndexOutOfRangeException; });
1354 Expect.throws(() { view[view.length]; },
1355 (e) { return e is IndexOutOfRangeException; });
1356 Expect.throws(() { view[10] = 0; },
1357 (e) { return e is IndexOutOfRangeException; });
1358 Expect.throws(() { view.add(0); },
1359 (e) { return e is UnsupportedOperationException; });
1360 Expect.throws(() { view.addAll([0]); },
1361 (e) { return e is UnsupportedOperationException; });
1362 Expect.throws(() { view.addLast(0); },
1363 (e) { return e is UnsupportedOperationException; });
1364 Expect.throws(() { view.clear(); },
1365 (e) { return e is UnsupportedOperationException; });
1366 Expect.throws(() { view.insertRange(0, view.length, 0); },
1367 (e) { return e is UnsupportedOperationException; });
1368 Expect.throws(() { view.length = 0; },
1369 (e) { return e is UnsupportedOperationException; });
1370 Expect.throws(() { view.removeLast(); },
1371 (e) { return e is UnsupportedOperationException; });
1372 Expect.throws(() { view.removeRange(0, view.length - 1); },
1373 (e) { return e is UnsupportedOperationException; });
1374 for (int i = 0; i < view.length; ++i) {
1375 view[i] = 1 + i;
1376 }
1377 Expect.listEquals([1, 2, 3, 4, 5,
1378 6, 7, 8, 9, 10],
1379 view);
1380 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0x01, 0x00, 0x00, 0x00,
1381 0x02, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00,
1382 0x04, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
1383 0x06, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00,
1384 0x08, 0x00, 0x00, 0x00, 0x09, 0x00, 0x00, 0x00,
1385 0x0A, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF],
1386 array);
1387 for (int i = 0; i < view.length; ++i) {
1388 view[i] = 0x100000000 + i;
1389 }
1390 Expect.listEquals([0, 1, 2, 3, 4,
1391 5, 6, 7, 8, 9],
1392 view);
1393 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
1394 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
1395 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
1396 0x05, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00,
1397 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
1398 0x09, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF],
1399 array);
1400 for (int i = 0; i < view.length; ++i) {
1401 view[i] = -10 + i;
1402 }
1403 Expect.listEquals([-10, -9, -8, -7, -6,
1404 -5, -4, -3, -2, -1],
1405 view);
1406 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xF6, 0xFF, 0xFF, 0xFF,
1407 0xF7, 0xFF, 0xFF, 0xFF, 0xF8, 0xFF, 0xFF, 0xFF,
1408 0xF9, 0xFF, 0xFF, 0xFF, 0xFA, 0xFF, 0xFF, 0xFF,
1409 0xFB, 0xFF, 0xFF, 0xFF, 0xFC, 0xFF, 0xFF, 0xFF,
1410 0xFD, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFF, 0xFF,
1411 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
1412 array);
1413 for (int i = 0; i < view.length; ++i) {
1414 view[i] = 0x7FFFFFFF - i;
1415 }
1416 Expect.listEquals([0x7FFFFFFF, 0x7FFFFFFE,
1417 0x7FFFFFFD, 0x7FFFFFFC,
1418 0x7FFFFFFB, 0x7FFFFFFA,
1419 0x7FFFFFF9, 0x7FFFFFF8,
1420 0x7FFFFFF7, 0x7FFFFFF6],
1421 view);
1422 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
1423 0xFE, 0xFF, 0xFF, 0x7F, 0xFD, 0xFF, 0xFF, 0x7F,
1424 0xFC, 0xFF, 0xFF, 0x7F, 0xFB, 0xFF, 0xFF, 0x7F,
1425 0xFA, 0xFF, 0xFF, 0x7F, 0xF9, 0xFF, 0xFF, 0x7F,
1426 0xF8, 0xFF, 0xFF, 0x7F, 0xF7, 0xFF, 0xFF, 0x7F,
1427 0xF6, 0xFF, 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF],
1428 array);
1429 for (int i = 0; i < view.length; ++i) {
1430 view[i] = -0x80000000 + i;
1431 }
1432 Expect.listEquals([-0x80000000, -0x7FFFFFFF,
1433 -0x7FFFFFFE, -0x7FFFFFFD,
1434 -0x7FFFFFFC, -0x7FFFFFFB,
1435 -0x7FFFFFFA, -0x7FFFFFF9,
1436 -0x7FFFFFF8, -0x7FFFFFF7],
1437 view);
1438 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x80,
1439 0x01, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, 0x80,
1440 0x03, 0x00, 0x00, 0x80, 0x04, 0x00, 0x00, 0x80,
1441 0x05, 0x00, 0x00, 0x80, 0x06, 0x00, 0x00, 0x80,
1442 0x07, 0x00, 0x00, 0x80, 0x08, 0x00, 0x00, 0x80,
1443 0x09, 0x00, 0x00, 0x80, 0xFF, 0xFF, 0xFF, 0xFF],
1444 array);
1445 for (int i = 0; i < view.length; ++i) {
1446 view[i] = i;
1447 }
1448 var copy = view.getRange(0, view.length);
1449 Expect.isFalse(copy === view);
1450 Expect.isTrue(copy is Int32Array);
1451 Expect.equals(10, copy.length);
1452 Expect.listEquals(view, copy);
1453 var region = view.getRange(3, view.length - 6);
1454 Expect.isTrue(copy is Int32Array);
1455 Expect.equals(4, region.length);
1456 Expect.listEquals([3, 4, 5, 6], region);
1457 view.setRange(3, 4, [-0x80000000, 0, 1, 0x7FFFFFFF]);
1458 Expect.listEquals([0, 1, 2, -0x80000000, 0, 1, 0x7FFFFFFF, 7, 8, 9],
1459 view);
1460 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,
1461 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
1462 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00,
1463 0x01, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0x7F,
1464 0x07, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
1465 0x09, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF],
1466 array);
1467 }
1468
1469 static testUint32ArrayView() {
1470 var array = new Int8Array(48);
1471 Expect.isTrue(array is List<int>);
1472 Expect.equals(48, array.length);
1473 Expect.equals(1, array.bytesPerElement());
1474 Expect.equals(48, array.lengthInBytes());
1475 for (int i = 0; i < array.length; ++i) {
1476 array[i] = -1;
1477 }
1478 Expect.throws(() { new Uint32Array.view(array.asByteArray(), -1); },
1479 (e) { return e is IndexOutOfRangeException; });
1480 Expect.throws(() { new Uint32Array.view(array.asByteArray(), 0, -1); },
1481 (e) { return e is IndexOutOfRangeException; });
1482 Expect.throws(() { new Uint32Array.view(array.asByteArray(),
1483 array.length); },
1484 (e) { return e is IndexOutOfRangeException; });
1485 Expect.throws(() { new Uint32Array.view(array.asByteArray(),
1486 0, array.length + 1); },
1487 (e) { return e is IndexOutOfRangeException; });
1488 Expect.throws(() { new Uint32Array.view(array.asByteArray(),
1489 array.length - 1, 2); },
1490 (e) { return e is IndexOutOfRangeException; });
1491 var view = new Uint32Array.view(array.asByteArray(), 4, 10);
1492 Expect.isTrue(view is List<int>);
1493 Expect.isTrue(view is Uint32Array);
1494 Expect.equals(10, view.length);
1495 Expect.equals(4, view.bytesPerElement());
1496 Expect.equals(40, view.lengthInBytes());
1497 Expect.listEquals([0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFF F,
1498 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFF F],
1499 view);
1500 Expect.throws(() { view[-1] = 0; },
1501 (e) { return e is IndexOutOfRangeException; });
1502 Expect.throws(() { return view[-1]; },
1503 (e) { return e is IndexOutOfRangeException; });
1504 Expect.throws(() { view[view.length]; },
1505 (e) { return e is IndexOutOfRangeException; });
1506 Expect.throws(() { view[view.length] = 0; },
1507 (e) { return e is IndexOutOfRangeException; });
1508 Expect.throws(() { view.add(0); },
1509 (e) { return e is UnsupportedOperationException; });
1510 Expect.throws(() { view.addAll([0]); },
1511 (e) { return e is UnsupportedOperationException; });
1512 Expect.throws(() { view.addLast(0); },
1513 (e) { return e is UnsupportedOperationException; });
1514 Expect.throws(() { view.clear(); },
1515 (e) { return e is UnsupportedOperationException; });
1516 Expect.throws(() { view.insertRange(0, view.length, 0); },
1517 (e) { return e is UnsupportedOperationException; });
1518 Expect.throws(() { view.length = 0; },
1519 (e) { return e is UnsupportedOperationException; });
1520 Expect.throws(() { view.removeLast(); },
1521 (e) { return e is UnsupportedOperationException; });
1522 Expect.throws(() { view.removeRange(0, view.length - 1); },
1523 (e) { return e is UnsupportedOperationException; });
1524 for (int i = 0; i < view.length; ++i) {
1525 view[i] = 1 + i;
1526 }
1527 Expect.listEquals([1, 2, 3, 4, 5,
1528 6, 7, 8, 9, 10],
1529 view);
1530 Expect.listEquals([-1, -1, -1, -1, 1, 0, 0, 0,
1531 2, 0, 0, 0, 3, 0, 0, 0,
1532 4, 0, 0, 0, 5, 0, 0, 0,
1533 6, 0, 0, 0, 7, 0, 0, 0,
1534 8, 0, 0, 0, 9, 0, 0, 0,
1535 10, 0, 0, 0, -1, -1, -1, -1],
1536 array);
1537 for (int i = 0; i < view.length; ++i) {
1538 view[i] = 0x100000000 + i;
1539 }
1540 Expect.listEquals([0, 1, 2, 3, 4,
1541 5, 6, 7, 8, 9],
1542 view);
1543 Expect.listEquals([-1, -1, -1, -1, 0, 0, 0, 0,
1544 1, 0, 0, 0, 2, 0, 0, 0,
1545 3, 0, 0, 0, 4, 0, 0, 0,
1546 5, 0, 0, 0, 6, 0, 0, 0,
1547 7, 0, 0, 0, 8, 0, 0, 0,
1548 9, 0, 0, 0, -1, -1, -1, -1],
1549 array);
1550 for (int i = 0; i < view.length; ++i) {
1551 view[i] = 0xFFFFFFFF - i;
1552 }
1553 Expect.listEquals([0xFFFFFFFF, 0xFFFFFFFE,
1554 0xFFFFFFFD, 0xFFFFFFFC,
1555 0xFFFFFFFB, 0xFFFFFFFA,
1556 0xFFFFFFF9, 0xFFFFFFF8,
1557 0xFFFFFFF7, 0xFFFFFFF6],
1558 view);
1559 Expect.listEquals([-1, -1, -1, -1, -1, -1, -1, -1,
1560 -2, -1, -1, -1, -3, -1, -1, -1,
1561 -4, -1, -1, -1, -5, -1, -1, -1,
1562 -6, -1, -1, -1, -7, -1, -1, -1,
1563 -8, -1, -1, -1, -9, -1, -1, -1,
1564 -10, -1, -1, -1, -1, -1, -1, -1],
1565 array);
1566 for (int i = 0; i < view.length; ++i) {
1567 view[i] = i;
1568 }
1569 var copy = view.getRange(0, view.length);
1570 Expect.isFalse(copy === view);
1571 Expect.isTrue(copy is Uint32Array);
1572 Expect.equals(10, copy.length);
1573 Expect.listEquals(view, copy);
1574 var region = view.getRange(3, view.length - 6);
1575 Expect.isTrue(copy is Uint32Array);
1576 Expect.equals(4, region.length);
1577 Expect.listEquals([3, 4, 5, 6], region);
1578 view.setRange(3, 4, [0x100000001, 0, 1, 0xFFFFFFFF]);
1579 Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFFFFFF, 7, 8, 9],
1580 view);
1581 Expect.listEquals([-1, -1, -1, -1, 0, 0, 0, 0,
1582 1, 0, 0, 0, 2, 0, 0, 0,
1583 1, 0, 0, 0, 0, 0, 0, 0,
1584 1, 0, 0, 0, -1, -1, -1, -1,
1585 7, 0, 0, 0, 8, 0, 0, 0,
1586 9, 0, 0, 0, -1, -1, -1, -1],
1587 array);
1588 }
1589
1590 static testInt64ArrayView() {
1591 var array = new Uint8Array(96);
1592 Expect.equals(96, array.length);
1593 Expect.equals(1, array.bytesPerElement());
1594 Expect.equals(96, array.lengthInBytes());
1595 for (int i = 0; i < array.length; ++i) {
1596 array[i] = 0xFF;
1597 }
1598 Expect.throws(() { new Int64Array.view(array.asByteArray(), -1); },
1599 (e) { return e is IndexOutOfRangeException; });
1600 Expect.throws(() { new Int64Array.view(array.asByteArray(), 0, -1); },
1601 (e) { return e is IndexOutOfRangeException; });
1602 Expect.throws(() { new Int64Array.view(array.asByteArray(),
1603 array.length); },
1604 (e) { return e is IndexOutOfRangeException; });
1605 Expect.throws(() { new Int64Array.view(array.asByteArray(),
1606 0, array.length + 1); },
1607 (e) { return e is IndexOutOfRangeException; });
1608 Expect.throws(() { new Int64Array.view(array.asByteArray(),
1609 array.length - 1, 2); },
1610 (e) { return e is IndexOutOfRangeException; });
1611 var view = new Int64Array.view(array.asByteArray(), 8, 10);
1612 Expect.isTrue(view is List<int>);
1613 Expect.isTrue(view is Int64Array);
1614 Expect.equals(10, view.length);
1615 Expect.equals(8, view.bytesPerElement());
1616 Expect.equals(80, view.lengthInBytes());
1617 Expect.listEquals([-1, -1, -1, -1, -1,
1618 -1, -1, -1, -1, -1],
1619 view);
1620 Expect.throws(() { view[-1] = 0; },
1621 (e) { return e is IndexOutOfRangeException; });
1622 Expect.throws(() { return view[-1]; },
1623 (e) { return e is IndexOutOfRangeException; });
1624 Expect.throws(() { view[view.length]; },
1625 (e) { return e is IndexOutOfRangeException; });
1626 Expect.throws(() { view[10] = 0; },
1627 (e) { return e is IndexOutOfRangeException; });
1628 Expect.throws(() { view.add(0); },
1629 (e) { return e is UnsupportedOperationException; });
1630 Expect.throws(() { view.addAll([0]); },
1631 (e) { return e is UnsupportedOperationException; });
1632 Expect.throws(() { view.addLast(0); },
1633 (e) { return e is UnsupportedOperationException; });
1634 Expect.throws(() { view.clear(); },
1635 (e) { return e is UnsupportedOperationException; });
1636 Expect.throws(() { view.insertRange(0, view.length, 0); },
1637 (e) { return e is UnsupportedOperationException; });
1638 Expect.throws(() { view.length = 0; },
1639 (e) { return e is UnsupportedOperationException; });
1640 Expect.throws(() { view.removeLast(); },
1641 (e) { return e is UnsupportedOperationException; });
1642 Expect.throws(() { view.removeRange(0, view.length - 1); },
1643 (e) { return e is UnsupportedOperationException; });
1644 for (int i = 0; i < view.length; ++i) {
1645 view[i] = 1 + i;
1646 }
1647 Expect.listEquals([1, 2, 3, 4, 5,
1648 6, 7, 8, 9, 10],
1649 view);
1650 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1651 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1652 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1653 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1654 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1655 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1656 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1657 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1658 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1659 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1660 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1661 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
1662 array);
1663 for (int i = 0; i < view.length; ++i) {
1664 view[i] = 0x10000000000000000 + i;
1665 }
1666 Expect.listEquals([0, 1, 2, 3, 4,
1667 5, 6, 7, 8, 9],
1668 view);
1669 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1670 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1671 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1672 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1673 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1674 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1675 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1676 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1677 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1678 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1679 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1680 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
1681 array);
1682 for (int i = 0; i < view.length; ++i) {
1683 view[i] = -10 + i;
1684 }
1685 Expect.listEquals([-10, -9, -8, -7, -6,
1686 -5, -4, -3, -2, -1],
1687 view);
1688 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1689 0xF6, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1690 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1691 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1692 0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1693 0xFA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1694 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1695 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1696 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1697 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1698 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1699 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
1700 array);
1701 for (int i = 0; i < view.length; ++i) {
1702 view[i] = 0x7FFFFFFFFFFFFFFF - i;
1703 }
1704 Expect.listEquals([0x7FFFFFFFFFFFFFFF, 0x7FFFFFFFFFFFFFFE,
1705 0x7FFFFFFFFFFFFFFD, 0x7FFFFFFFFFFFFFFC,
1706 0x7FFFFFFFFFFFFFFB, 0x7FFFFFFFFFFFFFFA,
1707 0x7FFFFFFFFFFFFFF9, 0x7FFFFFFFFFFFFFF8,
1708 0x7FFFFFFFFFFFFFF7, 0x7FFFFFFFFFFFFFF6],
1709 view);
1710 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1711 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
1712 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
1713 0xFD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
1714 0xFC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
1715 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
1716 0xFA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
1717 0xF9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
1718 0xF8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
1719 0xF7, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
1720 0xF6, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
1721 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
1722 array);
1723 for (int i = 0; i < view.length; ++i) {
1724 view[i] = -0x8000000000000000 + i;
1725 }
1726 Expect.listEquals([-0x8000000000000000, -0x7FFFFFFFFFFFFFFF,
1727 -0x7FFFFFFFFFFFFFFE, -0x7FFFFFFFFFFFFFFD,
1728 -0x7FFFFFFFFFFFFFFC, -0x7FFFFFFFFFFFFFFB,
1729 -0x7FFFFFFFFFFFFFFA, -0x7FFFFFFFFFFFFFF9,
1730 -0x7FFFFFFFFFFFFFF8, -0x7FFFFFFFFFFFFFF7],
1731 view);
1732 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1733 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1734 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1735 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1736 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1737 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1738 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1739 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1740 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1741 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1742 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1743 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
1744 array);
1745 for (int i = 0; i < view.length; ++i) {
1746 view[i] = i;
1747 }
1748 var copy = view.getRange(0, view.length);
1749 Expect.isFalse(copy === view);
1750 Expect.isTrue(copy is Int64Array);
1751 Expect.equals(10, copy.length);
1752 Expect.listEquals(view, copy);
1753 var region = view.getRange(3, view.length - 6);
1754 Expect.isTrue(copy is Int64Array);
1755 Expect.equals(4, region.length);
1756 Expect.listEquals([3, 4, 5, 6], region);
1757 view.setRange(3, 4, [-0x8000000000000000, 0, 1, 0x7FFFFFFFFFFFFFFF]);
1758 Expect.listEquals([0, 1, 2, -0x8000000000000000, 0,
1759 1, 0x7FFFFFFFFFFFFFFF, 7, 8, 9],
1760 view);
1761 Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
1762 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1763 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1764 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1765 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
1766 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1767 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1768 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F,
1769 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1770 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1771 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
1772 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
1773 array);
1774 }
1775
1776 static testUint64ArrayView() {
1777 var array = new Int8Array(96);
1778 Expect.isTrue(array is List<int>);
1779 Expect.equals(96, array.length);
1780 Expect.equals(1, array.bytesPerElement());
1781 Expect.equals(96, array.lengthInBytes());
1782 for (int i = 0; i < array.length; ++i) {
1783 array[i] = -1;
1784 }
1785 Expect.throws(() { new Uint64Array.view(array.asByteArray(), -1); },
1786 (e) { return e is IndexOutOfRangeException; });
1787 Expect.throws(() { new Uint64Array.view(array.asByteArray(), 0, -1); },
1788 (e) { return e is IndexOutOfRangeException; });
1789 Expect.throws(() { new Uint64Array.view(array.asByteArray(),
1790 array.length); },
1791 (e) { return e is IndexOutOfRangeException; });
1792 Expect.throws(() { new Uint64Array.view(array.asByteArray(),
1793 0, array.length + 1); },
1794 (e) { return e is IndexOutOfRangeException; });
1795 Expect.throws(() { new Uint64Array.view(array.asByteArray(),
1796 array.length - 1, 2); },
1797 (e) { return e is IndexOutOfRangeException; });
1798 var view = new Uint64Array.view(array.asByteArray(), 8, 10);
1799 Expect.isTrue(view is List<int>);
1800 Expect.isTrue(view is Uint64Array);
1801 Expect.equals(10, view.length);
1802 Expect.equals(8, view.bytesPerElement());
1803 Expect.equals(80, view.lengthInBytes());
1804 Expect.listEquals([0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
1805 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
1806 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
1807 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
1808 0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF],
1809 view);
1810 Expect.throws(() { view[-1] = 0; },
1811 (e) { return e is IndexOutOfRangeException; });
1812 Expect.throws(() { return view[-1]; },
1813 (e) { return e is IndexOutOfRangeException; });
1814 Expect.throws(() { view[view.length]; },
1815 (e) { return e is IndexOutOfRangeException; });
1816 Expect.throws(() { view[view.length] = 0; },
1817 (e) { return e is IndexOutOfRangeException; });
1818 Expect.throws(() { view.add(0); },
1819 (e) { return e is UnsupportedOperationException; });
1820 Expect.throws(() { view.addAll([0]); },
1821 (e) { return e is UnsupportedOperationException; });
1822 Expect.throws(() { view.addLast(0); },
1823 (e) { return e is UnsupportedOperationException; });
1824 Expect.throws(() { view.clear(); },
1825 (e) { return e is UnsupportedOperationException; });
1826 Expect.throws(() { view.insertRange(0, view.length, 0); },
1827 (e) { return e is UnsupportedOperationException; });
1828 Expect.throws(() { view.length = 0; },
1829 (e) { return e is UnsupportedOperationException; });
1830 Expect.throws(() { view.removeLast(); },
1831 (e) { return e is UnsupportedOperationException; });
1832 Expect.throws(() { view.removeRange(0, view.length - 1); },
1833 (e) { return e is UnsupportedOperationException; });
1834 for (int i = 0; i < view.length; ++i) {
1835 view[i] = 1 + i;
1836 }
1837 Expect.listEquals([1, 2, 3, 4, 5,
1838 6, 7, 8, 9, 10],
1839 view);
1840 Expect.listEquals([-1, -1, -1, -1, -1, -1, -1, -1,
1841 1, 0, 0, 0, 0, 0, 0, 0,
1842 2, 0, 0, 0, 0, 0, 0, 0,
1843 3, 0, 0, 0, 0, 0, 0, 0,
1844 4, 0, 0, 0, 0, 0, 0, 0,
1845 5, 0, 0, 0, 0, 0, 0, 0,
1846 6, 0, 0, 0, 0, 0, 0, 0,
1847 7, 0, 0, 0, 0, 0, 0, 0,
1848 8, 0, 0, 0, 0, 0, 0, 0,
1849 9, 0, 0, 0, 0, 0, 0, 0,
1850 10, 0, 0, 0, 0, 0, 0, 0,
1851 -1, -1, -1, -1, -1, -1, -1, -1],
1852 array);
1853 for (int i = 0; i < view.length; ++i) {
1854 view[i] = 0x10000000000000000 + i;
1855 }
1856 Expect.listEquals([0, 1, 2, 3, 4,
1857 5, 6, 7, 8, 9],
1858 view);
1859 Expect.listEquals([-1, -1, -1, -1, -1, -1, -1, -1,
1860 0, 0, 0, 0, 0, 0, 0, 0,
1861 1, 0, 0, 0, 0, 0, 0, 0,
1862 2, 0, 0, 0, 0, 0, 0, 0,
1863 3, 0, 0, 0, 0, 0, 0, 0,
1864 4, 0, 0, 0, 0, 0, 0, 0,
1865 5, 0, 0, 0, 0, 0, 0, 0,
1866 6, 0, 0, 0, 0, 0, 0, 0,
1867 7, 0, 0, 0, 0, 0, 0, 0,
1868 8, 0, 0, 0, 0, 0, 0, 0,
1869 9, 0, 0, 0, 0, 0, 0, 0,
1870 -1, -1, -1, -1, -1, -1, -1, -1],
1871 array);
1872 for (int i = 0; i < view.length; ++i) {
1873 view[i] = 0xFFFFFFFFFFFFFFFF - i;
1874 }
1875 Expect.listEquals([0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFE,
1876 0xFFFFFFFFFFFFFFFD, 0xFFFFFFFFFFFFFFFC,
1877 0xFFFFFFFFFFFFFFFB, 0xFFFFFFFFFFFFFFFA,
1878 0xFFFFFFFFFFFFFFF9, 0xFFFFFFFFFFFFFFF8,
1879 0xFFFFFFFFFFFFFFF7, 0xFFFFFFFFFFFFFFF6],
1880 view);
1881 Expect.listEquals([-1, -1, -1, -1, -1, -1, -1, -1,
1882 -1, -1, -1, -1, -1, -1, -1, -1,
1883 -2, -1, -1, -1, -1, -1, -1, -1,
1884 -3, -1, -1, -1, -1, -1, -1, -1,
1885 -4, -1, -1, -1, -1, -1, -1, -1,
1886 -5, -1, -1, -1, -1, -1, -1, -1,
1887 -6, -1, -1, -1, -1, -1, -1, -1,
1888 -7, -1, -1, -1, -1, -1, -1, -1,
1889 -8, -1, -1, -1, -1, -1, -1, -1,
1890 -9, -1, -1, -1, -1, -1, -1, -1,
1891 -10, -1, -1, -1, -1, -1, -1, -1,
1892 -1, -1, -1, -1, -1, -1, -1, -1],
1893 array);
1894 for (int i = 0; i < view.length; ++i) {
1895 view[i] = i;
1896 }
1897 var copy = view.getRange(0, view.length);
1898 Expect.isFalse(copy === view);
1899 Expect.isTrue(copy is Uint64Array);
1900 Expect.equals(10, copy.length);
1901 Expect.listEquals(view, copy);
1902 var region = view.getRange(3, view.length - 6);
1903 Expect.isTrue(copy is Uint64Array);
1904 Expect.equals(4, region.length);
1905 Expect.listEquals([3, 4, 5, 6], region);
1906 view.setRange(3, 4, [0x10000000000000001, 0, 1, 0xFFFFFFFFFFFFFFFF]);
1907 Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFFFFFFFFFFFFFF, 7, 8, 9],
1908 view);
1909 Expect.listEquals([-1, -1, -1, -1, -1, -1, -1, -1,
1910 0, 0, 0, 0, 0, 0, 0, 0,
1911 1, 0, 0, 0, 0, 0, 0, 0,
1912 2, 0, 0, 0, 0, 0, 0, 0,
1913 1, 0, 0, 0, 0, 0, 0, 0,
1914 0, 0, 0, 0, 0, 0, 0, 0,
1915 1, 0, 0, 0, 0, 0, 0, 0,
1916 -1, -1, -1, -1, -1, -1, -1, -1,
1917 7, 0, 0, 0, 0, 0, 0, 0,
1918 8, 0, 0, 0, 0, 0, 0, 0,
1919 9, 0, 0, 0, 0, 0, 0, 0,
1920 -1, -1, -1, -1, -1, -1, -1, -1],
1921 array);
1922 }
1923
1924 static testFloat32ArrayView() {
1925 var array = new Uint32Array(12);
1926 Expect.isTrue(array is List<int>);
1927 Expect.equals(12, array.length);
1928 Expect.equals(4, array.bytesPerElement());
1929 Expect.equals(48, array.lengthInBytes());
1930 for (int i = 0; i < array.length; ++i) {
1931 array[i] = 0xBF800000;
1932 }
1933 Expect.throws(() { new Float32Array.view(array.asByteArray(), -1); },
1934 (e) { return e is IndexOutOfRangeException; });
1935 Expect.throws(() { new Float32Array.view(array.asByteArray(), 0, -1); },
1936 (e) { return e is IndexOutOfRangeException; });
1937 Expect.throws(() { new Float32Array.view(array.asByteArray(),
1938 array.lengthInBytes() + 1); },
1939 (e) { return e is IndexOutOfRangeException; });
1940 Expect.throws(() { new Float32Array.view(array.asByteArray(),
1941 0, array.lengthInBytes() + 1); },
1942 (e) { return e is IndexOutOfRangeException; });
1943 Expect.throws(() { new Float32Array.view(array.asByteArray(),
1944 array.lengthInBytes() - 1, 2); },
1945 (e) { return e is IndexOutOfRangeException; });
1946 var view = new Float32Array.view(array.asByteArray(), 4, 10);
1947 Expect.isTrue(view is List<double>);
1948 Expect.equals(10, view.length);
1949 Expect.equals(4, view.bytesPerElement());
1950 Expect.equals(40, view.lengthInBytes());
1951 Expect.listEquals([-1.0, -1.0, -1.0, -1.0, -1.0,
1952 -1.0, -1.0, -1.0, -1.0, -1.0],
1953 view);
1954 Expect.throws(() { view[-1] = 0.0; },
1955 (e) { return e is IndexOutOfRangeException; });
1956 Expect.throws(() { return view[-1]; },
1957 (e) { return e is IndexOutOfRangeException; });
1958 Expect.throws(() { view[10]; },
1959 (e) { return e is IndexOutOfRangeException; });
1960 Expect.throws(() { view[10] = 0.0; },
1961 (e) { return e is IndexOutOfRangeException; });
1962 Expect.throws(() { array.add(0.0); },
1963 (e) { return e is UnsupportedOperationException; });
1964 Expect.throws(() { array.addAll([0]); },
1965 (e) { return e is UnsupportedOperationException; });
1966 Expect.throws(() { array.addLast(0.0); },
1967 (e) { return e is UnsupportedOperationException; });
1968 Expect.throws(() { array.clear(); },
1969 (e) { return e is UnsupportedOperationException; });
1970 Expect.throws(() { array.insertRange(0, array.length, 0.0); },
1971 (e) { return e is UnsupportedOperationException; });
1972 Expect.throws(() { array.length = 0; },
1973 (e) { return e is UnsupportedOperationException; });
1974 Expect.throws(() { array.removeLast(); },
1975 (e) { return e is UnsupportedOperationException; });
1976 Expect.throws(() { array.removeRange(0, array.length - 1); },
1977 (e) { return e is UnsupportedOperationException; });
1978 for (int i = 0; i < view.length; ++i) {
1979 view[i] = 1.0 + i;
1980 }
1981 Expect.listEquals([1.0, 2.0, 3.0, 4.0, 5.0,
1982 6.0, 7.0, 8.0, 9.0, 10.0],
1983 view);
1984 Expect.listEquals([0xBF800000, 0x3F800000,
1985 0x40000000, 0x40400000,
1986 0x40800000, 0x40A00000,
1987 0x40C00000, 0x40E00000,
1988 0x41000000, 0x41100000,
1989 0x41200000, 0xBF800000],
1990 array);
1991 // TODO: min, max, and round
1992 for (int i = 0; i < view.length; ++i) {
1993 view[i] = i * 1.0;
1994 }
1995 var copy = view.getRange(0, view.length);
1996 Expect.isFalse(copy === view);
1997 Expect.isTrue(copy is Float32Array);
1998 Expect.equals(10, copy.length);
1999 Expect.listEquals(view, copy);
2000 var region = view.getRange(3, view.length - 6);
2001 Expect.isTrue(copy is Float32Array);
2002 Expect.equals(4, region.length);
2003 Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
2004 view.setRange(3, 4, [double.NEGATIVE_INFINITY, 0.0, 1.0, double.INFINITY]);
2005 Expect.listEquals([0.0, 1.0, 2.0, double.NEGATIVE_INFINITY, 0.0,
2006 1.0, double.INFINITY, 7.0, 8.0, 9.0],
2007 view);
2008 Expect.listEquals([0xBF800000, 0x00000000,
2009 0x3F800000, 0x40000000,
2010 0xFF800000, 0x00000000,
2011 0x3F800000, 0x7F800000,
2012 0x40E00000, 0x41000000,
2013 0x41100000, 0xBF800000],
2014 array);
2015 }
2016
2017 static testFloat64ArrayView() {
2018 var array = new Uint64Array(12);
2019 Expect.isTrue(array is List<int>);
2020 Expect.equals(12, array.length);
2021 Expect.equals(8, array.bytesPerElement());
2022 Expect.equals(96, array.lengthInBytes());
2023 for (int i = 0; i < array.length; ++i) {
2024 array[i] = 0xBFF0000000000000;
2025 }
2026 Expect.throws(() { new Float64Array.view(array.asByteArray(), -1); },
2027 (e) { return e is IndexOutOfRangeException; });
2028 Expect.throws(() { new Float64Array.view(array.asByteArray(), 0, -1); },
2029 (e) { return e is IndexOutOfRangeException; });
2030 Expect.throws(() { new Float64Array.view(array.asByteArray(),
2031 array.lengthInBytes() + 1); },
2032 (e) { return e is IndexOutOfRangeException; });
2033 Expect.throws(() { new Float64Array.view(array.asByteArray(),
2034 0, array.lengthInBytes() + 1); },
2035 (e) { return e is IndexOutOfRangeException; });
2036 Expect.throws(() { new Float64Array.view(array.asByteArray(),
2037 array.lengthInBytes() - 1, 2); },
2038 (e) { return e is IndexOutOfRangeException; });
2039 var view = new Float64Array.view(array.asByteArray(), 8, 10);
2040 Expect.isTrue(view is List<double>);
2041 Expect.equals(10, view.length);
2042 Expect.equals(8, view.bytesPerElement());
2043 Expect.equals(80, view.lengthInBytes());
2044 Expect.listEquals([-1.0, -1.0, -1.0, -1.0, -1.0,
2045 -1.0, -1.0, -1.0, -1.0, -1.0],
2046 view);
2047 Expect.throws(() { view[-1] = 0.0; },
2048 (e) { return e is IndexOutOfRangeException; });
2049 Expect.throws(() { return view[-1]; },
2050 (e) { return e is IndexOutOfRangeException; });
2051 Expect.throws(() { view[10]; },
2052 (e) { return e is IndexOutOfRangeException; });
2053 Expect.throws(() { view[10] = 0.0; },
2054 (e) { return e is IndexOutOfRangeException; });
2055 Expect.throws(() { array.add(0.0); },
2056 (e) { return e is UnsupportedOperationException; });
2057 Expect.throws(() { array.addAll([0]); },
2058 (e) { return e is UnsupportedOperationException; });
2059 Expect.throws(() { array.addLast(0.0); },
2060 (e) { return e is UnsupportedOperationException; });
2061 Expect.throws(() { array.clear(); },
2062 (e) { return e is UnsupportedOperationException; });
2063 Expect.throws(() { array.insertRange(0, array.length, 0.0); },
2064 (e) { return e is UnsupportedOperationException; });
2065 Expect.throws(() { array.length = 0; },
2066 (e) { return e is UnsupportedOperationException; });
2067 Expect.throws(() { array.removeLast(); },
2068 (e) { return e is UnsupportedOperationException; });
2069 Expect.throws(() { array.removeRange(0, array.length - 1); },
2070 (e) { return e is UnsupportedOperationException; });
2071 for (int i = 0; i < view.length; ++i) {
2072 view[i] = 1.0 + i;
2073 }
2074 Expect.listEquals([1.0, 2.0, 3.0, 4.0, 5.0,
2075 6.0, 7.0, 8.0, 9.0, 10.0],
2076 view);
2077 Expect.listEquals([0xBFF0000000000000, 0x3FF0000000000000,
2078 0x4000000000000000, 0x4008000000000000,
2079 0x4010000000000000, 0x4014000000000000,
2080 0x4018000000000000, 0x401C000000000000,
2081 0x4020000000000000, 0x4022000000000000,
2082 0x4024000000000000, 0xBFF0000000000000],
2083 array);
2084 // TODO: min, max
2085 for (int i = 0; i < view.length; ++i) {
2086 view[i] = i * 1.0;
2087 }
2088 var copy = view.getRange(0, view.length);
2089 Expect.isFalse(copy === view);
2090 Expect.isTrue(copy is Float64Array);
2091 Expect.equals(10, copy.length);
2092 Expect.listEquals(view, copy);
2093 var region = view.getRange(3, view.length - 6);
2094 Expect.isTrue(copy is Float64Array);
2095 Expect.equals(4, region.length);
2096 Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
2097 view.setRange(3, 4, [double.NEGATIVE_INFINITY, 0.0, 1.0, double.INFINITY]);
2098 Expect.listEquals([0.0, 1.0, 2.0, double.NEGATIVE_INFINITY, 0.0,
2099 1.0, double.INFINITY, 7.0, 8.0, 9.0],
2100 view);
2101 Expect.listEquals([0xBFF0000000000000, 0x0000000000000000,
2102 0x3FF0000000000000, 0x4000000000000000,
2103 0xFFF0000000000000, 0x0000000000000000,
2104 0x3FF0000000000000, 0x7FF0000000000000,
2105 0x401C000000000000, 0x4020000000000000,
2106 0x4022000000000000, 0xBFF0000000000000],
2107 array);
2108 }
2109
2110 static testMain() {
2111 testInt8Array();
2112 testUint8Array();
2113 testInt16Array();
2114 testUint16Array();
2115 testInt32Array();
2116 testUint32Array();
2117 testInt64Array();
2118 testUint64Array();
2119 testFloat32Array();
2120 testFloat64Array();
2121 testByteArray();
2122 testInt8ArrayView();
2123 testUint8ArrayView();
2124 testInt16ArrayView();
2125 testUint16ArrayView();
2126 testInt32ArrayView();
2127 testUint32ArrayView();
2128 testInt64ArrayView();
2129 testUint64ArrayView();
2130 testFloat32ArrayView();
2131 testFloat64ArrayView();
2132 }
2133 }
2134
2135 main() {
2136 ByteArrayTest.testMain();
2137 }
OLDNEW
« runtime/lib/byte_array.dart ('K') | « runtime/lib/byte_array.dart ('k') | runtime/vm/bootstrap_natives.h » ('j') | runtime/vm/dart_api_impl.cc » ('J')

Powered by Google App Engine
This is Rietveld 408576698