anchor.diff:          });
           test('negativeInfinity', () {
             final fraction = Fraction.fromDouble(double.negativeInfinity);
  -          expect(fraction, Fraction.negativeInfinity);
  +          expect(fraction, isFraction(Fraction.negativeInfinity));
             expect(fraction.isNaN, isFalse);
             expect(fraction.isInfinite, isTrue);
             expect(fraction.isNegative, isTrue);
             expect(fraction.isFinite, isFalse);
           });
         });
  -      test('zero', () {
  -        expect(Fraction.zero, Fraction(0));
  -        expect(Fraction(1, 2) + Fraction.zero, Fraction(1, 2));
  -      });
  -      test('one', () {
  -        expect(Fraction.one, Fraction(1));
  -        expect(Fraction(1, 2) * Fraction.one, Fraction(1, 2));
  -      });
         group('tryParse', () {
           test('basic', () {
  -          expect(Fraction.tryParse('1/2'), Fraction(1, 2));
  -          expect(Fraction.tryParse(' 1/2'), Fraction(1, 2));
  -          expect(Fraction.tryParse('1 /2'), Fraction(1, 2));
  -          expect(Fraction.tryParse('1/ 2'), Fraction(1, 2));
  -          expect(Fraction.tryParse('1/2 '), Fraction(1, 2));
  +          expect(Fraction.tryParse('1/2'), isFraction(Fraction(1, 2)));
  +          expect(Fraction.tryParse(' 1/2'), isFraction(Fraction(1, 2)));
  +          expect(Fraction.tryParse('1 /2'), isFraction(Fraction(1, 2)));
  +          expect(Fraction.tryParse('1/ 2'), isFraction(Fraction(1, 2)));
  +          expect(Fraction.tryParse('1/2 '), isFraction(Fraction(1, 2)));
           });
           test('negative', () {
  -          expect(Fraction.tryParse('-1/2'), Fraction(-1, 2));
  -          expect(Fraction.tryParse('1/-2'), Fraction(-1, 2));
  -          expect(Fraction.tryParse('-1/-2'), Fraction(1, 2));
  +          expect(Fraction.tryParse('-1/2'), isFraction(Fraction(-1, 2)));
  +          expect(Fraction.tryParse('1/-2'), isFraction(Fraction(-1, 2)));
  +          expect(Fraction.tryParse('-1/-2'), isFraction(Fraction(1, 2)));
           });
           test('integer', () {
  -          expect(Fraction.tryParse('3'), Fraction(3));
  -          expect(Fraction.tryParse(' 3'), Fraction(3));
  -          expect(Fraction.tryParse('3 '), Fraction(3));
  +          expect(Fraction.tryParse('3'), isFraction(Fraction(3)));
  +          expect(Fraction.tryParse(' 3'), isFraction(Fraction(3)));
  +          expect(Fraction.tryParse('3 '), isFraction(Fraction(3)));
           });
           test('error', () {
             expect(Fraction.tryParse(''), isNull);
  
positive.code:     });
    });
    group('fraction', () {
      group('construction', () {
        test('irreducible', () {
          final fraction = Fraction(3, 7);
  
negative.code:       });
      });
      group('testing', () {
        test('isFinite', () {
          expect(Fraction.zero.isFinite, isTrue);
          expect(Fraction.nan.isFinite, isFalse);
          expect(Fraction.infinity.isFinite, isFalse);
          expect(Fraction.negativeInfinity.isFinite, isFalse);
        });
        test('isNan', () {
          expect(Fraction.zero.isNaN, isFalse);
          expect(Fraction.nan.isNaN, isTrue);
          expect(Fraction.infinity.isNaN, isFalse);
          expect(Fraction.negativeInfinity.isNaN, isFalse);
        });
        test('isInfinite', () {
          expect(Fraction.zero.isInfinite, isFalse);
          expect(Fraction.nan.isInfinite, isFalse);
          expect(Fraction.infinity.isInfinite, isTrue);
          expect(Fraction.negativeInfinity.isInfinite, isTrue);
        });
        test('isNegative', () {
          expect(Fraction(1).isNegative, isFalse);
          expect(Fraction(-1).isNegative, isTrue);
          expect(Fraction(1, -1).isNegative, isTrue);
          expect(Fraction(-1, -1).isNegative, isFalse);
          expect(Fraction.zero.isNegative, isFalse);
          expect(Fraction.nan.isNegative, isFalse);
          expect(Fraction.infinity.isNegative, isFalse);
          expect(Fraction.negativeInfinity.isNegative, isTrue);
        });
      });
      group('arithmetic', () {
        test('addition', () {
          expect(Fraction(1, 2) + Fraction(1, 4), isFraction(Fraction(3, 4)));
          expect(Fraction(1, 2) + Fraction(3, 4), isFraction(Fraction(5, 4)));
          expect(Fraction(1, 2) + Fraction(1, 2), isFraction(Fraction(1)));
          expect(Fraction(1, 2) + 3, isFraction(Fraction(7, 2)));
          expect(() => Fraction(1, 2) + 'foo', throwsArgumentError);
          expect(Fraction(1, 2) + Fraction.nan, isFraction(Fraction.nan));
          expect(
              Fraction(1, 2) + Fraction.infinity, isFraction(Fraction.infinity));
          expect(Fraction(1, 2) + Fraction.negativeInfinity,
              isFraction(Fraction.negativeInfinity));
          expect(Fraction.nan + Fraction(1, 2), isFraction(Fraction.nan));
          expect(
              Fraction.infinity + Fraction(1, 2), isFraction(Fraction.infinity));
          expect(Fraction.negativeInfinity + Fraction(1, 2),
              isFraction(Fraction.negativeInfinity));
          expect(Fraction.nan + Fraction.nan, isFraction(Fraction.nan));
          expect(Fraction.infinity + Fraction.infinity, isFraction(Fraction.nan));
          expect(Fraction.negativeInfinity + Fraction.negativeInfinity,
              isFraction(Fraction.nan));
        });
        test('subtraction', () {
          expect(Fraction(1, 2) - Fraction(1, 4), isFraction(Fraction(1, 4)));
          expect(Fraction(1, 2) - Fraction(3, 4), isFraction(Fraction(-1, 4)));
          expect(Fraction(1, 2) - Fraction(1, 2), isFraction(Fraction(0)));
          expect(Fraction(1, 2) - 3, isFraction(Fraction(-5, 2)));
          expect(() => Fraction(1, 2) - 'foo', throwsArgumentError);
          expect(Fraction(1, 2) - Fraction.nan, isFraction(Fraction.nan));
          expect(Fraction(1, 2) - Fraction.infinity,
              isFraction(Fraction.negativeInfinity));
          expect(Fraction(1, 2) - Fraction.negativeInfinity,
              isFraction(Fraction.infinity));
          expect(Fraction.nan - Fraction(1, 2), isFraction(Fraction.nan));
          expect(
              Fraction.infinity - Fraction(1, 2), isFraction(Fraction.infinity));
          expect(Fraction.negativeInfinity - Fraction(1, 2),
              isFraction(Fraction.negativeInfinity));
          expect(Fraction.nan - Fraction.nan, isFraction(Fraction.nan));
          expect(Fraction.infinity - Fraction.infinity, isFraction(Fraction.nan));
          expect(Fraction.negativeInfinity - Fraction.negativeInfinity,
              isFraction(Fraction.nan));
        });
        test('multiplication', () {
          expect(Fraction(2, 3) * Fraction(1, 4), isFraction(Fraction(1, 6)));
          expect(Fraction(3, 4) * Fraction(2, 5), isFraction(Fraction(3, 10)));
          expect(Fraction(3, 4) * 2, isFraction(Fraction(3, 2)));
          expect(() => Fraction(3, 4) * 'foo', throwsArgumentError);
          expect(Fraction(1, 2) * Fraction.nan, isFraction(Fraction.nan));
          expect(
              Fraction(1, 2) * Fraction.infinity, isFraction(Fraction.infinity));
          expect(Fraction(1, 2) * Fraction.negativeInfinity,
              Fraction.negativeInfinity);
          expect(Fraction.nan * Fraction(1, 2), isFraction(Fraction.nan));
          expect(
              Fraction.infinity * Fraction(1, 2), isFraction(Fraction.infinity));
          expect(Fraction.negativeInfinity * Fraction(1, 2),
              isFraction(Fraction.negativeInfinity));
          expect(Fraction.nan * Fraction.nan, isFraction(Fraction.nan));
          expect(Fraction.infinity * Fraction.infinity,
              isFraction(Fraction.infinity));
          expect(Fraction.negativeInfinity * Fraction.negativeInfinity,
              isFraction(Fraction.infinity));
        });
        test('reciprocal', () {
          expect(Fraction(3, 4).reciprocal(), isFraction(Fraction(4, 3)));
          expect(Fraction(-3, 4).reciprocal(), isFraction(Fraction(-4, 3)));
          expect(Fraction.nan.reciprocal(), isFraction(Fraction.nan));
          expect(Fraction.infinity.reciprocal(), isFraction(Fraction.zero));
          expect(
              Fraction.negativeInfinity.reciprocal(), isFraction(Fraction.zero));
        });
        test('division', () {
          expect(Fraction(2, 3) / Fraction(1, 4), isFraction(Fraction(8, 3)));
          expect(Fraction(3, 4) / Fraction(2, 5), isFraction(Fraction(15, 8)));
          expect(Fraction(3, 4) / 2, isFraction(Fraction(3, 8)));
          expect(() => Fraction(3, 4) / 'foo', throwsArgumentError);
          expect(Fraction(1, 2) / Fraction.nan, isFraction(Fraction.nan));
          expect(Fraction(1, 2) / Fraction.infinity, isFraction(Fraction.zero));
          expect(Fraction(1, 2) / Fraction.negativeInfinity,
              isFraction(Fraction.zero));
          expect(Fraction.nan / Fraction(1, 2), isFraction(Fraction.nan));
          expect(
              Fraction.infinity / Fraction(1, 2), isFraction(Fraction.infinity));
          expect(Fraction.negativeInfinity / Fraction(1, 2),
              isFraction(Fraction.negativeInfinity));
          expect(Fraction.nan / Fraction.nan, isFraction(Fraction.nan));
          expect(Fraction.infinity / Fraction.infinity, isFraction(Fraction.nan));
          expect(Fraction.negativeInfinity / Fraction.negativeInfinity,
              isFraction(Fraction.nan));
        });
        test('negate', () {
          expect(-Fraction(2, 3), isFraction(Fraction(-2, 3)));
          expect(-Fraction(-2, 3), isFraction(Fraction(2, 3)));
          expect(-Fraction.nan, isFraction(Fraction.nan));
          expect(-Fraction.infinity, isFraction(Fraction.negativeInfinity));
          expect(-Fraction.negativeInfinity, isFraction(Fraction.infinity));
        });
        test('pow', () {
          expect(Fraction.zero.pow(2), isFraction(Fraction.zero));
          expect(Fraction(2, 3).pow(0), isFraction(Fraction.one));
          expect(Fraction(2, 3).pow(2), isFraction(Fraction(4, 9)));
          expect(Fraction(2, 3).pow(-2), isFraction(Fraction(9, 4)));
        });
        test('abs', () {
          expect(Fraction(-2, -3).abs(), isFraction(Fraction(2, 3)));
          expect(Fraction(-2, 3).abs(), isFraction(Fraction(2, 3)));
          expect(Fraction(2, -3).abs(), isFraction(Fraction(2, 3)));
          expect(Fraction(2, 3).abs(), isFraction(Fraction(2, 3)));
          expect(Fraction.zero.abs(), isFraction(Fraction.zero));
          expect(Fraction.nan.abs(), isFraction(Fraction.nan));
          expect(Fraction.infinity.abs(), isFraction(Fraction.infinity));
          expect(Fraction.negativeInfinity.abs(), isFraction(Fraction.infinity));
        });
        test('sign', () {
          expect(Fraction(-2, -3).sign, 1);
  