Merge branch 'persona' into 'develop'

Persona

See merge request !1

.classpath

@@ -6,7 +6,6 @@
 			<attribute name="maven.pomderived" value="true"/>
 		</attributes>
 	</classpathentry>
-	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>
 	<classpathentry kind="con" path="org.eclipse.m2e.MAVEN2_CLASSPATH_CONTAINER">
 		<attributes>
 			<attribute name="maven.pomderived" value="true"/>

src/main/java/inf/uva/es/ivagonz/practica4/ColaDeAmigos.java

+package inf.uva.es.ivagonz.practica4;
+
+import java.util.ArrayList;
+
+/**
+ * Implementación de una Cola de amigos para la última práctica de la asignatura
+ * TDS.
+ * 
+ * @author ivagonz.
+ *
+ */
+public class ColaDeAmigos {
+
+	/**
+	 * Constructor que recibe una lista, que simboliza las personas que hay al
+	 * comienzo.
+	 * 
+	 * @param cola
+	 *            Lista que contiene las personas iniciales. Debe ser correcta:
+	 *            No nula y no puede contener elementos nulos.
+	 * @throws IllegalArgumentException
+	 *             si se incumple alguna de las condiciones impuestas al
+	 *             parámetro.
+	 */
+	public ColaDeAmigos(ArrayList<Persona> cola) {
+		// TODO Auto-generated constructor stub
+	}
+
+	/**
+	 * 
+	 * @return lista que simboliza la cola de la cola de amigos.
+	 */
+	public ArrayList<Persona> getCola() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	/**
+	 * Dado un identificador de una Persona que está en la cola, devolverá la
+	 * cantidad de amigos para los que dijo que guardaba sitio al entrar.
+	 * 
+	 * @param id
+	 *            identificador de la Persona que se quiere saber la cantidad de
+	 *            amigos para los que revervó sitio. Debe ser correcto: Positivo
+	 *            y debe haber una Persona con ese id en la cola.
+	 * @return cantidad de amigos asociados al id para los que se reservó sitio
+	 *         en la cola.
+	 * @throws IllegalArgumentException
+	 *             si se incumple alguna de las condiciones impuestas al
+	 *             parámetro.
+	 */
+	public int reservasParaAmigos(int id) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	/**
+	 * Dado un identificador de una Persona que está en la cola, devolverá la
+	 * cantidad de amigos que esa Persona puede colar aún.
+	 * 
+	 * @param id
+	 *            identificador de la Persona que se quiere saber la cantidad de
+	 *            amigos que puede colar. Debe ser correcto: Positivo y debe
+	 *            estar en la cola.
+	 * @return cantidad de amigos que aún puede colar la Persona que coincide
+	 *         con el id pasado como parámetro.Debe ser correcto: Positivo y
+	 *         debe haber una Persona con ese id en la cola.
+	 * @throws IllegalArgumentException
+	 *             si se incumple alguna de las condiciones impuestas al
+	 *             parámetro.
+	 */
+	public int amigosPorColar(int id) {
+		// TODO Auto-generated method stub
+		return 0;
+	}
+
+	/**
+	 * Dado un identificador de una Persona, se obtendrán cuales de los que
+	 * están por delante de dicha Persona son los amigos para los que pidió vez
+	 * al entrar en la cola.
+	 * 
+	 * @param id
+	 *            Identificador de la Persona que se quiere saber la
+	 *            información. Debe ser correcto: Positivo y debe haber una
+	 *            Persona con ese id en la cola.
+	 * @return Lista con los amigos que están por delante de la Persona a la que
+	 *         pertenece el id.
+	 * @throws IllegalArgumentException
+	 *             si se incumple alguna de las condiciones impuestas al
+	 *             parámetro.
+	 */
+	public ArrayList<Persona> amigosPorDelante(int id) {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	/**
+	 * @return obtiene la siguiente Persona a atender en la cola según el
+	 *         orden(la primera)
+	 */
+	public Persona getSiguiente() {
+		// TODO Auto-generated method stub
+		return null;
+	}
+
+	/**
+	 * Atiende a la Persona que está en la primera posición de la cola, es
+	 * decir, la quita.
+	 */
+	public void atender() {
+		// TODO Auto-generated method stub
+
+	}
+
+	/**
+	 * Dada una persona, se le introducirá al final de la cola y se reservará
+	 * sitio para una cantidad determinada de amigos, sin posibilidad de
+	 * reservar para más que los que dice al entrar en la cola.
+	 * 
+	 * @param persona
+	 *            Persona que entra en la cola. Debe ser correcta: No null, no
+	 *            puede estar ya en la cola y no puede tener el mismo id que una
+	 *            Persona que esté ya en la cola.
+	 * @param maxAmigos
+	 *            Cantidad máxima de amigos que puede colar this. Debe ser
+	 *            correcto: Positivo y menor de 10.
+	 * @throws IllegalArgumentException
+	 *             en caso de incumplir alguna de las condiciones impuestas a
+	 *             los parámetros.
+	 */
+	public void pedirVez(Persona persona, int maxAmigos) {
+		// TODO Auto-generated method stub
+
+	}
+
+	/**
+	 * Dada una persona la colará en la cola siempre que cumpla unas condiciones
+	 * que pondremos a continuación.
+	 * 
+	 * @param persona
+	 *            Persona que se va a colar en la cola.Debe cumplir lo
+	 *            siguiente: No debe ser null, no debe estar ya en la cola, debe
+	 *            tener un amigo que esté en la cola, y que este a su vez lo
+	 *            tenga como amigo, su amigo debe haber reservado sitio, su
+	 *            amigo debe poder colar aún a gente.
+	 * @throws IllegalArgumentException
+	 *             si se incumple alguna de las condiones puestas al parámetro.
+	 */
+	public void colarse(Persona persona) {
+		// TODO Auto-generated method stub
+
+	}
+
+}

src/main/java/inf/uva/es/ivagonz/practica4/Persona.java

 package inf.uva.es.ivagonz.practica4;
 
+import java.util.ArrayList;
+
+/**
+ * Implementación de una Persona para poder llevar a cabo la funcionalidad de
+ * una cola de amigos.
+ * 
+ * @author ivan
+ *
+ */
 public class Persona {
 
-	public Persona(String nombre) {
-		// TODO Auto-generated constructor stub
+	private String nombre;
+	private int id;
+	private ArrayList<Persona> amigos;
+	private ArrayList<Persona> conocidos;
+	private int maxAmigos;
+	private int amigosPorColar;
+
+	/**
+	 * Constructor parametrizado de la clase Persona en el que se espifica lo
+	 * siguiente. Como aclaración, una Persona puede hacer amigos en la cola,
+	 * pero para que alguien se amigo de this, primero tiene que ser conocido.
+	 * 
+	 * @param nombre
+	 *            Nombre de una Persona. Debe ser correcto: Distinto de cadena
+	 *            vacía y no nulo. No contemplamos la posibilidad de que
+	 *            contenga números o caracteres extraños.
+	 * @param id
+	 *            Identificador de una Persona. Debe ser correcto: Positivo.
+	 * @param amigos
+	 *            Lista de amigos de this. Debe ser correcta: No nula y no
+	 *            contener elementos nulos.
+	 * @param conocidos
+	 *            Lista de conocidos de this. Debe ser correcta: No nula y no
+	 *            contener elementos nulos.
+	 * @throws IllegalArgumentException
+	 *             si se incumple alguna de las condiciones impuestas a los
+	 *             parámetros.
+	 */
+	public Persona(String nombre, int id, ArrayList<Persona> amigos, ArrayList<Persona> conocidos) {
+		if (nombre == null)
+			throw new IllegalArgumentException("El nombre no puede ser null.");
+		if (nombre.equals(""))
+			throw new IllegalArgumentException("El nombre no puede ser cadena vacía.");
+		if (id < 0)
+			throw new IllegalArgumentException("El identificador de la Persona no puede ser negativo.");
+		if (amigos == null)
+			throw new IllegalArgumentException("La lista de amigos no puede ser nula.");
+		if (hasElementoNull(amigos))
+			throw new IllegalArgumentException("La lista de amigos no puede contener elementos nulos.");
+		if (conocidos == null)
+			throw new IllegalArgumentException("La lista de conocidos no puede ser nula.");
+		if (hasElementoNull(conocidos))
+			throw new IllegalArgumentException("La lista de conocidos no puede contener elementos nulos.");
+		this.nombre = nombre;
+		this.id = id;
+		this.amigos = amigos;
+		this.conocidos = conocidos;
+		maxAmigos = 0;
+		amigosPorColar = maxAmigos;
+	}
+
+	/**
+	 * Comprueba si la lista pasada como parámetro tiene elementos nulos.
+	 * 
+	 * @param lista
+	 *            ArrayList a comprobar si tiene elementos nulos.Debe ser
+	 *            correcto: no nulo.
+	 * @return true si hay algún elemento nulo, false en caso contrario.
+	 */
+	public boolean hasElementoNull(ArrayList<Persona> lista) {
+		if (lista == null)
+			throw new IllegalArgumentException("La lista no puede ser nula.");
+		for (int i = 0; i < lista.size(); i++) {
+			if (lista.get(i) == null)
+				return true;
+		}
+		return false;
+	}
+
+	/**
+	 * Método que agregará una Persona que conoce this.
+	 * 
+	 * @param persona
+	 *            Persona que this ha conocido. Debe ser correcta: No ser null,
+	 *            no estar ya en la lista de conocidos y no tener el mismo id
+	 *            que this.
+	 * @throws IllegalArgumentException
+	 *             si se incumple alguna de las condiciones impuestas al
+	 *             parámetro.
+	 */
+	public void addConocido(Persona persona) {
+		if (persona == null)
+			throw new IllegalArgumentException("La persona no puede ser nula.");
+		if (persona.getId() == id)
+			throw new IllegalArgumentException("La persona no puede tener el mismo id que this.");
+		if (isConocido(persona))
+			throw new IllegalArgumentException("La persona no puede ser ya un conocido.");
+		conocidos.add(persona);
+	}
+
+	/**
+	 * Comprobará si una Persona es conocido de this.
+	 * 
+	 * @param persona
+	 *            Persona que puede ser conocido o no de this. Debe ser
+	 *            correcto: No null.
+	 * @return true si la persona es conocido de this, false en caso contrario.
+	 * @throws IllegalArgumentException
+	 *             si se incumple alguna de las condiciones impuestas al
+	 *             parámetro.
+	 */
+
+	public boolean isConocido(Persona persona) {
+		if (persona == null)
+			throw new IllegalArgumentException("La persona no puede ser nula.");
+		return getConocidos().contains(persona);
+	}
+
+	/**
+	 * Método que agregará un amigo de this.
+	 * 
+	 * @param persona
+	 *            Persona que se ha hecho amiga de this. Debe ser correcto: No
+	 *            ser null, debe estar en la lista de conocidos y no debe estar
+	 *            ya en la lista de amigos.
+	 * @throws IllegalArgumentException
+	 *             si se incumple alguna de las condiciones impuestas al
+	 *             parámetro.
+	 */
+	public void addAmigo(Persona persona) {
+		if (persona == null)
+			throw new IllegalArgumentException("La Persona no puede ser null.");
+		if (!isConocido(persona))
+			throw new IllegalArgumentException("La Persona debe ser un conocido.");
+		if (isAmigo(persona))
+			throw new IllegalArgumentException("La Persona no puede ser ya un amigo.");
+		getAmigos().add(persona);
+		getConocidos().remove(persona);
+
+	}
+
+	/**
+	 * Comprueba si el parámetro es amigo de this.
+	 * 
+	 * @param p
+	 *            Persona que puede o no ser amigo de this. Debe ser correcto:
+	 *            No null.
+	 * @return true si p es amigo de this, false en caso contrario.
+	 * @throws IllegalArgumentException
+	 *             si se incumple alguna de las condiciones impuestas al
+	 *             parámetro.
+	 */
+	public boolean isAmigo(Persona persona) {
+		if (persona == null)
+			throw new IllegalArgumentException("La Persona no puede ser null.");
+		return getAmigos().contains(persona);
+	}
+
+	/**
+	 * Borra un amigo de this y lo vuelve a pasar a conocidos.
+	 * 
+	 * @param persona
+	 *            Amigo a borrar de la lista de amigos. Debe ser correcto: No
+	 *            null, debe estar en la lista de amigos.
+	 * @throws IllegalArgumentException
+	 *             si se incumple alguna de las condiciones impuestas al
+	 *             parámetro.
+	 */
+	public void removeAmigo(Persona persona) {
+		if (persona == null)
+			throw new IllegalArgumentException("La persona no puede ser null.");
+		if (!isAmigo(persona))
+			throw new IllegalArgumentException("La persona debe ser un amigos.");
+		getAmigos().remove(persona);
+		getConocidos().add(persona);
+
+	}
+
+	public String getNombre() {
+		return nombre;
+	}
+
+	public int getId() {
+		return id;
+	}
+
+	/**
+	 * 
+	 * @return numero maximo de amigos que puede colar this.
+	 */
+	public int getMaxAmigos() {
+		return maxAmigos;
+	}
+
+	/**
+	 * Cambia la cantidad máxima de amigos que puede colar this.
+	 * 
+	 * @param maxAmigos
+	 *            cantidad de amigos a colar. Debe ser correcta: Mayor o igual a
+	 *            0 y menor o igual de 10.
+	 * @throws IllegalArgumentException
+	 *             si se incumple alguna de las condiciones impuestas al
+	 *             parámetro.
+	 */
+	public void setMaxAmigos(int maxAmigos) {
+		if (maxAmigos < 0)
+			throw new IllegalArgumentException("El identificador debe ser positivo.");
+		if (maxAmigos > 10)
+			throw new IllegalArgumentException("El identificador debe ser menor de 10.");
+		this.maxAmigos = maxAmigos;
+		amigosPorColar = maxAmigos;
+	}
+
+	/**
+	 * 
+	 * @return cantidad de amigos que aún puede colar this.
+	 */
+	public int getAmigosPorColar() {
+		return amigosPorColar;
+	}
+
+	/**
+	 * @return lista de amigos de this.
+	 */
+	public ArrayList<Persona> getAmigos() {
+		return amigos;
+	}
+
+	/**
+	 * 
+	 * @return lista de conocidos de this.
+	 */
+	public ArrayList<Persona> getConocidos() {
+		return conocidos;
 	}
 
 }

src/test/java/inf/uva/es/ivagonz/practica4/AllPersonaTest.java

+package inf.uva.es.ivagonz.practica4;
+
+import org.junit.runner.RunWith;
+import org.junit.runners.Suite;
+import org.junit.runners.Suite.SuiteClasses;
+
+@RunWith(Suite.class)
+@SuiteClasses({ PersonaConstructorTDDTest.class, PersonaGettersTDDTest.class, PersonaOperacionesTDDTest.class,
+		PersonaOperacionesAMayoresTest.class })
+public class AllPersonaTest {
+
+}

src/test/java/inf/uva/es/ivagonz/practica4/ColaDeAmigosTDDTest.java

+package inf.uva.es.ivagonz.practica4;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+
+import org.junit.Test;
+
+public class ColaDeAmigosTDDTest {
+
+	@Test
+	public void constructorCorrectoTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		assertEquals(colaInicial, colaDeAmigos.getCola());
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructorConColaInicialNullTest() {
+		@SuppressWarnings("unused")
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(null);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructorConElementoNullEnColaInicialTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		colaInicial.add(null);
+		@SuppressWarnings("unused")
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+	}
+
+	@Test
+	public void getColaCorrectoTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		assertEquals(colaInicial, colaDeAmigos.getCola());
+	}
+
+	@Test
+	public void reservasParaAmigosCorrectoTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		p.setMaxAmigos(5);
+		colaInicial.add(p);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.reservasParaAmigos(1);
+		assertEquals(5, colaDeAmigos.reservasParaAmigos(1));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void reservasParaAmigosConIdDePersonaNegativoTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		p.setMaxAmigos(5);
+		colaInicial.add(p);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.reservasParaAmigos(-1);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void reservasParaAmigosConIdDePersonaQueNoEstaEnLaColaTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.reservasParaAmigos(1);
+	}
+
+	@Test
+	public void amigosPorColarCorrectoTest() {
+		fail("Quitar en implementación");
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		p.setMaxAmigos(5);
+		colaInicial.add(p);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.amigosPorColar(1);
+		assertEquals(p.getAmigosPorColar(), colaDeAmigos.amigosPorColar(1));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void amigosPorColarConIdDePersonaNegativoTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		p.setMaxAmigos(5);
+		colaInicial.add(p);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.amigosPorColar(-1);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void amigosPorColarConIdDePersonaQueNoEstaEnLaColaTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.amigosPorColar(1);
+	}
+
+	@Test
+	public void amigosPorDelanteCorrectoTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		ArrayList<Persona> amigos = new ArrayList<Persona>();
+		Persona amigo = new Persona("Manu", 2, new ArrayList<Persona>(), new ArrayList<Persona>());
+		amigos.add(amigo);
+		Persona p = new Persona("Pepe", 1, amigos, new ArrayList<Persona>());
+		colaInicial.add(p);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.amigosPorDelante(1);
+		assertEquals(amigos, colaDeAmigos.amigosPorDelante(1));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void amigosPorDelanteConIdDePersonaNegativoTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		colaInicial.add(p);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.amigosPorDelante(-1);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void amigosPorDelanteConIdDePersonaQueNoEstaEnLaColaTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.amigosPorDelante(1);
+	}
+
+	@Test
+	public void getSiguienteCorrectoTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		colaInicial.add(p);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		Persona siguiente = colaDeAmigos.getSiguiente();
+		assertEquals(p, siguiente);
+	}
+
+	@Test
+	public void atenderCorrectoTest() {
+		fail("Quitar en implementación");
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		colaInicial.add(p);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.atender();
+	}
+
+	@Test
+	public void pedirVezCorrectoTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.pedirVez(p, 5);
+		assertEquals(5, p.getMaxAmigos());
+		assertEquals(p, colaDeAmigos.getCola().get(colaDeAmigos.getCola().size() - 1));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void pedirVezConPersonaNullTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.pedirVez(null, 5);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void pedirVezConPersonaQueYaEstaEnLaColaTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		colaInicial.add(p);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.pedirVez(p, 5);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void pedirVezConPersonaQueTieneMismoIdQuePersonaQueEstaEnLaColaTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		colaInicial.add(p);
+		Persona p2 = new Persona("Manu", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.pedirVez(p2, 5);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void pedirVezConCantidadAReservarNegativaTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.pedirVez(p, -1);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void pedirVezConCantidadAReservarMayorDeDiezTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.pedirVez(p, 11);
+	}
+
+	@Test
+	public void colarseCorrectoTest() {
+		fail("Quitar en implementación");
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		Persona p2 = new Persona("Manu", 2, new ArrayList<Persona>(), new ArrayList<Persona>());
+		colaInicial.add(p);
+
+		p.getConocidos().add(p2);
+		p.getAmigos().add(p2);
+		p2.getConocidos().add(p);
+		p2.getAmigos().add(p);
+
+		p.setMaxAmigos(2);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.colarse(p2);
+		assertEquals(p2, colaDeAmigos.getCola().get(colaDeAmigos.getCola().indexOf(p) - 1));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void colarseConPersonaNullTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.colarse(null);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void colarseConPersonaQueYaEstaEnLaColaTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		colaInicial.add(p);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.colarse(p);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void colarseConPersonaQueTieneAOtroComoAmigoQueNoLoTieneAElTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		Persona p = new Persona("Pepe", 1, new ArrayList<Persona>(), new ArrayList<Persona>());
+		ArrayList<Persona> conocidos = new ArrayList<Persona>();
+		ArrayList<Persona> amigos = new ArrayList<Persona>();
+		Persona p2 = new Persona("Manu", 2, amigos, conocidos);
+		colaInicial.add(p);
+		conocidos.add(p);
+		amigos.add(p);
+		colaDeAmigos.colarse(p2);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void colarseConPersonaQueTieneAmigoQueNoHaReservadoTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		ArrayList<Persona> amigos = new ArrayList<Persona>();
+		ArrayList<Persona> conocidos = new ArrayList<Persona>();
+		ArrayList<Persona> amigos2 = new ArrayList<Persona>();
+		ArrayList<Persona> conocidos2 = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, amigos, conocidos);
+		Persona p2 = new Persona("Manu", 2, amigos2, conocidos2);
+		colaInicial.add(p);
+		conocidos.add(p2);
+		amigos.add(p2);
+		conocidos2.add(p);
+		amigos2.add(p);
+
+		p.setMaxAmigos(0);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.colarse(p2);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void colarseConPersonaQueTieneAmigoQueNoPuedeColarAMasAmigosTest() {
+		ArrayList<Persona> colaInicial = new ArrayList<Persona>();
+		ArrayList<Persona> amigos = new ArrayList<Persona>();
+		ArrayList<Persona> conocidos = new ArrayList<Persona>();
+		ArrayList<Persona> amigos2 = new ArrayList<Persona>();
+		ArrayList<Persona> conocidos2 = new ArrayList<Persona>();
+		ArrayList<Persona> amigos3 = new ArrayList<Persona>();
+		ArrayList<Persona> conocidos3 = new ArrayList<Persona>();
+		Persona p = new Persona("Pepe", 1, amigos, conocidos);
+		Persona p2 = new Persona("Manu", 2, amigos2, conocidos2);
+		Persona p3 = new Persona("Manu", 3, amigos3, conocidos3);
+
+		colaInicial.add(p);
+
+		conocidos.add(p2);
+		conocidos.add(p3);
+		amigos.add(p2);
+		amigos.add(p3);
+
+		conocidos2.add(p);
+		amigos2.add(p);
+
+		conocidos3.add(p);
+		conocidos3.add(p);
+
+		p.setMaxAmigos(1);
+		ColaDeAmigos colaDeAmigos = new ColaDeAmigos(colaInicial);
+		colaDeAmigos.colarse(p3);
+		colaDeAmigos.colarse(p2);
+	}
+
+}

