package cse1030;

import org.junit.Before;
import static org.junit.Assert.*;

import org.junit.Test;

public class ComplexTest {

  private Complex c11;
  private Complex minusC11;

  @Before
  public void setUp() throws Exception {
    c11 = new Complex(1.0, 1.0);
    minusC11 = new Complex(-1.0, -1.0);
  }

  /**
   * Test for Complex()
   */
  @Test
  public void testComplex() {
    Complex c = new Complex();
    assertTrue(c.re() == 0.0);
    assertTrue(c.im() == 0.0);
  }

  /**
   * Test for Complex(double)
   */
  @Test
  public void testComplexDouble() {
    Complex c = new Complex(1.0);
    assertTrue(c.re() == 1.0);
    assertTrue(c.im() == 0.0);
  }

  /**
   * Test for Complex(Complex)
   */
  @Test
  public void testComplexComplex() {
    Complex copy = new Complex(c11);
    assertTrue(copy.re() == 1.0);
    assertTrue(copy.im() == 1.0);
  }

  /**
   * Test for Complex(double, double)
   */
  @Test
  public void testComplexDoubleDouble() {
    assertTrue(c11.re() == 1.0);
    assertTrue(c11.im() == 1.0);
  }

  /**
   * Test for re()
   */
  @Test
  public void testRe() {
    assertTrue(c11.re() == 1.0);
  }

  /**
   * Test for im()
   */
  @Test
  public void testIm() {
    assertTrue(c11.im() == 1.0);
  }

  /**
   * Test for add(Complex)
   */
  @Test
  public void testAdd() {
    Complex sum = c11.add(minusC11);
    assertEquals(0.0, sum.re(), Math.ulp(0.0));
    assertEquals(0.0, sum.im(), Math.ulp(0.0));
  }

  /**
   * Test for multiply(Complex)
   */
  @Test
  public void testMultiply() {
    Complex prod = c11.multiply(minusC11);
    assertEquals(0.0, prod.re(), Math.ulp(0.0));
    assertEquals(-2.0, prod.im(), Math.ulp(-2.0));
  }

  /**
   * Test for mag()
   */
  @Test
  public void testMag() {
    final double EXPECTED = Math.sqrt(2.0);
    assertEquals(EXPECTED, c11.mag(), Math.ulp(EXPECTED));
  }

  /**
   * Test for equals(Object)
   */
  @Test
  public void testEqualsObject() {
    Complex alias = c11;
    Complex copy = new Complex(c11);
    assertTrue(c11.equals(alias));
    assertTrue(c11.equals(copy));
    assertFalse(c11.equals(minusC11));
  }

  /**
   * Test for hashCode()
   */
  @Test
  public void testHashCode() {
    Complex c = new Complex(c11.re() + Math.ulp(c11.re()), c11.im());
    assertFalse(c.hashCode() == c11.hashCode());
  }

  /**
   * Test for toString()
   */
  @Test
  public void testToString() {
    assertEquals("1.0 + 1.0i", c11.toString());
    assertEquals("-1.0 - 1.0i", minusC11.toString());
  }

  /**
   * Test for valueOf(String)
   */
  @Test
  public void testValueOfString() {
    assertTrue(c11.equals(Complex.valueOf(c11.toString())));
    assertTrue(minusC11.equals(Complex.valueOf(minusC11.toString())));
  }

  /**
   * Tests for valueOf(String) where we expect the method to throw an exception.
   */
  @Test(expected = IllegalArgumentException.class)
  public void testValueOfStringEx1() {
    // missing i
    Complex.valueOf("1 + 1");
  }

  @Test(expected = IllegalArgumentException.class)
  public void testValueOfStringEx2() {
    // missing sign
    Complex.valueOf("1 1");
  }

  @Test(expected = IllegalArgumentException.class)
  public void testValueOfStringEx3() {
    // missing imaginary part
    Complex.valueOf("1 + ");
  }
}