Collection2UnitTest.java

package tests;

import static org.junit.Assert.*;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Type;

import static org.hamcrest.CoreMatchers.instanceOf;

import org.junit.Test;

import abstractClasses.Character;
import abstractClasses.Enemy;
import abstractClasses.Item;
import abstractClasses.Place;
import abstractClasses.Player;
import exceptions.LocationException;
import interfaces.CharacterActions;
import models.Archer;
import models.City;
import models.Forest;
import models.NPC;
import models.Swordman;
import models.Treasure;
import models.enemies.Angeling;
import models.enemies.Deviling;
import models.items.Coin;
import models.items.LifePotion;
import models.items.ManaPotion;
import models.items.Weapon;
import utilities.Utilities;
import utilities.hashTable.HashTable;
import utilities.list.List;
import utilities.list.Queue;
import utilities.list.Stack;

public class Collection2UnitTest {

	private NPC npc1;
	private NPC npc2;
	
	private Swordman swordman;
	private Archer archer;

	private City city;
	
	private Forest forest;
	
	private Treasure treasure;
	
	private List list;
	
	private Stack stack;
	
	private Deviling deviling;
	
	private Queue queue;
	
	private HashTable hashTable;
	
	private Weapon weapon;
	
	private Coin coin;
	
	private LifePotion lifePotion;
	
	private ManaPotion manaPotion;
	
	private utilities.genericList.List<Integer> genericList;
	
	private utilities.genericList.Stack<Character> genericStack;
	
	private utilities.genericList.Queue<Character> genericQueue;
	
	private utilities.genericHashTable.HashTable<String, Character> genericHashTable;
	
	private Angeling angeling;

	public Collection2UnitTest() {
		this.npc1 = new NPC("Blacksmith", 1, 2, "¿Que te arreglo?");
		this.npc2 = new NPC("Archer", 3, 4, "¿Quieres flechas?");
		
		this.swordman = new Swordman("Emanie", 5, 5);
		this.archer = new Archer("Légolas", 3, 2);

		this.city = new City("Prontera", this.npc1);
		
		this.forest = new Forest("Payon", this.npc2);
		
		this.treasure = new Treasure();
		
		this.list = new List();
		
		this.stack = new Stack();
		
		this.deviling = new Deviling(5, 4);
		
		this.queue = new Queue();
		
		this.hashTable = new HashTable(5);
		
		this.weapon = new Weapon(10, 200);
		
		this.coin = new Coin(1);
		
		this.lifePotion = new LifePotion(50);
		
		this.manaPotion = new ManaPotion(10);
		
		this.genericList = new utilities.genericList.List<Integer>();
		
		this.genericStack = new utilities.genericList.Stack<Character>();
		
		this.genericQueue = new utilities.genericList.Queue<Character>();
		
		this.genericHashTable = new utilities.genericHashTable.HashTable<String, Character>(10);
		
		this.angeling = new Angeling(3, 1);
	}
	
	/**
	 * Test de Clases
	 */

	@Test
	public void testNPC1() {
		assertEquals(npc1.getName(), "Blacksmith");
	}
	
	@Test
	public void testNPC2() {
		assertEquals(npc1.getX(), 1);
	}
	
	@Test
	public void testNPC3() {
		assertEquals(npc1.getY(), 2);
	}
	
	@Test
	public void testNPC4() {
		assertEquals(npc2.getSpeech(), "¿Quieres flechas?");
	}
	
	@Test
	public void testPlayer() {
		assertEquals(swordman.getName(), "Emanie");
	}
	
	@Test
	public void testPlace1() {
		city.addPlayer(swordman);
		//assertEquals(city.getPlayer().getName(), "Emanie");
		assertTrue(city.containsPlayer(swordman));
	}

	@Test
	public void testPlace2() {
		forest.setNPC(npc2);
		NPC npc = forest.getNPC(npc2.getName());
		assertEquals(npc.getName(), "Archer");
	}
	
	@Test
	public void testPlace3() {
		assertEquals(city.getName(), "Prontera");
	}
	
	/**
	 * Test de herencia
	 */
	
	@Test
	public void testInstance1() {
        assertThat(swordman, instanceOf(Character.class));
	}

	@Test
	public void testInstance2() {
        assertThat(npc1, instanceOf(Character.class));
	}

	@Test
	public void testInstance3() {
        assertThat(city, instanceOf(Place.class));
	}
	
	@Test
	public void testInstance4() {
        assertThat(forest, instanceOf(Place.class));
	}

	/**
	 * Interfaces
	 */

	@Test
	public void testInterfaces1() {
		assertTrue(CharacterActions.class.isInterface());
	}
	
	@Test
	public void testInterfaces2() {
		assertFalse(Place.class.isInterface());
	}
	
	@Test
	public void testInterfaces3() {
		assertFalse(Player.class.isInterface());
	}
	
	@Test
	public void testInterfaces4() {
		assertFalse(Archer.class.isInterface());
	}
	
	@Test
	public void testInterfaces5() {
		assertFalse(City.class.isInterface());
	}
	
	@Test
	public void testInterfaces6() {
        assertEquals(swordman.speech(0), "Grrrr");
        assertEquals(swordman.speech(1), "Tsk");
        assertEquals(swordman.speech(2), "¡Te clavaré mi espada!");
	}
	
	@Test
	public void testInterfaces7() {
        assertEquals(archer.speech(0), "Hola mariposa");
        assertEquals(archer.speech(1), "Adiós orco");
        assertEquals(archer.speech(2), "¡Flecha va!");
	}
	
	@Test
	public void testInterfaces8() {
		assertEquals(swordman.distance(), 1);
	}
	
	@Test
	public void testInterfaces9() {
		assertEquals(archer.distance(), 5);
	}
	
	@Test
	public void testInterfaces10() {
		assertEquals(swordman.attack(), 5);
	}
	
	@Test
	public void testInterfaces11() {
		assertEquals(archer.attack(), 1);
	}
	
	@Test
	public void testInterfaces12() {
        assertThat(swordman, instanceOf(CharacterActions.class));
	}
	
