Google Git
Sign in
dart / sdk / 38ea3a8f5e930ee77a0ff407cdbbec0629d22faa / . / runtime / tests / vm / dart / byte_array_optimized_test.dart
blob: 83b39fedd15be075859389c7a3a73c1f0774aeab [file] [log] [blame]
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
// VMOptions=--optimization_counter_threshold=10 --no-background-compilation
// Library tag to be able to run in html test framework.
library byte_array_test;
import "package:expect/expect.dart";
import 'dart:typed_data';
// This test exercises optimized [] and []= operators
// on byte array views.
class OptimizedByteArrayTest {
static testInt8ListImpl(Int8List array) {
Expect.isTrue(array is List<int>);
Expect.equals(10, array.length);
Expect.equals(1, array.elementSizeInBytes);
Expect.equals(10, array.lengthInBytes);
Expect.listEquals([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], array);
Expect.throws(
() {
array[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeRange(0, array.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < array.length; ++i) {
array[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0x100 + i;
}
Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], array);
for (int i = 0; i < array.length; ++i) {
array[i] = -10 + i;
}
Expect.listEquals([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0x7F - i;
}
Expect.listEquals([
127,
126,
125,
124,
123,
122,
121,
120,
119,
118,
], array);
for (int i = 0; i < array.length; ++i) {
array[i] = -0x80 + i;
}
Expect.listEquals([
-128,
-127,
-126,
-125,
-124,
-123,
-122,
-121,
-120,
-119,
], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
var copy = array.sublist(0, array.length);
Expect.isFalse(identical(copy, array));
Expect.isTrue(copy is Int8List);
Expect.equals(10, copy.length);
Expect.listEquals(array, copy);
var empty = array.sublist(array.length, array.length);
Expect.equals(0, empty.length);
var region = array.sublist(3, array.length - 3);
Expect.isTrue(copy is Int8List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
array.setRange(3, 7, [-128, 0, 1, 127]);
Expect.listEquals([0, 1, 2, -128, 0, 1, 127, 7, 8, 9], array);
}
static testInt8List() {
Expect.throws(
() {
new Int8List(-1);
},
(e) {
return e is ArgumentError;
},
);
var array = new Int8List(10);
testInt8ListImpl(array);
}
static testUint8ListImpl(Uint8List array) {
Expect.isTrue(array is List<int>);
Expect.equals(10, array.length);
Expect.equals(1, array.elementSizeInBytes);
Expect.equals(10, array.lengthInBytes);
Expect.listEquals([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], array);
Expect.throws(
() {
array[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeRange(0, array.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < array.length; ++i) {
array[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0x100 + i;
}
Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0xFF - i;
}
Expect.listEquals([
0xFF,
0xFE,
0xFD,
0xFC,
0xFB,
0xFA,
0xF9,
0xF8,
0xF7,
0xF6,
], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
var copy = array.sublist(0, array.length);
Expect.isFalse(identical(copy, array));
Expect.isTrue(copy is Uint8List);
Expect.equals(10, copy.length);
Expect.listEquals(array, copy);
var empty = array.sublist(array.length, array.length);
Expect.equals(0, empty.length);
var region = array.sublist(3, array.length - 3);
Expect.isTrue(copy is Uint8List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
array.setRange(3, 7, [257, 0, 1, 255]);
Expect.listEquals([0, 1, 2, 1, 0, 1, 255, 7, 8, 9], array);
}
static testUint8List() {
Expect.throws(
() {
new Uint8List(-1);
},
(e) {
return e is ArgumentError;
},
);
var array = new Uint8List(10);
testUint8ListImpl(array);
}
static testInt16ListImpl(Int16List array) {
Expect.isTrue(array is List<int>);
Expect.equals(10, array.length);
Expect.equals(2, array.elementSizeInBytes);
Expect.equals(20, array.lengthInBytes);
Expect.listEquals([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], array);
Expect.throws(
() {
array[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeRange(0, array.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < array.length; ++i) {
array[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0x10000 + i;
}
Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], array);
for (int i = 0; i < array.length; ++i) {
array[i] = -10 + i;
}
Expect.listEquals([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0x7FFF - i;
}
Expect.listEquals([
0x7FFF,
0x7FFE,
0x7FFD,
0x7FFC,
0x7FFB,
0x7FFA,
0x7FF9,
0x7FF8,
0x7FF7,
0x7FF6,
], array);
for (int i = 0; i < array.length; ++i) {
array[i] = -0x8000 + i;
}
Expect.listEquals([
-0x8000,
-0x7FFF,
-0x7FFE,
-0x7FFD,
-0x7FFC,
-0x7FFB,
-0x7FFA,
-0x7FF9,
-0x7FF8,
-0x7FF7,
], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
var copy = array.sublist(0, array.length);
Expect.isFalse(identical(copy, array));
Expect.isTrue(copy is Int16List);
Expect.equals(10, copy.length);
Expect.listEquals(array, copy);
var empty = array.sublist(array.length, array.length);
Expect.equals(0, empty.length);
var region = array.sublist(3, array.length - 3);
Expect.isTrue(copy is Int16List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
array.setRange(3, 7, [-32768, 0, 1, 32767]);
Expect.listEquals([0, 1, 2, -32768, 0, 1, 32767, 7, 8, 9], array);
}
static testInt16List() {
Expect.throws(
() {
new Int16List(-1);
},
(e) {
return e is ArgumentError;
},
);
var array = new Int16List(10);
testInt16ListImpl(array);
}
static testUint16ListImpl(Uint16List array) {
Expect.isTrue(array is List<int>);
Expect.equals(10, array.length);
Expect.equals(2, array.elementSizeInBytes);
Expect.equals(20, array.lengthInBytes);
Expect.listEquals([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], array);
Expect.throws(
() {
array[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeRange(0, array.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < array.length; ++i) {
array[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0x10000 + i;
}
Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0xFFFF - i;
}
Expect.listEquals([
0xFFFF,
0xFFFE,
0xFFFD,
0xFFFC,
0xFFFB,
0xFFFA,
0xFFF9,
0xFFF8,
0xFFF7,
0xFFF6,
], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
var copy = array.sublist(0, array.length);
Expect.isFalse(identical(copy, array));
Expect.isTrue(copy is Uint16List);
Expect.equals(10, copy.length);
Expect.listEquals(array, copy);
var empty = array.sublist(array.length, array.length);
Expect.equals(0, empty.length);
var region = array.sublist(3, array.length - 3);
Expect.isTrue(copy is Uint16List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
array.setRange(3, 7, [0x10001, 0, 1, 0xFFFF]);
Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFF, 7, 8, 9], array);
}
static testUint16List() {
Expect.throws(
() {
new Uint16List(-1);
},
(e) {
return e is ArgumentError;
},
);
var array = new Uint16List(10);
testUint16ListImpl(array);
}
static testInt32ListImpl(Int32List array) {
Expect.isTrue(array is List<int>);
Expect.equals(10, array.length);
Expect.equals(4, array.elementSizeInBytes);
Expect.equals(40, array.lengthInBytes);
Expect.listEquals([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], array);
Expect.throws(
() {
array[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeRange(0, array.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < array.length; ++i) {
array[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0x100000000 + i;
}
Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], array);
for (int i = 0; i < array.length; ++i) {
array[i] = -10 + i;
}
Expect.listEquals([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0x7FFFFFFF - i;
}
Expect.listEquals([
0x7FFFFFFF,
0x7FFFFFFE,
0x7FFFFFFD,
0x7FFFFFFC,
0x7FFFFFFB,
0x7FFFFFFA,
0x7FFFFFF9,
0x7FFFFFF8,
0x7FFFFFF7,
0x7FFFFFF6,
], array);
for (int i = 0; i < array.length; ++i) {
array[i] = -0x80000000 + i;
}
Expect.listEquals([
-0x80000000,
-0x7FFFFFFF,
-0x7FFFFFFE,
-0x7FFFFFFD,
-0x7FFFFFFC,
-0x7FFFFFFB,
-0x7FFFFFFA,
-0x7FFFFFF9,
-0x7FFFFFF8,
-0x7FFFFFF7,
], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
var copy = array.sublist(0, array.length);
Expect.isFalse(identical(copy, array));
Expect.isTrue(copy is Int32List);
Expect.equals(10, copy.length);
Expect.listEquals(array, copy);
var empty = array.sublist(array.length, array.length);
Expect.equals(0, empty.length);
var region = array.sublist(3, array.length - 3);
Expect.isTrue(copy is Int32List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
array.setRange(3, 7, [-0x80000000, 0, 1, 0x7FFFFFFF]);
Expect.listEquals([0, 1, 2, -0x80000000, 0, 1, 0x7FFFFFFF, 7, 8, 9], array);
}
static testInt32List() {
Expect.throws(
() {
new Int32List(-1);
},
(e) {
return e is ArgumentError;
},
);
var array = new Int32List(10);
testInt32ListImpl(array);
}
static testUint32ListImpl(Uint32List array) {
Expect.isTrue(array is List<int>);
Expect.equals(10, array.length);
Expect.equals(4, array.elementSizeInBytes);
Expect.equals(40, array.lengthInBytes);
Expect.listEquals([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], array);
Expect.throws(
() {
array[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeRange(0, array.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < array.length; ++i) {
array[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0x100000000 + i;
}
Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0xFFFFFFFF - i;
}
Expect.listEquals([
0xFFFFFFFF,
0xFFFFFFFE,
0xFFFFFFFD,
0xFFFFFFFC,
0xFFFFFFFB,
0xFFFFFFFA,
0xFFFFFFF9,
0xFFFFFFF8,
0xFFFFFFF7,
0xFFFFFFF6,
], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
var copy = array.sublist(0, array.length);
Expect.isFalse(identical(copy, array));
Expect.isTrue(copy is Uint32List);
Expect.equals(10, copy.length);
Expect.listEquals(array, copy);
var empty = array.sublist(array.length, array.length);
Expect.equals(0, empty.length);
var region = array.sublist(3, array.length - 3);
Expect.isTrue(copy is Uint32List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
array.setRange(3, 7, [0x100000001, 0, 1, 0xFFFFFFFF]);
Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFFFFFF, 7, 8, 9], array);
}
static testUint32List() {
Expect.throws(
() {
new Uint32List(-1);
},
(e) {
return e is ArgumentError;
},
);
Expect.throws(
() {
new Uint32List(-1);
},
(e) {
return e is ArgumentError;
},
);
var array = new Uint32List(10);
testUint32ListImpl(array);
}
static testInt64ListImpl(Int64List array) {
Expect.isTrue(array is List<int>);
Expect.equals(10, array.length);
Expect.equals(8, array.elementSizeInBytes);
Expect.equals(80, array.lengthInBytes);
Expect.listEquals([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], array);
Expect.throws(
() {
array[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeRange(0, array.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < array.length; ++i) {
array[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], array);
for (int i = 0; i < array.length; ++i) {
array[i] = -10 + i;
}
Expect.listEquals([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0x7FFFFFFFFFFFFFFF - i;
}
Expect.listEquals([
0x7FFFFFFFFFFFFFFF,
0x7FFFFFFFFFFFFFFE,
0x7FFFFFFFFFFFFFFD,
0x7FFFFFFFFFFFFFFC,
0x7FFFFFFFFFFFFFFB,
0x7FFFFFFFFFFFFFFA,
0x7FFFFFFFFFFFFFF9,
0x7FFFFFFFFFFFFFF8,
0x7FFFFFFFFFFFFFF7,
0x7FFFFFFFFFFFFFF6,
], array);
for (int i = 0; i < array.length; ++i) {
array[i] = -0x8000000000000000 + i;
}
Expect.listEquals([
-0x8000000000000000,
-0x7FFFFFFFFFFFFFFF,
-0x7FFFFFFFFFFFFFFE,
-0x7FFFFFFFFFFFFFFD,
-0x7FFFFFFFFFFFFFFC,
-0x7FFFFFFFFFFFFFFB,
-0x7FFFFFFFFFFFFFFA,
-0x7FFFFFFFFFFFFFF9,
-0x7FFFFFFFFFFFFFF8,
-0x7FFFFFFFFFFFFFF7,
], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
var copy = array.sublist(0, array.length);
Expect.isFalse(identical(copy, array));
Expect.isTrue(copy is Int64List);
Expect.equals(10, copy.length);
Expect.listEquals(array, copy);
var empty = array.sublist(array.length, array.length);
Expect.equals(0, empty.length);
var region = array.sublist(3, array.length - 3);
Expect.isTrue(copy is Int64List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
array.setRange(3, 7, [-0x8000000000000000, 0, 1, 0x7FFFFFFFFFFFFFFF]);
Expect.listEquals([
0,
1,
2,
-0x8000000000000000,
0,
1,
0x7FFFFFFFFFFFFFFF,
7,
8,
9,
], array);
}
static testInt64List() {
Expect.throws(
() {
new Int64List(-1);
},
(e) {
return e is ArgumentError;
},
);
var array = new Int64List(10);
testInt64ListImpl(array);
}
static testUint64ListImpl(Uint64List array) {
Expect.isTrue(array is List<int>);
Expect.equals(10, array.length);
Expect.equals(8, array.elementSizeInBytes);
Expect.equals(80, array.lengthInBytes);
Expect.listEquals([0, 0, 0, 0, 0, 0, 0, 0, 0, 0], array);
Expect.throws(
() {
array[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeRange(0, array.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < array.length; ++i) {
array[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0xFFFFFFFFFFFFFFFF - i;
}
Expect.listEquals([
0xFFFFFFFFFFFFFFFF,
0xFFFFFFFFFFFFFFFE,
0xFFFFFFFFFFFFFFFD,
0xFFFFFFFFFFFFFFFC,
0xFFFFFFFFFFFFFFFB,
0xFFFFFFFFFFFFFFFA,
0xFFFFFFFFFFFFFFF9,
0xFFFFFFFFFFFFFFF8,
0xFFFFFFFFFFFFFFF7,
0xFFFFFFFFFFFFFFF6,
], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
var copy = array.sublist(0, array.length);
Expect.isFalse(identical(copy, array));
Expect.isTrue(copy is Uint64List);
Expect.equals(10, copy.length);
Expect.listEquals(array, copy);
var empty = array.sublist(array.length, array.length);
Expect.equals(0, empty.length);
var region = array.sublist(3, array.length - 3);
Expect.isTrue(copy is Uint64List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
array.setRange(3, 7, [-0x8000000000000000, 0, 1, 0xFFFFFFFFFFFFFFFF]);
Expect.listEquals([
0,
1,
2,
-0x8000000000000000,
0,
1,
0xFFFFFFFFFFFFFFFF,
7,
8,
9,
], array);
}
static testUint64List() {
Expect.throws(
() {
new Uint64List(-1);
},
(e) {
return e is ArgumentError;
},
);
var array = new Uint64List(10);
testUint64ListImpl(array);
}
static testFloat32ListImpl(Float32List array) {
Expect.isTrue(array is List<double>);
Expect.equals(10, array.length);
Expect.equals(4, array.elementSizeInBytes);
Expect.equals(40, array.lengthInBytes);
Expect.listEquals([
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
], array);
Expect.throws(
() {
array[-1] = 0.0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10] = 0.0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array.add(0.0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.addAll([0.0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeRange(0, array.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < array.length; ++i) {
array[i] = 1.0 + i;
}
Expect.listEquals([
1.0,
2.0,
3.0,
4.0,
5.0,
6.0,
7.0,
8.0,
9.0,
10.0,
], array);
// TODO: min, max, and round
for (int i = 0; i < array.length; ++i) {
array[i] = i * 1.0;
}
var copy = array.sublist(0, array.length);
Expect.isFalse(identical(copy, array));
Expect.isTrue(copy is Float32List);
Expect.equals(10, copy.length);
Expect.listEquals(array, copy);
var empty = array.sublist(array.length, array.length);
Expect.equals(0, empty.length);
var region = array.sublist(3, array.length - 3);
Expect.isTrue(copy is Float32List);
Expect.equals(4, region.length);
Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
array.setRange(3, 7, [double.negativeInfinity, 0.0, 1.0, double.infinity]);
Expect.listEquals([
0.0,
1.0,
2.0,
double.negativeInfinity,
0.0,
1.0,
double.infinity,
7.0,
8.0,
9.0,
], array);
}
static testFloat32List() {
Expect.throws(
() {
new Float32List(-1);
},
(e) {
return e is ArgumentError;
},
);
var array = new Float32List(10);
testFloat32ListImpl(array);
}
static testFloat64ListImpl(Float64List array) {
Expect.isTrue(array is List<double>);
Expect.equals(10, array.length);
Expect.equals(8, array.elementSizeInBytes);
Expect.equals(80, array.lengthInBytes);
Expect.listEquals([
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
0.0,
], array);
Expect.throws(
() {
array[-1] = 0.0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array[10] = 0.0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
array.add(0.0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.addAll([0.0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
array.removeRange(0, array.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < array.length; ++i) {
array[i] = 1.0 + i;
}
Expect.listEquals([
1.0,
2.0,
3.0,
4.0,
5.0,
6.0,
7.0,
8.0,
9.0,
10.0,
], array);
// TODO: min, max
for (int i = 0; i < array.length; ++i) {
array[i] = i * 1.0;
}
var copy = array.sublist(0, array.length);
Expect.isFalse(identical(copy, array));
Expect.isTrue(copy is Float64List);
Expect.equals(10, copy.length);
Expect.listEquals(array, copy);
var empty = array.sublist(array.length, array.length);
Expect.equals(0, empty.length);
var region = array.sublist(3, array.length - 3);
Expect.isTrue(copy is Float64List);
Expect.equals(4, region.length);
Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
array.setRange(3, 7, [double.negativeInfinity, 0.0, 1.0, double.infinity]);
Expect.listEquals([
0.0,
1.0,
2.0,
double.negativeInfinity,
0.0,
1.0,
double.infinity,
7.0,
8.0,
9.0,
], array);
}
static testFloat64List() {
Expect.throws(
() {
new Float64List(-1);
},
(e) {
return e is ArgumentError;
},
);
var array = new Float64List(10);
testFloat64ListImpl(array);
}
static testInt8ListViewImpl(var array) {
Expect.equals(12, array.length);
Expect.equals(1, array.elementSizeInBytes);
Expect.equals(12, array.lengthInBytes);
for (int i = 0; i < array.length; ++i) {
array[i] = 0xFF;
}
Expect.throws(
() {
new Int8List.view(array.buffer, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int8List.view(array.buffer, 0, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int8List.view(array.buffer, array.lengthInBytes + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int8List.view(array.buffer, 0, array.length + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int8List.view(array.buffer, array.length - 1, 2);
},
(e) {
return e is RangeError;
},
);
var empty = new Int8List.view(array.buffer, array.lengthInBytes);
Expect.isTrue(empty is List<int>);
Expect.isTrue(empty is Int8List);
Expect.equals(0, empty.length);
var whole = new Int8List.view(array.buffer);
Expect.isTrue(whole is List<int>);
Expect.isTrue(whole is Int8List);
Expect.equals(12, whole.length);
var view = new Int8List.view(array.buffer, 1, array.length - 2);
Expect.isTrue(view is List<int>);
Expect.isTrue(view is Int8List);
Expect.equals(10, view.length);
Expect.equals(1, view.elementSizeInBytes);
Expect.equals(10, view.lengthInBytes);
Expect.listEquals([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], view);
Expect.throws(
() {
view[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[view.length];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[10] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeRange(0, view.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < view.length; ++i) {
view[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], view);
Expect.listEquals([0xFF, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0xFF], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0x100 + i;
}
Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], view);
Expect.listEquals([0xFF, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0xFF], array);
for (int i = 0; i < view.length; ++i) {
view[i] = -10 + i;
}
Expect.listEquals([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1], view);
Expect.listEquals([
0xFF,
0xF6,
0xF7,
0xF8,
0xF9,
0xFA,
0xFB,
0xFC,
0xFD,
0xFE,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0x7F - i;
}
Expect.listEquals([127, 126, 125, 124, 123, 122, 121, 120, 119, 118], view);
Expect.listEquals([
0xFF,
127,
126,
125,
124,
123,
122,
121,
120,
119,
118,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = -0x80 + i;
}
Expect.listEquals([
-128,
-127,
-126,
-125,
-124,
-123,
-122,
-121,
-120,
-119,
], view);
Expect.listEquals([
0xFF,
0x80,
0x81,
0x82,
0x83,
0x84,
0x85,
0x86,
0x87,
0x88,
0x89,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = i;
}
var copy = view.sublist(0, view.length);
Expect.isFalse(identical(copy, view));
Expect.isTrue(copy is Int8List);
Expect.equals(10, copy.length);
Expect.listEquals(view, copy);
var region = view.sublist(3, view.length - 3);
Expect.isTrue(copy is Int8List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
view.setRange(3, 7, [-128, 0, 1, 127]);
Expect.listEquals([0, 1, 2, -128, 0, 1, 127, 7, 8, 9], view);
Expect.listEquals([0xFF, 0, 1, 2, 128, 0, 1, 127, 7, 8, 9, 0xFF], array);
}
static testInt8ListView() {
var array = new Uint8List(12);
testInt8ListViewImpl(array);
}
static testUint8ListViewImpl(var array) {
Expect.isTrue(array is List<int>);
Expect.equals(12, array.length);
Expect.equals(1, array.elementSizeInBytes);
Expect.equals(12, array.lengthInBytes);
for (int i = 0; i < array.length; ++i) {
array[i] = -1;
}
Expect.throws(
() {
new Uint8List.view(array.buffer, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint8List.view(array.buffer, 0, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint8List.view(array.buffer, array.lengthInBytes + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint8List.view(array.buffer, 0, array.length + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint8List.view(array.buffer, array.length - 1, 2);
},
(e) {
return e is RangeError;
},
);
var empty = new Uint8List.view(array.buffer, array.lengthInBytes);
Expect.isTrue(empty is List<int>);
Expect.isTrue(empty is Uint8List);
Expect.equals(0, empty.length);
var whole = new Uint8List.view(array.buffer);
Expect.isTrue(whole is List<int>);
Expect.isTrue(whole is Uint8List);
Expect.equals(12, whole.length);
var view = new Uint8List.view(array.buffer, 1, array.length - 2);
Expect.isTrue(view is List<int>);
Expect.isTrue(view is Uint8List);
Expect.equals(10, view.length);
Expect.equals(1, view.elementSizeInBytes);
Expect.equals(10, view.lengthInBytes);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
], view);
Expect.throws(
() {
view[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[view.length];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[view.length] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeRange(0, view.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < view.length; ++i) {
view[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], view);
Expect.listEquals([-1, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, -1], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0x100 + i;
}
Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], view);
Expect.listEquals([-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0xFF - i;
}
Expect.listEquals([
0xFF,
0xFE,
0xFD,
0xFC,
0xFB,
0xFA,
0xF9,
0xF8,
0xF7,
0xF6,
], view);
Expect.listEquals([-1, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -1], array);
for (int i = 0; i < view.length; ++i) {
view[i] = i;
}
var copy = view.sublist(0, view.length);
Expect.isFalse(identical(copy, view));
Expect.isTrue(copy is Uint8List);
Expect.equals(10, copy.length);
Expect.listEquals(view, copy);
var region = view.sublist(3, view.length - 3);
Expect.isTrue(copy is Uint8List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
view.setRange(3, 7, [257, 0, 1, 255]);
Expect.listEquals([0, 1, 2, 1, 0, 1, 255, 7, 8, 9], view);
}
static testUint8ListView() {
var array = new Int8List(12);
testUint8ListViewImpl(array);
}
static testInt16ListViewImpl(var array) {
Expect.equals(24, array.length);
Expect.equals(1, array.elementSizeInBytes);
Expect.equals(24, array.lengthInBytes);
for (int i = 0; i < array.length; ++i) {
array[i] = 0xFF;
}
Expect.throws(
() {
new Int16List.view(array.buffer, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int16List.view(array.buffer, 0, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int16List.view(array.buffer, array.lengthInBytes + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int16List.view(array.buffer, 0, array.length + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int16List.view(array.buffer, array.length - 1, 2);
},
(e) {
return e is RangeError;
},
);
var empty = new Int16List.view(array.buffer, array.lengthInBytes);
Expect.isTrue(empty is List<int>);
Expect.isTrue(empty is Int16List);
Expect.equals(0, empty.length);
var whole = new Int16List.view(array.buffer);
Expect.isTrue(whole is List<int>);
Expect.isTrue(whole is Int16List);
Expect.equals(12, whole.length);
var view = new Int16List.view(array.buffer, 2, 10);
Expect.isTrue(view is List<int>);
Expect.isTrue(view is Int16List);
Expect.equals(10, view.length);
Expect.equals(2, view.elementSizeInBytes);
Expect.equals(20, view.lengthInBytes);
Expect.listEquals([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], view);
Expect.throws(
() {
view[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[view.length];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[10] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeRange(0, view.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < view.length; ++i) {
view[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], view);
Expect.listEquals([
0xFF,
0xFF,
0x01,
0x00,
0x02,
0x00,
0x03,
0x00,
0x04,
0x00,
0x05,
0x00,
0x06,
0x00,
0x07,
0x00,
0x08,
0x00,
0x09,
0x00,
0x0A,
0x00,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0x10000 + i;
}
Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], view);
Expect.listEquals([
0xFF,
0xFF,
0x00,
0x00,
0x01,
0x00,
0x02,
0x00,
0x03,
0x00,
0x04,
0x00,
0x05,
0x00,
0x06,
0x00,
0x07,
0x00,
0x08,
0x00,
0x09,
0x00,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = -10 + i;
}
Expect.listEquals([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1], view);
Expect.listEquals([
0xFF,
0xFF,
0xF6,
0xFF,
0xF7,
0xFF,
0xF8,
0xFF,
0xF9,
0xFF,
0xFA,
0xFF,
0xFB,
0xFF,
0xFC,
0xFF,
0xFD,
0xFF,
0xFE,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0x7FFF - i;
}
Expect.listEquals([
0x7FFF,
0x7FFE,
0x7FFD,
0x7FFC,
0x7FFB,
0x7FFA,
0x7FF9,
0x7FF8,
0x7FF7,
0x7FF6,
], view);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0x7F,
0xFE,
0x7F,
0xFD,
0x7F,
0xFC,
0x7F,
0xFB,
0x7F,
0xFA,
0x7F,
0xF9,
0x7F,
0xF8,
0x7F,
0xF7,
0x7F,
0xF6,
0x7F,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = -0x8000 + i;
}
Expect.listEquals([
-0x8000,
-0x7FFF,
-0x7FFE,
-0x7FFD,
-0x7FFC,
-0x7FFB,
-0x7FFA,
-0x7FF9,
-0x7FF8,
-0x7FF7,
], view);
Expect.listEquals([
0xFF,
0xFF,
0x00,
0x80,
0x01,
0x80,
0x02,
0x80,
0x03,
0x80,
0x04,
0x80,
0x05,
0x80,
0x06,
0x80,
0x07,
0x80,
0x08,
0x80,
0x09,
0x80,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = i;
}
var copy = view.sublist(0, view.length);
Expect.isFalse(identical(copy, view));
Expect.isTrue(copy is Int16List);
Expect.equals(10, copy.length);
Expect.listEquals(view, copy);
var region = view.sublist(3, view.length - 3);
Expect.isTrue(copy is Int16List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
view.setRange(3, 7, [-32768, 0, 1, 32767]);
Expect.listEquals([0, 1, 2, -32768, 0, 1, 32767, 7, 8, 9], view);
Expect.listEquals([
0xFF,
0xFF,
0x00,
0x00,
0x01,
0x00,
0x02,
0x00,
0x00,
0x80,
0x00,
0x00,
0x01,
0x00,
0xFF,
0x7F,
0x07,
0x00,
0x08,
0x00,
0x09,
0x00,
0xFF,
0xFF,
], array);
}
static testInt16ListView() {
var array = new Uint8List(24);
testInt16ListViewImpl(array);
}
static testUint16ListViewImpl(var array) {
Expect.isTrue(array is List<int>);
Expect.equals(24, array.length);
Expect.equals(1, array.elementSizeInBytes);
Expect.equals(24, array.lengthInBytes);
for (int i = 0; i < array.length; ++i) {
array[i] = -1;
}
Expect.throws(
() {
new Uint16List.view(array.buffer, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint16List.view(array.buffer, 0, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint16List.view(array.buffer, array.lengthInBytes + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint16List.view(array.buffer, 0, array.length + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint16List.view(array.buffer, array.length - 1, 2);
},
(e) {
return e is RangeError;
},
);
var empty = new Uint16List.view(array.buffer, array.lengthInBytes);
Expect.isTrue(empty is List<int>);
Expect.isTrue(empty is Uint16List);
Expect.equals(0, empty.length);
var whole = new Uint16List.view(array.buffer);
Expect.isTrue(whole is List<int>);
Expect.isTrue(whole is Uint16List);
Expect.equals(12, whole.length);
var view = new Uint16List.view(array.buffer, 2, 10);
Expect.isTrue(view is List<int>);
Expect.isTrue(view is Uint16List);
Expect.equals(10, view.length);
Expect.equals(2, view.elementSizeInBytes);
Expect.equals(20, view.lengthInBytes);
Expect.listEquals([
0xFFFF,
0xFFFF,
0xFFFF,
0xFFFF,
0xFFFF,
0xFFFF,
0xFFFF,
0xFFFF,
0xFFFF,
0xFFFF,
], view);
Expect.throws(
() {
view[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[view.length];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[view.length] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeRange(0, view.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < view.length; ++i) {
view[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], view);
Expect.listEquals([
-1,
-1,
1,
0,
2,
0,
3,
0,
4,
0,
5,
0,
6,
0,
7,
0,
8,
0,
9,
0,
10,
0,
-1,
-1,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0x10000 + i;
}
Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], view);
Expect.listEquals([
-1,
-1,
0,
0,
1,
0,
2,
0,
3,
0,
4,
0,
5,
0,
6,
0,
7,
0,
8,
0,
9,
0,
-1,
-1,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0xFFFF - i;
}
Expect.listEquals([
0xFFFF,
0xFFFE,
0xFFFD,
0xFFFC,
0xFFFB,
0xFFFA,
0xFFF9,
0xFFF8,
0xFFF7,
0xFFF6,
], view);
Expect.listEquals([
-1,
-1,
-1,
-1,
-2,
-1,
-3,
-1,
-4,
-1,
-5,
-1,
-6,
-1,
-7,
-1,
-8,
-1,
-9,
-1,
-10,
-1,
-1,
-1,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = i;
}
var copy = view.sublist(0, view.length);
Expect.isFalse(identical(copy, view));
Expect.isTrue(copy is Uint16List);
Expect.equals(10, copy.length);
Expect.listEquals(view, copy);
var region = view.sublist(3, view.length - 3);
Expect.isTrue(copy is Uint16List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
view.setRange(3, 7, [0x10001, 0, 1, 0xFFFF]);
Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFF, 7, 8, 9], view);
Expect.listEquals([
-1,
-1,
0,
0,
1,
0,
2,
0,
1,
0,
0,
0,
1,
0,
-1,
-1,
7,
0,
8,
0,
9,
0,
-1,
-1,
], array);
}
static testUint16ListView() {
var array = new Int8List(24);
testUint16ListViewImpl(array);
}
static testInt32ListView() {
var array = new Uint8List(48);
Expect.equals(48, array.length);
Expect.equals(1, array.elementSizeInBytes);
Expect.equals(48, array.lengthInBytes);
for (int i = 0; i < array.length; ++i) {
array[i] = 0xFF;
}
Expect.throws(
() {
new Int32List.view(array.buffer, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int32List.view(array.buffer, 0, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int32List.view(array.buffer, array.lengthInBytes + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int32List.view(array.buffer, 0, array.length + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int32List.view(array.buffer, array.length - 1, 2);
},
(e) {
return e is RangeError;
},
);
var empty = new Int32List.view(array.buffer, array.lengthInBytes);
Expect.isTrue(empty is List<int>);
Expect.isTrue(empty is Int32List);
Expect.equals(0, empty.length);
var whole = new Int32List.view(array.buffer);
Expect.isTrue(whole is List<int>);
Expect.isTrue(whole is Int32List);
Expect.equals(12, whole.length);
var view = new Int32List.view(array.buffer, 4, 10);
Expect.isTrue(view is List<int>);
Expect.isTrue(view is Int32List);
Expect.equals(10, view.length);
Expect.equals(4, view.elementSizeInBytes);
Expect.equals(40, view.lengthInBytes);
Expect.listEquals([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], view);
Expect.throws(
() {
view[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[view.length];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[10] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeRange(0, view.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < view.length; ++i) {
view[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], view);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0xFF,
0x01,
0x00,
0x00,
0x00,
0x02,
0x00,
0x00,
0x00,
0x03,
0x00,
0x00,
0x00,
0x04,
0x00,
0x00,
0x00,
0x05,
0x00,
0x00,
0x00,
0x06,
0x00,
0x00,
0x00,
0x07,
0x00,
0x00,
0x00,
0x08,
0x00,
0x00,
0x00,
0x09,
0x00,
0x00,
0x00,
0x0A,
0x00,
0x00,
0x00,
0xFF,
0xFF,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0x100000000 + i;
}
Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], view);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0xFF,
0x00,
0x00,
0x00,
0x00,
0x01,
0x00,
0x00,
0x00,
0x02,
0x00,
0x00,
0x00,
0x03,
0x00,
0x00,
0x00,
0x04,
0x00,
0x00,
0x00,
0x05,
0x00,
0x00,
0x00,
0x06,
0x00,
0x00,
0x00,
0x07,
0x00,
0x00,
0x00,
0x08,
0x00,
0x00,
0x00,
0x09,
0x00,
0x00,
0x00,
0xFF,
0xFF,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = -10 + i;
}
Expect.listEquals([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1], view);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0xFF,
0xF6,
0xFF,
0xFF,
0xFF,
0xF7,
0xFF,
0xFF,
0xFF,
0xF8,
0xFF,
0xFF,
0xFF,
0xF9,
0xFF,
0xFF,
0xFF,
0xFA,
0xFF,
0xFF,
0xFF,
0xFB,
0xFF,
0xFF,
0xFF,
0xFC,
0xFF,
0xFF,
0xFF,
0xFD,
0xFF,
0xFF,
0xFF,
0xFE,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0x7FFFFFFF - i;
}
Expect.listEquals([
0x7FFFFFFF,
0x7FFFFFFE,
0x7FFFFFFD,
0x7FFFFFFC,
0x7FFFFFFB,
0x7FFFFFFA,
0x7FFFFFF9,
0x7FFFFFF8,
0x7FFFFFF7,
0x7FFFFFF6,
], view);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x7F,
0xFE,
0xFF,
0xFF,
0x7F,
0xFD,
0xFF,
0xFF,
0x7F,
0xFC,
0xFF,
0xFF,
0x7F,
0xFB,
0xFF,
0xFF,
0x7F,
0xFA,
0xFF,
0xFF,
0x7F,
0xF9,
0xFF,
0xFF,
0x7F,
0xF8,
0xFF,
0xFF,
0x7F,
0xF7,
0xFF,
0xFF,
0x7F,
0xF6,
0xFF,
0xFF,
0x7F,
0xFF,
0xFF,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = -0x80000000 + i;
}
Expect.listEquals([
-0x80000000,
-0x7FFFFFFF,
-0x7FFFFFFE,
-0x7FFFFFFD,
-0x7FFFFFFC,
-0x7FFFFFFB,
-0x7FFFFFFA,
-0x7FFFFFF9,
-0x7FFFFFF8,
-0x7FFFFFF7,
], view);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0xFF,
0x00,
0x00,
0x00,
0x80,
0x01,
0x00,
0x00,
0x80,
0x02,
0x00,
0x00,
0x80,
0x03,
0x00,
0x00,
0x80,
0x04,
0x00,
0x00,
0x80,
0x05,
0x00,
0x00,
0x80,
0x06,
0x00,
0x00,
0x80,
0x07,
0x00,
0x00,
0x80,
0x08,
0x00,
0x00,
0x80,
0x09,
0x00,
0x00,
0x80,
0xFF,
0xFF,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = i;
}
var copy = view.sublist(0, view.length);
Expect.isFalse(identical(copy, view));
Expect.isTrue(copy is Int32List);
Expect.equals(10, copy.length);
Expect.listEquals(view, copy);
var region = view.sublist(3, view.length - 3);
Expect.isTrue(copy is Int32List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
view.setRange(3, 7, [-0x80000000, 0, 1, 0x7FFFFFFF]);
Expect.listEquals([0, 1, 2, -0x80000000, 0, 1, 0x7FFFFFFF, 7, 8, 9], view);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0xFF,
0x00,
0x00,
0x00,
0x00,
0x01,
0x00,
0x00,
0x00,
0x02,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x00,
0x00,
0x00,
0x00,
0x01,
0x00,
0x00,
0x00,
0xFF,
0xFF,
0xFF,
0x7F,
0x07,
0x00,
0x00,
0x00,
0x08,
0x00,
0x00,
0x00,
0x09,
0x00,
0x00,
0x00,
0xFF,
0xFF,
0xFF,
0xFF,
], array);
}
static testUint32ListViewImpl(var array) {
Expect.isTrue(array is List<int>);
Expect.equals(48, array.length);
Expect.equals(1, array.elementSizeInBytes);
Expect.equals(48, array.lengthInBytes);
for (int i = 0; i < array.length; ++i) {
array[i] = -1;
}
Expect.throws(
() {
new Uint32List.view(array.buffer, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint32List.view(array.buffer, 0, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint32List.view(array.buffer, array.lengthInBytes + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint32List.view(array.buffer, 0, array.length + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint32List.view(array.buffer, array.length - 1, 2);
},
(e) {
return e is RangeError;
},
);
var empty = new Uint32List.view(array.buffer, array.lengthInBytes);
Expect.isTrue(empty is List<int>);
Expect.isTrue(empty is Uint32List);
Expect.equals(0, empty.length);
var whole = new Uint32List.view(array.buffer);
Expect.isTrue(whole is List<int>);
Expect.isTrue(whole is Uint32List);
Expect.equals(12, whole.length);
var view = new Uint32List.view(array.buffer, 4, 10);
Expect.isTrue(view is List<int>);
Expect.isTrue(view is Uint32List);
Expect.equals(10, view.length);
Expect.equals(4, view.elementSizeInBytes);
Expect.equals(40, view.lengthInBytes);
Expect.listEquals([
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF,
0xFFFFFFFF,
], view);
Expect.throws(
() {
view[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[view.length];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[view.length] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeRange(0, view.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < view.length; ++i) {
view[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], view);
Expect.listEquals([
-1,
-1,
-1,
-1,
1,
0,
0,
0,
2,
0,
0,
0,
3,
0,
0,
0,
4,
0,
0,
0,
5,
0,
0,
0,
6,
0,
0,
0,
7,
0,
0,
0,
8,
0,
0,
0,
9,
0,
0,
0,
10,
0,
0,
0,
-1,
-1,
-1,
-1,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0x100000000 + i;
}
Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], view);
Expect.listEquals([
-1,
-1,
-1,
-1,
0,
0,
0,
0,
1,
0,
0,
0,
2,
0,
0,
0,
3,
0,
0,
0,
4,
0,
0,
0,
5,
0,
0,
0,
6,
0,
0,
0,
7,
0,
0,
0,
8,
0,
0,
0,
9,
0,
0,
0,
-1,
-1,
-1,
-1,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0xFFFFFFFF - i;
}
Expect.listEquals([
0xFFFFFFFF,
0xFFFFFFFE,
0xFFFFFFFD,
0xFFFFFFFC,
0xFFFFFFFB,
0xFFFFFFFA,
0xFFFFFFF9,
0xFFFFFFF8,
0xFFFFFFF7,
0xFFFFFFF6,
], view);
Expect.listEquals([
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-2,
-1,
-1,
-1,
-3,
-1,
-1,
-1,
-4,
-1,
-1,
-1,
-5,
-1,
-1,
-1,
-6,
-1,
-1,
-1,
-7,
-1,
-1,
-1,
-8,
-1,
-1,
-1,
-9,
-1,
-1,
-1,
-10,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = i;
}
var copy = view.sublist(0, view.length);
Expect.isFalse(identical(copy, view));
Expect.isTrue(copy is Uint32List);
Expect.equals(10, copy.length);
Expect.listEquals(view, copy);
var region = view.sublist(3, view.length - 3);
Expect.isTrue(copy is Uint32List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
view.setRange(3, 7, [0x100000001, 0, 1, 0xFFFFFFFF]);
Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFFFFFF, 7, 8, 9], view);
Expect.listEquals([
-1,
-1,
-1,
-1,
0,
0,
0,
0,
1,
0,
0,
0,
2,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
-1,
-1,
-1,
-1,
7,
0,
0,
0,
8,
0,
0,
0,
9,
0,
0,
0,
-1,
-1,
-1,
-1,
], array);
}
static testUint32ListView() {
var array = new Int8List(48);
testUint32ListViewImpl(array);
}
static testInt64ListViewImpl(var array) {
Expect.equals(96, array.length);
Expect.equals(1, array.elementSizeInBytes);
Expect.equals(96, array.lengthInBytes);
for (int i = 0; i < array.length; ++i) {
array[i] = 0xFF;
}
Expect.throws(
() {
new Int64List.view(array.buffer, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int64List.view(array.buffer, 0, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int64List.view(array.buffer, array.lengthInBytes + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int64List.view(array.buffer, 0, array.length + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Int64List.view(array.buffer, array.length - 1, 2);
},
(e) {
return e is RangeError;
},
);
var empty = new Int64List.view(array.buffer, array.lengthInBytes);
Expect.isTrue(empty is List<int>);
Expect.isTrue(empty is Int64List);
Expect.equals(0, empty.length);
var whole = new Int64List.view(array.buffer);
Expect.isTrue(whole is List<int>);
Expect.isTrue(whole is Int64List);
Expect.equals(12, whole.length);
var view = new Int64List.view(array.buffer, 8, 10);
Expect.isTrue(view is List<int>);
Expect.isTrue(view is Int64List);
Expect.equals(10, view.length);
Expect.equals(8, view.elementSizeInBytes);
Expect.equals(80, view.lengthInBytes);
Expect.listEquals([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1], view);
Expect.throws(
() {
view[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[view.length];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[10] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeRange(0, view.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < view.length; ++i) {
view[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], view);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x01,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x02,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x03,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x04,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x05,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x06,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x07,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x08,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x09,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x0A,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = -10 + i;
}
Expect.listEquals([-10, -9, -8, -7, -6, -5, -4, -3, -2, -1], view);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xF6,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xF7,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xF8,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xF9,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFA,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFB,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFC,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFD,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFE,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0x7FFFFFFFFFFFFFFF - i;
}
Expect.listEquals([
0x7FFFFFFFFFFFFFFF,
0x7FFFFFFFFFFFFFFE,
0x7FFFFFFFFFFFFFFD,
0x7FFFFFFFFFFFFFFC,
0x7FFFFFFFFFFFFFFB,
0x7FFFFFFFFFFFFFFA,
0x7FFFFFFFFFFFFFF9,
0x7FFFFFFFFFFFFFF8,
0x7FFFFFFFFFFFFFF7,
0x7FFFFFFFFFFFFFF6,
], view);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x7F,
0xFE,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x7F,
0xFD,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x7F,
0xFC,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x7F,
0xFB,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x7F,
0xFA,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x7F,
0xF9,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x7F,
0xF8,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x7F,
0xF7,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x7F,
0xF6,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x7F,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = -0x8000000000000000 + i;
}
Expect.listEquals([
-0x8000000000000000,
-0x7FFFFFFFFFFFFFFF,
-0x7FFFFFFFFFFFFFFE,
-0x7FFFFFFFFFFFFFFD,
-0x7FFFFFFFFFFFFFFC,
-0x7FFFFFFFFFFFFFFB,
-0x7FFFFFFFFFFFFFFA,
-0x7FFFFFFFFFFFFFF9,
-0x7FFFFFFFFFFFFFF8,
-0x7FFFFFFFFFFFFFF7,
], view);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x01,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x02,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x03,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x04,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x05,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x06,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x07,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x08,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x09,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = i;
}
var copy = view.sublist(0, view.length);
Expect.isFalse(identical(copy, view));
Expect.isTrue(copy is Int64List);
Expect.equals(10, copy.length);
Expect.listEquals(view, copy);
var region = view.sublist(3, view.length - 3);
Expect.isTrue(copy is Int64List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
view.setRange(3, 7, [-0x8000000000000000, 0, 1, 0x7FFFFFFFFFFFFFFF]);
Expect.listEquals([
0,
1,
2,
-0x8000000000000000,
0,
1,
0x7FFFFFFFFFFFFFFF,
7,
8,
9,
], view);
Expect.listEquals([
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x01,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x02,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x80,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x01,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0x7F,
0x07,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x08,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x09,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
0xFF,
], array);
}
static testInt64ListView() {
var array = new Uint8List(96);
testInt64ListViewImpl(array);
}
static testUint64ListViewImpl(var array) {
Expect.isTrue(array is List<int>);
Expect.equals(96, array.length);
Expect.equals(1, array.elementSizeInBytes);
Expect.equals(96, array.lengthInBytes);
for (int i = 0; i < array.length; ++i) {
array[i] = -1;
}
Expect.throws(
() {
new Uint64List.view(array.buffer, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint64List.view(array.buffer, 0, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint64List.view(array.buffer, array.lengthInBytes + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint64List.view(array.buffer, 0, array.length + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Uint64List.view(array.buffer, array.length - 1, 2);
},
(e) {
return e is RangeError;
},
);
var empty = new Uint64List.view(array.buffer, array.lengthInBytes);
Expect.isTrue(empty is List<int>);
Expect.isTrue(empty is Uint64List);
Expect.equals(0, empty.length);
var whole = new Uint64List.view(array.buffer);
Expect.isTrue(whole is List<int>);
Expect.isTrue(whole is Uint64List);
Expect.equals(12, whole.length);
var view = new Uint64List.view(array.buffer, 8, 10);
Expect.isTrue(view is List<int>);
Expect.isTrue(view is Uint64List);
Expect.equals(10, view.length);
Expect.equals(8, view.elementSizeInBytes);
Expect.equals(80, view.lengthInBytes);
Expect.listEquals([
0xFFFFFFFFFFFFFFFF,
0xFFFFFFFFFFFFFFFF,
0xFFFFFFFFFFFFFFFF,
0xFFFFFFFFFFFFFFFF,
0xFFFFFFFFFFFFFFFF,
0xFFFFFFFFFFFFFFFF,
0xFFFFFFFFFFFFFFFF,
0xFFFFFFFFFFFFFFFF,
0xFFFFFFFFFFFFFFFF,
0xFFFFFFFFFFFFFFFF,
], view);
Expect.throws(
() {
view[-1] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[view.length];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[view.length] = 0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view.add(0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.addAll([0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeRange(0, view.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < view.length; ++i) {
view[i] = 1 + i;
}
Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], view);
Expect.listEquals([
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
1,
0,
0,
0,
0,
0,
0,
0,
2,
0,
0,
0,
0,
0,
0,
0,
3,
0,
0,
0,
0,
0,
0,
0,
4,
0,
0,
0,
0,
0,
0,
0,
5,
0,
0,
0,
0,
0,
0,
0,
6,
0,
0,
0,
0,
0,
0,
0,
7,
0,
0,
0,
0,
0,
0,
0,
8,
0,
0,
0,
0,
0,
0,
0,
9,
0,
0,
0,
0,
0,
0,
0,
10,
0,
0,
0,
0,
0,
0,
0,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = 0xFFFFFFFFFFFFFFFF - i;
}
Expect.listEquals([
0xFFFFFFFFFFFFFFFF,
0xFFFFFFFFFFFFFFFE,
0xFFFFFFFFFFFFFFFD,
0xFFFFFFFFFFFFFFFC,
0xFFFFFFFFFFFFFFFB,
0xFFFFFFFFFFFFFFFA,
0xFFFFFFFFFFFFFFF9,
0xFFFFFFFFFFFFFFF8,
0xFFFFFFFFFFFFFFF7,
0xFFFFFFFFFFFFFFF6,
], view);
Expect.listEquals([
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-2,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-3,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-4,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-5,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-6,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-7,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-8,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-9,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-10,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
], array);
for (int i = 0; i < view.length; ++i) {
view[i] = i;
}
var copy = view.sublist(0, view.length);
Expect.isFalse(identical(copy, view));
Expect.isTrue(copy is Uint64List);
Expect.equals(10, copy.length);
Expect.listEquals(view, copy);
var region = view.sublist(3, view.length - 3);
Expect.isTrue(copy is Uint64List);
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
view.setRange(3, 7, [0x8000000000000001, 0, 1, 0xFFFFFFFFFFFFFFFF]);
Expect.listEquals([
0,
1,
2,
0x8000000000000001,
0,
1,
0xFFFFFFFFFFFFFFFF,
7,
8,
9,
], view);
Expect.listEquals([
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
2,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
-128,
0,
0,
0,
0,
0,
0,
0,
0,
1,
0,
0,
0,
0,
0,
0,
0,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
7,
0,
0,
0,
0,
0,
0,
0,
8,
0,
0,
0,
0,
0,
0,
0,
9,
0,
0,
0,
0,
0,
0,
0,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
-1,
], array);
}
static testUint64ListView() {
var array = new Int8List(96);
testUint64ListViewImpl(array);
}
static testFloat32ListViewImpl(var array) {
Expect.isTrue(array is List<int>);
Expect.equals(12, array.length);
Expect.equals(4, array.elementSizeInBytes);
Expect.equals(48, array.lengthInBytes);
for (int i = 0; i < array.length; ++i) {
array[i] = 0xBF800000;
}
Expect.throws(
() {
new Float32List.view(array.buffer, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Float32List.view(array.buffer, 0, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Float32List.view(array.buffer, array.lengthInBytes + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Float32List.view(array.buffer, 0, array.lengthInBytes + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Float32List.view(array.buffer, array.lengthInBytes - 1, 2);
},
(e) {
return e is RangeError;
},
);
var empty = new Float32List.view(array.buffer, array.lengthInBytes);
Expect.isTrue(empty is List<double>);
Expect.isTrue(empty is Float32List);
Expect.equals(0, empty.length);
var whole = new Float32List.view(array.buffer);
Expect.isTrue(whole is List<double>);
Expect.isTrue(whole is Float32List);
Expect.equals(12, whole.length);
var view = new Float32List.view(array.buffer, 4, 10);
Expect.isTrue(view is List<double>);
Expect.isTrue(view is Float32List);
Expect.equals(10, view.length);
Expect.equals(4, view.elementSizeInBytes);
Expect.equals(40, view.lengthInBytes);
Expect.listEquals([
-1.0,
-1.0,
-1.0,
-1.0,
-1.0,
-1.0,
-1.0,
-1.0,
-1.0,
-1.0,
], view);
Expect.throws(
() {
view[-1] = 0.0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[10];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[10] = 0.0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view.add(0.0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.addAll([0.0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeRange(0, array.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < view.length; ++i) {
view[i] = 1.0 + i;
}
Expect.listEquals([
1.0,
2.0,
3.0,
4.0,
5.0,
6.0,
7.0,
8.0,
9.0,
10.0,
], view);
Expect.listEquals([
0xBF800000,
0x3F800000,
0x40000000,
0x40400000,
0x40800000,
0x40A00000,
0x40C00000,
0x40E00000,
0x41000000,
0x41100000,
0x41200000,
0xBF800000,
], array);
// TODO: min, max, and round
for (int i = 0; i < view.length; ++i) {
view[i] = i * 1.0;
}
var copy = view.sublist(0, view.length);
Expect.isFalse(identical(copy, view));
Expect.isTrue(copy is Float32List);
Expect.equals(10, copy.length);
Expect.listEquals(view, copy);
var region = view.sublist(3, view.length - 3);
Expect.isTrue(copy is Float32List);
Expect.equals(4, region.length);
Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
view.setRange(3, 7, [double.negativeInfinity, 0.0, 1.0, double.infinity]);
Expect.listEquals([
0.0,
1.0,
2.0,
double.negativeInfinity,
0.0,
1.0,
double.infinity,
7.0,
8.0,
9.0,
], view);
Expect.listEquals([
0xBF800000,
0x00000000,
0x3F800000,
0x40000000,
0xFF800000,
0x00000000,
0x3F800000,
0x7F800000,
0x40E00000,
0x41000000,
0x41100000,
0xBF800000,
], array);
}
static testFloat32ListView() {
var array = new Uint32List(12);
testFloat32ListViewImpl(array);
}
static testFloat64ListViewImpl(var array) {
Expect.isTrue(array is List<int>);
Expect.equals(12, array.length);
Expect.equals(8, array.elementSizeInBytes);
Expect.equals(96, array.lengthInBytes);
for (int i = 0; i < array.length; ++i) {
array[i] = 0xBFF0000000000000;
}
Expect.throws(
() {
new Float64List.view(array.buffer, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Float64List.view(array.buffer, 0, -1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Float64List.view(array.buffer, array.lengthInBytes + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Float64List.view(array.buffer, 0, array.lengthInBytes + 1);
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
new Float64List.view(array.buffer, array.lengthInBytes - 1, 2);
},
(e) {
return e is RangeError;
},
);
var empty = new Float64List.view(array.buffer, array.lengthInBytes);
Expect.isTrue(empty is List<double>);
Expect.isTrue(empty is Float64List);
Expect.equals(0, empty.length);
var whole = new Float64List.view(array.buffer);
Expect.isTrue(whole is List<double>);
Expect.isTrue(whole is Float64List);
Expect.equals(12, whole.length);
var view = new Float64List.view(array.buffer, 8, 10);
Expect.isTrue(view is List<double>);
Expect.isTrue(view is Float64List);
Expect.equals(10, view.length);
Expect.equals(8, view.elementSizeInBytes);
Expect.equals(80, view.lengthInBytes);
Expect.listEquals([
-1.0,
-1.0,
-1.0,
-1.0,
-1.0,
-1.0,
-1.0,
-1.0,
-1.0,
-1.0,
], view);
Expect.throws(
() {
view[-1] = 0.0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[-1];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[10];
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view[10] = 0.0;
},
(e) {
return e is RangeError;
},
);
Expect.throws(
() {
view.add(0.0);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.addAll([0.0]);
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.clear();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.length = 0;
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeLast();
},
(e) {
return e is UnsupportedError;
},
);
Expect.throws(
() {
view.removeRange(0, array.length - 1);
},
(e) {
return e is UnsupportedError;
},
);
for (int i = 0; i < view.length; ++i) {
view[i] = 1.0 + i;
}
Expect.listEquals([
1.0,
2.0,
3.0,
4.0,
5.0,
6.0,
7.0,
8.0,
9.0,
10.0,
], view);
Expect.listEquals([
0xBFF0000000000000,
0x3FF0000000000000,
0x4000000000000000,
0x4008000000000000,
0x4010000000000000,
0x4014000000000000,
0x4018000000000000,
0x401C000000000000,
0x4020000000000000,
0x4022000000000000,
0x4024000000000000,
0xBFF0000000000000,
], array);
// TODO: min, max
for (int i = 0; i < view.length; ++i) {
view[i] = i * 1.0;
}
var copy = view.sublist(0, view.length);
Expect.isFalse(identical(copy, view));
Expect.isTrue(copy is Float64List);
Expect.equals(10, copy.length);
Expect.listEquals(view, copy);
var region = view.sublist(3, view.length - 3);
Expect.isTrue(copy is Float64List);
Expect.equals(4, region.length);
Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
view.setRange(3, 7, [double.negativeInfinity, 0.0, 1.0, double.infinity]);
Expect.listEquals([
0.0,
1.0,
2.0,
double.negativeInfinity,
0.0,
1.0,
double.infinity,
7.0,
8.0,
9.0,
], view);
Expect.listEquals([
0xBFF0000000000000,
0x0000000000000000,
0x3FF0000000000000,
0x4000000000000000,
0xFFF0000000000000,
0x0000000000000000,
0x3FF0000000000000,
0x7FF0000000000000,
0x401C000000000000,
0x4020000000000000,
0x4022000000000000,
0xBFF0000000000000,
], array);
}
static testFloat64ListView() {
var array = new Uint64List(12);
testFloat64ListViewImpl(array);
}
static testMain() {
testInt8List();
testUint8List();
testInt16List();
testUint16List();
testInt32List();
testUint32List();
testInt64List();
testUint64List();
testFloat32List();
testFloat64List();
//testByteList();
testInt8ListView();
testUint8ListView();
testInt16ListView();
testUint16ListView();
testInt32ListView();
testUint32ListView();
testInt64ListView();
testUint64ListView();
testFloat32ListView();
testFloat64ListView();
}
}
main() {
for (var i = 0; i < 20; i++) {
OptimizedByteArrayTest.testMain();
}
}