import static org.junit.Assert.*;
import org.junit.Test;
// import java.util.*;

/** Test.
 * @author Jaanus
 */
public class ComplexTest {

    /** double numbers less than DELTA are considered zero */
    public static final double DELTA = 0.000001;

    @Test (timeout=1000)
    public void testConstructor() {
        Complex k1 = new Complex (-5., -81.);
        assertNotNull ("constructor of -5-81i returns null", k1);
        assertFalse ("constructor of -5-81i returns zero", k1.isZero());
        Complex k2 = new Complex (0., 350.);
        assertNotNull ("constructor returns null", k2);
        assertNotSame ("different numbers must be different objects", k2, k1);
        Complex k3 = new Complex (0., 0.);
        assertNotNull ("zero is not null", k3);
    }

    @Test (timeout=1000)
    public void testGetReIm() {
        Complex k1 = new Complex (3., 7.);
        double re = k1.getRe();
        assertEquals ("3+7i has wrong real part", 3., re, DELTA);
        k1 = new Complex (0., 0.);
        re = k1.getRe();
        assertEquals ("zero has wrong real part", 0., re, DELTA);
        k1 = new Complex (-456., 200.);
        re = k1.getRe();
        assertEquals ("-456+200i has wrong real part", -456., re, DELTA);
        k1 = new Complex (3., 7.);
        double im = k1.getIm();
        assertEquals ("3+7i has wrong imaginary part", 7., im, DELTA);
        k1 = new Complex (0., 0.);
        im = k1.getIm();
        assertEquals ("zero has wrong imaginary part", 0., im, DELTA);
        k1 = new Complex (-456., 200.);
        im = k1.getIm();
        assertEquals ("-456+200i has wrong imaginary part", 200., im, DELTA);
    }

    @Test (timeout=1000)
    public void testToString() {
        String s = new Complex (1., 4.).toString();
        assertTrue ("String <" + s + "> does not represent 1+4i",
                (s.indexOf('1') < s.indexOf('4')) && (s.indexOf('1') >= 0)
                        && (s.indexOf('1') < s.indexOf('i')));
        s = new Complex (-1., 5.).toString();
        assertTrue ("String <" + s + "> does not contain a minus",
                s.indexOf('-') >= 0);
    }

    @Test (timeout=1000)
    public void testValueOf() {
        Complex f = new Complex (2., 5.);
        assertEquals ("valueOf must read back what toString outputs. ",
                f, Complex.valueOf (f.toString()));
        f = new Complex (-17.55, 10.77);
        assertEquals ("valueOf must read back what toString outputs. ",
                f, Complex.valueOf (f.toString()));
        f = new Complex (0., 0.);
        assertEquals ("valueOf must read back what toString outputs. ",
                f, Complex.valueOf (f.toString()));
        f = new Complex (3., -2.);
        assertEquals ("valueOf must read back what toString outputs. ",
                f, Complex.valueOf (f.toString()));
        f = new Complex (-3., -5.);
        assertEquals ("valueOf must read back what toString outputs. ",
                f, Complex.valueOf (f.toString()));
        f = new Complex (3., -1.);
        assertEquals ("valueOf must read back what toString outputs. ",
                f, Complex.valueOf (f.toString()));
        f = new Complex (-3., 0.);
        assertEquals ("valueOf must read back what toString outputs. ",
                f, Complex.valueOf (f.toString()));
        f = new Complex (3., 1.);
        assertEquals ("valueOf must read back what toString outputs. ",
                f, Complex.valueOf (f.toString()));
        f = new Complex (0., -5.);
        assertEquals ("valueOf must read back what toString outputs. ",
                f, Complex.valueOf (f.toString()));
    }

    @Test (timeout=1000)
    public void testEquals() {
        Complex k1 = new Complex (3., 7.);
        Complex k2 = new Complex (3., -9.);
        Complex k3 = new Complex (3., 7.);
        assertTrue ("3+7i must be equal to 3+7i", k1.equals (k3));
        assertFalse ("3+7i must not be equal to 3-9i" , k1.equals (k2));
        Complex k4 = null;
        try {
            k4 = (Complex)k3.clone();
        } catch (CloneNotSupportedException e) {};
        assertTrue ("identical numbers must be equal", k1.equals(k1));
        assertTrue ("independent instances of the same number must be equal",
                k3.equals(k1));
        assertTrue ("clone must be equal to original", k3.equals(k4));
        assertFalse ("clone must not be identical to original", k3 == k4);
        assertFalse ("different numbers must not be equal", k1.equals(k2));
        assertTrue ("zero must satisfy isZero", new Complex (0., 0.).isZero());
        assertTrue ("number created from parts must be equal to original",
                k2.equals (new Complex (k2.getRe(), k2.getIm())));
        Complex k5 = new Complex (3.000000000000001, 7.000000000000001);
        assertTrue ("cannot compare real numbers using == operator",
                k5.equals (k1));
    }

