Improve Tests

lib/src/delegating_list.dart

@@ -86,13 +86,17 @@ class _$DelegatingList<E> extends $Iterable<E> implements List<E> {
 
   @override
   int lastIndexOf(E element, [int start]) {
-    start = _allowNegativeIndex(start);
+    if (start != null) {
+      start = _allowNegativeIndex(start);
+    }
     return source.lastIndexOf(element, start);
   }
 
   @override
   int lastIndexWhere(bool Function(E element) test, [int start]) {
-    start = _allowNegativeIndex(start);
+    if (start != null) {
+      start = _allowNegativeIndex(start);
+    }
     return source.lastIndexWhere(test, start);
   }
 
@@ -166,7 +170,9 @@ class _$DelegatingList<E> extends $Iterable<E> implements List<E> {
   @override
   $List<E> sublist(int start, [int end]) {
     start = _allowNegativeIndex(start);
-    end = _allowNegativeIndex(end);
+    if (end != null) {
+      end = _allowNegativeIndex(end);
+    }
     return $List(source.sublist(start, end));
   }
 }

test/delegating_iterable_test.dart

@@ -6,64 +6,64 @@ $Iterable<int> get empty => $Iterable<int>.empty();
 $Iterable<E> iterable<E>(List<E> elements) => $Iterable(elements).toIterable();
 
 void main() {
-  test('elementAt', () {
+  test('test elementAt', () {
     var elements = iterable([0, 1, 2, 3, 4]);
     expect(elements.elementAt(1), 1);
     expect(elements.elementAt(4), 4);
     expect(elements.elementAt(-1), 4);
     expect(() => elements.elementAt(5), throwsRangeError);
   });
 
-  test('iterator', () {
+  test('test iterator', () {
     var elements = iterable([0, 1, 2, 3, 4]);
     var i = 0;
     for (var element in elements) {
       expect(elements.elementAt(i++), element);
     }
   });
 
-  test('length', () {
+  test('test length', () {
     expect(empty.length, 0);
     expect(iterable([0, 1, 2, 3, 4]).length, 5);
   });
 
-  test('followedBy', () {
+  test('test followedBy', () {
     var elements = iterable([0, 1, 2, 3, 4]);
     expect(empty.followedBy(empty), empty);
     expect(empty.followedBy(elements), elements);
     expect(elements.followedBy(elements), [0, 1, 2, 3, 4, 0, 1, 2, 3, 4]);
     expect(elements.followedBy([1, 2]) is $Iterable, true);
   });
 
-  test('map', () {
+  test('test map', () {
     var elements = iterable([0, 1, 2, 3, 4]);
     var result = elements.map((e) => e * e);
     expect(result, [0, 1, 4, 9, 16]);
     expect(result is $Iterable, true);
   });
 
-  test('where', () {
+  test('test where', () {
     var elements = iterable([0, 1, 2, 3, 4]);
     var result = elements.where((e) => e > 2);
     expect(result, [3, 4]);
     expect(result is $Iterable, true);
   });
 
-  test('whereType', () {
+  test('test whereType', () {
     var elements = iterable([0, '1', 2, '3', 4]);
     var result = elements.whereType<int>();
     expect(result, [0, 2, 4]);
     expect(result is $Iterable, true);
   });
 
-  test('expand', () {
+  test('test expand', () {
     var elements = iterable([0, 1, 2]);
     var result = elements.expand((e) => [e, e, e]);
     expect(result, [0, 0, 0, 1, 1, 1, 2, 2, 2]);
     expect(result is $Iterable, true);
   });
 
-  test('toList', () {
+  test('test toList', () {
     var elements = iterable([0, 1, 2, 3, 4]);
     {
       var result = empty.toList();
@@ -77,28 +77,28 @@ void main() {
     }
   });
 
-  test('take', () {
+  test('test take', () {
     var elements = iterable([0, 1, 2, 3, 4]);
     var result = elements.take(3);
     expect(result, [0, 1, 2]);
     expect(result is $Iterable, true);
   });
 
-  test('takeWhile', () {
+  test('test takeWhile', () {
     var elements = iterable([0, 1, 2, 3, 4]);
     var result = elements.takeWhile((e) => e < 3);
     expect(result, [0, 1, 2]);
     expect(result is $Iterable, true);
   });
 
-  test('skip', () {
+  test('test skip', () {
     var elements = iterable([0, 1, 2, 3, 4]);
     var result = elements.skip(2);
     expect(result, [2, 3, 4]);
     expect(result is $Iterable, true);
   });
 
-  test('skipWhile', () {
+  test('test skipWhile', () {
     var elements = iterable([0, 1, 2, 3, 4]);
     var result = elements.skipWhile((e) => e < 3);
     expect(result, [3, 4]);

test/delegating_list_test.dart

@@ -1 +1,173 @@
-void main() {}
+import 'dart:math';
+
+import 'package:superpower/superpower.dart';
+import 'package:test/test.dart';
+
+$List<int> get empty => $List<int>();
+
+void main() {
+  test('test []', () {
+    var list = $([0, 1, 2, 3, 4]);
+    expect(list[0], 0);
+    expect(list[2], 2);
+    list[2] = 10;
+    expect(list[2], 10);
+  });
+
+  test('test add', () {
+    var list = $([0, 1, 2, 3, 4]);
+    list.add(5);
+    expect(list, [0, 1, 2, 3, 4, 5]);
+  });
+
+  test('test addAll', () {
+    var list = $([0, 1, 2, 3, 4]);
+    list.addAll([5, 5, 5]);
+    expect(list, [0, 1, 2, 3, 4, 5, 5, 5]);
+  });
+
+  test('test asMap', () {
+    var list = $(['0', '1', '2']);
+    expect(list.asMap(), {0: '0', 1: '1', 2: '2'});
+  });
+
+  test('test clear', () {
+    var list = $([0, 1, 2, 3, 4]);
+    list.clear();
+    expect(list, <int>[]);
+  });
+
+  test('test fillRange', () {
+    var list = $([0, 1, 2, 3, 4]);
+    list.fillRange(1, 4, 9);
+    expect(list, [0, 9, 9, 9, 4]);
+  });
+
+  test('test first', () {
+    var list = $([0, 1, 2, 3, 4]);
+    expect(list.first, 0);
+  });
+
+  test('test getRange', () {
+    var list = $([0, 1, 2, 3, 4]);
+    var result = list.getRange(1, 4);
+    expect(result, [1, 2, 3]);
+    expect(result is $Iterable, true);
+  });
+
+  test('test indexOf', () {
+    var list = $(['0', '1', '2', '3', '4']);
+    expect(list.indexOf('2'), 2);
+  });
+
+  test('test indexWhere', () {
+    var list = $(['0', '1', '2', '3', '4']);
+    expect(list.indexWhere((e) => e == '2'), 2);
+  });
+
+  test('test insert', () {
+    var list = $([0, 1, 2, 3, 4]);
+    list.insert(2, 5);
+    expect(list, [0, 1, 5, 2, 3, 4]);
+  });
+
+  test('test insertAll', () {
+    var list = $([0, 1, 2]);
+    list.insertAll(1, [5, 5, 5]);
+    expect(list, [0, 5, 5, 5, 1, 2]);
+  });
+
+  test('test last', () {
+    var list = $([0, 1, 2, 3, 4]);
+    expect(list.last, 4);
+  });
+
+  test('test lastIndexOf lastIndexWhere', () {
+    var list = $([0, 1, 2, 3, 4, 2, 3, 2, 4]);
+    expect(list.lastIndexOf(2, 8), 7);
+    expect(list.lastIndexWhere((e) => e == 2, 8), 7);
+  });
+
+  test('test remove', () {
+    var list = $([0, 1, 2, 3, 2]);
+    list.remove(2);
+    expect(list, [0, 1, 3, 2]);
+  });
+
+  test('test removeAt', () {
+    var list = $([0, 1, 2, 3, 2]);
+    list.removeAt(3);
+    expect(list, [0, 1, 2, 2]);
+  });
+
+  test('test removeLast', () {
+    var list = $([0, 1, 2, 3, 2]);
+    list.removeLast();
+    expect(list, [0, 1, 2, 3]);
+  });
+
+  test('test removeRange', () {
+    var list = $([0, 1, 2, 3, 4]);
+    list.removeRange(1, 4);
+    expect(list, [0, 4]);
+  });
+
+  test('test removeWhere', () {
+    var list = $([0, 1, 2, 3, 4]);
+    list.removeWhere((e) => e < 3);
+    expect(list, [3, 4]);
+  });
+
+  test('test replaceRange', () {
+    var list = $([0, 1, 2, 3, 4]);
+    list.replaceRange(1, 4, [5, 5]);
+    expect(list, [0, 5, 5, 4]);
+  });
+
+  test('test retainWhere', () {
+    var list = $([0, 1, 2, 3, 4]);
+    list.retainWhere((e) => e != 2);
+    expect(list, [0, 1, 3, 4]);
+  });
+
+  test('test reversed', () {
+    var list = $([0, 1, 2, 3, 4]);
+    var result = list.reverse();
+    expect(result, [4, 3, 2, 1, 0]);
+    expect(result is $Iterable, true);
+  });
+
+  test('test setAll', () {
+    var list = $([0, 1, 2, 3, 4]);
+    list.setAll(1, [5, 5, 5]);
+    expect(list, [0, 5, 5, 5, 4]);
+  });
+
+  test('test setRange', () {
+    var list = $([0, 1, 2, 3, 4]);
+    list.setRange(1, 2, [5, 5, 5]);
+    expect(list, [0, 5, 2, 3, 4]);
+  });
+
+  test('test shuffle', () {
+    var baseList = [0, 1, 2, 3, 4];
+    var list = $(baseList);
+    var random = Random();
+    baseList.shuffle(random);
+    list.shuffle(random);
+    expect(list, baseList);
+  });
+
+  test('test sort', () {
+    var list = $([3, 0, 2, 1, 4]);
+    list.sort();
+    expect(list, [0, 1, 2, 3, 4]);
+  });
+
+  test('test sublist', () {
+    var list = $([0, 1, 2, 3, 4]);
+    var result = list.sublist(1, 4);
+    expect(result, [1, 2, 3]);
+    expect(result is $List, true);
+  });
+}