	@Test
	public void testInterfaces13() {
        assertThat(archer, instanceOf(CharacterActions.class));
	}
	
	/**
	 * Clases abstractas
	 */
	
	@Test
	public void testAbstract1() {
		assertEquals(swordman.walk(), 1);
	}
	
	@Test
	public void testAbstract2() {
		assertEquals(archer.walk(), 5);
	}
	
	@Test
	public void testAbstract3() {
		assertEquals(npc1.walk(), 0);
		assertEquals(npc2.walk(), 0);
	}
	
	/**
	 * Sobrecarga de métodos
	 */
	
	@Test
	public void testOverload1() {
		assertNotNull(swordman.speech());
		assertNotNull(archer.speech());
	}
	
	/**
	 * Polimorfismo
	 */
	
	@Test
	public void testPolymorphism1() {
		assertEquals(swordman.getLifePoints(), 100);
	}
	
	@Test
	public void testPolymorphism2() {
		assertEquals(archer.getLifePoints(), 60);
	}
	
	@Test
	public void testPolymorphism3() {
		assertEquals(swordman.defend(30), 70);
		assertEquals(swordman.getLifePoints(), 70);
	}
	
	@Test
	public void testPolymorphism4() {
		assertEquals(archer.defend(45), 15);
		assertEquals(archer.getLifePoints(), 15);
	}
	
	/**
	 * Encapsulamiento
	 */
	
	@Test(expected=NoSuchMethodException.class)
	public void testEncapsulation1() throws NoSuchMethodException {
		try{
		archer.getClass().getMethod("setLifePoints", Integer.class);
		}catch (SecurityException s) {
			System.out.println(s.getStackTrace());
		}
	}
	
	@Test(expected=NoSuchMethodException.class)
	public void testEncapsulation2() throws NoSuchMethodException {
		try{
		swordman.getClass().getMethod("setLifePoints", Integer.class);
		}catch (SecurityException s) {
			System.out.println(s.getStackTrace());
		}
	}
	
	@Test(expected=NoSuchMethodException.class)
	public void testEncapsulation3() throws NoSuchMethodException {
		try{
			archer.getClass().getMethod("setBaseLife");
		}catch (SecurityException s) {
			System.out.println(s.getStackTrace());
		}
	}
	
	@Test(expected=NoSuchMethodException.class)
	public void testEncapsulation4() throws NoSuchMethodException {
		try{
			swordman.getClass().getMethod("setBaseLife");
		}catch (SecurityException s) {
			System.out.println(s.getStackTrace());
		}
	}
	
	@Test(expected=NoSuchMethodException.class)
	public void testEncapsulation5() throws NoSuchMethodException {
		try{
			archer.getClass().getMethod("getBaseLife");
		}catch (SecurityException s) {
			System.out.println(s.getStackTrace());
		}
	}
	
	@Test(expected=NoSuchMethodException.class)
	public void testEncapsulation6() throws NoSuchMethodException {
		try{
			swordman.getClass().getMethod("getBaseLife");
		}catch (SecurityException s) {
			System.out.println(s.getStackTrace());
		}
	}
	
	@Test(expected=NoSuchMethodException.class)
	public void testEncapsulation7() throws NoSuchMethodException {
		try{
			Player.class.getMethod("setLifePoints", Integer.class);
		}catch (SecurityException s) {
			System.out.println(s.getStackTrace());
		}
	}
	
	/**
	 * Propiedad final
	 */
	
	@Test
	public void testFinalProperty1() {
		Field[] declaredFields = Archer.class.getDeclaredFields();
		Field finalField = null;
		for (Field field : declaredFields) {
		    if (java.lang.reflect.Modifier.isFinal(field.getModifiers())) {
		    	if(field.getName() == "baseLife")
		        finalField = field;
		    }
		}
		
		assertNotNull(finalField);
		assertTrue(finalField.getName() == "baseLife");
		assertTrue(finalField.getType() == int.class);
	}
	
	@Test
	public void testFinalProperty2() {
		Field[] declaredFields = Swordman.class.getDeclaredFields();
		Field finalField = null;
		for (Field field : declaredFields) {
		    if (java.lang.reflect.Modifier.isFinal(field.getModifiers())) {
		    	if(field.getName() == "baseLife")
		        finalField = field;
		    }
		}
		
		assertNotNull(finalField);
		assertTrue(finalField.getName() == "baseLife");
		assertTrue(finalField.getType() == int.class);
	}
	
	@Test
	public void testFinalProperty3() {
		Field[] declaredFields = Player.class.getDeclaredFields();
		Field finalField = null;
		for (Field field : declaredFields) {
		    if (java.lang.reflect.Modifier.isFinal(field.getModifiers())) {
		    	if(field.getName() == "lifePoints")
		        finalField = field;
		    }
		}
		
		assertNull(finalField);
	}
	
	/**
	 * Propiedad static
	 */
	
	@Test
	public void testStaticProperty1() {
		Field[] declaredFields = Archer.class.getDeclaredFields();
		Field staticField = null;
		for (Field field : declaredFields) {
		    if (java.lang.reflect.Modifier.isStatic(field.getModifiers())) {
		    	if(field.getName() == "baseLife")
		        staticField = field;
		    }
		}
		
		assertNotNull(staticField);
		assertTrue(staticField.getName() == "baseLife");
		assertTrue(staticField.getType() == int.class);
	}
	
	@Test
	public void testStaticProperty2() {
		Field[] declaredFields = Swordman.class.getDeclaredFields();
		Field staticField = null;
		for (Field field : declaredFields) {
		    if (java.lang.reflect.Modifier.isStatic(field.getModifiers())) {
		    	if(field.getName() == "baseLife")
		        staticField = field;
		    }
		}
		
		assertNotNull(staticField);
		assertTrue(staticField.getName() == "baseLife");
		assertTrue(staticField.getType() == int.class);
	}
	