    @Test (timeout=1000)
    public void testIsZero() {
        Complex k1 = new Complex (0., 0.);
        assertTrue ("0+0i must be zero", k1.isZero());
        k1 = new Complex (0., 1.);
        assertFalse ("0-1i must not be zero", k1.isZero());
    }

    @Test (timeout=1000)
    public void testClone() {
        Complex f1 = new Complex (2., 5.);
        Complex f2 = null;
        try {
            f2 = (Complex)f1.clone();
        } catch (CloneNotSupportedException e){};
        assertNotSame ("clone must differ from original", f2, f1);
        assertEquals ("clone must be equal to original", f1, f2);
        assertEquals ("clone must be equal to original", f2, f1);
        f1 = f2.plus(f2);
        assertEquals ("clone must be independent from original",
                new Complex (2., 5.), f2);
        f1 = new Complex (0., 0.);
        try {
            f2 = (Complex)f1.clone();
        } catch (CloneNotSupportedException e) {};
        assertNotSame ("clone must differ from original", f2, f1);
        assertEquals ("clone must be equal to original", f1, f2);
    }

    @Test (timeout=1000)
    public void testOpposite() {
        Complex f1 = new Complex (1., 6.);
        Complex f2 = f1.opposite();
        assertEquals ("Wrong opposite: 1+6i", new Complex (-1., -6.), f2);
        assertEquals ("Do not change the argument of opposite",
                new Complex (1., 6.), f1);
        f1 = new Complex (-4., 75.);
        f2 = f1.opposite();
        assertEquals ("Wrong opposite: -4+75i", new Complex (4., -75.), f2);
        f1 = new Complex (0., 0.);
        f2 = f1.opposite();
        assertEquals ("zero must be neutral to opposite", f1, f2);
    }

    @Test (timeout=1000)
    public void testConjugate() {
        Complex f1 = new Complex (1., 6.);
        Complex f2 = f1.conjugate();
        assertEquals ("Wrong conjugate: 1+6i", new Complex (1., -6.), f2);
        assertEquals ("Do not change the argument of conjugate",
                new Complex (1., 6.), f1);
        f1 = new Complex (-4., -75.);
        f2 = f1.conjugate();
        assertEquals ("Wrong conjugate: -4-75i", new Complex (-4., 75.), f2);
        f1 = new Complex (12340., 0.);
        f2 = f1.conjugate();
        assertEquals ("real number must be neutral to conjugate", f1, f2);
    }

    @Test (timeout=1000)
    public void testPlus() {
        Complex f1 = new Complex (2., 5.);
        Complex f2 = new Complex (4., 15.);
        Complex sum = f1.plus(f2);
        assertEquals ("Wrong sum: <" + f1 + "> + <" + f2 + ">",
                new Complex (6., 20.), sum);
        sum = f1.plus (f1);
        assertEquals ("plus must not change the arguments!", new Complex (2., 5.),
                f1);
        f1 = new Complex (-1., 25.);
        f2 = new Complex (1., -25.);
        sum = f1.plus(f2);
        assertEquals ("Wrong sum: <" + f1 + "> + <" + f2 + ">",
                new Complex (0., 0.), sum);
        f1 = new Complex (1., -22.);
        f2 = new Complex (0., 0.);
        sum = f1.plus (f2);
        assertEquals ("Wrong sum: <" + f1 + "> + <" + f2 + ">",
                new Complex (1., -22.), sum);
        f1 = new Complex (0., 0.);
        f2 = new Complex (-1., 41.);
        sum = f1.plus (f2);
        assertEquals ("Wrong sum: <" + f1 + "> + <" + f2 + ">",
                new Complex (-1., 41.), sum);
        f1 = new Complex (-2., -5.);
        f2 = new Complex (-1., -6.);
        sum = f1.plus(f2);
        assertEquals ("Wrong sum: <" + f1 + "> + <" + f2 + ">",
                new Complex (-3., -11.), sum);
    }

