anchor.diff:        });
         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), []);
  +          verify(BigIntRange(BigInt.from(3)).sublist(0),
  +              included: [0, 1, 2], excluded: [-1, 3]);
  +          verify(BigIntRange(BigInt.from(3)).sublist(1),
  +              included: [1, 2], excluded: [-1, 0, 3]);
  +          verify(BigIntRange(BigInt.from(3)).sublist(2),
  +              included: [2], excluded: [-1, 0, 1, 3]);
  +          verify(BigIntRange(BigInt.from(3)).sublist(3),
  +              included: [], excluded: [-1, 0, 1, 2, 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), []);
  +          verify(BigIntRange(BigInt.from(3)).sublist(0, 3),
  +              included: [0, 1, 2], excluded: [-1, 3]);
  +          verify(BigIntRange(BigInt.from(3)).sublist(0, 2),
  +              included: [0, 1], excluded: [-1, 2, 3]);
  +          verify(BigIntRange(BigInt.from(3)).sublist(0, 1),
  +              included: [0], excluded: [-1, 1, 2, 3]);
  +          verify(BigIntRange(BigInt.from(3)).sublist(0, 0),
  +              included: [], excluded: [-1, 0, 1, 2, 3]);
             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(), []);
  +          verify(BigIntRange(BigInt.from(3)).getRange(0, 3),
  +              included: [0, 1, 2], excluded: [-1, 3]);
  +          verify(BigIntRange(BigInt.from(3)).getRange(0, 2),
  +              included: [0, 1], excluded: [-1, 2, 3]);
  +          verify(BigIntRange(BigInt.from(3)).getRange(0, 1),
  +              included: [0], excluded: [-1, 1, 2, 3]);
  +          verify(BigIntRange(BigInt.from(3)).getRange(0, 0),
  +              included: [], excluded: [-1, 0, 1, 2, 3]);
             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', () {
  
positive.code:           expect(() => IntegerRange(3).getRange(0, 4), throwsRangeError);
          });
        });
        group('index', () {
          test('indexOf (positive step)', () {
            final r = IntegerRange(2, 7, 2); // [2, 4, 6]
            expect(r.indexOf(null), -1);
            expect(r.indexOf(1), -1);
            expect(r.indexOf(2), 0);
            expect(r.indexOf(3), -1);
            expect(r.indexOf(4), 1);
            expect(r.indexOf(5), -1);
            expect(r.indexOf(6), 2);
            expect(r.indexOf(7), -1);
            expect(r.indexOf(8), -1);
            expect(r.indexOf(2, 0), 0);
            expect(r.indexOf(2, 1), -1);
            expect(r.indexOf(4, 1), 1);
            expect(r.indexOf(4, 2), -1);
            expect(r.indexOf(6, 2), 2);
            expect(r.indexOf(6, 3), -1);
          });
          test('contains (positive step)', () {
            final r = IntegerRange(2, 7, 2); // [2, 4, 6]
            expect(r.contains(null), isFalse);
            expect(r.contains(0), isFalse);
            expect(r.contains(1), isFalse);
            expect(r.contains(2), isTrue);
            expect(r.contains(3), isFalse);
            expect(r.contains(4), isTrue);
            expect(r.contains(5), isFalse);
            expect(r.contains(6), isTrue);
            expect(r.contains(7), isFalse);
            expect(r.contains(8), isFalse);
          });
          test('indexOf (negative step)', () {
            final r = IntegerRange(7, 2, -2); // [7, 5, 3]
            expect(r.indexOf(null), -1);
            expect(r.indexOf(0), -1);
            expect(r.indexOf(1), -1);
            expect(r.indexOf(2), -1);
            expect(r.indexOf(3), 2);
            expect(r.indexOf(4), -1);
            expect(r.indexOf(5), 1);
            expect(r.indexOf(6), -1);
            expect(r.indexOf(7), 0);
            expect(r.indexOf(8), -1);
            expect(r.indexOf(9), -1);
            expect(r.indexOf(3, 2), 2);
            expect(r.indexOf(3, 3), -1);
            expect(r.indexOf(5, 1), 1);
            expect(r.indexOf(5, 2), -1);
            expect(r.indexOf(7, 0), 0);
            expect(r.indexOf(7, 1), -1);
          });
          test('contains (negative step)', () {
            final r = IntegerRange(7, 2, -2); // [7, 5, 3]
            expect(r.contains(null), isFalse);
            expect(r.contains(0), isFalse);
            expect(r.contains(1), isFalse);
            expect(r.contains(2), isFalse);
            expect(r.contains(3), isTrue);
            expect(r.contains(4), isFalse);
            expect(r.contains(5), isTrue);
            expect(r.contains(6), isFalse);
            expect(r.contains(7), isTrue);
            expect(r.contains(8), isFalse);
            expect(r.contains(9), isFalse);
          });
          test('lastIndexOf (positive step)', () {
            final r = IntegerRange(2, 7, 2); // [2, 4, 6]
            expect(r.lastIndexOf(null), -1);
            expect(r.lastIndexOf(0), -1);
            expect(r.lastIndexOf(1), -1);
            expect(r.lastIndexOf(2), 0);
            expect(r.lastIndexOf(3), -1);
            expect(r.lastIndexOf(4), 1);
            expect(r.lastIndexOf(5), -1);
            expect(r.lastIndexOf(6), 2);
            expect(r.lastIndexOf(7), -1);
            expect(r.lastIndexOf(8), -1);
            expect(r.lastIndexOf(2, 0), 0);
            expect(r.lastIndexOf(2, -1), -1);
            expect(r.lastIndexOf(4, 1), 1);
            expect(r.lastIndexOf(4, 0), -1);
            expect(r.lastIndexOf(6, 2), 2);
            expect(r.lastIndexOf(6, 1), -1);
          });
          test('lastIndexOf (negative step)', () {
            final r = IntegerRange(7, 2, -2); // [7, 5, 3]
            expect(r.lastIndexOf(null), -1);
            expect(r.lastIndexOf(1), -1);
            expect(r.lastIndexOf(2), -1);
            expect(r.lastIndexOf(3), 2);
            expect(r.lastIndexOf(4), -1);
            expect(r.lastIndexOf(5), 1);
            expect(r.lastIndexOf(6), -1);
            expect(r.lastIndexOf(7), 0);
            expect(r.lastIndexOf(8), -1);
            expect(r.lastIndexOf(8), -1);
            expect(r.lastIndexOf(3, 2), 2);
            expect(r.lastIndexOf(3, 1), -1);
            expect(r.lastIndexOf(5, 1), 1);
            expect(r.lastIndexOf(5, 0), -1);
            expect(r.lastIndexOf(7, 0), 0);
            expect(r.lastIndexOf(7, -1), -1);
          });
        });
        test('printing', () {
          expect(IntegerRange().toString(), 'IntegerRange()');
          expect(IntegerRange(1).toString(), 'IntegerRange(1)');
  
negative.code:         {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 {
  