anchor.diff:          expect(fraction.numerator, -1);
           expect(fraction.denominator, 2);
         });
  +      test('zero', () {
  +        expect(Fraction.zero, isFraction(Fraction(0)));
  +        expect(Fraction(1, 2) + Fraction.zero, isFraction(Fraction(1, 2)));
  +      });
  +      test('one', () {
  +        expect(Fraction.one, isFraction(Fraction(1)));
  +        expect(Fraction(1, 2) * Fraction.one, isFraction(Fraction(1, 2)));
  +      });
         test('nan', () {
           final fraction = Fraction(0, 0);
  -        expect(fraction, same(Fraction.nan));
  +        expect(fraction, isFraction(Fraction.nan));
           expect(fraction.isNaN, isTrue);
           expect(fraction.isInfinite, isFalse);
           expect(fraction.isNegative, isFalse);
           expect(fraction.isFinite, isFalse);
         });
         test('infinity', () {
  -        expect(Fraction(1, 0), Fraction.infinity);
  -        expect(Fraction(2, 0), Fraction.infinity);
  -        expect(Fraction(42, 0), Fraction.infinity);
  +        expect(Fraction(1, 0), isFraction(Fraction.infinity));
  +        expect(Fraction(2, 0), isFraction(Fraction.infinity));
  +        expect(Fraction(42, 0), isFraction(Fraction.infinity));
         });
         test('negativeInfinity', () {
  -        expect(Fraction(-1, 0), Fraction.negativeInfinity);
  -        expect(Fraction(-2, 0), Fraction.negativeInfinity);
  -        expect(Fraction(-42, 0), Fraction.negativeInfinity);
  +        expect(Fraction(-1, 0), isFraction(Fraction.negativeInfinity));
  +        expect(Fraction(-2, 0), isFraction(Fraction.negativeInfinity));
  +        expect(Fraction(-42, 0), isFraction(Fraction.negativeInfinity));
         });
         group('fromDouble', () {
           test('basic', () {
  -          expect(Fraction.fromDouble(0), Fraction.zero);
  -          expect(Fraction.fromDouble(2), Fraction(2));
  -          expect(Fraction.fromDouble(100), Fraction(100));
  +          expect(Fraction.fromDouble(0), isFraction(Fraction.zero));
  +          expect(Fraction.fromDouble(2), isFraction(Fraction(2)));
  +          expect(Fraction.fromDouble(100), isFraction(Fraction(100)));
           });
           test('finite', () {
  -          expect(Fraction.fromDouble(1 / 2), Fraction(1, 2));
  -          expect(Fraction.fromDouble(1 / 4), Fraction(1, 4));
  +          expect(Fraction.fromDouble(1 / 2), isFraction(Fraction(1, 2)));
  +          expect(Fraction.fromDouble(1 / 4), isFraction(Fraction(1, 4)));
           });
           test('finite, whole', () {
  -          expect(Fraction.fromDouble(5 / 2), Fraction(5, 2));
  -          expect(Fraction.fromDouble(9 / 4), Fraction(9, 4));
  +          expect(Fraction.fromDouble(5 / 2), isFraction(Fraction(5, 2)));
  +          expect(Fraction.fromDouble(9 / 4), isFraction(Fraction(9, 4)));
           });
           test('infinite', () {
  -          expect(Fraction.fromDouble(1 / 3), Fraction(1, 3));
  -          expect(Fraction.fromDouble(1 / 7), Fraction(1, 7));
  +          expect(Fraction.fromDouble(1 / 3), isFraction(Fraction(1, 3)));
  +          expect(Fraction.fromDouble(1 / 7), isFraction(Fraction(1, 7)));
           });
           test('infinite, whole', () {
  -          expect(Fraction.fromDouble(5 / 3), Fraction(5, 3));
  -          expect(Fraction.fromDouble(9 / 7), Fraction(9, 7));
  +          expect(Fraction.fromDouble(5 / 3), isFraction(Fraction(5, 3)));
  +          expect(Fraction.fromDouble(9 / 7), isFraction(Fraction(9, 7)));
           });
           test('negative', () {
  -          expect(Fraction.fromDouble(-1 / 3), Fraction(-1, 3));
  -          expect(Fraction.fromDouble(-5 / 3), Fraction(-5, 3));
  +          expect(Fraction.fromDouble(-1 / 3), isFraction(Fraction(-1, 3)));
  +          expect(Fraction.fromDouble(-5 / 3), isFraction(Fraction(-5, 3)));
           });
           test('all', () {
             for (var num = -10; num <= 10; num++) {
               for (var den = -10; den <= 10; den++) {
                 if (den != 0) {
  -                expect(Fraction.fromDouble(num / den), Fraction(num, den));
  +                expect(Fraction.fromDouble(num / den),
  +                    isFraction(Fraction(num, den)));
                 }
               }
             }
           });
           test('nan', () {
             final fraction = Fraction.fromDouble(double.nan);
  -          expect(fraction, same(Fraction.nan));
  +          expect(fraction, isFraction(Fraction.nan));
             expect(fraction.isNaN, isTrue);
             expect(fraction.isInfinite, isFalse);
             expect(fraction.isNegative, isFalse);
  
positive.code:         });
          test('negativeInfinity', () {
            final fraction = Fraction.fromDouble(double.negativeInfinity);
            expect(fraction, 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));
          });
          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));
          });
          test('integer', () {
            expect(Fraction.tryParse('3'), Fraction(3));
            expect(Fraction.tryParse(' 3'), Fraction(3));
            expect(Fraction.tryParse('3 '), Fraction(3));
          });
          test('error', () {
            expect(Fraction.tryParse(''), isNull);
  
negative.code:         expect(Fraction(1, 2).closeTo(Fraction(1, 3), 0.1), isFalse);
          expect(Fraction(1, 2).closeTo(Fraction(2, 4), 0.1), isTrue);
          expect(Fraction(1, 2).closeTo(Fraction(3, 5), 0.2), isTrue);
          expect(Fraction.nan.closeTo(Fraction(1, 2), 0.1), isFalse);
          expect(Fraction(1, 2).closeTo(Fraction.nan, 0.1), isFalse);
          expect(Fraction.nan.closeTo(Fraction.nan, 0.1), isFalse);
          expect(Fraction.infinity.closeTo(Fraction(1, 2), 0.1), isFalse);
          expect(Fraction(1, 2).closeTo(Fraction.infinity, 0.1), isFalse);
          expect(Fraction.infinity.closeTo(Fraction.infinity, 0.1), isFalse);
          expect(Fraction.negativeInfinity.closeTo(Fraction(1, 2), 0.1), isFalse);
          expect(Fraction(1, 2).closeTo(Fraction.negativeInfinity, 0.1), isFalse);
          expect(
              Fraction.negativeInfinity.closeTo(Fraction.negativeInfinity, 0.1),
              isFalse);
        });
        test('equals', () {
          expect(Fraction(2, 3) == Fraction(2, 3), isTrue);
          expect(Fraction(2, 3) == Fraction(4, 5), isFalse);
          expect(Fraction(4, 5) == Fraction(2, 3), isFalse);
          expect(Fraction.nan == Fraction(2, 3), isFalse);
          expect(Fraction(2, 3) == Fraction.nan, isFalse);
          expect(Fraction.nan == Fraction.nan, isFalse);
          expect(Fraction.infinity == Fraction.infinity, isTrue);
          expect(Fraction.negativeInfinity == Fraction.negativeInfinity, isTrue);
        });
        test('hash', () {
          expect(Fraction(2, 3).hashCode, Fraction(2, 3).hashCode);
  