    @Test (timeout=1000)
    public void testMinus() {
        Complex f1 = new Complex (2., 5.);
        Complex f2 = new Complex (4., 15.);
        Complex dif = f1.minus(f2);
        assertEquals ("Wrong difference: <" + f1 + "> - <" + f2 + ">",
                new Complex (-2., -10.), dif);
        dif = f1.minus (f1);
        assertEquals ("plus must not change the arguments!", new Complex (2., 5.),
                f1);
        assertEquals ("Wrong difference: <" + f1 + "> - <" + f1 + ">",
                new Complex (0., 0.), dif);
        f1 = new Complex (4., 25.);
        f2 = new Complex (1., 5.);
        dif = f1.minus(f2);
        assertEquals ("Wrong difference: <" + f1 + "> - <" + f2 + ">",
                new Complex (3., 20.), dif);
    }

    @Test (timeout=1000)
    public void testTimes() {
        Complex f1 = new Complex (4., -3.);
        Complex f2 = new Complex (-24., 7.);
        Complex prd = f1.times (f2);
        assertEquals ("Wrong product: <" + f1 + "> * <" + f2 + ">",
                new Complex (-75., 100.), prd);
        f1 = new Complex (1., -1.);
        f2 = new Complex (3., 7.);
        prd = f1.times (f2);
        assertEquals ("Wrong product: <" + f1 + "> * <" + f2 + ">",
                new Complex (10., 4.), prd);
        Complex pr2 = prd.times (prd);
        assertEquals ("Wrong prd.times(prd) for 10+4i",
                new Complex (84., 80.), pr2);
        assertEquals ("Do not change the arguments of the product",
                new Complex (10., 4.), prd);
        f1 = new Complex (0., 0.);
        f2 = new Complex (2., 3.);
        prd = f1.times (f2);
        assertEquals ("Wrong product: <" + f1 + "> * <" + f2 + ">",
                new Complex (0., 0.), prd);
        f1 = new Complex (1., 0.);
        f2 = new Complex (2., 3.);
        prd = f1.times (f2);
        assertEquals ("Wrong product: <" + f1 + "> * <" + f2 + ">",
                new Complex (2., 3.), prd);
        f2 = new Complex (0., 0.);
        f1 = new Complex (2., 3.);
        prd = f1.times (f2);
        assertEquals ("Wrong product: <" + f1 + "> * <" + f2 + ">",
                new Complex (0., 0.), prd);
        f2 = new Complex (1., 0.);
        f1 = new Complex (2., 3.);
        prd = f1.times (f2);
        assertEquals ("Wrong product: <" + f1 + "> * <" + f2 + ">",
                new Complex (2., 3.), prd);
    }

    @Test (timeout=1000)
    public void testModule() {
        Complex k1 = new Complex (3., 4.);
        double mm = k1.module();
        assertEquals ("wrong module for 3+4i", 5., mm, DELTA);
        k1 = new Complex (0., 0.);
        mm = k1.module();
        assertEquals ("wrong module for zero", 0., mm, DELTA);
        k1 = new Complex (-1., 0.);
        mm = k1.module();
        assertEquals ("wrong module for -1+0i", 1., mm, DELTA);
        k1 = new Complex (0., 8.);
        mm = k1.module();
        assertEquals ("wrong module for 0+8i", 8., mm, DELTA);
    }

    @Test (timeout=1000)
    public void testInverse() {
        Complex f1 = new Complex (0.3, -0.4);
        Complex f2 = f1.inverse();
        assertEquals ("Wrong inverse: 0.3-0.4i ", new Complex (1.2, 1.6), f2);
        assertEquals ("Do not change the argument of inverse",
                new Complex (0.3, -0.4), f1);
        f1 = new Complex (0.6, 0.8);
        f2 = f1.inverse();
        assertEquals ("Wrong inverse: 0.6+0.8i", new Complex (0.6, -0.8), f2);
        f1 = new Complex (1., 0);
        f2 = f1.inverse();
        assertEquals ("1 must be neutral to inverse", f1, f2);
    }

    @Test (expected=RuntimeException.class)
    public void testZeroInverse() {
        Complex f = new Complex (0., 0.);
        f.inverse();
    }

