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

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: runtime/tests/vm/dart/byte_array_optimized_test.dart

Issue 2759973004: Fix observatory tests broken by running dartfmt. Temporarily reverted formatting for evaluate_activ… (Closed)
Patch Set: Created 3 years, 9 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « runtime/observatory/tests/ui/log.dart ('k') | runtime/tests/vm/dart/byte_array_test.dart » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: runtime/tests/vm/dart/byte_array_optimized_test.dart
diff --git a/runtime/tests/vm/dart/byte_array_optimized_test.dart b/runtime/tests/vm/dart/byte_array_optimized_test.dart
index 755c3b1b6d7ef6ad165c9ff1f104ba13ce5836c1..59b7085ba6f31f25d31c69c47e25375124d5be8e 100644
--- a/runtime/tests/vm/dart/byte_array_optimized_test.dart
+++ b/runtime/tests/vm/dart/byte_array_optimized_test.dart
@@ -17,59 +17,79 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ Expect.listEquals(
+ [-128, -127, -126, -125, -124, -123, -122, -121, -120, -119], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
@@ -85,12 +105,15 @@ class OptimizedByteArrayTest {
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);
+ 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; });
+ Expect.throws(() {
+ new Int8List(-1);
+ }, (e) {
+ return e is ArgumentError;
+ });
var array = new Int8List(10);
testInt8ListImpl(array);
}
@@ -100,47 +123,70 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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);
+ 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);
+ Expect.listEquals(
+ [0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8, 0xF7, 0xF6], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
@@ -156,13 +202,15 @@ class OptimizedByteArrayTest {
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);
+ 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; });
+ Expect.throws(() {
+ new Uint8List(-1);
+ }, (e) {
+ return e is ArgumentError;
+ });
var array = new Uint8List(10);
testUint8ListImpl(array);
}
@@ -172,59 +220,99 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ Expect.listEquals([
+ -0x8000,
+ -0x7FFF,
+ -0x7FFE,
+ -0x7FFD,
+ -0x7FFC,
+ -0x7FFB,
+ -0x7FFA,
+ -0x7FF9,
+ -0x7FF8,
+ -0x7FF7
+ ], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
@@ -240,13 +328,15 @@ class OptimizedByteArrayTest {
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);
+ 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; });
+ Expect.throws(() {
+ new Int16List(-1);
+ }, (e) {
+ return e is ArgumentError;
+ });
var array = new Int16List(10);
testInt16ListImpl(array);
}
@@ -256,47 +346,80 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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);
+ 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);
+ Expect.listEquals([
+ 0xFFFF,
+ 0xFFFE,
+ 0xFFFD,
+ 0xFFFC,
+ 0xFFFB,
+ 0xFFFA,
+ 0xFFF9,
+ 0xFFF8,
+ 0xFFF7,
+ 0xFFF6
+ ], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
@@ -312,13 +435,15 @@ class OptimizedByteArrayTest {
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);
+ 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; });
+ Expect.throws(() {
+ new Uint16List(-1);
+ }, (e) {
+ return e is ArgumentError;
+ });
var array = new Uint16List(10);
testUint16ListImpl(array);
}
@@ -328,65 +453,99 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ Expect.listEquals([
+ -0x80000000,
+ -0x7FFFFFFF,
+ -0x7FFFFFFE,
+ -0x7FFFFFFD,
+ -0x7FFFFFFC,
+ -0x7FFFFFFB,
+ -0x7FFFFFFA,
+ -0x7FFFFFF9,
+ -0x7FFFFFF8,
+ -0x7FFFFFF7
+ ], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
@@ -402,13 +561,15 @@ class OptimizedByteArrayTest {
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);
+ 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; });
+ Expect.throws(() {
+ new Int32List(-1);
+ }, (e) {
+ return e is ArgumentError;
+ });
var array = new Int32List(10);
testInt32ListImpl(array);
}
@@ -418,50 +579,80 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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);
+ 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);
+ Expect.listEquals([
+ 0xFFFFFFFF,
+ 0xFFFFFFFE,
+ 0xFFFFFFFD,
+ 0xFFFFFFFC,
+ 0xFFFFFFFB,
+ 0xFFFFFFFA,
+ 0xFFFFFFF9,
+ 0xFFFFFFF8,
+ 0xFFFFFFF7,
+ 0xFFFFFFF6
+ ], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
@@ -477,18 +668,22 @@ class OptimizedByteArrayTest {
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);
+ 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; });
+ 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) {
@@ -496,65 +691,99 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0x10000000000000000 + i;
}
- Expect.listEquals([0, 1, 2, 3, 4,
- 5, 6, 7, 8, 9],
- array);
+ 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);
+ 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);
+ 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);
+ Expect.listEquals([
+ -0x8000000000000000,
+ -0x7FFFFFFFFFFFFFFF,
+ -0x7FFFFFFFFFFFFFFE,
+ -0x7FFFFFFFFFFFFFFD,
+ -0x7FFFFFFFFFFFFFFC,
+ -0x7FFFFFFFFFFFFFFB,
+ -0x7FFFFFFFFFFFFFFA,
+ -0x7FFFFFFFFFFFFFF9,
+ -0x7FFFFFFFFFFFFFF8,
+ -0x7FFFFFFFFFFFFFF7
+ ], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
@@ -570,14 +799,17 @@ class OptimizedByteArrayTest {
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);
+ 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; });
+ Expect.throws(() {
+ new Int64List(-1);
+ }, (e) {
+ return e is ArgumentError;
+ });
var array = new Int64List(10);
testInt64ListImpl(array);
}
@@ -587,50 +819,80 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ Expect.listEquals([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], array);
for (int i = 0; i < array.length; ++i) {
array[i] = 0x10000000000000000 + i;
}
- Expect.listEquals([0, 1, 2, 3, 4,
- 5, 6, 7, 8, 9],
- array);
+ Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], 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);
+ Expect.listEquals([
+ 0xFFFFFFFFFFFFFFFF,
+ 0xFFFFFFFFFFFFFFFE,
+ 0xFFFFFFFFFFFFFFFD,
+ 0xFFFFFFFFFFFFFFFC,
+ 0xFFFFFFFFFFFFFFFB,
+ 0xFFFFFFFFFFFFFFFA,
+ 0xFFFFFFFFFFFFFFF9,
+ 0xFFFFFFFFFFFFFFF8,
+ 0xFFFFFFFFFFFFFFF7,
+ 0xFFFFFFFFFFFFFFF6
+ ], array);
for (int i = 0; i < array.length; ++i) {
array[i] = i;
}
@@ -646,13 +908,15 @@ class OptimizedByteArrayTest {
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
array.setRange(3, 7, [0x10000000000000001, 0, 1, 0xFFFFFFFFFFFFFFFF]);
- Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFFFFFFFFFFFFFF, 7, 8, 9],
- array);
+ Expect.listEquals([0, 1, 2, 1, 0, 1, 0xFFFFFFFFFFFFFFFF, 7, 8, 9], array);
}
static testUint64List() {
- Expect.throws(() { new Uint64List(-1); },
- (e) { return e is ArgumentError; });
+ Expect.throws(() {
+ new Uint64List(-1);
+ }, (e) {
+ return e is ArgumentError;
+ });
var array = new Uint64List(10);
testUint64ListImpl(array);
}
@@ -662,35 +926,63 @@ class OptimizedByteArrayTest {
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(() { return 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]); },
- (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; });
+ 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(() {
+ return 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]);
+ }, (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);
+ 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;
@@ -707,14 +999,26 @@ class OptimizedByteArrayTest {
Expect.equals(4, region.length);
Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
array.setRange(3, 7, [double.NEGATIVE_INFINITY, 0.0, 1.0, double.INFINITY]);
- Expect.listEquals([0.0, 1.0, 2.0, double.NEGATIVE_INFINITY, 0.0,
- 1.0, double.INFINITY, 7.0, 8.0, 9.0],
- array);
+ Expect.listEquals([
+ 0.0,
+ 1.0,
+ 2.0,
+ double.NEGATIVE_INFINITY,
+ 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; });
+ Expect.throws(() {
+ new Float32List(-1);
+ }, (e) {
+ return e is ArgumentError;
+ });
var array = new Float32List(10);
testFloat32ListImpl(array);
}
@@ -724,35 +1028,63 @@ class OptimizedByteArrayTest {
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(() { return 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]); },
- (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; });
+ 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(() {
+ return 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]);
+ }, (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);
+ 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;
@@ -769,14 +1101,26 @@ class OptimizedByteArrayTest {
Expect.equals(4, region.length);
Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
array.setRange(3, 7, [double.NEGATIVE_INFINITY, 0.0, 1.0, double.INFINITY]);
- Expect.listEquals([0.0, 1.0, 2.0, double.NEGATIVE_INFINITY, 0.0,
- 1.0, double.INFINITY, 7.0, 8.0, 9.0],
- array);
+ Expect.listEquals([
+ 0.0,
+ 1.0,
+ 2.0,
+ double.NEGATIVE_INFINITY,
+ 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; });
+ Expect.throws(() {
+ new Float64List(-1);
+ }, (e) {
+ return e is ArgumentError;
+ });
var array = new Float64List(10);
testFloat64ListImpl(array);
}
@@ -788,21 +1132,32 @@ class OptimizedByteArrayTest {
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.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);
@@ -816,74 +1171,110 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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;
}
@@ -897,11 +1288,10 @@ class OptimizedByteArrayTest {
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);
+ 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);
@@ -915,21 +1305,32 @@ class OptimizedByteArrayTest {
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.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);
@@ -943,56 +1344,74 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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);
+ 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);
+ 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;
}
@@ -1006,8 +1425,7 @@ class OptimizedByteArrayTest {
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);
+ Expect.listEquals([0, 1, 2, 1, 0, 1, 255, 7, 8, 9], view);
}
static testUint8ListView() {
@@ -1022,21 +1440,32 @@ class OptimizedByteArrayTest {
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.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);
@@ -1050,79 +1479,229 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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;
}
@@ -1136,12 +1715,33 @@ class OptimizedByteArrayTest {
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);
+ 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() {
@@ -1157,21 +1757,32 @@ class OptimizedByteArrayTest {
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.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);
@@ -1185,57 +1796,169 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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);
+ 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);
+ 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;
}
@@ -1249,12 +1972,33 @@ class OptimizedByteArrayTest {
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);
+ 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() {
@@ -1270,21 +2014,32 @@ class OptimizedByteArrayTest {
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.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);
@@ -1298,100 +2053,349 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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);
+ 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);
+ 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);
+ 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);
+ 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;
}
@@ -1405,15 +2409,57 @@ class OptimizedByteArrayTest {
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);
+ 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) {
@@ -1424,21 +2470,32 @@ class OptimizedByteArrayTest {
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.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);
@@ -1452,71 +2509,241 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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);
+ 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);
+ 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;
}
@@ -1530,15 +2757,57 @@ class OptimizedByteArrayTest {
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);
+ 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() {
@@ -1553,21 +2822,32 @@ class OptimizedByteArrayTest {
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.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);
@@ -1581,130 +2861,589 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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] = 0x10000000000000000 + i;
}
- Expect.listEquals([0, 1, 2, 3, 4,
- 5, 6, 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,
- 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,
- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
- array);
+ Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 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,
+ 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,
+ 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);
+ 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);
+ 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);
+ 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;
}
@@ -1718,22 +3457,107 @@ class OptimizedByteArrayTest {
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);
+ 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() {
@@ -1749,21 +3573,32 @@ class OptimizedByteArrayTest {
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.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);
@@ -1777,92 +3612,385 @@ class OptimizedByteArrayTest {
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(() { return 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; });
+ 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(() {
+ return 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);
+ 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] = 0x10000000000000000 + i;
}
- Expect.listEquals([0, 1, 2, 3, 4,
- 5, 6, 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,
- 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,
- -1, -1, -1, -1, -1, -1, -1, -1],
- array);
+ Expect.listEquals([0, 1, 2, 3, 4, 5, 6, 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,
+ 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,
+ -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);
+ 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;
}
@@ -1876,21 +4004,105 @@ class OptimizedByteArrayTest {
Expect.equals(4, region.length);
Expect.listEquals([3, 4, 5, 6], region);
view.setRange(3, 7, [0x10000000000000001, 0, 1, 0xFFFFFFFFFFFFFFFF]);
- Expect.listEquals([0, 1, 2, 1, 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, 0,
- 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);
+ Expect.listEquals([0, 1, 2, 1, 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,
+ 0,
+ 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() {
@@ -1906,21 +4118,32 @@ class OptimizedByteArrayTest {
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.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);
@@ -1934,42 +4157,77 @@ class OptimizedByteArrayTest {
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(() { return 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(() { array.add(0.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; });
+ 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(() {
+ return 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(() {
+ array.add(0.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 < 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);
+ 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;
@@ -1984,16 +4242,32 @@ class OptimizedByteArrayTest {
Expect.equals(4, region.length);
Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
view.setRange(3, 7, [double.NEGATIVE_INFINITY, 0.0, 1.0, double.INFINITY]);
- Expect.listEquals([0.0, 1.0, 2.0, double.NEGATIVE_INFINITY, 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);
+ Expect.listEquals([
+ 0.0,
+ 1.0,
+ 2.0,
+ double.NEGATIVE_INFINITY,
+ 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() {
@@ -2009,21 +4283,32 @@ class OptimizedByteArrayTest {
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.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);
@@ -2037,42 +4322,77 @@ class OptimizedByteArrayTest {
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(() { return 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(() { array.add(0.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; });
+ 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(() {
+ return 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(() {
+ array.add(0.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 < 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);
+ 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;
@@ -2087,16 +4407,32 @@ class OptimizedByteArrayTest {
Expect.equals(4, region.length);
Expect.listEquals([3.0, 4.0, 5.0, 6.0], region);
view.setRange(3, 7, [double.NEGATIVE_INFINITY, 0.0, 1.0, double.INFINITY]);
- Expect.listEquals([0.0, 1.0, 2.0, double.NEGATIVE_INFINITY, 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);
+ Expect.listEquals([
+ 0.0,
+ 1.0,
+ 2.0,
+ double.NEGATIVE_INFINITY,
+ 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() {
@@ -2130,7 +4466,7 @@ class OptimizedByteArrayTest {
}
main() {
- for (var i=0; i<20; i++) {
+ for (var i = 0; i < 20; i++) {
OptimizedByteArrayTest.testMain();
}
}
« no previous file with comments | « runtime/observatory/tests/ui/log.dart ('k') | runtime/tests/vm/dart/byte_array_test.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698