home4/test/LfractionTest.java

336 lines
12 KiB
Java
Raw Normal View History

2016-09-22 12:39:36 +03:00
import static org.junit.Assert.*;
import org.junit.Test;
import java.util.*;
/** Testklass.
* @author Jaanus
*/
public class LfractionTest {
@Test (timeout=1000)
public void testPlus() {
Lfraction f1 = new Lfraction (2, 5);
Lfraction f2 = new Lfraction (4, 15);
Lfraction sum = f1.plus(f2);
assertEquals ("Wrong sum: <" + f1 + "> + <" + f2 + ">",
new Lfraction (2, 3), sum);
Lfraction sm2 = sum.plus (sum);
assertEquals ("Wrong sum.plus(sum): <2/3> + <2/3>",
new Lfraction (4, 3), sm2);
assertEquals ("Do not change the arguments of the sum",
new Lfraction (2, 3), sum);
f1 = new Lfraction (-1, 250);
f2 = new Lfraction (-1, 375);
sum = f1.plus(f2);
assertEquals ("Wrong sum: <" + f1 + "> + <" + f2 + ">",
new Lfraction (-1, 150), sum);
f1 = new Lfraction (1, 221);
f2 = new Lfraction (1, 323);
sum = f1.plus (f2);
assertEquals ("Wrong sum: <" + f1 + "> + <" + f2 + ">",
new Lfraction (32, 4199), sum);
f1 = new Lfraction (1, 39203);
f2 = new Lfraction (1, 41989);
sum = f1.plus (f2);
assertEquals ("Wrong sum: <" + f1 + "> + <" + f2 + ">",
new Lfraction (408, 8271833), sum);
f1 = new Lfraction (-2, 5);
f2 = new Lfraction (2, 5);
sum = f1.plus(f2);
assertEquals ("Wrong sum: <" + f1 + "> + <" + f2 + ">",
new Lfraction (0, 1), sum);
}
@Test (timeout=1000)
public void testTimes() {
Lfraction f1 = new Lfraction (2, 5);
Lfraction f2 = new Lfraction (4, 15);
Lfraction prd = f1.times (f2);
assertEquals ("Wrong product: <" + f1 + "> * <" + f2 + ">",
new Lfraction (8, 75), prd);
f1 = new Lfraction (-3, 5);
f2 = new Lfraction (-5, 7);
prd = f1.times (f2);
assertEquals ("Wrong product: <" + f1 + "> * <" + f2 + ">",
new Lfraction (3, 7), prd);
Lfraction pr2 = prd.times (prd);
assertEquals ("Wrong prd.times(prd): <3/7> * <3/7>",
new Lfraction (9, 49), pr2);
assertEquals ("Do not change the arguments of the product",
new Lfraction (3, 7), prd);
f1 = new Lfraction (0, 1);
f2 = new Lfraction (2, 3);
prd = f1.times (f2);
assertEquals ("Wrong product: <" + f1 + "> * <" + f2 + ">",
new Lfraction (0, 1), prd);
f1 = new Lfraction (3, 2);
f2 = new Lfraction (2, 3);
prd = f1.times (f2);
assertEquals ("Wrong product: <" + f1 + "> * <" + f2 + ">",
new Lfraction (1, 1), prd);
f1 = new Lfraction (3, 5);
f2 = new Lfraction (5, 7);
prd = f1.times (f2);
assertTrue ("Result must be reduced: 3/5 * 5/7 -> 3/7",
prd.getDenominator()==7);
}
@Test (expected=RuntimeException.class)
public void testCreateZeroDenominator() {
Lfraction f = new Lfraction (1, 0);
}
@Test (expected=RuntimeException.class)
public void testZeroInverse() {
Lfraction f = new Lfraction (0, 1);
f.inverse();
}
@Test (timeout=1000)
public void testClone() {
Lfraction f1 = new Lfraction (2, 5);
Lfraction f2 = null;
try {
f2 = (Lfraction)f1.clone();
} catch (CloneNotSupportedException e) {};
assertNotSame ("clone must differ from original", f2, f1);
assertEquals ("clone must be equal to original", f1, f2);
f1 = f2.plus(f1);
assertEquals ("clone must be independent from original",
new Lfraction (2, 5), f2);
}
@Test (timeout=1000)
public void testToString() {
String s = new Lfraction (1, 4).toString();
assertTrue (s + " must represent quarter",
(s.indexOf('1') < s.indexOf('4')) && (s.indexOf('1') >= 0));
s = new Lfraction (-1, 5).toString();
assertTrue (s + " does not contain minus", s.indexOf('-') >= 0);
}
@Test (expected=RuntimeException.class)
public void testDivideByZero() {
Lfraction f1 = new Lfraction (1, 5);
Lfraction f2 = new Lfraction (0, 1);
Lfraction q = f1.divideBy (f2);
}
@Test (timeout=1000)
public void testMinus() {
Lfraction f1 = new Lfraction (2, 5);
Lfraction f2 = new Lfraction (4, 15);
Lfraction dif = f1.minus (f2);
assertEquals ("Wrong difference: <" + f1 + "> - <" + f2 + ">",
new Lfraction (2, 15), dif);
Lfraction df2 = dif.minus (dif);
assertEquals ("Wrong difference: <2/15> - <2/15>",
new Lfraction (0, 1), df2);
assertEquals ("Do not change the arguments of the difference",
new Lfraction (2, 15), dif);
f1 = new Lfraction (-2, 5);
f2 = new Lfraction (-4, 15);
dif = f1.minus (f2);
assertEquals ("Wrong difference: <" + f1 + "> - <" + f2 + ">",
new Lfraction (-2, 15), dif);
}
@Test (timeout=1000)
public void testDivideBy() {
Lfraction f1 = new Lfraction (-2, 7);
Lfraction f2 = new Lfraction (-1, 14);
Lfraction f = f1.divideBy (f2);
assertEquals ("Wrong quotient: <" + f1 + "> / <" + f2 + ">",
new Lfraction (4, 1), f);
f = f2.divideBy (f1);
assertEquals ("Wrong quotient: <" + f1 + "> / <" + f2 + ">",
new Lfraction (1, 4), f);
Lfraction f3 = f.divideBy (f);
assertEquals (f.toString() + " divided by itself",
new Lfraction (1, 1), f3);
assertEquals ("Do not change the arguments of the quotient",
new Lfraction (1, 4), f);
}
@Test (timeout=1000)
public void testOpposite() {
Lfraction f1 = new Lfraction (1, 6);
Lfraction f2 = f1.opposite();
assertEquals ("Wrong opposite", new Lfraction (-1, 6), f2);
assertEquals ("Do not change the argument of opposite",
new Lfraction (1, 6), f1);
f1 = new Lfraction (-4, 75);
f2 = f1.opposite();
assertEquals ("Wrong opposite", new Lfraction (4, 75), f2);
f1 = new Lfraction (0, 1);
f2 = f1.opposite();
assertEquals ("zero must be neutral to opposite", f1, f2);
}
@Test (timeout=1000)
public void testInverse() {
Lfraction f1 = new Lfraction (2, 3);
Lfraction f2 = f1.inverse();
assertEquals ("Wrong inverse ", new Lfraction (3, 2), f2);
assertEquals ("Do not change the argument of inverse",
new Lfraction (2, 3), f1);
f1 = new Lfraction (-4, 75);
f2 = f1.inverse();
assertEquals ("Wrong inverse", new Lfraction (-75, 4), f2);
assertTrue ("Denominator must always be positive",
f2.getDenominator() > 0);
f1 = new Lfraction (1, 1);
f2 = f1.inverse();
assertEquals ("1 must be neutral to inverse", f1, f2);
}
@Test (timeout=1000)
public void testGetters() {
Lfraction f1 = new Lfraction (2, 3);
long num = f1.getNumerator();
assertEquals ("wrong numerator ", 2, num);
f1 = new Lfraction (-4, 75);
num = f1.getNumerator();
assertEquals ("Wrong numerator", -4, num);
f1 = new Lfraction (0, 7);
num = f1.getNumerator();
assertEquals ("Wrong numerator", 0, num);
f1 = new Lfraction (2, 3);
long den = f1.getDenominator();
assertEquals ("wrong denominator ", 3, den);
f1 = new Lfraction (-4, 75);
den = f1.getDenominator();
assertEquals ("Wrong denominator", 75, den);
}
@Test (timeout=1000)
public void testIntegerPart() {
Lfraction f1 = new Lfraction (2, 3);
long i = f1.integerPart();
assertEquals ("wrong integer part ", 0, i);
f1 = new Lfraction (3, 2);
i = f1.integerPart();
assertEquals ("wrong integer part ", 1, i);
f1 = new Lfraction (32, 3);
i = f1.integerPart();
assertEquals ("wrong integer part ", 10, i);
f1 = new Lfraction (33, 3);
i = f1.integerPart();
assertEquals ("wrong integer part ", 11, i);
f1 = new Lfraction (-33, 3);
i = f1.integerPart();
assertEquals ("wrong integer part ", -11, i);
}
@Test (timeout=1000)
public void testLfractionPart() {
Lfraction f1 = new Lfraction (2, 3);
Lfraction i = f1.fractionPart();
assertEquals ("wrong fraction part ", new Lfraction (2, 3), i);
f1 = new Lfraction (3, 2);
i = f1.fractionPart();
assertEquals ("wrong fraction part ", new Lfraction (1, 2), i);
f1 = new Lfraction (32, 3);
i = f1.fractionPart();
assertEquals ("wrong fraction part ", new Lfraction (2, 3), i);
f1 = new Lfraction (33, 3);
i = f1.fractionPart();
assertEquals ("wrong fraction part ", new Lfraction (0, 1), i);
f1 = new Lfraction (-33, 3);
i = f1.fractionPart();
assertEquals ("wrong fraction part ", new Lfraction (0, 1), i);
f1 = new Lfraction (-5, 4);
i = f1.fractionPart();
assertTrue ("wrong fraction part " + i.toString()
+ " for " + f1.toString(),
i.equals (new Lfraction (-1, 4)) || i.equals (new Lfraction (3, 4)));
}
@Test (timeout=1000)
public void testEquals() {
Lfraction f1 = new Lfraction (2, 5);
Lfraction f2 = new Lfraction (4, 10);
assertTrue ("2/5 must be equal to 4/10", f1.equals (f2));
assertFalse ("2/5 is not 3/5", f1.equals (new Lfraction (3, 5)));
f1 = new Lfraction (12345678901234567L, 1L);
f2 = new Lfraction (12345678901234568L, 1L);
assertFalse ("12345678901234567/1 is not 12345678901234568/1",
f1.equals (f2));
}
@Test (timeout=1000)
public void testCompareTo() {
Lfraction f1 = new Lfraction (2, 5);
Lfraction f2 = new Lfraction (4, 7);
assertTrue ("2/5 must be less than 4/7", f1.compareTo (f2) < 0);
assertTrue ("2/5 must be equal to 4/10",
f1.compareTo (new Lfraction (4, 10)) == 0);
assertTrue ("4/7 must be greater than 2/5", f2.compareTo (f1) > 0);
f1 = new Lfraction (-2, 5);
f2 = new Lfraction (-4, 7);
assertTrue ("-2/5 must be greater than -4/7", f1.compareTo (f2) > 0);
assertTrue ("-2/5 must be equal to -4/10",
f1.compareTo (new Lfraction (-4, 10)) == 0);
assertTrue ("-4/7 must be less than -2/5", f2.compareTo (f1) < 0);
f1 = new Lfraction (12345678901234567L, 1L);
f2 = new Lfraction (12345678901234568L, 1L);
assertFalse ("12345678901234567/1 is not 12345678901234568/1",
f1.compareTo (f2) == 0);
}
@Test (timeout=1000)
public void testToLfraction() {
Lfraction f1 = Lfraction.toLfraction (Math.PI, 7);
Lfraction f2 = new Lfraction (22, 7);
assertTrue ("Math.PI must be nearly 22/7", f1.equals (f2));
f1 = Lfraction.toLfraction (-10., 2);
f2 = new Lfraction (-20, 2);
assertTrue ("-10. must be -20/2", f1.equals (f2));
}
@Test (timeout=1000)
public void testToDouble() {
Lfraction f = new Lfraction (2, 5);
assertEquals ("2/5 must be nearly 0.4", 0.4, f.toDouble(), 0.00001);
f = new Lfraction (-17, 100);
assertEquals ("-17/100 must be nearly -0.17", -0.17,
f.toDouble(), 0.00001);
}
@Test (timeout=1000)
public void testValueOf() {
Lfraction f = new Lfraction (2, 5);
assertEquals ("valueOf must read back what toString outputs. ",
f, Lfraction.valueOf (f.toString()));
f = new Lfraction (-17, 100);
assertEquals ("valueOf must read back what toString outputs. ",
f, Lfraction.valueOf (f.toString()));
}
@Test (timeout=1000)
public void testHashCode() {
Lfraction q1 = new Lfraction (1L, 2L);
int h1 = q1.hashCode();
Lfraction q2 = new Lfraction (1L, 2L);
int h2 = q2.hashCode();
Lfraction q3 = null;
try {
q3 = (Lfraction)q1.clone();
} catch (CloneNotSupportedException e) {};
int h3 = q3.hashCode();
assertTrue ("hashCode has to be same for equal objects", h1 == h2);
assertTrue ("hashCode has to be same for clone objects", h1 == h3);
assertTrue ("hashCode has to be same for the same object",
h1 == q1.hashCode());
q2 = new Lfraction (0L, 2L);
h2 = q2.hashCode();
q3 = new Lfraction (1L, 3L);
h3 = q3.hashCode();
assertFalse ("hashCode does not depend on numerator", h1 == h2);
assertFalse ("hashCode does not depend on denominator", h1 == h3);
}
}