    @Test (timeout=1000)
    public void testDivideBy() {
        Complex k1 = new Complex (3.0, 7.0);
        Complex k2 = new Complex (3.000000000000001, 7.000000000000001);
        assertTrue ("cannot compare real numbers using == operator",
                k1.equals (k2));
        Complex f1 = new Complex (-75., 100.);
        Complex f2 = new Complex (-24., 7.);
        Complex qt = f1.divideBy (f2);
        assertEquals ("Wrong quotient: <" + f1 + "> / <" + f2 + ">",
                new Complex (4., -3.), qt);
        qt = f1.divideBy (f1);
        assertEquals ("Do not change the arguments of the quotient",
                new Complex (-75., 100.), f1);
        assertEquals ("Wrong quotient: <" + f1 + "> / <" + f1 + ">",
                new Complex (1., 0.), qt);
        f1 = new Complex (10., 4.);
        f2 = new Complex (1., -1.);
        qt = f1.divideBy (f2);
        assertEquals ("Wrong quotient: <" + f1 + "> / <" + f2 + ">",
                new Complex (3., 7.), qt);
    }

    @Test (expected=RuntimeException.class)
    public void testDivideByZero() {
        Complex f1 = new Complex (1., 5.);
        Complex f2 = new Complex (0., 0.);
        f1.divideBy (f2);
    }

    /** kas module ja nurk on koosk6las? */
    boolean consistent (Complex c) {
        double p = c.angle();
        if (Math.abs(p) >= 2.*Math.PI)
            return false;
        double m = c.module();
        Complex k = new Complex (m*Math.cos(p), m*Math.sin(p));
        return k.equals(c);
    } // consistent

    /** liitmise, lahutamise, vastandarvu ja kaaskompleksi koosk6la */
    boolean consistent1 (Complex c) {
        if (!(c.plus(c.opposite()).isZero()))
            return false;
        if (!(c.equals(c.opposite().opposite())))
            return false;
        if (!(c.minus(c).isZero()))
            return false;
        if (!(new Complex(c.minus(c.conjugate()).getRe(),
                c.plus(c.conjugate()).getIm()).isZero()))
            return false;
        return true;
    } // consistent1

    /** korrutamise, jagamise ja p66rdarvu consistent */
    boolean consistent2 (Complex c) {
        Complex yks = new Complex (1., 0.);
        if (!(c.divideBy(c).equals(yks)))
            return false;
        if (!(c.times(c.inverse()).equals(yks)))
            return false;
        if (!(yks.divideBy(c.inverse()).equals(c)))
            return false;
        if (!(c.inverse().inverse().equals(c)))
            return false;
        return true;
    } // consistent2

    @Test (timeout=1000)
    public void testAngle() {  // testime k6iki nelja veerandit
        Complex k1 = new Complex (3.0, 7.0);
        Complex k2 = new Complex (3.000000000000001, 7.000000000000001);
        assertTrue ("cannot compare real numbers using == operator",
                k1.equals (k2));
        assertTrue ("error if re>0, im>0: 1.8+6.4i",
                consistent (new Complex (1.8, 6.4)));
        assertTrue ("error if re>0, im<0: 3.2-8.1i",
                consistent (new Complex (3.2, -8.1)));
        assertTrue ("error if re<0, im<0: -5.6-7.2i",
                consistent (new Complex (-5.6, -7.2)));
        assertTrue ("error if re<0, im>0: -4.67+2.5i",
                consistent (new Complex (-4.67, 2.5)));
        assertTrue ("real numbers are not exact! sqrt(2.)",
                new Complex (2., 0.).equals (new Complex
                        (new Complex (Math.sqrt(2.), -Math.sqrt(2.)).module(), 0.)));
        assertTrue ("real numbers are not exact! sqrt(25.)",
                new Complex (5., 0.).equals (new Complex
                        (new Complex (-3., -4.).module(), 0.)));
    } // testAngle

    @Test (expected=RuntimeException.class)
    public void testZeroAngle() {
        new Complex (0., 0.).angle();
    }

    @Test (timeout=1000)
    public void testConsistency() {
        assertTrue ("1+1i is not ok + -", consistent1 (new Complex (1., 1.)));
        assertTrue ("0+0i is not ok + -", consistent1 (new Complex (0., 0.)));
        assertTrue ("2-3i is not ok + -", consistent1 (new Complex (2., -3.)));
        assertTrue ("-5-1i is not ok + - ", consistent1 (new Complex (-5., -1.)));
        assertTrue ("5-4i is not ok * /", consistent2 (new Complex (5., -4.)));
        assertTrue ("-1+0i is not ok * /", consistent2 (new Complex (-1., 0.)));
        assertTrue ("-100-130i is not ok * /",
                consistent2 (new Complex (-100., -130.)));
    }

}