package basics.testing;

import static org.junit.Assert.*;
import org.junit.Test;
import basics.immutabledata.Pair;

public class PairTEST {
	/**
	 *  Constructor should throw IllegalArgumentException if either
	 *  argument is null.
	 */
	@Test
	public void testConstructor() {
		try {
			new Pair<String,String>(null,"cat");
			// constructor should have thrown exception
			fail();
		} catch (IllegalArgumentException e) { }
		try {
			new Pair<String,String>("dog",null);
			// constructor should have thrown exception
			fail();
		} catch (IllegalArgumentException e) { }
		try {
			new Pair<String,String>(null,null);
			// constructor should have thrown exception
			fail();
		} catch (IllegalArgumentException e) { }
		try {
			new Pair<String,String>("dog","cat");
		} catch (IllegalArgumentException e) {
			// constructor should have succeeded
			fail();
		}
	}

	/**
	 *  first() and second() should return references to the objects
	 *  given to the constructor.
	 */
	@Test
	public void testFirstAndSecond() {
		Integer i = 42;
		Integer j = 91;
		Pair<Integer,Integer> p = new Pair<Integer,Integer>(i, j);
		assertSame(i, p.first());
		assertSame(j, p.second());
	}

	/**
	 *  Here is a weaker version of the above test; this version allows
	 *  Pair() to clone its arguments.
	 */
	@Test
	public void testFirstAndSecond_WeakerVersion() {
		Integer i = 42;
		Integer j = 91;
		Pair<Integer,Integer> p = new Pair<Integer,Integer>(i, j);
		assertEquals(i, p.first());
		assertEquals(j, p.second());
	}

	@Test
	public void testToString() {
		Pair<Integer,Integer> p = new Pair<Integer,Integer>(42, 91);
		assertEquals("Pair(42,91)", p.toString());
	}

	@Test
	public void testEquals() {
		Pair<Integer,Integer> p1 = new Pair<Integer,Integer>(42, 91);
		Pair<Integer,Integer> p2 = new Pair<Integer,Integer>(42, 91);
		Pair<Integer,Integer> p3 = new Pair<Integer,Integer>(43, 91);
		Pair<Integer,Integer> p4 = new Pair<Integer,Integer>(42, 92);
		assertTrue(p1.equals(p1));
		assertTrue(p1.equals(p2));
		assertFalse(p1.equals(p3));
		assertFalse(p1.equals(p4));
		assertFalse(p1.equals(new Object()));
	}

	@Test
	public void testHashCode() {
		Pair<Integer,Integer> p1 = new Pair<Integer,Integer>(42, 91);
		Pair<Integer,Integer> p2 = new Pair<Integer,Integer>(42, 91);
		Pair<Integer,Integer> p3 = new Pair<Integer,Integer>(43, 91);
		Pair<Integer,Integer> p4 = new Pair<Integer,Integer>(42, 92);
		assertEquals(p1.hashCode(), p1.hashCode());
		assertEquals(p1.hashCode(), p2.hashCode());
		assertTrue(p1.hashCode() != p3.hashCode());
		assertTrue(p1.hashCode() != p4.hashCode());
	}

	@Test
	public void testCompareTo() {
		Pair<Integer,Integer> p1 = new Pair<Integer,Integer>(42, 91);
		Pair<Integer,Integer> p2 = new Pair<Integer,Integer>(42, 91);
		Pair<Integer,Integer> p3 = new Pair<Integer,Integer>(43, 91);
		Pair<Integer,Integer> p4 = new Pair<Integer,Integer>(42, 92);
		assertTrue(0 == p1.compareTo(p1));
		assertTrue(0 == p1.compareTo(p2));
		assertTrue(0 >  p1.compareTo(p3));
		assertTrue(0 >  p1.compareTo(p4));
		assertTrue(0 == p2.compareTo(p1));
		assertTrue(0 <  p3.compareTo(p1));
		assertTrue(0 <  p4.compareTo(p1));
		// Using generic types, the following will not compile.
		// try {
		//   p1.compareTo(new Object());
		//   // compareTo should have thrown exception
		//   fail();
		// } catch (ClassCastException e) { }
	}
}