	@Test
	public void testStaticProperty3() {
		Field[] declaredFields = Player.class.getDeclaredFields();
		Field staticField = null;
		for (Field field : declaredFields) {
		    if (java.lang.reflect.Modifier.isStatic(field.getModifiers())) {
		    	if(field.getName() == "lifePoints")
		        staticField = field;
		    }
		}
		
		assertNull(staticField);
	}
	
	@Test
	public void testStaticProperty4() {
		Method[] declaredMethods = Utilities.class.getMethods();
		Method staticMethod = null;
		for (Method method : declaredMethods) {
		    if (java.lang.reflect.Modifier.isStatic(method.getModifiers())) {
		    	if(method.getName() == "calculateDamage")
		        staticMethod = method;
		    }
		}
		
		Type[] methodParameters = staticMethod.getGenericParameterTypes();
		assertNotNull(staticMethod);
		assertTrue(staticMethod.getName() == "calculateDamage");
		assertTrue(staticMethod.getReturnType() == int.class);
		assertEquals(methodParameters.length, 2);
		assertEquals(methodParameters[0].getTypeName(), "int");
		assertEquals(methodParameters[1].getTypeName(), "int");
	}
	
	/**
	 * Excepciones
	 */
	@Test(expected=LocationException.class)
	public void testException1() throws LocationException {
		throw new LocationException();
	}
	
	@Test(expected=LocationException.class)
	public void testException2() throws LocationException {
		swordman.walk(5, 5);
	}
	
	@Test(expected=LocationException.class)
	public void testException3() throws LocationException {
		archer.walk(3, 2);
	}
	
	@Test
	public void testException4() {
		try {
			swordman.walk(5, 5);
			// Lanzando la excepción fuerzo a que si no salta lo anterior, salta aquí y falla el test
			throw new LocationException();
		} catch (LocationException e) {
			assertEquals(e.getMessage(), "Misma X e Y");
		}
	}
	
	@Test
	public void testException5() {
		try {
			archer.walk(3, 2);
			throw new LocationException();
		} catch (LocationException e) {
			assertEquals(e.getMessage(), "Misma X e Y");
		}
	}
	
	/**
	 * IO
	 */
	
	/**
	 * IO-Zip
	 */
	
	/**
	 * IO-Serialization
	 */
	
	/**
	 * Arrays
	 */
	@Test
	public void testTreasure1() {
		assertTrue(treasure.getX() >= 0 && treasure.getX() <= 10);
	}
	
	@Test
	public void testTreasure2() {
		assertTrue(treasure.getY() >= 0 && treasure.getY() <= 10);
	}
	
	@Test
	public void testTreasure3() {
		if(treasure.isOpen() && treasure.getWeapon() == null){
			assertTrue(true);
		}else if(treasure.isOpen() && treasure.getWeapon() != null){
			assertTrue(false);
		}else if(!treasure.isOpen() && treasure.getWeapon() != null){
			assertTrue(true);
		}else{
			assertTrue(false);
		}
	}
	
	@Test
	public void testTreasure4() {
		assertTrue(city.getTreasures().length == 5);
	}
	
	@Test
	public void testTreasure5() {
		assertTrue(city.getTreasures().length == 5);
	}
	
	/**
	 * Lista
	 */
	
	@Test
	public void testList1() {
		assertEquals(0, list.getSize());
		assertEquals(list.getHead(), list.getTail());
		assertNull(list.getHead());
		assertNull(list.getTail());
		assertNull(list.getCurrent());
	}
	
	@Test
	public void testList2() {
		list.add(5);
		assertEquals(1, list.getSize());
		assertEquals(list.getHead(), list.getTail());
		assertNotNull(list.getHead());
		assertNotNull(list.getTail());
	}
	
	@Test
	public void testList3() {
		list.add(5);
		list.add(3);
		assertEquals(2, list.getSize());
		assertNotEquals(list.getHead(), list.getTail());
		assertEquals(5, list.getHead());
		assertEquals(3, list.getTail());
	}
	
	@Test
	public void testList4() {
		list.add(5);
		list.add(3);
		list.add(7);
		list.delete(3);
		assertEquals(2, list.getSize());
		assertNotEquals(list.getHead(), list.getTail());
		assertEquals(5, list.getHead());
		assertEquals(7, list.getTail());
	}
	
	@Test
	public void testList5() {
		assertEquals(0, list.getSize());
		list.delete(1);
		assertEquals(0, list.getSize());
		assertEquals(list.getHead(), list.getTail());
		assertNull(list.getHead());
		assertNull(list.getTail());		
	}
	
	@Test
	public void testList6() {
		assertNull(list.getCurrent());
		list.add(1);
		list.add(2);
		list.add(3);
		list.add(4);
		list.add(5);
		assertNotNull(list.getCurrent());
		assertNotNull(list.getHead());
		assertEquals(list.getHead(), list.getCurrent());
		assertEquals(1, list.getCurrent());
		list.next();
		assertEquals(2, list.getCurrent());
		list.next();
		assertEquals(3, list.getCurrent());
		list.next();
		assertEquals(4, list.getCurrent());
		list.next();
		assertEquals(5, list.getCurrent());
		assertEquals(list.getTail(), list.getCurrent());
		list.next();
		assertEquals(list.getTail(), list.getCurrent());
	}
	
	/**
	 * Uso de las listas
	 */
	
	@Test
	public void testList21() {
		city.setNPC(npc2);
		
		NPC npc = new NPC("Foodseller", 2, 3, "Tengo carne");
		city.setNPC(npc);
		
		assertEquals(3, city.getListNPC().getSize());
		
		assertEquals(city.getNPC("Foodseller").getSpeech(), "Tengo carne");
		assertEquals(city.getNPC("Archer").getSpeech(), "¿Quieres flechas?");
	}
	
	@Test
	public void testList22() {
		assertEquals(1, forest.getListNPC().getSize());
	}	
	
	@Test
	public void testList23() {
		NPC npc = new NPC("Foodseller", 2, 3, "Tengo carne");
		utilities.genericList.List <NPC> listNPC = new utilities.genericList.List<NPC>();
		listNPC.add(npc);
		listNPC.add(npc1);
		listNPC.add(npc2);
		
		City city = new City("Aldebarán", listNPC);		
		assertEquals(3, city.getListNPC().getSize());
	}	
	
	@Test
	public void testList24() {
		NPC npc = new NPC("Foodseller", 2, 3, "Tengo carne");
		utilities.genericList.List <NPC> listNPC = new utilities.genericList.List<NPC>();
		listNPC.add(npc);
		listNPC.add(npc1);
		listNPC.add(npc2);
		
		Forest forest = new Forest("Izlude", listNPC);		
		assertEquals(3, forest.getListNPC().getSize());
	}
	
	/**
	 * Pila
	 */
	
	@Test
	public void testStack1() {
		assertNull(stack.pop());
		assertNull(stack.getCurrent());
	}
	
	@Test
	public void testStack2() {
		stack.push(swordman);
		assertEquals("Emanie", ((Player)stack.getCurrent()).getName());
		assertEquals(swordman, stack.getCurrent());
	}
	
	@Test
	public void testStack3() {
		stack.push(swordman);
		stack.push(archer);
		stack.push(npc1);
		assertEquals("¿Que te arreglo?", ((NPC)stack.getCurrent()).getSpeech());
	}
	
	@Test
	public void testStack4() {
		stack.push(npc1);
		stack.push(swordman);
		stack.push(archer);		
		assertEquals("Légolas", ((Character)stack.getCurrent()).getName());
		assertEquals(archer, stack.pop());
		assertEquals("Emanie", ((Character)stack.getCurrent()).getName());
		assertEquals(swordman, stack.pop());
		assertEquals("Blacksmith", ((Character)stack.getCurrent()).getName());
		assertEquals(npc1, stack.pop());
		assertNull(stack.pop());
		assertNull(stack.getCurrent());
		assertNull(stack.pop());
		assertNull(stack.getCurrent());
		assertNull(stack.pop());
	}
	
	@Test
	public void testStack5() {
		stack.push(archer);		
		assertEquals("Légolas", ((Character)stack.getCurrent()).getName());
		assertEquals(archer, stack.pop());
		assertNull(stack.pop());
		assertNull(stack.getCurrent());		
		stack.push(npc1);
		stack.push(swordman);		
		assertEquals("Emanie", ((Character)stack.getCurrent()).getName());
		assertEquals(swordman, stack.pop());
		assertEquals("Blacksmith", ((Character)stack.getCurrent()).getName());
		assertEquals(npc1, stack.pop());		
		assertNull(stack.pop());
		assertNull(stack.getCurrent());
		assertNull(stack.pop());		
		stack.push(archer);		
		assertEquals("Légolas", ((Character)stack.getCurrent()).getName());
	}
	
	/**
	 * Uso de las pilas
	 */
	@Test
	public void testDeviling1() {
		assertEquals(deviling.getName(), "Deviling");
	}
	
	@Test
	public void testDeviling2() {
		assertEquals(deviling.getX(), 5);
	}
	
	@Test
	public void testDeviling3() {
		assertEquals(deviling.getY(), 4);
	}
	
	@Test
	public void testDeviling4() {
		assertEquals(deviling.getRemainingLife(), 300);
	}
	
	@Test
	public void testDeviling5() {
		assertEquals(deviling.walk(), 2);
	}
	
	@Test(expected=NullPointerException.class)
	public void testDeviling6() throws LocationException {
		deviling.chase();
	}
	
	@Test
	public void testDeviling7() throws LocationException {
		assertEquals(null, deviling.getCurrentObjective());
		deviling.see(swordman);
		deviling.see(archer);
		deviling.chase();
		assertEquals(archer, deviling.getCurrentObjective());
	}
	
	@Test
	public void testDeviling8() throws LocationException {
		deviling.see(archer);
		deviling.see(swordman);
		deviling.chase();
		assertEquals(swordman, deviling.getCurrentObjective());
		swordman.setX(10);
		swordman.setY(10);
		deviling.chase();
		assertEquals(archer, deviling.getCurrentObjective());
		deviling.see(swordman);
		archer.setX(5);
		archer.setY(4);
		deviling.see(archer);
		deviling.chase();
		assertEquals(archer, deviling.getCurrentObjective());
	}
	
	@Test(expected=LocationException.class)
	public void testDeviling9() throws LocationException {
		deviling.setX(5);
		deviling.setY(5);
		deviling.see(swordman);
		deviling.chase();
	}
	
	@Test(expected=LocationException.class)
	public void testDeviling10() throws LocationException {
		deviling.see(swordman);
		deviling.chase();
		deviling.see(archer);
		deviling.chase();
		deviling.see(swordman);
		deviling.chase();
		deviling.see(swordman);
		deviling.chase();
	}
	
	/**
	 * Cola
	 */
	
	@Test
	public void testQueue1() {
		assertTrue(queue.isEmpty());
		assertTrue(queue.size() == 0);
		assertNull(queue.dequeue());
	}
	
	@Test
	public void testQueue2() {
		queue.enqueue(swordman);
		assertFalse(queue.isEmpty());
		assertTrue(queue.size() == 1);
		Player player = ((Player)(queue.dequeue()));
		assertEquals("Emanie", player.getName());
		assertTrue(queue.isEmpty());
		assertTrue(queue.size() == 0);
		assertNull(queue.dequeue());
	}
	
	@Test
	public void testQueue3() {
		queue.enqueue(swordman);
		queue.enqueue(archer);
		queue.enqueue(npc1);
		assertEquals("Emanie", ((Player)queue.dequeue()).getName());
		assertEquals("Légolas", ((Player)queue.dequeue()).getName());
		assertEquals("Blacksmith", ((Character)(queue.dequeue())).getName());
		assertNull(queue.dequeue());
	}
	
	@Test
	public void testQueue4() {
		queue.enqueue(swordman);
		queue.enqueue(archer);
		queue.enqueue(npc1);
		
		assertEquals("Emanie", ((Player)queue.dequeue()).getName());
		assertEquals("Légolas", ((Player)queue.dequeue()).getName());
		
		queue.enqueue(npc2);
		assertEquals("Blacksmith", ((Character)(queue.dequeue())).getName());
		
		queue.enqueue(swordman);
		assertEquals("Archer", ((Character)(queue.dequeue())).getName());
		
		assertEquals("Emanie", ((Character)(queue.dequeue())).getName());
		
		assertNull(queue.dequeue());
		assertNull(queue.dequeue());
	}
	
	/**
	 * Uso de las colas
	 */
	
	@Test
	public void testQueue21() {
		assertNull(swordman.killNextEnemy());
		assertTrue(swordman.getEnemiesToKill().isEmpty());
		assertEquals(0, swordman.getEnemiesToKill().size());
	}
	
	@Test
	public void testQueue22() {
		archer.addNewEnemy(deviling);
		assertEquals(1, archer.getEnemiesToKill().size());
		Enemy enemy = archer.killNextEnemy();
		assertNotNull(enemy);
		assertEquals(deviling, enemy);		
		assertTrue(archer.getEnemiesToKill().isEmpty());
		
		assertNull(archer.killNextEnemy());
		assertTrue(archer.getEnemiesToKill().isEmpty());
		assertEquals(0, archer.getEnemiesToKill().size());
		assertEquals(null, archer.killNextEnemy());
		
		assertNull(swordman.killNextEnemy());
		assertTrue(swordman.getEnemiesToKill().isEmpty());
		assertEquals(0, swordman.getEnemiesToKill().size());
		assertEquals(null, swordman.killNextEnemy());
	}
	
	@Test
	public void testQueue23() {
		Deviling deviling2 = new Deviling(0, 0);
		Deviling deviling3 = new Deviling(1, 1);
		Deviling deviling4 = new Deviling(2, 2);
		
		swordman.addNewEnemy(deviling);
		swordman.addNewEnemy(deviling2);
		swordman.addNewEnemy(deviling3);
		swordman.addNewEnemy(deviling4);
		
		assertEquals(deviling, swordman.killNextEnemy());
		assertEquals(deviling2, swordman.killNextEnemy());
		assertEquals(deviling3, swordman.killNextEnemy());
		assertEquals(deviling4, swordman.killNextEnemy());
		
		assertNull(swordman.killNextEnemy());
	}
	
	@Test
	public void testQueue24() {
		Deviling deviling2 = new Deviling(0, 0);
		Deviling deviling3 = new Deviling(1, 1);
		Deviling deviling4 = new Deviling(2, 2);
		Deviling deviling5 = new Deviling(3,3);
		
		swordman.addNewEnemy(deviling);
		swordman.addNewEnemy(deviling2);
		
		archer.addNewEnemy(deviling3);
		archer.addNewEnemy(deviling4);
		
		assertEquals(deviling, swordman.killNextEnemy());
		assertEquals(deviling3, archer.killNextEnemy());
		
		swordman.addNewEnemy(deviling5);
		
		assertEquals(deviling2, swordman.killNextEnemy());
		assertEquals(deviling4, archer.killNextEnemy());
		
		assertEquals(deviling5, swordman.killNextEnemy());
		assertEquals(null, archer.killNextEnemy());
		
		assertEquals(null, swordman.killNextEnemy());
		assertEquals(null, archer.killNextEnemy());
	}
	
	/**
	 * Tabla Hash
	 */
	
	@Test
	public void testHashTable1() {
		assertNull(hashTable.remove(swordman));
		assertNull(hashTable.search(swordman));
		assertTrue(hashTable.size() == 0);
	}
	
	@Test(expected=NullPointerException.class)
	public void testHashTable2() {
		hashTable.put(null, swordman);
	}
	
	@Test(expected=NullPointerException.class)
	public void testHashTable3() {
		hashTable.put(swordman.getName(), null);
	}
	
	@Test
	public void testHashTable4() {
		hashTable.put(swordman.getName(), swordman);
		hashTable.put(archer.getName(), archer);
		assertEquals(2, hashTable.size());
		hashTable.put(npc1.getName(), npc1);
		hashTable.put(npc2.getName(), npc2);
		assertEquals(4, hashTable.size());
		hashTable.put(npc1.getName(), npc1);
		hashTable.put(npc2.getName(), npc2);
		assertEquals(6, hashTable.size());
	}
	
	@Test
	public void testHashTable5() {
		hashTable.put(swordman.getName(), swordman);
		hashTable.put(archer.getName(), archer);
		assertEquals(2, hashTable.size());
		Player player = ((Player)hashTable.search(swordman.getName()));
		assertEquals("Emanie", player.getName());
		assertEquals(2, hashTable.size());
		player = ((Player)hashTable.search("Légolas"));
		assertEquals("Légolas", player.getName());
		assertEquals(2, hashTable.size());
	}
	
	@Test
	public void testHashTable6() {
		hashTable.put(swordman.getName(), swordman);
		hashTable.put(npc1.getName(), npc1);
		assertEquals(2, hashTable.size());
		Player player = ((Player)hashTable.remove(swordman.getName()));
		assertEquals("Emanie", player.getName());
		assertEquals(1, hashTable.size());
		player = ((Player)hashTable.remove("House"));
		assertNull(player);
		assertEquals(1, hashTable.size());
		NPC npc = ((NPC)hashTable.remove(npc1.getName()));
		assertEquals("Blacksmith", npc.getName());
		assertEquals(0, hashTable.size());
		assertNull(hashTable.remove(swordman.getName()));
		assertNull(hashTable.remove(archer.getName()));
		assertNull(hashTable.remove(npc1.getName()));
		assertNull(hashTable.remove("Test"));
	}
	
	@Test
	public void testHashTable7() {
		hashTable.put(swordman.getName(), swordman);
		hashTable.put(archer.getName(), archer);
		assertEquals(2, hashTable.size());
		Player player = ((Player)hashTable.remove(swordman.getName()));
		assertEquals("Emanie", player.getName());
		assertEquals(1, hashTable.size());
		player = ((Player)hashTable.remove("Légolas"));
		assertEquals("Légolas", player.getName());
		assertEquals(0, hashTable.size());

		hashTable.put(archer.getName(), archer);
		assertEquals(1, hashTable.size());
		hashTable.put(swordman.getName(), swordman);
		assertEquals(2, hashTable.size());
		hashTable.put(npc1.getName(), npc1);
		assertEquals(3, hashTable.size());
		
		hashTable.put(5, 5);
		assertEquals(4, hashTable.size());
		hashTable.put("Cadena de texto", "Hola Mundo Cruel");
		assertEquals(5, hashTable.size());
		hashTable.put("Tesoro", "Espada+1");
		assertEquals(6, hashTable.size());
		hashTable.put(7, 7);
		assertEquals(7, hashTable.size());
	}
	
	/**
	 * Uso de la Tabla Hash
	 */
	
	@Test
	public void testItem1() {
		assertThat(coin, instanceOf(Item.class));
	}
	
	@Test
	public void testItem2() {
		assertThat(weapon, instanceOf(Item.class));
	}
	
	@Test
	public void testItem3() {
		assertThat(lifePotion, instanceOf(Item.class));
	}
	
	@Test
	public void testItem4() {
		assertThat(manaPotion, instanceOf(Item.class));
	}
	
	@Test
	public void testCoin1() {
		assertEquals(coin.getValue(), 1);
	}
	
	@Test
	public void testCoin2() {
		assertEquals("coin", coin.getName());
	}
	
	@Test
	public void testPotion1() {
		assertEquals(lifePotion.getQuantity(), 50);
	}
	
	@Test
	public void testPotion2() {
		assertEquals("lifePotion", lifePotion.getName());
	}
	
	@Test
	public void testPotion3() {
		assertEquals(manaPotion.getQuantity(), 10);
	}
	
	@Test
	public void testPotion4() {
		assertEquals("manaPotion", manaPotion.getName());
	}
	
	@Test
	public void testWeapon() {
		assertEquals("weapon", weapon.getName());
	}
	
	@Test
	public void testHashTable21() {
		assertNull(swordman.getItem("Algo"));
		assertNull(archer.getItem("Algo"));
	}
	
	@Test
	public void testHashTable22() {
		assertEquals(0, swordman.getRucksack().size());
		swordman.addItem(coin);
		assertEquals(1, swordman.getRucksack().size());
		swordman.addItem(weapon);
		assertEquals(2, swordman.getRucksack().size());
		swordman.addItem(lifePotion);
		assertEquals(3, swordman.getRucksack().size());
		swordman.addItem(manaPotion);
		assertEquals(4, swordman.getRucksack().size());
	}
	
	@Test
	public void testHashTable23() {
		swordman.addItem(coin);		
		swordman.addItem(weapon);
		swordman.addItem(lifePotion);
		swordman.addItem(manaPotion);
		assertEquals(lifePotion, swordman.getItem(lifePotion.getName()));
		assertEquals(weapon, swordman.getItem(weapon.getName()));
		assertEquals(coin, swordman.getItem(coin.getName()));
		assertEquals(manaPotion, swordman.getItem(manaPotion.getName()));
	}
	
	@Test
	public void testHashTable24() {
		archer.addItem(coin);		
		archer.addItem(weapon);
		swordman.addItem(lifePotion);
		swordman.addItem(manaPotion);
		Coin coin = new Coin(10);
		swordman.addItem(coin);
		
		assertEquals(1, (((Coin) archer.getItem(coin.getName())).getValue()));
		assertEquals(10, (((Coin) swordman.getItem(coin.getName())).getValue()));
		
		this.coin.setValue(2);
		assertEquals(2, (((Coin) archer.getItem(coin.getName())).getValue()));
		
		coin.setValue(5);
		assertEquals(5, (((Coin) swordman.getItem(coin.getName())).getValue()));
		
		assertNull(archer.getItem(lifePotion.getName()));
		assertNull(archer.getItem(manaPotion.getName()));
		assertNull(swordman.getItem(weapon.getName()));
	}
	
	/**
	 * Genéricos
	 */
	
	@Test
	public void testGenericList1() {
		assertEquals(0, genericList.getSize());
		assertEquals(genericList.getHead(), genericList.getTail());
		assertNull(genericList.getHead());
		assertNull(genericList.getTail());
		assertNull(genericList.getCurrent());
	}
	
	@Test
	public void testGenericList2() {
		genericList.add(5);
		assertEquals(1, genericList.getSize());
		assertEquals(genericList.getHead(), genericList.getTail());
		assertNotNull(genericList.getHead());
		assertNotNull(genericList.getTail());
	}
	
	@Test
	public void testGenericList3() {
		genericList.add(5);
		genericList.add(3);
		assertEquals(2, genericList.getSize());
		assertNotEquals(genericList.getHead(), genericList.getTail());
		assertEquals(5, (genericList.getHead()).intValue());
		assertEquals(3, (genericList.getTail()).intValue());
	}
	
	@Test
	public void testGenericList4() {
		genericList.add(5);
		genericList.add(3);
		genericList.add(7);
		genericList.delete(3);
		assertEquals(2, genericList.getSize());
		assertNotEquals(genericList.getHead(), genericList.getTail());
		assertEquals(5, (genericList.getHead()).intValue());
		assertEquals(7, (genericList.getTail()).intValue());
	}
	
	@Test
	public void testGenericList5() {
		assertEquals(0, genericList.getSize());
		genericList.delete(1);
		assertEquals(0, genericList.getSize());
		assertEquals(genericList.getHead(), genericList.getTail());
		assertNull(genericList.getHead());
		assertNull(genericList.getTail());		
	}
	
	@Test
	public void testGenericList6() {
		genericList.add(1);
		genericList.add(2);
		genericList.add(3);
		genericList.add(4);
		genericList.add(5);
		//assertNull(genericList.getCurrent());
		assertNotNull(genericList.getHead());
		assertEquals(genericList.getHead(), genericList.getCurrent());
		assertEquals(1, genericList.getCurrent().intValue());
		genericList.next();
		assertEquals(2, genericList.getCurrent().intValue());
		genericList.next();
		assertEquals(3, genericList.getCurrent().intValue());
		genericList.next();
		assertEquals(4, genericList.getCurrent().intValue());
		genericList.next();
		assertEquals(5, genericList.getCurrent().intValue());
		assertEquals(genericList.getTail(), genericList.getCurrent());
		genericList.next();
		assertEquals(genericList.getTail(), genericList.getCurrent());
	}
	
	@Test
	public void testGenericStack1() {
		assertNull(genericStack.pop());
		assertNull(genericStack.getCurrent());
	}
	
	@Test
	public void testGenericStack2() {
		genericStack.push(swordman);
		assertEquals("Emanie", genericStack.getCurrent().getName());
		assertEquals(swordman, genericStack.getCurrent());
	}
	
	@Test
	public void testGenericStack3() {
		genericStack.push(swordman);
		genericStack.push(archer);
		genericStack.push(npc1);
		assertEquals("¿Que te arreglo?", ((NPC)genericStack.getCurrent()).getSpeech());
	}
	
	@Test
	public void testGenericStack4() {
		genericStack.push(npc1);
		genericStack.push(swordman);
		genericStack.push(archer);		
		assertEquals("Légolas", genericStack.getCurrent().getName());
		assertEquals(archer, genericStack.pop());
		assertEquals("Emanie", genericStack.getCurrent().getName());
		assertEquals(swordman, genericStack.pop());
		assertEquals("Blacksmith", genericStack.getCurrent().getName());
		assertEquals(npc1, genericStack.pop());
		assertNull(genericStack.pop());
		assertNull(genericStack.getCurrent());
		assertNull(genericStack.pop());
		assertNull(genericStack.getCurrent());
		assertNull(genericStack.pop());
	}
	
	@Test
	public void testGenericStack5() {
		genericStack.push(archer);		
		assertEquals("Légolas", genericStack.getCurrent().getName());
		assertEquals(archer, genericStack.pop());
		assertNull(genericStack.pop());
		assertNull(genericStack.getCurrent());		
		genericStack.push(npc1);
		genericStack.push(swordman);		
		assertEquals("Emanie", genericStack.getCurrent().getName());
		assertEquals(swordman, genericStack.pop());
		assertEquals("Blacksmith", genericStack.getCurrent().getName());
		assertEquals(npc1, genericStack.pop());		
		assertNull(genericStack.pop());
		assertNull(genericStack.getCurrent());
		assertNull(genericStack.pop());		
		genericStack.push(archer);		
		assertEquals("Légolas", genericStack.getCurrent().getName());
	}
	
	@Test
	public void testGenericQueue1() {
		assertTrue(genericQueue.isEmpty());
		assertTrue(genericQueue.size() == 0);
		assertNull(genericQueue.dequeue());
	}
	
	@Test
	public void testGenericQueue2() {
		genericQueue.enqueue(swordman);
		assertFalse(genericQueue.isEmpty());
		assertTrue(genericQueue.size() == 1);
		Player player = (Player) genericQueue.dequeue();
		assertEquals("Emanie", player.getName());
		assertTrue(genericQueue.isEmpty());
		assertTrue(genericQueue.size() == 0);
		assertNull(genericQueue.dequeue());
	}
	
	@Test
	public void testGenericQueue3() {
		genericQueue.enqueue(swordman);
		genericQueue.enqueue(archer);
		genericQueue.enqueue(npc1);
		assertEquals("Emanie", genericQueue.dequeue().getName());
		assertEquals("Légolas", genericQueue.dequeue().getName());
		assertEquals("Blacksmith", genericQueue.dequeue().getName());
		assertNull(genericQueue.dequeue());
	}
	
	@Test
	public void testGenericQueue4() {
		genericQueue.enqueue(swordman);
		genericQueue.enqueue(archer);
		genericQueue.enqueue(npc1);
		
		assertEquals("Emanie", genericQueue.dequeue().getName());
		assertEquals("Légolas", genericQueue.dequeue().getName());
		
		genericQueue.enqueue(npc2);
		assertEquals("Blacksmith", genericQueue.dequeue().getName());
		
		genericQueue.enqueue(swordman);
		assertEquals("Archer", genericQueue.dequeue().getName());
		
		assertEquals("Emanie", genericQueue.dequeue().getName());
		
		assertNull(genericQueue.dequeue());
		assertNull(genericQueue.dequeue());
	}
	
	@Test
	public void testGenericHashTable1() {
		assertNull(genericHashTable.remove(swordman.getName()));
		assertNull(genericHashTable.search(swordman.getName()));
		assertTrue(genericHashTable.size() == 0);
	}
	
	@Test(expected=NullPointerException.class)
	public void testGenericHashTable2() {
		genericHashTable.put(null, swordman);
	}
	
	@Test(expected=NullPointerException.class)
	public void testGenericHashTable3() {
		genericHashTable.put(swordman.getName(), null);
	}
	
	@Test
	public void testGenericHashTable4() {
		genericHashTable.put(swordman.getName(), swordman);
		genericHashTable.put(archer.getName(), archer);
		assertEquals(2, genericHashTable.size());
		genericHashTable.put(npc1.getName(), npc1);
		genericHashTable.put(npc2.getName(), npc2);
		assertEquals(4, genericHashTable.size());
		genericHashTable.put(npc1.getName(), npc1);
		genericHashTable.put(npc2.getName(), npc2);
		assertEquals(6, genericHashTable.size());
	}
	
	@Test
	public void testGenericHashTable5() {
		genericHashTable.put(swordman.getName(), swordman);
		genericHashTable.put(archer.getName(), archer);
		assertEquals(2, genericHashTable.size());
		Player player = ((Player)genericHashTable.search(swordman.getName()));
		assertEquals("Emanie", player.getName());
		assertEquals(2, genericHashTable.size());
		player = ((Player)genericHashTable.search("Légolas"));
		assertEquals("Légolas", player.getName());
		assertEquals(2, genericHashTable.size());
	}
	