src/test/java/inf/uva/es/ivagonz/practica4/EjemploTest.java

-package inf.uva.es.ivagonz.practica4;
-
-import static org.junit.Assert.*;
-
-import org.junit.Test;
-
-public class EjemploTest {
-
-	@Test
-	public void constructorCorrectoTest() {
-		//fail("Not yet implemented");
-		String nombre = "pepe";
-		Persona p = new Persona(nombre);
-	}
-
-}

src/test/java/inf/uva/es/ivagonz/practica4/PersonaConstructorTDDTest.java

+package inf.uva.es.ivagonz.practica4;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+public class PersonaConstructorTDDTest {
+
+	private String nombre;
+	private int id;
+	private ArrayList<Persona> amigos;
+	private ArrayList<Persona> conocidos;
+
+	@Before
+	public void setUp() {
+		nombre = "Pepe";
+		id = 1;
+		amigos = new ArrayList<Persona>();
+		conocidos = new ArrayList<Persona>();
+	}
+
+	@After
+	public void tearDown() {
+		nombre = null;
+		id = 0;
+		amigos = null;
+		conocidos = null;
+	}
+
+	@Test
+	public void constructorCorrectoTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+
+		assertEquals(nombre, p.getNombre());
+		assertEquals(id, p.getId());
+		assertEquals(amigos, p.getAmigos());
+		assertEquals(conocidos, p.getConocidos());
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructorConNombreCadenaVaciaTest() {
+		nombre = "";
+		@SuppressWarnings("unused")
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructorConNombreNullTest() {
+		@SuppressWarnings("unused")
+		Persona p = new Persona(null, id, amigos, conocidos);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructorConIdNegativoTest() {
+		id = -1;
+		@SuppressWarnings("unused")
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructorConListaDeAmigosNullTest() {
+		amigos = null;
+		@SuppressWarnings("unused")
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructorConListaDeAmigosConElementoNullTest() {
+		amigos.add(null);
+		@SuppressWarnings("unused")
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructorConListaDeConocidosNullTest() {
+		conocidos = null;
+		@SuppressWarnings("unused")
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void constructorConListaDeConocidosConElementoNullTest() {
+		conocidos.add(null);
+		@SuppressWarnings("unused")
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+	}
+
+}

src/test/java/inf/uva/es/ivagonz/practica4/PersonaGettersTDDTest.java

+package inf.uva.es.ivagonz.practica4;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class PersonaGettersTDDTest {
+
+	private String nombre;
+	private int id;
+	private ArrayList<Persona> amigos;
+	private ArrayList<Persona> conocidos;
+
+	@Before
+	public void setUp() {
+		nombre = "Pepe";
+		id = 1;
+		amigos = new ArrayList<Persona>();
+		conocidos = new ArrayList<Persona>();
+	}
+
+	@After
+	public void tearDown() {
+		nombre = null;
+		id = 0;
+		amigos = null;
+		conocidos = null;
+	}
+
+	@Test
+	public void getNombreCorrectoTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		assertEquals(nombre, p.getNombre());
+	}
+
+	@Test
+	public void getIdCorrectoTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		assertEquals(id, p.getId());
+
+	}
+
+	@Test
+	public void getMaxAmigosCorrectoTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.setMaxAmigos(5);
+		assertEquals(5, p.getMaxAmigos());
+	}
+
+	public void getAmigosPorColarCorrectoTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		int amigosPorColar = p.getMaxAmigos();
+		assertEquals(amigosPorColar, p.getAmigosPorColar());
+	}
+
+	@Test
+	public void getAmigosCorrectoTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		assertEquals(amigos, p.getAmigos());
+	}
+
+	@Test
+	public void getConocidosCorrectoTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		assertEquals(conocidos, p.getConocidos());
+	}
+
+	@Test
+	public void setMaxAmigosCorrectoTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.setMaxAmigos(2);
+		assertEquals(2, p.getMaxAmigos());
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void setMaxAmigosConNumeroNegativoTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.setMaxAmigos(-1);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void setMaxAmigosConNumeroMayorDeDiezTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.setMaxAmigos(11);
+	}
+
+}

