Last active
May 11, 2017 10:46
-
-
Save gonzalezgarciacristian/b0711ff32ab52ec695a1ab1606b18dbb to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
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.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 GenericUnitTest { | |
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; | |
public GenericUnitTest() { | |
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); | |
} | |
/** | |
* 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.setPlayer(swordman); | |
assertEquals(city.getPlayer().getName(), "Emanie"); | |
} | |
@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()); | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment