import org.junit.*;
import org.junit.runner.*;
import org.junit.Assert.*;

public class RlistTest {

	/**
	 * Prüft Ringliste auf Konsistenz.
	 * Liste enthält genau ein Ankerelement und Ringverkettung ist intakt.
	 * Methode darf nur auf dem Ankerelement aufgerufen werden.
	 *
	 * @return Gibt true zurück, wenn Liste konsistent ist.
	 */
	private static boolean check(Rlist<?> list) {
		if(list.get() != null) new RuntimeException("not called on anchor.");

		Rlist cur = list;
		do {
			cur = cur.next();
			// Auf beliebigen Anker gestoßen
			if(cur.get() == null) {
				if(cur != list) // Anker sind nicht gleich, also gibt es mehrere Anker
					return false;
			}
		} while(cur.get() != null);

		return true;
	}


	@Test
	public void testEmptyList() {
		/**
		 * @test
		 * <b>tag</b>TC001<br>
		 * <b>event</b>empty list<br>
		 * <b>expected </b>is empty, has size 0<br> */
		Rlist<String> testList = new Rlist<String>();


		Assert.assertTrue("Empty list isEmpty returns true.", testList.isEmpty());
		Assert.assertTrue("Empty list is size is 0.", testList.size() == 0);

		Assert.assertTrue("Consistency check", check(testList));
	}


	@Test
	public void testAdd() {
		/**
		 * @test
		 * <b>tag</b>TC002<br>
		 * <b>event</b>Adding elements to the list<br>
		 * <b>expected </b>Elements added right of current element.<br> */
		String[] expected1String = {"TestString1"};
		Rlist expected1 = new Rlist(expected1String);
		String[] expected2String = {"TestString2", "TestString1"};
		Rlist expected2 = new Rlist(expected2String);

		Rlist<String> testList = new Rlist<String>();
		testList.add("TestString1");

		Assert.assertTrue("One Element added right of anchor", testList.equals(expected1));
		Assert.assertTrue("List size has to be 1.", testList.size() == 1);

		testList.add(null);
		Assert.assertTrue("Test that null is not added", testList.equals(expected1));
		Assert.assertTrue("List size still has to be 1.", testList.size() == 1);

		testList.add("TestString2");
		Assert.assertTrue("Test that adding another element pushes others to the right.", testList.equals(expected2));
		Assert.assertTrue("List size has to be 2.", testList.size() == 2);

		Assert.assertTrue("Consistency check", check(testList));
	}

	@Test
	public void testInsert() {
		/**
		 * @test
		 * <b>tag</b>TC003<br>
		 * <b>event</b>Inserting elements into the list.<br>
		 * <b>expected </b>Elements added left of current element.<br> */
		String[] expected1String = {"TestString1"};
		Rlist expected1 = new Rlist(expected1String);
		String[] expected2String = {"TestString1", "TestString2", "TestString3"};
		Rlist expected2 = new Rlist(expected2String);
		String[] expected3String = {"TestString1", "TestString2", "a", "b", "c", "TestString3"};
		Rlist expected3 = new Rlist(expected3String);

		Rlist<String> testList = new Rlist<String>();
		Rlist anchor = testList;

		testList.insert("TestString1");

		Assert.assertTrue("One Element inserted left of anchor", anchor.equals(expected1));
		Assert.assertTrue("List size has to be 1.", anchor.size() == 1);

		testList.insert("TestString2");
		testList.insert("TestString3");
		Assert.assertTrue("Three Elements left of anchor", anchor.equals(expected2));
		Assert.assertTrue("List size has to be 3.", anchor.size() == 3);

		testList = testList.next().next().next();
		testList.insert("a");
		testList.insert("b");
		testList.insert("c");

		Assert.assertTrue("Inserting 3 elements in the middle.", anchor.equals(expected3));
		Assert.assertTrue("List size has to be 6.", anchor.size() == 6);

		Assert.assertTrue("Consistency check", check(anchor));
	}

	@Test
	public void testFind() {
		/**
		 * @test
		 * <b>tag</b>TC004<br>
		 * <b>event</b>Finding elements on list.<br>
		 * <b>expected </b>Existing element is found. Non-existing is not found.<br> */
		Rlist<String> testList = new Rlist<String>();
		Rlist anchor = testList;

		testList.insert("TestString1");
		testList.insert("TestString2");
		testList.insert("TestString3");
		testList.insert("a");
		testList.insert("b");
		testList.insert("c");



		Assert.assertTrue("Element is found.", anchor.find("a").get() == "a");
		Assert.assertTrue("Element is not found.", anchor.find("42") == null);

		Assert.assertTrue("Consistency check", check(anchor));
	}

	@Test
	public void testRemove() {
		/**
		 * @test
		 * <b>tag</b>TC005<br>
		 * <b>event</b>Removing elements on list.<br>
		 * <b>expected </b>Normal element is removed. Anchor is not removed.<br> */
		String[] expectedString = {"TestString1", "TestString2", "a", "b", "c"};
		Rlist expected = new Rlist(expectedString);

		Rlist<String> testList = new Rlist<String>();
		Rlist anchor = testList;

		testList.insert("TestString1");
		testList.insert("TestString2");
		testList.insert("TestString3");
		testList.insert("a");
		testList.insert("b");
		testList.insert("c");


		testList = testList.next().next().next();
		testList.remove();
		Assert.assertTrue("Element is found.", anchor.equals(expected));

		anchor.remove();
		Assert.assertTrue("Remove on anchor has no effect.", anchor.equals(expected));

		Assert.assertTrue("Consistency check", check(anchor));
	}

	@Test
	public void testIsSorted() {
		/**
		 * @test
		 * <b>tag</b>TC006<br>
		 * <b>event</b>Checking of sorted lists.<br>
		 * <b>expected </b>Sorted list returns true. Unsorted list returns false.<br> */
		Rlist<String> testList = new Rlist<String>();
		Rlist anchor = testList;

		testList.insert("1");
		testList.insert("2");
		testList.insert("3");
		testList.insert("4");
		testList.insert("5");
		testList.insert("6");

		Assert.assertTrue("Sorted list returns true.", anchor.isSorted());

		testList.insert("2");
		Assert.assertTrue("Unsorted list returns false.", anchor.isSorted() == false);

		Assert.assertTrue("Consistency check", check(anchor));
	}

	@Test
	public void testAddSorted() {
		/**
		 * @test
		 * <b>tag</b>TC007<br>
		 * <b>event</b>Adding of sorted list elements.<br>
		 * <b>expected </b>Inserting an element sorts it into the list.<br> */
		Rlist<String> testList = new Rlist<String>();
		Rlist anchor = testList;

		testList.insert("1");
		testList.insert("2");
		testList.insert("3");
		testList.insert("5");
		testList.insert("6");

		Assert.assertTrue("List is sorted.", anchor.isSorted());

		testList.addSorted("4");
		Assert.assertTrue("List is still sorted.", anchor.isSorted());
		Assert.assertTrue("Consistency check", check(anchor));

	}

	@Test
	public void testEquals() {
		/**
		 * @test
		 * <b>tag</b>TC008<br>
		 * <b>event</b>equals() compares 2 lists.<br>
		 * <b>expected </b>2 identical lists are evaluated to true.<br> */
		String[] expected1String = {"TestString1", "TestString2", "a", "b", "c"};
		Rlist expected1 = new Rlist(expected1String);
		String[] expected2String = {"TestString1", "TestString2", "a", "b", "c"};
		Rlist expected2 = new Rlist(expected2String);

		Assert.assertTrue("Lists are equal.", expected1.equals(expected2));
		expected1.add("42");
		Assert.assertTrue("Lists are not equal anymore.", expected1.equals(expected2) == false);

		Assert.assertTrue("Consistency check on expected1", check(expected1));
		Assert.assertTrue("Consistency check on expected2", check(expected2));
	}


	public static void main(String[] args) {
		JUnitCore junit = new JUnitCore();
		junit.addListener(new PI1TestRunListener());
		junit.run(RlistTest.class);
	}

}