anchor.diff:          {required List<T> included, required List<T> excluded}) {
         expect(range, included);
         expect(range.length, included.length);
  +      expect(range.reversed, included.reversed);
         if (included.isEmpty) {
           expect(range.isEmpty, isTrue);
         } else {
  
positive.code:       });
        group('sublist', () {
          test('sublist (1 argument)', () {
            verify(BigIntRange(BigInt.from(3)).sublist(0), [0, 1, 2]);
            verify(BigIntRange(BigInt.from(3)).sublist(1), [1, 2]);
            verify(BigIntRange(BigInt.from(3)).sublist(2), [2]);
            verify(BigIntRange(BigInt.from(3)).sublist(3), []);
            expect(
                () => BigIntRange(BigInt.from(3)).sublist(4), throwsRangeError);
          });
          test('sublist (2 arguments)', () {
            verify(BigIntRange(BigInt.from(3)).sublist(0, 3), [0, 1, 2]);
            verify(BigIntRange(BigInt.from(3)).sublist(0, 2), [0, 1]);
            verify(BigIntRange(BigInt.from(3)).sublist(0, 1), [0]);
            verify(BigIntRange(BigInt.from(3)).sublist(0, 0), []);
            expect(() => BigIntRange(BigInt.from(3)).sublist(0, 4),
                throwsRangeError);
          });
          test('getRange', () {
            verify(
                BigIntRange(BigInt.from(3)).getRange(0, 3).toList(), [0, 1, 2]);
            verify(BigIntRange(BigInt.from(3)).getRange(0, 2).toList(), [0, 1]);
            verify(BigIntRange(BigInt.from(3)).getRange(0, 1).toList(), [0]);
            verify(BigIntRange(BigInt.from(3)).getRange(0, 0).toList(), []);
            expect(() => BigIntRange(BigInt.from(3)).getRange(0, 4),
                throwsRangeError);
          });
        });
        group('index', () {
          test('indexOf (positive step)', () {
            final r = BigIntRange(
                BigInt.from(2), BigInt.from(7), BigInt.from(2)); // [2, 4, 6]
            expect(r.indexOf(null), -1);
            expect(r.indexOf(BigInt.from(1)), -1);
            expect(r.indexOf(BigInt.from(2)), 0);
            expect(r.indexOf(BigInt.from(3)), -1);
            expect(r.indexOf(BigInt.from(4)), 1);
            expect(r.indexOf(BigInt.from(5)), -1);
            expect(r.indexOf(BigInt.from(6)), 2);
            expect(r.indexOf(BigInt.from(7)), -1);
            expect(r.indexOf(BigInt.from(8)), -1);
            expect(r.indexOf(BigInt.from(2), 0), 0);
            expect(r.indexOf(BigInt.from(2), 1), -1);
            expect(r.indexOf(BigInt.from(4), 1), 1);
            expect(r.indexOf(BigInt.from(4), 2), -1);
            expect(r.indexOf(BigInt.from(6), 2), 2);
            expect(r.indexOf(BigInt.from(6), 3), -1);
          });
          test('contains (positive step)', () {
            final r = BigIntRange(
                BigInt.from(2), BigInt.from(7), BigInt.from(2)); // [2, 4, 6]
            expect(r.contains(null), isFalse);
            expect(r.contains(BigInt.from(0)), isFalse);
            expect(r.contains(BigInt.from(1)), isFalse);
            expect(r.contains(BigInt.from(2)), isTrue);
            expect(r.contains(BigInt.from(3)), isFalse);
            expect(r.contains(BigInt.from(4)), isTrue);
            expect(r.contains(BigInt.from(5)), isFalse);
            expect(r.contains(BigInt.from(6)), isTrue);
            expect(r.contains(BigInt.from(7)), isFalse);
            expect(r.contains(BigInt.from(8)), isFalse);
          });
          test('indexOf (negative step)', () {
            final r = BigIntRange(
                BigInt.from(7), BigInt.from(2), BigInt.from(-2)); // [7, 5, 3]
            expect(r.indexOf(null), -1);
            expect(r.indexOf(BigInt.from(0)), -1);
            expect(r.indexOf(BigInt.from(1)), -1);
            expect(r.indexOf(BigInt.from(2)), -1);
            expect(r.indexOf(BigInt.from(3)), 2);
            expect(r.indexOf(BigInt.from(4)), -1);
            expect(r.indexOf(BigInt.from(5)), 1);
            expect(r.indexOf(BigInt.from(6)), -1);
            expect(r.indexOf(BigInt.from(7)), 0);
            expect(r.indexOf(BigInt.from(8)), -1);
            expect(r.indexOf(BigInt.from(9)), -1);
            expect(r.indexOf(BigInt.from(3), 2), 2);
            expect(r.indexOf(BigInt.from(3), 3), -1);
            expect(r.indexOf(BigInt.from(5), 1), 1);
            expect(r.indexOf(BigInt.from(5), 2), -1);
            expect(r.indexOf(BigInt.from(7), 0), 0);
            expect(r.indexOf(BigInt.from(7), 1), -1);
          });
          test('contains (negative step)', () {
            final r = BigIntRange(
                BigInt.from(7), BigInt.from(2), BigInt.from(-2)); // [7, 5, 3]
            expect(r.contains(null), isFalse);
            expect(r.contains(BigInt.from(0)), isFalse);
            expect(r.contains(BigInt.from(1)), isFalse);
            expect(r.contains(BigInt.from(2)), isFalse);
            expect(r.contains(BigInt.from(3)), isTrue);
            expect(r.contains(BigInt.from(4)), isFalse);
            expect(r.contains(BigInt.from(5)), isTrue);
            expect(r.contains(BigInt.from(6)), isFalse);
            expect(r.contains(BigInt.from(7)), isTrue);
            expect(r.contains(BigInt.from(8)), isFalse);
            expect(r.contains(BigInt.from(9)), isFalse);
          });
          test('lastIndexOf (positive step)', () {
            final r = BigIntRange(
                BigInt.from(2), BigInt.from(7), BigInt.from(2)); // [2, 4, 6]
            expect(r.lastIndexOf(null), -1);
            expect(r.lastIndexOf(BigInt.from(0)), -1);
            expect(r.lastIndexOf(BigInt.from(1)), -1);
            expect(r.lastIndexOf(BigInt.from(2)), 0);
            expect(r.lastIndexOf(BigInt.from(3)), -1);
            expect(r.lastIndexOf(BigInt.from(4)), 1);
            expect(r.lastIndexOf(BigInt.from(5)), -1);
            expect(r.lastIndexOf(BigInt.from(6)), 2);
            expect(r.lastIndexOf(BigInt.from(7)), -1);
            expect(r.lastIndexOf(BigInt.from(8)), -1);
            expect(r.lastIndexOf(BigInt.from(2), 0), 0);
            expect(r.lastIndexOf(BigInt.from(2), -1), -1);
            expect(r.lastIndexOf(BigInt.from(4), 1), 1);
            expect(r.lastIndexOf(BigInt.from(4), 0), -1);
            expect(r.lastIndexOf(BigInt.from(6), 2), 2);
            expect(r.lastIndexOf(BigInt.from(6), 1), -1);
          });
          test('lastIndexOf (negative step)', () {
            final r = BigIntRange(
                BigInt.from(7), BigInt.from(2), BigInt.from(-2)); // [7, 5, 3]
            expect(r.lastIndexOf(null), -1);
            expect(r.lastIndexOf(BigInt.from(1)), -1);
            expect(r.lastIndexOf(BigInt.from(2)), -1);
            expect(r.lastIndexOf(BigInt.from(3)), 2);
            expect(r.lastIndexOf(BigInt.from(4)), -1);
            expect(r.lastIndexOf(BigInt.from(5)), 1);
            expect(r.lastIndexOf(BigInt.from(6)), -1);
            expect(r.lastIndexOf(BigInt.from(7)), 0);
            expect(r.lastIndexOf(BigInt.from(8)), -1);
            expect(r.lastIndexOf(BigInt.from(8)), -1);
            expect(r.lastIndexOf(BigInt.from(3), 2), 2);
            expect(r.lastIndexOf(BigInt.from(3), 1), -1);
            expect(r.lastIndexOf(BigInt.from(5), 1), 1);
            expect(r.lastIndexOf(BigInt.from(5), 0), -1);
            expect(r.lastIndexOf(BigInt.from(7), 0), 0);
            expect(r.lastIndexOf(BigInt.from(7), -1), -1);
          });
        });
        test('printing', () {
  
negative.code:           expect(() => IntegerRange(3).getRange(0, 4), throwsRangeError);
          });
        });
        test('printing', () {
          expect(IntegerRange().toString(), 'IntegerRange()');
          expect(IntegerRange(1).toString(), 'IntegerRange(1)');
  