	@Test
	public void testGenericHashTable6() {
		genericHashTable.put(swordman.getName(), swordman);
		genericHashTable.put(npc1.getName(), npc1);
		assertEquals(2, genericHashTable.size());
		Player player = ((Player)genericHashTable.remove(swordman.getName()));
		assertEquals("Emanie", player.getName());
		assertEquals(1, genericHashTable.size());
		player = ((Player)genericHashTable.remove("House"));
		assertNull(player);
		assertEquals(1, genericHashTable.size());
		NPC npc = ((NPC)genericHashTable.remove(npc1.getName()));
		assertEquals("Blacksmith", npc.getName());
		assertEquals(0, genericHashTable.size());
		assertNull(genericHashTable.remove(swordman.getName()));
		assertNull(genericHashTable.remove(archer.getName()));
		assertNull(genericHashTable.remove(npc1.getName()));
		assertNull(genericHashTable.remove("Test"));
	}
	
	@Test
	public void testGenericHashTable7() {
		genericHashTable.put(swordman.getName(), swordman);
		genericHashTable.put(archer.getName(), archer);
		assertEquals(2, genericHashTable.size());
		Player player = ((Player)genericHashTable.remove(swordman.getName()));
		assertEquals("Emanie", player.getName());
		assertEquals(1, genericHashTable.size());
		player = ((Player)genericHashTable.remove("Légolas"));
		assertEquals("Légolas", player.getName());
		assertEquals(0, genericHashTable.size());

		genericHashTable.put(archer.getName(), archer);
		assertEquals(1, genericHashTable.size());
		genericHashTable.put(swordman.getName(), swordman);
		assertEquals(2, genericHashTable.size());
		genericHashTable.put(npc1.getName(), npc1);
		assertEquals(3, genericHashTable.size());
	}
	
	/**
	 * Collection 1 - LinkedList
	 */
	
	@Test
	public void testAngeling1() {
		assertEquals(angeling.getName(), "Angeling");
	}
	
	@Test
	public void testAngeling2() {
		assertEquals(angeling.getX(), 3);
	}
	
	@Test
	public void testAngeling3() {
		assertEquals(angeling.getY(), 1);
	}
	
	@Test
	public void testAngeling4() {
		assertEquals(angeling.getRemainingLife(), 250);
	}
	
	@Test
	public void testAngeling5() {
		assertEquals(angeling.walk(), 1);
	}
	
	@Test(expected=NullPointerException.class)
	public void testAngeling6() throws LocationException {
		angeling.chase();
	}
	
	@Test
	public void testAngeling7() throws LocationException {
		assertEquals(null, angeling.getCurrentObjective());
		angeling.see(swordman);
		angeling.see(archer);
		angeling.chase();
		assertEquals(archer, angeling.getCurrentObjective());
	}
	
	@Test
	public void testAngeling8() throws LocationException {
		angeling.see(archer);
		angeling.see(swordman);
		angeling.chase();
		assertEquals(archer, angeling.getCurrentObjective());
		swordman.setX(10);
		swordman.setY(10);
		angeling.see(archer);
		angeling.see(swordman);
		archer.setX(1);
		archer.setY(1);
		angeling.chase();
		assertEquals(archer, angeling.getCurrentObjective());
		angeling.see(swordman);
		archer.setX(5);
		archer.setY(4);
		angeling.setX(6);
		angeling.setY(7);
		angeling.see(archer);
		angeling.chase();
		assertEquals(archer, angeling.getCurrentObjective());
	}
	
	@Test(expected=LocationException.class)
	public void testAngeling9() throws LocationException {
		angeling.setX(5);
		angeling.setY(5);
		angeling.see(swordman);
		angeling.chase();
	}
	
	@Test(expected=LocationException.class)
	public void testAngeling10() throws LocationException {
		swordman.setY(2);
		angeling.setY(3);
		angeling.see(swordman);
		angeling.chase();
		angeling.see(archer);
		angeling.chase();
		angeling.see(swordman);
		angeling.chase();
		angeling.see(swordman);
		angeling.chase();
	}
	
	@Test
	public void testCollection1LinkedList() {
		assertEquals(5, forest.getEnemies().size());
		assertEquals(1, city.getEnemies().size());
	}
	
	@Test
	public void testCollection2LinkedList() {
		forest.addEnemy(new Angeling((int)Math.random()*10, (int)Math.random()*10));
		forest.addEnemy(new Angeling((int)Math.random()*10, (int)Math.random()*10));
		forest.addEnemy(new Deviling((int)Math.random()*10, (int)Math.random()*10));
		forest.addEnemy(new Deviling((int)Math.random()*10, (int)Math.random()*10));
		
		assertEquals(9, forest.getEnemies().size());
		
		city.addEnemy(new Angeling((int)Math.random()*10, (int)Math.random()*10));
		city.addEnemy(new Angeling((int)Math.random()*10, (int)Math.random()*10));
		city.addEnemy(new Deviling((int)Math.random()*10, (int)Math.random()*10));
		city.addEnemy(new Deviling((int)Math.random()*10, (int)Math.random()*10));
		assertEquals(5, city.getEnemies().size());
	}
	
	@Test
	public void testCollection3LinkedList() {
		forest.clearEnemies();		
		assertEquals(0, forest.getEnemies().size());
		forest.restoreEnemies();
		
		city.clearEnemies();
		assertEquals(0, city.getEnemies().size());
	}
	
	/**
	 * Collection 2 - HashSet
	 */
	@Test
	public void testCollection1HashSet() {
		assertEquals(0, city.getPlayers().size());
		assertFalse(city.containsPlayer(swordman));
		assertFalse(city.removePlayer(swordman));
		assertFalse(city.containsPlayer(archer));
		assertFalse(city.removePlayer(archer));		
		assertEquals(0, city.getPlayers().size());
		city.addPlayer(swordman);
		city.addPlayer(archer);
		assertEquals(2, city.getPlayers().size());
		assertTrue(city.containsPlayer(archer));
		assertTrue(city.removePlayer(archer));
		assertEquals(1, city.getPlayers().size());
	}
	
}