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

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: runtime/tests/vm/dart/byte_array_optimized_test.dart

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

Powered by Google App Engine
This is Rietveld 408576698