1b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin/* 2b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * Copyright (C) 2013 The Android Open Source Project 3b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * 4b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * Licensed under the Apache License, Version 2.0 (the "License"); 5b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * you may not use this file except in compliance with the License. 6b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * You may obtain a copy of the License at 7b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * 8b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * http://www.apache.org/licenses/LICENSE-2.0 9b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * 10b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * Unless required by applicable law or agreed to in writing, software 11b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * distributed under the License is distributed on an "AS IS" BASIS, 12b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * See the License for the specific language governing permissions and 14b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * limitations under the License. 15b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin */ 16b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 17b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkinpackage com.android.mediaframeworktest.unit; 18b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 19b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkinimport android.test.suitebuilder.annotation.SmallTest; 2072f9f0a96e4476ef231d5001cb30521ad4ce5b1eIgor Murashkinimport android.util.Rational; 21b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 22007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkinimport java.io.ByteArrayInputStream; 23007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkinimport java.io.ByteArrayOutputStream; 24007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkinimport java.io.IOException; 25007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkinimport java.io.InvalidObjectException; 26007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkinimport java.io.ObjectInputStream; 27007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkinimport java.io.ObjectOutputStream; 28007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkinimport java.io.Serializable; 29007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkinimport java.lang.reflect.Field; 30007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 31007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkinimport static android.util.Rational.*; 32007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 33b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin/** 34b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * <pre> 35b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * adb shell am instrument \ 36b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * -e class 'com.android.mediaframeworktest.unit.RationalTest' \ 37b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * -w com.android.mediaframeworktest/.MediaFrameworkUnitTestRunner 38b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin * </pre> 39b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin */ 40b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkinpublic class RationalTest extends junit.framework.TestCase { 41007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 42007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin /** (1,1) */ 43007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static final Rational UNIT = new Rational(1, 1); 44007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 45007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin /** 46007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin * Test @hide greatest common divisior functionality that cannot be tested in CTS. 47007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin */ 48007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin @SmallTest 49007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin public void testGcd() { 50007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(1, Rational.gcd(1, 2)); 51007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(1, Rational.gcd(2, 3)); 52007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(78, Rational.gcd(5*78, 7*78)); 53007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(1, Rational.gcd(-1, 2)); 54007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(1, Rational.gcd(-2, 3)); 55007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 56007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 57b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin @SmallTest 58b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin public void testConstructor() { 59b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 60b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin // Simple case 61b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin Rational r = new Rational(1, 2); 62b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(1, r.getNumerator()); 63b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(2, r.getDenominator()); 64b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 65b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin // Denominator negative 66b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin r = new Rational(-1, 2); 67b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(-1, r.getNumerator()); 68b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(2, r.getDenominator()); 69b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 70b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin // Numerator negative 71b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin r = new Rational(1, -2); 72b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(-1, r.getNumerator()); 73b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(2, r.getDenominator()); 74b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 75b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin // Both negative 76b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin r = new Rational(-1, -2); 77b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(1, r.getNumerator()); 78b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(2, r.getDenominator()); 79b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 8023c8809568b68430f875df759108c58016c44c16Timothy Knight // Infinity. 8123c8809568b68430f875df759108c58016c44c16Timothy Knight r = new Rational(1, 0); 82007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(1, r.getNumerator()); 8323c8809568b68430f875df759108c58016c44c16Timothy Knight assertEquals(0, r.getDenominator()); 8423c8809568b68430f875df759108c58016c44c16Timothy Knight 8523c8809568b68430f875df759108c58016c44c16Timothy Knight // Negative infinity. 8623c8809568b68430f875df759108c58016c44c16Timothy Knight r = new Rational(-1, 0); 87007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(-1, r.getNumerator()); 8823c8809568b68430f875df759108c58016c44c16Timothy Knight assertEquals(0, r.getDenominator()); 8923c8809568b68430f875df759108c58016c44c16Timothy Knight 9023c8809568b68430f875df759108c58016c44c16Timothy Knight // NaN. 9123c8809568b68430f875df759108c58016c44c16Timothy Knight r = new Rational(0, 0); 9223c8809568b68430f875df759108c58016c44c16Timothy Knight assertEquals(0, r.getNumerator()); 9323c8809568b68430f875df759108c58016c44c16Timothy Knight assertEquals(0, r.getDenominator()); 94b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin } 95b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 96b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin @SmallTest 97b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin public void testEquals() { 98b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin Rational r = new Rational(1, 2); 99b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(1, r.getNumerator()); 100b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(2, r.getDenominator()); 101b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 102b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(r, r); 103b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertFalse(r.equals(null)); 104b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertFalse(r.equals(new Object())); 105b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 106b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin Rational twoThirds = new Rational(2, 3); 107b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertFalse(r.equals(twoThirds)); 108b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertFalse(twoThirds.equals(r)); 109b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 110b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin Rational fourSixths = new Rational(4, 6); 111b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(twoThirds, fourSixths); 112b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(fourSixths, twoThirds); 113b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 114b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin Rational moreComplicated = new Rational(5*6*7*8*9, 1*2*3*4*5); 115b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin Rational moreComplicated2 = new Rational(5*6*7*8*9*78, 1*2*3*4*5*78); 116b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(moreComplicated, moreComplicated2); 117b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(moreComplicated2, moreComplicated); 118b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 119b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin // Ensure negatives are fine 120b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin twoThirds = new Rational(-2, 3); 121b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin fourSixths = new Rational(-4, 6); 122b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(twoThirds, fourSixths); 123b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(fourSixths, twoThirds); 124b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 125b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin moreComplicated = new Rational(-5*6*7*8*9, 1*2*3*4*5); 126b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin moreComplicated2 = new Rational(-5*6*7*8*9*78, 1*2*3*4*5*78); 127b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(moreComplicated, moreComplicated2); 128b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin assertEquals(moreComplicated2, moreComplicated); 129b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin 130007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // Zero is always equal to itself 131007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational zero2 = new Rational(0, 100); 132007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(ZERO, zero2); 133007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(zero2, ZERO); 134007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 135007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // NaN is always equal to itself 136007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational nan = NaN; 13723c8809568b68430f875df759108c58016c44c16Timothy Knight Rational nan2 = new Rational(0, 0); 13823c8809568b68430f875df759108c58016c44c16Timothy Knight assertTrue(nan.equals(nan)); 13923c8809568b68430f875df759108c58016c44c16Timothy Knight assertTrue(nan.equals(nan2)); 14023c8809568b68430f875df759108c58016c44c16Timothy Knight assertTrue(nan2.equals(nan)); 14123c8809568b68430f875df759108c58016c44c16Timothy Knight assertFalse(nan.equals(r)); 14223c8809568b68430f875df759108c58016c44c16Timothy Knight assertFalse(r.equals(nan)); 14323c8809568b68430f875df759108c58016c44c16Timothy Knight 14423c8809568b68430f875df759108c58016c44c16Timothy Knight // Infinities of the same sign are equal. 145007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational posInf = POSITIVE_INFINITY; 14623c8809568b68430f875df759108c58016c44c16Timothy Knight Rational posInf2 = new Rational(2, 0); 147007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational negInf = NEGATIVE_INFINITY; 14823c8809568b68430f875df759108c58016c44c16Timothy Knight Rational negInf2 = new Rational(-2, 0); 14923c8809568b68430f875df759108c58016c44c16Timothy Knight assertEquals(posInf, posInf); 15023c8809568b68430f875df759108c58016c44c16Timothy Knight assertEquals(negInf, negInf); 15123c8809568b68430f875df759108c58016c44c16Timothy Knight assertEquals(posInf, posInf2); 15223c8809568b68430f875df759108c58016c44c16Timothy Knight assertEquals(negInf, negInf2); 15323c8809568b68430f875df759108c58016c44c16Timothy Knight 15423c8809568b68430f875df759108c58016c44c16Timothy Knight // Infinities aren't equal to anything else. 15523c8809568b68430f875df759108c58016c44c16Timothy Knight assertFalse(posInf.equals(negInf)); 15623c8809568b68430f875df759108c58016c44c16Timothy Knight assertFalse(negInf.equals(posInf)); 15723c8809568b68430f875df759108c58016c44c16Timothy Knight assertFalse(negInf.equals(r)); 15823c8809568b68430f875df759108c58016c44c16Timothy Knight assertFalse(posInf.equals(r)); 15923c8809568b68430f875df759108c58016c44c16Timothy Knight assertFalse(r.equals(negInf)); 16023c8809568b68430f875df759108c58016c44c16Timothy Knight assertFalse(r.equals(posInf)); 16123c8809568b68430f875df759108c58016c44c16Timothy Knight assertFalse(posInf.equals(nan)); 16223c8809568b68430f875df759108c58016c44c16Timothy Knight assertFalse(negInf.equals(nan)); 16323c8809568b68430f875df759108c58016c44c16Timothy Knight assertFalse(nan.equals(posInf)); 16423c8809568b68430f875df759108c58016c44c16Timothy Knight assertFalse(nan.equals(negInf)); 165b519cc52ecba8f44da31173c9fc90a7b66d52b79Igor Murashkin } 166007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 167007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin @SmallTest 168007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin public void testReduction() { 169007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational moreComplicated = new Rational(5 * 78, 7 * 78); 170007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(new Rational(5, 7), moreComplicated); 171007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(5, moreComplicated.getNumerator()); 172007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(7, moreComplicated.getDenominator()); 173007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 174007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational posInf = new Rational(5, 0); 175007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(1, posInf.getNumerator()); 176007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(0, posInf.getDenominator()); 177007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(POSITIVE_INFINITY, posInf); 178007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 179007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational negInf = new Rational(-100, 0); 180007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(-1, negInf.getNumerator()); 181007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(0, negInf.getDenominator()); 182007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(NEGATIVE_INFINITY, negInf); 183007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 184007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational zero = new Rational(0, -100); 185007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(0, zero.getNumerator()); 186007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(1, zero.getDenominator()); 187007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(ZERO, zero); 188007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 189007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational flipSigns = new Rational(1, -1); 190007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(-1, flipSigns.getNumerator()); 191007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(1, flipSigns.getDenominator()); 192007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 193007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational flipAndReduce = new Rational(100, -200); 194007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(-1, flipAndReduce.getNumerator()); 195007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals(2, flipAndReduce.getDenominator()); 196007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 197007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 198007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin @SmallTest 199007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin public void testCompareTo() { 200007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // unit is equal to itself 201007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertCompareEquals(UNIT, new Rational(1, 1)); 202007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 203007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // NaN is greater than anything but NaN 204007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertCompareEquals(NaN, new Rational(0, 0)); 205007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertGreaterThan(NaN, UNIT); 206007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertGreaterThan(NaN, POSITIVE_INFINITY); 207007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertGreaterThan(NaN, NEGATIVE_INFINITY); 208007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertGreaterThan(NaN, ZERO); 209007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 210007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // Positive infinity is greater than any other non-NaN 211007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertCompareEquals(POSITIVE_INFINITY, new Rational(1, 0)); 212007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertGreaterThan(POSITIVE_INFINITY, UNIT); 213007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertGreaterThan(POSITIVE_INFINITY, NEGATIVE_INFINITY); 214007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertGreaterThan(POSITIVE_INFINITY, ZERO); 215007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 216007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // Negative infinity is smaller than any other non-NaN 217007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertCompareEquals(NEGATIVE_INFINITY, new Rational(-1, 0)); 218007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertLessThan(NEGATIVE_INFINITY, UNIT); 219007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertLessThan(NEGATIVE_INFINITY, POSITIVE_INFINITY); 220007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertLessThan(NEGATIVE_INFINITY, ZERO); 221007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 222007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // A finite number with the same denominator is trivially comparable 223007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertGreaterThan(new Rational(3, 100), new Rational(1, 100)); 224007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertGreaterThan(new Rational(3, 100), ZERO); 225007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 226007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // Compare finite numbers with different divisors 227007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertGreaterThan(new Rational(5, 25), new Rational(1, 10)); 228007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertGreaterThan(new Rational(5, 25), ZERO); 229007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 230007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // Compare finite numbers with different signs 231007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertGreaterThan(new Rational(5, 25), new Rational(-1, 10)); 232007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertLessThan(new Rational(-5, 25), ZERO); 233007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 234007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 235007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin @SmallTest 236007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin public void testConvenienceMethods() { 237007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // isFinite 238007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertFinite(ZERO, true); 239007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertFinite(NaN, false); 240007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertFinite(NEGATIVE_INFINITY, false); 241007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertFinite(POSITIVE_INFINITY, false); 242007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertFinite(UNIT, true); 243007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 244007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // isInfinite 245007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertInfinite(ZERO, false); 246007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertInfinite(NaN, false); 247007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertInfinite(NEGATIVE_INFINITY, true); 248007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertInfinite(POSITIVE_INFINITY, true); 249007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertInfinite(UNIT, false); 250007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 251007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // isNaN 252007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertNaN(ZERO, false); 253007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertNaN(NaN, true); 254007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertNaN(NEGATIVE_INFINITY, false); 255007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertNaN(POSITIVE_INFINITY, false); 256007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertNaN(UNIT, false); 257007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 258007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // isZero 259007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertZero(ZERO, true); 260007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertZero(NaN, false); 261007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertZero(NEGATIVE_INFINITY, false); 262007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertZero(POSITIVE_INFINITY, false); 263007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertZero(UNIT, false); 264007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 265007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 266007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin @SmallTest 267007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin public void testValueConversions() { 268007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // Unit, simple case 269007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(UNIT, 1.0f); 270007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(UNIT, 1.0); 271007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(UNIT, 1L); 272007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(UNIT, 1); 273007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(UNIT, (short)1); 274007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 275007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // Zero, simple case 276007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(ZERO, 0.0f); 277007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(ZERO, 0.0); 278007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(ZERO, 0L); 279007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(ZERO, 0); 280007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(ZERO, (short)0); 281007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 282007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // NaN is 0 for integers, not-a-number for floating point 283007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(NaN, Float.NaN); 284007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(NaN, Double.NaN); 285007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(NaN, 0L); 286007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(NaN, 0); 287007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(NaN, (short)0); 288007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 289007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // Positive infinity, saturates upwards for integers 290007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(POSITIVE_INFINITY, Float.POSITIVE_INFINITY); 291007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(POSITIVE_INFINITY, Double.POSITIVE_INFINITY); 292007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(POSITIVE_INFINITY, Long.MAX_VALUE); 293007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(POSITIVE_INFINITY, Integer.MAX_VALUE); 294007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(POSITIVE_INFINITY, (short)-1); 295007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 296007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // Negative infinity, saturates downwards for integers 297007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(NEGATIVE_INFINITY, Float.NEGATIVE_INFINITY); 298007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(NEGATIVE_INFINITY, Double.NEGATIVE_INFINITY); 299007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(NEGATIVE_INFINITY, Long.MIN_VALUE); 300007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(NEGATIVE_INFINITY, Integer.MIN_VALUE); 301007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(NEGATIVE_INFINITY, (short)0); 302007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 303007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // Normal finite values, round down for integers 304007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin final Rational oneQuarter = new Rational(1, 4); 305007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(oneQuarter, 1.0f / 4.0f); 306007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(oneQuarter, 1.0 / 4.0); 307007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(oneQuarter, 0L); 308007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(oneQuarter, 0); 309007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(oneQuarter, (short)0); 310007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 311007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin final Rational nineFifths = new Rational(9, 5); 312007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(nineFifths, 9.0f / 5.0f); 313007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(nineFifths, 9.0 / 5.0); 314007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(nineFifths, 1L); 315007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(nineFifths, 1); 316007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(nineFifths, (short)1); 317007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 318007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin final Rational negativeHundred = new Rational(-1000, 10); 319007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(negativeHundred, -100.f / 1.f); 320007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(negativeHundred, -100.0 / 1.0); 321007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(negativeHundred, -100L); 322007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(negativeHundred, -100); 323007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(negativeHundred, (short)-100); 324007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 325007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // Short truncates if the result is too large 326007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(new Rational(Integer.MAX_VALUE, 1), (short)Integer.MAX_VALUE); 327007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(new Rational(0x00FFFFFF, 1), (short)0x00FFFFFF); 328007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertValueEquals(new Rational(0x00FF00FF, 1), (short)0x00FF00FF); 329007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 330007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 331007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin @SmallTest 332007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin public void testSerialize() throws ClassNotFoundException, IOException { 333007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin /* 334007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin * Check correct [de]serialization 335007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin */ 336007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEqualsAfterSerializing(ZERO); 337007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEqualsAfterSerializing(NaN); 338007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEqualsAfterSerializing(NEGATIVE_INFINITY); 339007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEqualsAfterSerializing(POSITIVE_INFINITY); 340007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEqualsAfterSerializing(UNIT); 341007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEqualsAfterSerializing(new Rational(100, 200)); 342007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEqualsAfterSerializing(new Rational(-100, 200)); 343007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEqualsAfterSerializing(new Rational(5, 1)); 344007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEqualsAfterSerializing(new Rational(Integer.MAX_VALUE, Integer.MIN_VALUE)); 345007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 346007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin /* 347007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin * Check bad deserialization fails 348007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin */ 349007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin try { 350007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational badZero = createIllegalRational(0, 100); // [0, 100] , should be [0, 1] 351007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational results = serializeRoundTrip(badZero); 352007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin fail("Deserializing " + results + " should not have succeeded"); 353007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } catch (InvalidObjectException e) { 354007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // OK 355007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 356007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 357007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin try { 358007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational badPosInfinity = createIllegalRational(100, 0); // [100, 0] , should be [1, 0] 359007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational results = serializeRoundTrip(badPosInfinity); 360007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin fail("Deserializing " + results + " should not have succeeded"); 361007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } catch (InvalidObjectException e) { 362007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // OK 363007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 364007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 365007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin try { 366007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational badNegInfinity = 367007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin createIllegalRational(-100, 0); // [-100, 0] , should be [-1, 0] 368007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational results = serializeRoundTrip(badNegInfinity); 369007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin fail("Deserializing " + results + " should not have succeeded"); 370007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } catch (InvalidObjectException e) { 371007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // OK 372007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 373007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 374007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin try { 375007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational badReduced = createIllegalRational(2, 4); // [2,4] , should be [1, 2] 376007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational results = serializeRoundTrip(badReduced); 377007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin fail("Deserializing " + results + " should not have succeeded"); 378007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } catch (InvalidObjectException e) { 379007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // OK 380007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 381007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 382007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin try { 383007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational badReducedNeg = createIllegalRational(-2, 4); // [-2, 4] should be [-1, 2] 384007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational results = serializeRoundTrip(badReducedNeg); 385007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin fail("Deserializing " + results + " should not have succeeded"); 386007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } catch (InvalidObjectException e) { 387007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin // OK 388007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 389007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 390007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 391007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static void assertValueEquals(Rational object, float expected) { 392007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals("Checking floatValue() for " + object + ";", 393007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin expected, object.floatValue()); 394007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 395007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 396007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static void assertValueEquals(Rational object, double expected) { 397007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals("Checking doubleValue() for " + object + ";", 398007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin expected, object.doubleValue()); 399007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 400007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 401007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static void assertValueEquals(Rational object, long expected) { 402007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals("Checking longValue() for " + object + ";", 403007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin expected, object.longValue()); 404007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 405007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 406007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static void assertValueEquals(Rational object, int expected) { 407007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals("Checking intValue() for " + object + ";", 408007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin expected, object.intValue()); 409007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 410007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 411007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static void assertValueEquals(Rational object, short expected) { 412007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals("Checking shortValue() for " + object + ";", 413007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin expected, object.shortValue()); 414007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 415007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 416007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static void assertFinite(Rational object, boolean expected) { 417007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertAction("finite", object, expected, object.isFinite()); 418007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 419007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 420007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static void assertInfinite(Rational object, boolean expected) { 421007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertAction("infinite", object, expected, object.isInfinite()); 422007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 423007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 424007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static void assertNaN(Rational object, boolean expected) { 425007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertAction("NaN", object, expected, object.isNaN()); 426007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 427007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 428007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static void assertZero(Rational object, boolean expected) { 429007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertAction("zero", object, expected, object.isZero()); 430007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 431007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 432007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static <T> void assertAction(String action, T object, boolean expected, 433007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin boolean actual) { 434007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin String expectedMessage = expected ? action : ("not " + action); 435007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals("Expected " + object + " to be " + expectedMessage, 436007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin expected, actual); 437007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 438007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 439007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static <T extends Comparable<? super T>> void assertLessThan(T left, T right) { 440007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertTrue("Expected (LR) left " + left + " to be less than right " + right, 441007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin left.compareTo(right) < 0); 442007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertTrue("Expected (RL) left " + left + " to be less than right " + right, 443007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin right.compareTo(left) > 0); 444007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 445007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 446007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static <T extends Comparable<? super T>> void assertGreaterThan(T left, T right) { 447007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertTrue("Expected (LR) left " + left + " to be greater than right " + right, 448007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin left.compareTo(right) > 0); 449007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertTrue("Expected (RL) left " + left + " to be greater than right " + right, 450007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin right.compareTo(left) < 0); 451007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 452007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 453007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static <T extends Comparable<? super T>> void assertCompareEquals(T left, T right) { 454007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertTrue("Expected (LR) left " + left + " to be compareEquals to right " + right, 455007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin left.compareTo(right) == 0); 456007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertTrue("Expected (RL) left " + left + " to be compareEquals to right " + right, 457007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin right.compareTo(left) == 0); 458007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 459007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 460007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static <T extends Serializable> byte[] serialize(T obj) throws IOException { 461007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin ByteArrayOutputStream byteStream = new ByteArrayOutputStream(); 462007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin try (ObjectOutputStream objectStream = new ObjectOutputStream(byteStream)) { 463007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin objectStream.writeObject(obj); 464007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 465007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin return byteStream.toByteArray(); 466007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 467007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 468007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static <T extends Serializable> T deserialize(byte[] array, Class<T> klass) 469007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin throws IOException, ClassNotFoundException { 470007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin ByteArrayInputStream bais = new ByteArrayInputStream(array); 471007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin ObjectInputStream ois = new ObjectInputStream(bais); 472007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Object obj = ois.readObject(); 473007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin return klass.cast(obj); 474007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 475007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 476007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin @SuppressWarnings("unchecked") 477007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static <T extends Serializable> T serializeRoundTrip(T obj) 478007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin throws IOException, ClassNotFoundException { 479007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Class<T> klass = (Class<T>) obj.getClass(); 480007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin byte[] arr = serialize(obj); 481007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin T serialized = deserialize(arr, klass); 482007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin return serialized; 483007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 484007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 485007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static <T extends Serializable> void assertEqualsAfterSerializing(T obj) 486007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin throws ClassNotFoundException, IOException { 487007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin T serialized = serializeRoundTrip(obj); 488007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin assertEquals("Expected values to be equal after serialization round-trip", obj, serialized); 489007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 490007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 491007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static Rational createIllegalRational(int numerator, int denominator) { 492007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Rational r = new Rational(numerator, denominator); 493007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin mutateField(r, "mNumerator", numerator); 494007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin mutateField(r, "mDenominator", denominator); 495007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin return r; 496007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 497007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin 498007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin private static <T> void mutateField(T object, String name, int value) { 499007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin try { 500007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin Field f = object.getClass().getDeclaredField(name); 501007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin f.setAccessible(true); 502007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin f.set(object, value); 503007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } catch (NoSuchFieldException e) { 504007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin throw new AssertionError(e); 505007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } catch (IllegalAccessException e) { 506007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin throw new AssertionError(e); 507007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } catch (IllegalArgumentException e) { 508007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin throw new AssertionError(e); 509007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 510007bfb14d2d720cdd699cfbb36ce206246901cefIgor Murashkin } 51123c8809568b68430f875df759108c58016c44c16Timothy Knight} 512