src/test/java/inf/uva/es/ivagonz/practica4/PersonaOperacionesAMayoresTest.java

+package inf.uva.es.ivagonz.practica4;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class PersonaOperacionesAMayoresTest {
+
+	private String nombre;
+	private int id;
+	private ArrayList<Persona> amigos;
+	private ArrayList<Persona> conocidos;
+
+	@Before
+	public void setUp() {
+		nombre = "Pepe";
+		id = 1;
+		amigos = new ArrayList<Persona>();
+		conocidos = new ArrayList<Persona>();
+	}
+
+	@After
+	public void tearDown() {
+		nombre = null;
+		id = 0;
+		amigos = null;
+		conocidos = null;
+	}
+
+	@Test
+	public void hasElementoNullCorrectoTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.hasElementoNull(amigos);
+		assertFalse(p.hasElementoNull(amigos));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void hasAmigoNullConListaNullTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.hasElementoNull(null);
+	}
+
+}

src/test/java/inf/uva/es/ivagonz/practica4/PersonaOperacionesTDDTest.java

+package inf.uva.es.ivagonz.practica4;
+
+import static org.junit.Assert.*;
+
+import java.util.ArrayList;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+public class PersonaOperacionesTDDTest {
+
+	private String nombre;
+	private int id;
+	private ArrayList<Persona> amigos;
+	private ArrayList<Persona> conocidos;
+
+	@Before
+	public void setUp() {
+		nombre = "Pepe";
+		id = 1;
+		amigos = new ArrayList<Persona>();
+		conocidos = new ArrayList<Persona>();
+	}
+
+	@After
+	public void tearDown() {
+		nombre = null;
+		id = 0;
+		amigos = null;
+		conocidos = null;
+	}
+
+	@Test
+	public void addConocidoCorrecto() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		Persona p2 = new Persona("Manu", 2, amigos, conocidos);
+		p.addConocido(p2);
+		assertEquals(p2.getId(), p.getConocidos().get(p.getConocidos().size() - 1).getId());
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void addConocidoConPersonaNullTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.addConocido(null);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void addConocidoExistenteTest() {
+		Persona p2 = new Persona("Manu", 2, amigos, conocidos);
+		conocidos = new ArrayList<Persona>();
+		conocidos.add(p2);
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.addConocido(p2);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void addConocidoConMismoIdQueThisTest() {
+		Persona p2 = new Persona("Manu", id, amigos, conocidos);
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.addConocido(p2);
+	}
+
+	@Test
+	public void isConocidoCorrectoTest() {
+		Persona p2 = new Persona("Manu", 2, amigos, conocidos);
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.addConocido(p2);
+		p.isConocido(p2);
+		assertTrue(p.isConocido(p2));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void isConocidoConConocidoNullTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.isConocido(null);
+	}
+
+	@Test
+	public void addAmigoCorrectoTest() {
+		Persona p2 = new Persona("Manu", 2, amigos, conocidos);
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.addConocido(p2);
+		p.addAmigo(p2);
+		assertEquals(p2.getId(), p.getAmigos().get(p.getAmigos().size() - 1).getId());
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void addAmigoConPersonaNullTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.addAmigo(null);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void addAmigoExistenteTest() {
+		Persona p2 = new Persona("Manu", 2, amigos, conocidos);
+		amigos = new ArrayList<Persona>();
+		amigos.add(p2);
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.addConocido(p2);
+		p.addAmigo(p2);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void addAmigoQueNoEsConocidoTest() {
+		Persona p2 = new Persona("Manu", 2, amigos, conocidos);
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.addAmigo(p2);
+	}
+
+	@Test
+	public void isAmigoCorrectoTest() {
+		Persona p2 = new Persona("Manu", 2, amigos, conocidos);
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.addConocido(p2);
+		p.addAmigo(p2);
+		p.isAmigo(p2);
+		assertTrue(p.isAmigo(p2));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void isAmigoConAmigoNullTest() {
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.isAmigo(null);
+	}
+
+	@Test
+	public void removeAmigoCorrectoTest() {
+		Persona p2 = new Persona("Manu", 2, amigos, conocidos);
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.addConocido(p2);
+		p.addAmigo(p2);
+		p.removeAmigo(p2);
+		assertTrue(p.getConocidos().contains(p2));
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void removeAmigoConAmigoNullTest() {
+		Persona p2 = new Persona("Manu", 2, amigos, conocidos);
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.addConocido(p2);
+		p.addAmigo(p2);
+		p.removeAmigo(null);
+	}
+
+	@Test(expected = IllegalArgumentException.class)
+	public void removeAmigoConAmigoQueNoExisteTest() {
+		Persona p2 = new Persona("Manu", 2, amigos, conocidos);
+		Persona p = new Persona(nombre, id, amigos, conocidos);
+		p.addConocido(p2);
+		p.removeAmigo(p2);
+	}
+
+}