package edu.neu.ccs.evergreen.ir;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import org.junit.Test;

/**
 * Test cases for the Relation class.
 */
public class RelationTest {
	// For all test cases each variable is in the following position:
	// x = 2, y = 1, z = 0

	/**
	 * Test method for
	 * {@link edu.neu.ccs.evergreen.ir.Relation#forcedValue(int, int)}.
	 */
	@Test
	public void testForcedValue() {
		for (int relationNumber = 0; relationNumber < 256; relationNumber++) {
			for (int variablePosition = 0; variablePosition < 3; variablePosition++) {
				int forcedValue = Relation.forcedValue(relationNumber,
						variablePosition);
				assertTrue((forcedValue >= -1) && (forcedValue <= 1));
			}
		}

		// y && !z
		assertEquals(0, Relation.forcedValue(68, 0));
		assertEquals(1, Relation.forcedValue(68, 1));
		assertEquals(-1, Relation.forcedValue(68, 2));

		// x || y || z
		assertEquals(-1, Relation.forcedValue(254, 0));
		assertEquals(-1, Relation.forcedValue(254, 1));
		assertEquals(-1, Relation.forcedValue(254, 2));

		// (!x || (x && y)) && !z
		assertEquals(0, Relation.forcedValue(69, 0));
		assertEquals(-1, Relation.forcedValue(69, 1));
		assertEquals(-1, Relation.forcedValue(69, 2));

		// z
		assertEquals(1, Relation.forcedValue(170, 0));
		assertEquals(-1, Relation.forcedValue(170, 1));
		assertEquals(-1, Relation.forcedValue(170, 2));

		// !z
		assertEquals(0, Relation.forcedValue(85, 0));
		assertEquals(-1, Relation.forcedValue(85, 1));
		assertEquals(-1, Relation.forcedValue(85, 2));

		// y
		assertEquals(-1, Relation.forcedValue(204, 0));
		assertEquals(1, Relation.forcedValue(204, 1));
		assertEquals(-1, Relation.forcedValue(204, 2));

		// !x && !y && !z
		assertEquals(0, Relation.forcedValue(1, 0));
		assertEquals(0, Relation.forcedValue(1, 1));
		assertEquals(0, Relation.forcedValue(1, 2));

		// x && y && z
		assertEquals(1, Relation.forcedValue(128, 0));
		assertEquals(1, Relation.forcedValue(128, 1));
		assertEquals(1, Relation.forcedValue(128, 2));

		// 0
		assertEquals(-1, Relation.forcedValue(0, 0));
		assertEquals(-1, Relation.forcedValue(0, 1));
		assertEquals(-1, Relation.forcedValue(0, 2));

		// 1
		assertEquals(-1, Relation.forcedValue(255, 0));
		assertEquals(-1, Relation.forcedValue(255, 1));
		assertEquals(-1, Relation.forcedValue(255, 2));

		try {
			Relation.forcedValue(-1, 0);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.forcedValue(256, 0);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.forcedValue(1, -1);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.forcedValue(1, 3);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
	}

	/**
	 * Test method for
	 * {@link edu.neu.ccs.evergreen.ir.Relation#reduce(int, int, int)}.
	 */
	@Test
	public void testReduce() {
		for (int relationNumber = 0; relationNumber < 256; relationNumber++) {
			for (int variablePosition = 0; variablePosition < 3; variablePosition++) {
				for (int value = 0; value < 2; value++) {
					int reducedRelationNumber = Relation.reduce(relationNumber,
							variablePosition, value);
					assertTrue((reducedRelationNumber >= 0)
							&& (reducedRelationNumber <= 255));
				}
			}
		}

		// y && !z
		assertEquals(204, Relation.reduce(68, 0, 0));
		assertEquals(0, Relation.reduce(68, 0, 1));
		assertEquals(0, Relation.reduce(68, 1, 0));
		assertEquals(85, Relation.reduce(68, 1, 1));
		assertEquals(68, Relation.reduce(68, 2, 0));
		assertEquals(68, Relation.reduce(68, 2, 1));

		// x || y || z
		assertEquals(252, Relation.reduce(254, 0, 0));
		assertEquals(255, Relation.reduce(254, 0, 1));
		assertEquals(250, Relation.reduce(254, 1, 0));
		assertEquals(255, Relation.reduce(254, 1, 1));
		assertEquals(238, Relation.reduce(254, 2, 0));
		assertEquals(255, Relation.reduce(254, 2, 1));

		// (!x || (x && y)) && !z
		assertEquals(207, Relation.reduce(69, 0, 0));
		assertEquals(0, Relation.reduce(69, 0, 1));
		assertEquals(5, Relation.reduce(69, 1, 0));
		assertEquals(85, Relation.reduce(69, 1, 1));
		assertEquals(85, Relation.reduce(69, 2, 0));
		assertEquals(68, Relation.reduce(69, 2, 1));

		// z
		assertEquals(0, Relation.reduce(170, 0, 0));
		assertEquals(255, Relation.reduce(170, 0, 1));
		assertEquals(170, Relation.reduce(170, 1, 0));
		assertEquals(170, Relation.reduce(170, 1, 1));
		assertEquals(170, Relation.reduce(170, 2, 0));
		assertEquals(170, Relation.reduce(170, 2, 1));

		// !z
		assertEquals(255, Relation.reduce(85, 0, 0));
		assertEquals(0, Relation.reduce(85, 0, 1));
		assertEquals(85, Relation.reduce(85, 1, 0));
		assertEquals(85, Relation.reduce(85, 1, 1));
		assertEquals(85, Relation.reduce(85, 2, 0));
		assertEquals(85, Relation.reduce(85, 2, 1));

		// y
		assertEquals(204, Relation.reduce(204, 0, 0));
		assertEquals(204, Relation.reduce(204, 0, 1));
		assertEquals(0, Relation.reduce(204, 1, 0));
		assertEquals(255, Relation.reduce(204, 1, 1));
		assertEquals(204, Relation.reduce(204, 2, 0));
		assertEquals(204, Relation.reduce(204, 2, 1));

		// !x && !y && !z
		assertEquals(3, Relation.reduce(1, 0, 0));
		assertEquals(0, Relation.reduce(1, 0, 1));
		assertEquals(5, Relation.reduce(1, 1, 0));
		assertEquals(0, Relation.reduce(1, 1, 1));
		assertEquals(17, Relation.reduce(1, 2, 0));
		assertEquals(0, Relation.reduce(1, 2, 1));

		// x && y && z
		assertEquals(0, Relation.reduce(128, 0, 0));
		assertEquals(192, Relation.reduce(128, 0, 1));
		assertEquals(0, Relation.reduce(128, 1, 0));
		assertEquals(160, Relation.reduce(128, 1, 1));
		assertEquals(0, Relation.reduce(128, 2, 0));
		assertEquals(136, Relation.reduce(128, 2, 1));

		// 0
		assertEquals(0, Relation.reduce(0, 0, 0));
		assertEquals(0, Relation.reduce(0, 0, 1));
		assertEquals(0, Relation.reduce(0, 1, 0));
		assertEquals(0, Relation.reduce(0, 1, 1));
		assertEquals(0, Relation.reduce(0, 2, 0));
		assertEquals(0, Relation.reduce(0, 2, 1));

		// 1
		assertEquals(255, Relation.reduce(255, 0, 0));
		assertEquals(255, Relation.reduce(255, 0, 1));
		assertEquals(255, Relation.reduce(255, 0, 0));
		assertEquals(255, Relation.reduce(255, 0, 1));
		assertEquals(255, Relation.reduce(255, 2, 0));
		assertEquals(255, Relation.reduce(255, 2, 1));

		try {
			Relation.reduce(-1, 0, 0);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.reduce(-1, 0, 1);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.reduce(256, 0, 0);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.reduce(256, 0, 1);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.reduce(1, -1, 0);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.reduce(1, -1, 1);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.reduce(1, 3, 0);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.reduce(1, 3, 1);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.reduce(1, 1, -1);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.reduce(1, 1, 2);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
	}

	/**
	 * Test method for
	 * {@link edu.neu.ccs.evergreen.ir.Relation#rename(int, int)}.
	 */
	@Test
	public void testRename() {
		for (int relationNumber = 0; relationNumber < 256; relationNumber++) {
			for (int variablePosition = 0; variablePosition < 3; variablePosition++) {
				int renamedRelationNumber = Relation.rename(relationNumber,
						variablePosition);
				assertTrue((renamedRelationNumber >= 0)
						&& (renamedRelationNumber <= 255));
			}
		}

		// y && !z
		assertEquals(136, Relation.rename(68, 0));
		assertEquals(17, Relation.rename(68, 1));
		assertEquals(68, Relation.rename(68, 2));

		// x || y || z
		assertEquals(253, Relation.rename(254, 0));
		assertEquals(251, Relation.rename(254, 1));
		assertEquals(239, Relation.rename(254, 2));

		// (!x || (x && y)) && !z
		assertEquals(138, Relation.rename(69, 0));
		assertEquals(21, Relation.rename(69, 1));
		assertEquals(84, Relation.rename(69, 2));

		// z
		assertEquals(85, Relation.rename(170, 0));
		assertEquals(170, Relation.rename(170, 1));
		assertEquals(170, Relation.rename(170, 2));

		// !z
		assertEquals(170, Relation.rename(85, 0));
		assertEquals(85, Relation.rename(85, 1));
		assertEquals(85, Relation.rename(85, 2));

		// y
		assertEquals(204, Relation.rename(204, 0));
		assertEquals(51, Relation.rename(204, 1));
		assertEquals(204, Relation.rename(204, 2));

		// !x && !y && !z
		assertEquals(2, Relation.rename(1, 0));
		assertEquals(4, Relation.rename(1, 1));
		assertEquals(16, Relation.rename(1, 2));

		// x && y && z
		assertEquals(64, Relation.rename(128, 0));
		assertEquals(32, Relation.rename(128, 1));
		assertEquals(8, Relation.rename(128, 2));

		// 0
		assertEquals(0, Relation.rename(0, 0));
		assertEquals(0, Relation.rename(0, 1));
		assertEquals(0, Relation.rename(0, 2));

		// 1
		assertEquals(255, Relation.rename(255, 0));
		assertEquals(255, Relation.rename(255, 1));
		assertEquals(255, Relation.rename(255, 2));

		try {
			Relation.rename(-1, 0);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.rename(256, 0);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.rename(1, -1);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.rename(1, 3);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
	}

	/**
	 * Test method for
	 * {@link edu.neu.ccs.evergreen.ir.Relation#variableCount(int)}.
	 */
	@Test
	public void testVariableCount() {
		for (int relationNumber = 0; relationNumber < 256; relationNumber++) {
			int variableCount = Relation.variableCount(relationNumber);
			assertTrue((variableCount >= 0) && (variableCount <= 3));
		}

		// y && !z
		assertEquals(2, Relation.variableCount(68));

		// x || y || z
		assertEquals(3, Relation.variableCount(254));

		// (!x || (x && y)) && !z
		assertEquals(3, Relation.variableCount(69));

		// z
		assertEquals(1, Relation.variableCount(170));

		// !z
		assertEquals(1, Relation.variableCount(85));

		// y
		assertEquals(1, Relation.variableCount(204));

		// !x && !y && !z
		assertEquals(3, Relation.variableCount(1));

		// x && y && z
		assertEquals(3, Relation.variableCount(128));

		// 0
		assertEquals(0, Relation.variableCount(0));

		// 1
		assertEquals(0, Relation.variableCount(255));

		try {
			Relation.variableCount(-1);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.variableCount(256);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
	}

	/**
	 * Test method for
	 * {@link edu.neu.ccs.evergreen.ir.Relation#containsRowCount(int, int)}.
	 */
	@Test
	public void testContainsRowCount() {
		for (int relationNumber = 0; relationNumber < 256; relationNumber++) {
			int totalContainsRowCount = 0;
			for (int trueCount = 0; trueCount < 4; trueCount++) {
				int containsRowCount = Relation.containsRowCount(
						relationNumber, trueCount);
				assertTrue((containsRowCount >= 0) && (containsRowCount <= 3));
				totalContainsRowCount += containsRowCount;
			}
			assertEquals(totalContainsRowCount, Relation
					.satisfyingRowCount(relationNumber));
		}

		// y && !z
		assertEquals(0, Relation.containsRowCount(68, 0));
		assertEquals(1, Relation.containsRowCount(68, 1));
		assertEquals(1, Relation.containsRowCount(68, 2));
		assertEquals(0, Relation.containsRowCount(68, 3));

		// x || y || z
		assertEquals(0, Relation.containsRowCount(254, 0));
		assertEquals(3, Relation.containsRowCount(254, 1));
		assertEquals(3, Relation.containsRowCount(254, 2));
		assertEquals(1, Relation.containsRowCount(254, 3));

		// (!x || (x && y)) && !z
		assertEquals(1, Relation.containsRowCount(69, 0));
		assertEquals(1, Relation.containsRowCount(69, 1));
		assertEquals(1, Relation.containsRowCount(69, 2));
		assertEquals(0, Relation.containsRowCount(69, 3));

		// z
		assertEquals(0, Relation.containsRowCount(170, 0));
		assertEquals(1, Relation.containsRowCount(170, 1));
		assertEquals(2, Relation.containsRowCount(170, 2));
		assertEquals(1, Relation.containsRowCount(170, 3));

		// !z
		assertEquals(1, Relation.containsRowCount(85, 0));
		assertEquals(2, Relation.containsRowCount(85, 1));
		assertEquals(1, Relation.containsRowCount(85, 2));
		assertEquals(0, Relation.containsRowCount(85, 3));

		// y
		assertEquals(0, Relation.containsRowCount(204, 0));
		assertEquals(1, Relation.containsRowCount(204, 1));
		assertEquals(2, Relation.containsRowCount(204, 2));
		assertEquals(1, Relation.containsRowCount(204, 3));

		// !x && !y && !z
		assertEquals(1, Relation.containsRowCount(1, 0));
		assertEquals(0, Relation.containsRowCount(1, 1));
		assertEquals(0, Relation.containsRowCount(1, 2));
		assertEquals(0, Relation.containsRowCount(1, 3));

		// x && y && z
		assertEquals(0, Relation.containsRowCount(128, 0));
		assertEquals(0, Relation.containsRowCount(128, 1));
		assertEquals(0, Relation.containsRowCount(128, 2));
		assertEquals(1, Relation.containsRowCount(128, 3));

		// 0
		assertEquals(0, Relation.containsRowCount(0, 0));
		assertEquals(0, Relation.containsRowCount(0, 1));
		assertEquals(0, Relation.containsRowCount(0, 2));
		assertEquals(0, Relation.containsRowCount(0, 3));

		// 1
		assertEquals(1, Relation.containsRowCount(255, 0));
		assertEquals(3, Relation.containsRowCount(255, 1));
		assertEquals(3, Relation.containsRowCount(255, 2));
		assertEquals(1, Relation.containsRowCount(255, 3));

		try {
			Relation.containsRowCount(-1, 0);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.containsRowCount(256, 0);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.containsRowCount(1, -1);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.containsRowCount(1, 4);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
	}

	/**
	 * Test method for
	 * {@link edu.neu.ccs.evergreen.ir.Relation#satisfyingRowCount(int)}.
	 */
	@Test
	public void testSatisfyingRowCount() {
		for (int relationNumber = 0; relationNumber < 256; relationNumber++) {
			int satisfyingRowCount = Relation
					.satisfyingRowCount(relationNumber);
			assertTrue((satisfyingRowCount >= 0) && (satisfyingRowCount <= 8));
		}

		// y && !z
		assertEquals(2, Relation.satisfyingRowCount(68));

		// x || y || z
		assertEquals(7, Relation.satisfyingRowCount(254));

		// (!x || (x && y)) && !z
		assertEquals(3, Relation.satisfyingRowCount(69));

		// z
		assertEquals(4, Relation.satisfyingRowCount(170));

		// !z
		assertEquals(4, Relation.satisfyingRowCount(85));

		// y
		assertEquals(4, Relation.satisfyingRowCount(204));

		// !x && !y && !z
		assertEquals(1, Relation.satisfyingRowCount(1));

		// x && y && z
		assertEquals(1, Relation.satisfyingRowCount(128));

		// 0
		assertEquals(0, Relation.satisfyingRowCount(0));

		// 1
		assertEquals(8, Relation.satisfyingRowCount(255));

		try {
			Relation.variableCount(-1);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.variableCount(256);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
	}

	/**
	 * Test method for
	 * {@link edu.neu.ccs.evergreen.ir.Relation#notInRelation(int, int)}.
	 */
	@Test
	public void testNotInRelation() {
		for (int relationNumber = 0; relationNumber < 256; relationNumber++) {
			for (int variablePosition = 0; variablePosition < 3; variablePosition++) {
				boolean notInRelation = Relation.notInRelation(relationNumber,
						variablePosition);
				assertEquals(Relation.reduce(relationNumber, variablePosition,
						0) == Relation.reduce(relationNumber, variablePosition,
						1), notInRelation);
			}
		}

		// y && !z
		assertFalse(Relation.notInRelation(68, 0));
		assertFalse(Relation.notInRelation(68, 1));
		assertTrue(Relation.notInRelation(68, 2));

		// x || y || z
		assertFalse(Relation.notInRelation(254, 0));
		assertFalse(Relation.notInRelation(254, 1));
		assertFalse(Relation.notInRelation(254, 2));

		// (!x || (x && y)) && !z
		assertFalse(Relation.notInRelation(69, 0));
		assertFalse(Relation.notInRelation(69, 1));
		assertFalse(Relation.notInRelation(69, 2));

		// z
		assertFalse(Relation.notInRelation(170, 0));
		assertTrue(Relation.notInRelation(170, 1));
		assertTrue(Relation.notInRelation(170, 2));

		// !z
		assertFalse(Relation.notInRelation(85, 0));
		assertTrue(Relation.notInRelation(85, 1));
		assertTrue(Relation.notInRelation(85, 2));

		// y
		assertTrue(Relation.notInRelation(204, 0));
		assertFalse(Relation.notInRelation(204, 1));
		assertTrue(Relation.notInRelation(204, 2));

		// !x && !y && !z
		assertFalse(Relation.notInRelation(1, 0));
		assertFalse(Relation.notInRelation(1, 1));
		assertFalse(Relation.notInRelation(1, 2));

		// x && y && z
		assertFalse(Relation.notInRelation(128, 0));
		assertFalse(Relation.notInRelation(128, 1));
		assertFalse(Relation.notInRelation(128, 2));

		// 0
		assertTrue(Relation.notInRelation(0, 0));
		assertTrue(Relation.notInRelation(0, 1));
		assertTrue(Relation.notInRelation(0, 2));

		// 1
		assertTrue(Relation.notInRelation(255, 0));
		assertTrue(Relation.notInRelation(255, 1));
		assertTrue(Relation.notInRelation(255, 2));

		try {
			Relation.notInRelation(-1, 0);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.notInRelation(256, 0);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.notInRelation(1, -1);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
		try {
			Relation.notInRelation(1, 3);
			fail("No error");
		} catch (IllegalArgumentException e) {
		}
	}
}