Fix some warnings in the core library identified by the static analyzer.

runtime/tests/vm/dart/byte_array_test.dart

 class ByteArrayTest {
   static testInt8List() {
     Expect.throws(() { new Int8List(-1); },
                   (e) { return e is IllegalArgumentException; });
     var array = new Int8List(10);
     Expect.isTrue(array is List<int>);
     Expect.equals(10, array.length);
     Expect.equals(1, array.bytesPerElement());
     Expect.equals(10, array.lengthInBytes());
     Expect.listEquals([0, 0, 0, 0, 0,
@@ skipping 914 matching lines @@
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int8List.view(array.asByteArray(),
                                           array.length); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int8List.view(array.asByteArray(),
                                           0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int8List.view(array.asByteArray(),
                                           array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var whole = new Int8List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Int8List);

[siva, 2012/06/21 23:33:08]

maybe a negative test too, e.g:

Expect.IsFalse(whole is Uint8List);

[cshapiro, 2012/06/22 04:27:00]

Probably not a bad idea.  However, I do a lot of these tests so I should add
them in all places that I do a type test and that probably merits another
change.

Should I test that all other type tests answer false or just the unsigned
variant?  Let me know, I'll add this in another change set.

[siva, 2012/06/22 18:12:30]

No I meant just one negative test each just to ensure that the implementation
does not always return true.

On 2012/06/22 04:27:00, cshapiro wrote:

+    Expect.equals(12, whole.length);
     var view = new Int8List.view(array.asByteArray(), 1, array.length - 2);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Int8List);
     Expect.equals(10, view.length);
     Expect.equals(1, view.bytesPerElement());
     Expect.equals(10, view.lengthInBytes());
     Expect.listEquals([-1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 99 matching lines @@
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint8List.view(array.asByteArray(),
                                            array.length); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint8List.view(array.asByteArray(),
                                            0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint8List.view(array.asByteArray(),
                                            array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var whole = new Uint8List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Uint8List);
+    Expect.equals(12, whole.length);
     var view = new Uint8List.view(array.asByteArray(), 1, array.length - 2);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Uint8List);
     Expect.equals(10, view.length);
     Expect.equals(1, view.bytesPerElement());
     Expect.equals(10, view.lengthInBytes());
     Expect.listEquals([0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
                        0xFF, 0xFF, 0xFF, 0xFF, 0xFF],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 78 matching lines @@
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int16List.view(array.asByteArray(),
                                            array.length); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int16List.view(array.asByteArray(),
                                            0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int16List.view(array.asByteArray(),
                                            array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var whole = new Int16List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Int16List);
+    Expect.equals(12, whole.length);
     var view = new Int16List.view(array.asByteArray(), 2, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Int16List);
     Expect.equals(10, view.length);
     Expect.equals(2, view.bytesPerElement());
     Expect.equals(20, view.lengthInBytes());
     Expect.listEquals([-1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 106 matching lines @@
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint16List.view(array.asByteArray(),
                                             array.length); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint16List.view(array.asByteArray(),
                                             0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint16List.view(array.asByteArray(),
                                             array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var whole = new Uint16List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Uint16List);
+    Expect.equals(12, whole.length);
     var view = new Uint16List.view(array.asByteArray(), 2, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Uint16List);
     Expect.equals(10, view.length);
     Expect.equals(2, view.bytesPerElement());
     Expect.equals(20, view.lengthInBytes());
     Expect.listEquals([0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF,
                        0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 83 matching lines @@
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int32List.view(array.asByteArray(),
                                            array.length); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int32List.view(array.asByteArray(),
                                            0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int32List.view(array.asByteArray(),
                                            array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var whole = new Int32List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Int32List);
+    Expect.equals(12, whole.length);
     var view = new Int32List.view(array.asByteArray(), 4, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Int32List);
     Expect.equals(10, view.length);
     Expect.equals(4, view.bytesPerElement());
     Expect.equals(40, view.lengthInBytes());
     Expect.listEquals([-1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 130 matching lines @@
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint32List.view(array.asByteArray(),
                                             array.length); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint32List.view(array.asByteArray(),
                                             0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint32List.view(array.asByteArray(),
                                             array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var whole = new Uint32List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Uint32List);
+    Expect.equals(12, whole.length);
     var view = new Uint32List.view(array.asByteArray(), 4, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Uint32List);
     Expect.equals(10, view.length);
     Expect.equals(4, view.bytesPerElement());
     Expect.equals(40, view.lengthInBytes());
     Expect.listEquals([0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF,
                        0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF, 0xFFFFFFFF],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 100 matching lines @@
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int64List.view(array.asByteArray(),
                                            array.length); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int64List.view(array.asByteArray(),
                                            0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Int64List.view(array.asByteArray(),
                                            array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var whole = new Int64List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Int64List);
+    Expect.equals(12, whole.length);
     var view = new Int64List.view(array.asByteArray(), 8, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Int64List);
     Expect.equals(10, view.length);
     Expect.equals(8, view.bytesPerElement());
     Expect.equals(80, view.lengthInBytes());
     Expect.listEquals([-1, -1, -1, -1, -1,
                        -1, -1, -1, -1, -1],
                       view);
     Expect.throws(() { view[-1] = 0; },
@@ skipping 167 matching lines @@
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint64List.view(array.asByteArray(),
                                             array.length); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint64List.view(array.asByteArray(),
                                             0, array.length + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Uint64List.view(array.asByteArray(),
                                             array.length - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var whole = new Uint64List.view(array.asByteArray());
+    Expect.isTrue(whole is List<int>);
+    Expect.isTrue(whole is Uint64List);
+    Expect.equals(12, whole.length);
     var view = new Uint64List.view(array.asByteArray(), 8, 10);
     Expect.isTrue(view is List<int>);
     Expect.isTrue(view is Uint64List);
     Expect.equals(10, view.length);
     Expect.equals(8, view.bytesPerElement());
     Expect.equals(80, view.lengthInBytes());
     Expect.listEquals([0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
                        0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
                        0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
                        0xFFFFFFFFFFFFFFFF, 0xFFFFFFFFFFFFFFFF,
@@ skipping 128 matching lines @@
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float32List.view(array.asByteArray(),
                                              array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float32List.view(array.asByteArray(),
                                              0, array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float32List.view(array.asByteArray(),
                                              array.lengthInBytes() - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var whole = new Float32List.view(array.asByteArray());
+    Expect.isTrue(whole is List<double>);
+    Expect.isTrue(whole is Float32List);
+    Expect.equals(12, whole.length);
     var view = new Float32List.view(array.asByteArray(), 4, 10);
     Expect.isTrue(view is List<double>);
+    Expect.isTrue(view is Float32List);
     Expect.equals(10, view.length);
     Expect.equals(4, view.bytesPerElement());
     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 IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
@@ skipping 71 matching lines @@
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float64List.view(array.asByteArray(),
                                              array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float64List.view(array.asByteArray(),
                                              0, array.lengthInBytes() + 1); },
                   (e) { return e is IndexOutOfRangeException; });
     Expect.throws(() { new Float64List.view(array.asByteArray(),
                                              array.lengthInBytes() - 1, 2); },
                   (e) { return e is IndexOutOfRangeException; });
+    var whole = new Float64List.view(array.asByteArray());
+    Expect.isTrue(whole is List<double>);
+    Expect.isTrue(whole is Float64List);
+    Expect.equals(12, whole.length);
     var view = new Float64List.view(array.asByteArray(), 8, 10);
     Expect.isTrue(view is List<double>);
+    Expect.isTrue(view is Float64List);
     Expect.equals(10, view.length);
     Expect.equals(8, view.bytesPerElement());
     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 IndexOutOfRangeException; });
     Expect.throws(() { return view[-1]; },
                   (e) { return e is IndexOutOfRangeException; });
@@ skipping 77 matching lines @@
     testInt64ListView();
     testUint64ListView();
     testFloat32ListView();
     testFloat64ListView();
   }
 }
 
 main() {
   ByteArrayTest.testMain();
 }