Skip to content
Snippets Groups Projects
Commit a61460d0 authored by sermigu's avatar sermigu
Browse files

hola

parents
Branches master
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
Showing
with 1890 additions and 0 deletions
.classpath 0 → 100644
+ 27
− 0
View file @ a61460d0
<?xml version="1.0" encoding="UTF-8"?>
<classpath>
<classpathentry kind="src" output="target/classes" path="src/main/java">
<attributes>
<attribute name="optional" value="true"/>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="src" output="target/test-classes" path="src/test/java">
<attributes>
<attribute name="optional" value="true"/>
<attribute name="maven.pomderived" value="true"/>
</attributes>
</classpathentry>
<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.8">
<attributes>
<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"/>
</attributes>
</classpathentry>
<classpathentry kind="output" path="target/classes"/>
</classpath>
.project 0 → 100644
+ 23
− 0
View file @ a61460d0
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>paraSonarQube2</name>
<comment></comment>
<projects>
</projects>
<buildSpec>
<buildCommand>
<name>org.eclipse.jdt.core.javabuilder</name>
<arguments>
</arguments>
</buildCommand>
<buildCommand>
<name>org.eclipse.m2e.core.maven2Builder</name>
<arguments>
</arguments>
</buildCommand>
</buildSpec>
<natures>
<nature>org.eclipse.m2e.core.maven2Nature</nature>
<nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>
.settings/org.eclipse.core.resources.prefs 0 → 100644
+ 4
− 0
View file @ a61460d0
eclipse.preferences.version=1
encoding//src/main/java=UTF-8
encoding//src/test/java=UTF-8
encoding/<project>=UTF-8
.settings/org.eclipse.jdt.core.prefs 0 → 100644
+ 5
− 0
View file @ a61460d0
eclipse.preferences.version=1
org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.8
org.eclipse.jdt.core.compiler.compliance=1.8
org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning
org.eclipse.jdt.core.compiler.source=1.8
.settings/org.eclipse.m2e.core.prefs 0 → 100644
+ 4
− 0
View file @ a61460d0
activeProfiles=
eclipse.preferences.version=1
resolveWorkspaceProjects=true
version=1
build.xml 0 → 100644
+ 102
− 0
View file @ a61460d0
<project name="paraSonarQube" default="compilar" basedir=".">
<description>
Fichero build de Ant con los objetivos de apoyo para el uso de maven
</description>
<!-- Properties -->
<property name="jacocoagent" location="target/coverage/jacoco.exec" />
<property environment="env"/>
<!-- Condiciones para el tratamiento de OS -->
<condition property="isWindows">
<os family="windows" />
</condition>
<condition property="isUnix">
<os family="unix" />
</condition>
<!-- Condicion para comprobar la existencia del agente -->
<condition property="jacoco-agent-present">
<available file="${jacocoagent}" />
</condition>
<!-- Objetivos -->
<!-- Objetivo compilar -->
<target name="compilar" description="obtiene dependencias y compila" depends="limpiar">
<exec dir="." executable="${executable}">
<arg line="${arglineIni} mvn compile test-compile ${arglineEnd}" />
</exec>
</target>
<!-- Objetivo ejecutarTodo -->
<target name="ejecutarTodo" depends="ejecutarTestsTDDyCajaNegra, ejecutarTestEnAislamiento" />
<!-- Objetivo ejecutarTestsTDDyCajaNegra -->
<target name="ejecutarTestsTDDyCajaNegra" description="pruebas TDD y de caja negra" depends="os-check">
<exec dir="." executable="${executable}">
<arg line="${arglineIni} mvn test -P Unit${arglineEnd}" />
</exec>
</target>
<!-- Objetivo ejecutarTestEnAislamiento -->
<target name="ejecutarTestEnAislamiento" description="pruebas de caja blanca en aislamiento" depends="os-check">
<exec dir="." executable="${executable}">
<arg line="${arglineIni} mvn test -P Isolation${arglineEnd}" />
</exec>
</target>
<!-- Objetivo ejecutarPruebasSecuencia -->
<target name="ejecutarPruebasSecuencia" description="caja negra, pruebas de secuencia" depends="os-check">
<exec dir="." executable="${executable}">
<arg line="${arglineIni} mvn test -P Sequence${arglineEnd}" />
</exec>
</target>
<!-- Objetivo obtenerInformeCobertura -->
<target name="obtenerInformeCobertura" description="obtener informes de cobertura" depends="compilar, prepare-agent">
<exec dir="." executable="${executable}">
<arg line="${arglineIni} mvn -X -Djacoco.dataFile=${jacocoagent} -Djacoco.outputDirectory=./jacoco_ut org.jacoco:jacoco-maven-plugin:report${arglineEnd}" />
</exec>
</target>
<target name="prepare-agent">
<exec dir="." executable="${executable}">
<arg line="${arglineIni} mvn -Djacoco.destFile=${jacocoagent} clean org.jacoco:jacoco-maven-plugin:prepare-agent install -Pcoverage-per-test${arglineEnd}"/>
</exec>
</target>
<!-- Objetivo medidas -->
<target name="medidas" description="obtener informe sobre medidas" depends="obtenerInformeCobertura">
<exec dir="." executable="${executable}">
<arg line="${arglineIni} mvn -P Unit, Integration jxr:jxr pmd:pmd sonar:sonar -Dsonar.host.url=https://sonarqube.inf.uva.es/ -Dsonar.login=${env.SONAR_USER_TOKEN} -Dsonar.analysis.mode=publish -Dsonar.issuesReport.console.enable=true -Dsonar.jacoco.reportPath=target/coverage/jacoco.exec -Dsonar.junit.reportPaths=target/surefire-reports ${arglineEnd}" />
</exec>
</target>
<!-- Objetivo documentar -->
<target name="documentar" description="genera el site de la documentación del proyecto" depends="os-check">
<exec dir="." executable="${executable}">
<arg line="${arglineIni} mvn site${arglineEnd}" />
</exec>
</target>
<!-- Objetivo limpiar -->
<target name="limpiar" description="Elimina archivos innecesarios" depends="os-check" >
<exec dir="." executable="${executable}">
<arg line="${arglineIni} mvn clean${arglineEnd}" />
</exec>
</target>
<target name="os-check" description="Determina sistema operativo y asigna executable y argline" depends="os-check-unix, os-check-win"/>
<target name="os-check-unix" if="isUnix">
<property name="executable" value="sh"/>
<property name="arglineIni" value="-c '"/>
<property name="arglineEnd" value="'"/>
</target>
<target name="os-check-win" if="isWindows">
<property name="executable" value="cmd"/>
<property name="arglineIni" value="/c "/>
<property name="arglineEnd" value=""/>
</target>
</project>
launchCoverageAnalysisWithJacoco.sh 0 → 100644
+ 3
− 0
View file @ a61460d0
mvn clean compile test-compile;
mvn -Djacoco.destFile=target/coverage/jacoco.exec org.jacoco:jacoco-maven-plugin:prepare-agent install -Pcoverage-per-test;
mvn -X -Djacoco.dataFile=target/coverage/jacoco.exec -Djacoco.outputDirectory=./jacoco_ut org.jacoco:jacoco-maven-plugin:report
pom.xml 0 → 100644
+ 149
− 0
View file @ a61460d0
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>uva.inf.parasonarqube</groupId>
<artifactId>paraSonarQube2</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>Proyecto para analizar con SonarQube</name>
<properties>
<maven.compiler.source>1.8</maven.compiler.source>
<maven.compiler.target>1.8</maven.compiler.target>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/org.easymock/easymock -->
<dependency>
<groupId>org.easymock</groupId>
<artifactId>easymock</artifactId>
<version>3.4</version>
<scope>test</scope>
</dependency>
</dependencies>
<profiles>
<profile>
<id>Unit</id>
<properties>
<testcase.groups>uva.inf.parasonarqube.Unit</testcase.groups>
</properties>
</profile>
<profile>
<id>Isolation</id>
<properties>
<testcase.groups>uva.inf.parasonarqube.Isolation</testcase.groups>
</properties>
</profile>
<profile>
<id>Sequence</id>
<properties>
<testcase.groups>uva.inf.parasonarqube.Sequence</testcase.groups>
</properties>
</profile>
<profile>
<id>Integration</id>
<properties>
<testcase.groups>uva.inf.parasonarqube.Integration</testcase.groups>
</properties>
</profile>
<profile>
<id>TDD</id>
<properties>
<testcase.groups>uva.inf.parasonarqube.TDD</testcase.groups>
</properties>
</profile>
<!-- BEGIN: Specific to mapping unit tests and covered code -->
<profile>
<id>coverage-per-test</id>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<!-- Minimal supported version is 2.4 -->
<version>2.20</version>
<configuration>
<properties>
<property>
<name>listener</name>
<value>org.sonar.java.jacoco.JUnitListener</value>
</property>
</properties>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.codehaus.sonar-plugins.java</groupId>
<artifactId>sonar-jacoco-listeners</artifactId>
<version>1.2</version>
<scope>test</scope>
</dependency>
</dependencies>
</profile>
<!-- END: Specific to mapping unit tests and covered code -->
</profiles>
<build>
<pluginManagement>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>2.20</version>
<configuration>
<groups>${testcase.groups}</groups>
</configuration>
<dependencies>
<dependency>
<groupId>org.apache.maven.surefire</groupId>
<artifactId>surefire-junit47</artifactId>
<version>2.20</version>
</dependency>
</dependencies>
</plugin>
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
<version>0.8.2</version>
</plugin>
<plugin>
<groupId>org.sonarsource.scanner.maven</groupId>
<artifactId>sonar-maven-plugin</artifactId>
<version>3.5.0.1254</version>
</plugin>
</plugins>
</pluginManagement>
</build>
<reporting>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-project-info-reports-plugin</artifactId>
<version>2.7</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jxr-plugin</artifactId>
<version>2.3</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-pmd-plugin</artifactId>
<version>3.8</version>
<configuration>
<linkXref>true</linkXref>
<sourceEncoding>utf-8</sourceEncoding>
<minimumTokens>100</minimumTokens>
<targetJdk>1.8</targetJdk>
</configuration>
</plugin>
</plugins>
</reporting>
</project>
sonar-project.properties 0 → 100644
+ 23
− 0
View file @ a61460d0
sonar.login=dc33d896c303867a2f1aa1072c60625aff291df7
# must be unique in a given SonarQube instance
sonar.projectKey=es.uva.inf.calau.paraSonarQube2
# this is the name and version displayed in the SonarQube UI. Was mandatory prior to SonarQube 6.1.
sonar.projectName=CALAU-ParaSonarQube2
sonar.projectVersion=1.0
# Path is relative to the sonar-project.properties file. Replace "\" by "/" on Windows.
# This property is optional if sonar.modules is set.
sonar.sources=./src/main/
sonar.java.binaries=./target/classes/
sonar.tests=./src/test/
sonar.java.test.binaries=./target/test-classes/
# Encoding of the source code. Default is default system encoding
sonar.sourceEncoding=UTF-8
sonar.junit.reportPaths=target/surefire-reports
sonar.jacoco.reportPaths=target/coverage/jacoco.exec
#IT means Integration Tests
#sonar.jacoco.itReportPaths=target/coverage/jacoco-it.exec
sonar.coverage.jacoco.xmlReportPaths=target/site/jacoco
src/main/java/uva/inf/parasonarqube/ColaDeAmigos.java 0 → 100644
+ 372
− 0
View file @ a61460d0
package uva.inf.parasonarqube;
import java.util.ArrayList;
/**
* Implemantacion de la clase ColaDeAmigos.
*
*/
public class ColaDeAmigos {
private static final String P_NO_ESTA_INCLUIDA_EN_LA_COLA = "p no esta incluida en la cola";
private static final String P_HA_SIDO_COLADA_Y_NO_HA_RESERVADO = "p ha sido colada y no ha reservado";
private static final String P_YA_ESTA_INCLUIDA = "p ya esta incluida";
private static final String P_NO_PUEDE_SER_NULL = "p no puede ser null";
protected ArrayList<Persona> fila;
protected ArrayList<Integer> huecos;
/**
* Constructor de ColaDeAmigos
*/
public ColaDeAmigos() {
fila = new ArrayList<>();
huecos = new ArrayList<>();
}
/**
* Permite conocer la longitud de la cola.
*
* @return Entero positivo.
*/
public int longitud() {
if (fila.isEmpty()) {
return 0;
}
int contador = 0;
for (int i = 0; i < fila.size(); i++) {
if (fila.get(i) != null) {
contador++;
}
}
return contador;
}
/**
* Permite a una persona situarse al final de la cola y reservar sitio para sus
* amigos.
*
* @param p
* Persona que pide la vez.
* @param amigos
* Numero de amigos para los que reserva sitio. Comprendido en un
* rango entre 0 y 10 ambos inclusive.
* @throws IllegalArgumentException
* si p es null.
* @throws IllegalArgumentException
* si amigos es menor que cero.
* @throws IllegalArgumentException
* si amigos es mayor que diez.
* @throws IllegalArgumentException
* si p ya esta en la cola.
*/
public void pideVez(Persona p, int amigos) {
if (p == null) {
throw new IllegalArgumentException(P_NO_PUEDE_SER_NULL);
}
if (fila.indexOf(p)!=-1) {
throw new IllegalArgumentException(P_YA_ESTA_INCLUIDA);
}
if (amigos < 0) {
throw new IllegalArgumentException("amigos no puede ser negativo");
}
if (amigos > 10) {
throw new IllegalArgumentException("amigos no puede ser mayor que diez");
}
for (int i = 0; i < amigos; i++) {
fila.add(null);
huecos.add(null);
}
fila.add(p);
huecos.add(amigos);
}
/**
* Permite conocer quien es el ultimo en la cola.
*
* @return Persona situada al final de la cola.
*/
public Persona ultimo() {
if (fila.isEmpty()) {
return null;
}
return fila.get(fila.size() - 1);
}
/**
* Proporciona las personas amigas a otra persona que estan aguardando cola.
*
* @param p
* Persona que quiere saber que amigos tiene en la cola.
* @return Array con los amigos en la cola de la persona que pregunta.
* @throws IllegalArgumentException
* si p es null.
* @throws IllegalArgumentException
* si p esta ya en la cola.
*/
public Persona[] buscaAmigosConHueco(Persona p) {
if (p == null) {
throw new IllegalArgumentException(P_NO_PUEDE_SER_NULL);
}
if (fila.indexOf(p)!=-1) {
throw new IllegalArgumentException(P_YA_ESTA_INCLUIDA);
}
ArrayList<Persona> amigos = new ArrayList<>();
for (int i = 0; i < fila.size(); i++) {
Persona q = fila.get(i);
if (q != null) {
amigoConHueco(p, amigos, q);
}
}
Persona[] array = new Persona[amigos.size()];
array = amigos.toArray(array);
return array;
}
private void amigoConHueco(Persona p, ArrayList<Persona> amigos, Persona q) {
if (q.esAmigo(p) && numeroHuecosDisponibles(q) > 0) {
amigos.add(q);
}
}
/**
* Permite a una persona que llega a la cola colarse junto a otro amigo.
*
* @param p
* Persona que se cuela (Colado).
* @param q
* Persona que cuela (Colador).
* @throws IllegalArgumentException
* si p es null.
* @throws IllegalArgumentException
* si p esta ya en la cola.
* @throws IllegalArgumentException
* si q es null.
* @throws IllegalArgumentException
* si q no esta en la cola.
* @throws IllegalArgumentException
* si p y q no son amigos.
* @throws IllegalStateException
* si q no tiene hueco para colar a p.
* @throws IllegalStateException
* si q es una persona que ha sido colada previemante.
*/
public void seCuelaCon(Persona p, Persona q) {
if (p == null) {
throw new IllegalArgumentException(P_NO_PUEDE_SER_NULL);
}
if (fila.indexOf(p)!=-1) {
throw new IllegalArgumentException(P_YA_ESTA_INCLUIDA);
}
if (q == null) {
throw new IllegalArgumentException("q no puede ser null");
}
if (fila.indexOf(q)==-1) {
throw new IllegalArgumentException("q no esta incluida");
}
if (!(p.esAmigo(q) && q.esAmigo(p))) {
throw new IllegalArgumentException("p y q deben ser amigos");
}
if (haSidoColada(q)) {
throw new IllegalStateException("q ha sido colado y no puede colar");
}
if (numeroHuecosDisponibles(q) == 0) {
throw new IllegalStateException("q no tiene hueco para colar a nadie mas");
}
int huecosDeQ = numeroHuecosDisponibles(q);
int posicionDeQ = fila.indexOf(q);
fila.add(posicionDeQ - huecosDeQ, p);
fila.remove(posicionDeQ - huecosDeQ + 1);
}
private int numeroHuecosDisponibles(Persona p) {
int index = fila.indexOf(p) - 1;
int contador = 0;
while (index >= 0 && fila.get(index) == null) {
contador++;
index--;
}
return contador;
}
private boolean haSidoColada(Persona p) {
int index = fila.indexOf(p);
return huecos.get(index) == null;
}
/**
* Permite conocer quien es el primero de la cola.
*
* @return Persona situada al principio de la cola.
*/
public Persona primero() {
if (fila.isEmpty()) {
return null;
}
int index = 0;
while (fila.get(index) == null) {
index++;
}
return fila.get(index);
}
/**
* Permite conocer el numero de amigos que dijo una persona cuando se situo al
* final de la cola.
*
* @param p
* Persona de la que se quiere saber los amigos iniciales.
* @return numero entero entre cero y diez.
* @throws IllegalArgumentException
* si p es null.
* @throws IllegalArgumentException
* si p no esta en la cola.
* @throws IllegalArgumentException
* si p ha sido colado.
*/
public int dameNumeroReservasInicial(Persona p) {
if (p == null) {
throw new IllegalArgumentException(P_NO_PUEDE_SER_NULL);
}
if (fila.indexOf(p)==-1) {
throw new IllegalArgumentException(P_NO_ESTA_INCLUIDA_EN_LA_COLA);
}
if (haSidoColada(p)) {
throw new IllegalArgumentException(P_HA_SIDO_COLADA_Y_NO_HA_RESERVADO);
}
return (int) huecos.get(fila.indexOf(p));
}
/**
* Permite conocer el numero de amigos que una persona puede colar aun.
*
* @param p
* Persona de la que se quiere saber los amigos que le quedan por
* colar.
* @return numero entero entre cero y diez.
* @throws IllegalArgumentException
* si p es null.
* @throws IllegalArgumentException
* si p no esta en la cola.
* @throws IllegalArgumentException
* si p ha sido colado.
*/
public int dameNumeroReservasActual(Persona p) {
if (p == null) {
throw new IllegalArgumentException(P_NO_PUEDE_SER_NULL);
}
if (fila.indexOf(p)==-1) {
throw new IllegalArgumentException(P_NO_ESTA_INCLUIDA_EN_LA_COLA);
}
if (haSidoColada(p)) {
throw new IllegalArgumentException(P_HA_SIDO_COLADA_Y_NO_HA_RESERVADO);
}
return numeroHuecosDisponibles(p);
}
/**
* Proporciona los amigos que ha colado una persona.
*
* @param p
* Persona que cuela
* @return array con los amigos colados.
* @throws IllegalArgumentException
* si p es null.
* @throws IllegalArgumentException
* si p no esta en la cola.
* @throws IllegalArgumentException
* si p ha sido colado.
*/
public Persona[] dameAmigosColadosDe(Persona p) {
if (p == null) {
throw new IllegalArgumentException(P_NO_PUEDE_SER_NULL);
}
if (fila.indexOf(p)==-1) {
throw new IllegalArgumentException(P_NO_ESTA_INCLUIDA_EN_LA_COLA);
}
if (haSidoColada(p)) {
throw new IllegalArgumentException(P_HA_SIDO_COLADA_Y_NO_HA_RESERVADO);
}
ArrayList<Persona> amigos = new ArrayList<>();
int index = fila.indexOf(p);
int back = index - huecos.get(index);
if (back < 0) {
for (int i = 0; i < index; i++) {
if (fila.get(i) != null) {
amigos.add(fila.get(i));
}
}
} else {
index--;
while (index >= back) {
if (fila.get(index) != null) {
amigos.add(fila.get(index));
}
index--;
}
}
Persona[] array = new Persona[amigos.size()];
array = amigos.toArray(array);
return array;
}
/**
* Simula el avance de la cola. El primero será atendido y eliminado de la cola,
* avanzado una posicion el resto de personas en la cola
*
* @throws IllegalStateException
* si la cola esta vacia
*/
public void avanza() {
if (fila.isEmpty()) {
throw new IllegalStateException("No se puede avanzar sobre una cola vacia");
}
Persona primero = primero();
int index = fila.indexOf(primero);
for (int i = 0; i <= index; i++) {
fila.remove(0);
huecos.remove(0);
}
}
/**
* Devuelve el numero de amigos que p ha colado.
*
* @param p
* Persona de los que se quiere conocer la cantidad de amigos que ha
* colado.
* @return Entero entre cero y diez.
* @throws IllegalArgumentException
* si p es null.
* @throws IllegalArgumentException
* si p no esta en la cola.
* @throws IllegalArgumentException
* si p ha sido colado.
*/
public int dameNumeroAmigosColados(Persona p) {
if (p == null) {
throw new IllegalArgumentException(P_NO_PUEDE_SER_NULL);
}
if (fila.indexOf(p)==-1) {
throw new IllegalArgumentException(P_NO_ESTA_INCLUIDA_EN_LA_COLA);
}
if (haSidoColada(p)) {
throw new IllegalArgumentException(P_HA_SIDO_COLADA_Y_NO_HA_RESERVADO);
}
return dameAmigosColadosDe(p).length;
}
}
src/main/java/uva/inf/parasonarqube/Persona.java 0 → 100644
+ 193
− 0
View file @ a61460d0
package uva.inf.parasonarqube;
import java.util.ArrayList;
/**
* Implementacion de la clase Persona.
*
*/
public class Persona {
private static final String P_NO_PUEDE_SER_NULL = "p no puede ser null";
private static final String Q_NO_PUEDE_SER_NULL = "q no puede ser null";
private static final String NOMBRE_NO_PUEDE_SER_NULL = "nombre no puede ser null";
protected String nombre;
protected ArrayList<Persona> conocidos;
protected ArrayList<Persona> amigos;
/**
* Constructor de Persona.
*
* @param nombre
* Nombre que va a tener la persona.
* @throws IllegalArgumentException
* si nombre es null
*/
public Persona(String nombre) {
if (nombre == null) {
throw new IllegalArgumentException(NOMBRE_NO_PUEDE_SER_NULL);
}
this.nombre = nombre;
conocidos = new ArrayList<>();
amigos = new ArrayList<>();
}
/**
* Devuelve el nombre de la persona.
*
* @return cadena de caracteres que representa el nombre de la persona.
*/
public String dameNombre() {
return nombre;
}
/**
* Permite saber si dos personas se conocen entre si. Si una persona conoce a
* otra implica que la otra conoce a la una.
*
* @param q
* Persona de la que se quiere saber si esta tiene conocimiento.
* @return true si lo conoce, false si no.
* @throws IllegalArgumentException
* si q es null.
*/
public boolean esConocido(Persona q) {
if (q == null) {
throw new IllegalArgumentException(Q_NO_PUEDE_SER_NULL);
}
return conocidos.indexOf(q)!=-1;
}
/**
* Permite hacer que dos personas se conozcan.
*
* @param p
* una persona.
* @param q
* otra persona.
* @throws IllegalArgumentException
* si p es null.
* @throws IllegalArgumentException
* si q es null.
*/
public static void creaConocimiento(Persona p, Persona q) {
if (p == null) {
throw new IllegalArgumentException(P_NO_PUEDE_SER_NULL);
}
if (q == null) {
throw new IllegalArgumentException(Q_NO_PUEDE_SER_NULL);
}
p.addConocido(q);
q.addConocido(p);
}
private void addConocido(Persona r) {
conocidos.add(r);
}
/**
* Permite saber si dos personas son amigos. Si una persona es amigo de otra
* implica que la otra es aimgo de la una.
*
* @param q
* Persona de la que se quiere saber si esta es amigo.
* @return true si son amigos, false si no lo son.
* @throws IllegalArgumentException
* si q es null.
*/
public boolean esAmigo(Persona q) {
if (q == null) {
throw new IllegalArgumentException(Q_NO_PUEDE_SER_NULL);
}
return amigos.indexOf(q)!=-1;
}
/**
* Permite crear amistad entre dos personas. Ambas personas deben conocerse
* previamente.
*
* @param p
* una persona.
* @param q
* otra persona.
* @throws IllegalArgumentException
* si p es null.
* @throws IllegalArgumentException
* si q es null.
* @throws IllegalStateException
* si p y q no se conocen de antes.
*/
public static void creaAmistad(Persona p, Persona q) {
if (p == null) {
throw new IllegalArgumentException(P_NO_PUEDE_SER_NULL);
}
if (q == null) {
throw new IllegalArgumentException(Q_NO_PUEDE_SER_NULL);
}
if (!(p.esConocido(q) && q.esConocido(p))) {
throw new IllegalStateException("p y q deben ser conocidos");
}
p.addAmigo(q);
q.addAmigo(p);
}
private void addAmigo(Persona r) {
amigos.add(r);
}
/**
* Permite obtener las personas conocidas por una persona.
*
* @return array con las personas que conoce.
*/
public Persona[] dameConocidos() {
Persona[] array = new Persona[conocidos.size()];
array = conocidos.toArray(array);
return array;
}
/**
* Permite obtener los amigos de una persona.
*
* @return array con los amigos de una persona.
*/
public Persona[] dameAmigos() {
Persona[] array = new Persona[amigos.size()];
array = amigos.toArray(array);
return array;
}
/**
* Permite poner fin a la amistad entre dos personas dejandolas unicamente como
* conocidos.
*
* @param p
* una persona.
* @param q
* otra persona.
* @throws IllegalArgumentException
* si p es null.
* @throws IllegalArgumentException
* si q es null.
* @throws IllegalStateException
* si p y q no son amigos de antes.
*/
public static void rompeAmistad(Persona p, Persona q) {
if (p == null) {
throw new IllegalArgumentException(P_NO_PUEDE_SER_NULL);
}
if (q == null) {
throw new IllegalArgumentException(Q_NO_PUEDE_SER_NULL);
}
if (!(p.esAmigo(q) && q.esAmigo(p))) {
throw new IllegalStateException("p y q deben ser amigos");
}
p.removeAmigo(q);
q.removeAmigo(p);
}
private void removeAmigo(Persona r) {
int index = amigos.indexOf(r);
amigos.remove(index);
}
}
src/test/java/uva/inf/parasonarqube/ColaDeAmigosAislamientoTest.java 0 → 100644
+ 139
− 0
View file @ a61460d0
package uva.inf.parasonarqube;
import static org.junit.Assert.*;
import org.easymock.Mock;
import org.junit.*;
import org.junit.experimental.categories.Category;
import static org.easymock.EasyMock.createMock;
import static org.easymock.EasyMock.eq;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.replay;
import static org.easymock.EasyMock.verify;
import static org.junit.Assert.*;
import org.easymock.Mock;
/**
* Test Aislamiento.
*
*/
@Category({Isolation.class})
public class ColaDeAmigosAislamientoTest {
@Mock
private Persona manolito;
@Mock
private Persona luisito;
@Mock
private Persona inesita;
@Mock
private Persona falsoAmigo;
private ColaDeAmigos cola;
@Before
public void setUp() {
manolito = createMock(Persona.class);
luisito = createMock(Persona.class);
inesita = createMock(Persona.class);
falsoAmigo = createMock(Persona.class);
expect(manolito.esAmigo(inesita)).andReturn(true).anyTimes();
expect(manolito.esAmigo(luisito)).andReturn(true).anyTimes();
expect(inesita.esAmigo(manolito)).andReturn(true).anyTimes();
expect(luisito.esAmigo(manolito)).andReturn(true).anyTimes();
expect(inesita.esAmigo(luisito)).andReturn(false).anyTimes();
expect(luisito.esAmigo(inesita)).andReturn(false).anyTimes();
expect(manolito.esAmigo(falsoAmigo)).andReturn(true).anyTimes();
expect(falsoAmigo.esAmigo(manolito)).andReturn(false).anyTimes(); //tu no eres su amigo, pero el si es amigo tuyo
replay(manolito, luisito, inesita);
cola = new ColaDeAmigos();
}
@After
public void tearDown() {
manolito = null;
luisito = null;
inesita=null;
cola=null;
}
//BuscaAmigos*************************************************************************
@Test
public void testBuscarAmigosConHueco() {
assertTrue(inesita.esAmigo(manolito));
cola.pideVez(manolito, 2);
Persona[] amigos = cola.buscaAmigosConHueco(inesita);
Persona[] expected = {manolito};
assertArrayEquals(amigos, expected);
}
@Test
public void testBuscarAmigosConHuecoSinHueco() {
ColaDeAmigos cola = new ColaDeAmigos();
cola.pideVez(manolito, 1);
cola.seCuelaCon(luisito, manolito);
Persona[] amigos = cola.buscaAmigosConHueco(inesita);
Persona[] expected = {};
assertArrayEquals(amigos, expected);
}
//SeCuelaCon*************************************************************************
@Test
public void testSeCuelaConElPrimeroEnLaCola() {
cola.pideVez(manolito, 1);
cola.pideVez(inesita, 1);
cola.seCuelaCon(luisito, manolito);
assertEquals(cola.primero(),luisito);
assertEquals(cola.longitud(),3);
}
@Test
public void testSeCuelaConPorElMedio() {
cola.pideVez(inesita, 1);
cola.pideVez(manolito, 1);
cola.seCuelaCon(luisito, manolito);
assertEquals(cola.primero(),inesita);
assertEquals(cola.longitud(),3);
}
@Test(expected=IllegalArgumentException.class)
public void testSeCuelaConNoSonAmigos() {
cola.pideVez(inesita, 1);
cola.pideVez(manolito, 1);
cola.seCuelaCon(luisito, inesita);
}
@Test(expected=IllegalStateException.class)
public void testSeCuelaConColado() {
cola.pideVez(inesita, 1);
cola.seCuelaCon(manolito, inesita);
cola.seCuelaCon(luisito, manolito);
}
@Test(expected=IllegalStateException.class)
public void testSeCuelaConNoTieneHueco() {
cola.pideVez(manolito,1);
cola.seCuelaCon(luisito, manolito);
cola.seCuelaCon(inesita, manolito);
}
//Este test solo se puede probar con mocks
@Test(expected=IllegalArgumentException.class)
public void testSeCuelaConFalsoAmigoColado() {
cola.pideVez(manolito, 1);
cola.seCuelaCon(falsoAmigo, manolito);
}
//Este test solo se puede probar con mocks
@Test(expected=IllegalArgumentException.class)
public void testSeCuelaConFalsoAmigoColador() {
cola.pideVez(falsoAmigo, 1);
cola.seCuelaCon(manolito, falsoAmigo);
}
}
src/test/java/uva/inf/parasonarqube/ColaDeAmigosCajaBlancaTest.java 0 → 100644
+ 64
− 0
View file @ a61460d0
package uva.inf.parasonarqube;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;
public class ColaDeAmigosCajaBlancaTest {
Persona manolito;
Persona inesita;
Persona sandrita;
ColaDeAmigos cola;
@Before
public void setUp() {
manolito = new Persona("Manolito");
inesita = new Persona("Inesita");
sandrita = new Persona("Sandrita");
Persona.creaConocimiento(inesita, manolito);
Persona.creaAmistad(inesita, manolito);
Persona.creaConocimiento(sandrita, manolito);
Persona.creaAmistad(sandrita, manolito);
cola = new ColaDeAmigos();
cola.pideVez(manolito, 2);
}
@After
public void tearDown() {
manolito = null;
inesita = null;
sandrita = null;
cola = null;
}
@Category({Integration.class})
@Test
public void testDameAmigosColadosAvanzandoColaSinHuecos() {
cola.seCuelaCon(inesita,manolito);
cola.seCuelaCon(sandrita,manolito);
cola.avanza();
Persona[] amigos = cola.dameAmigosColadosDe(manolito);
Persona[] expect = {sandrita};
assertArrayEquals(amigos,expect);
}
@Category({Integration.class})
@Test
public void testDameAmigosColadosAvanzandoColaConHuecos() {
cola.seCuelaCon(inesita,manolito);
cola.avanza();
Persona[] amigos = cola.dameAmigosColadosDe(manolito);
Persona[] expect = {};
assertArrayEquals(amigos,expect);
}
}
src/test/java/uva/inf/parasonarqube/ColaDeAmigosCajaNegraColaVaciaTest.java 0 → 100644
+ 40
− 0
View file @ a61460d0
package uva.inf.parasonarqube;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;
/**
* Test con una fixture de cola vacia.
*
*/
@Category({Unit.class})
public class ColaDeAmigosCajaNegraColaVaciaTest {
ColaDeAmigos cola;
@Before
public void setUp() {
cola = new ColaDeAmigos();
}
@After
public void tearDown() {
cola = null;
}
@Test
public void testPrimeroColaVacia() {
assertEquals(cola.primero(),null);
}
@Test
public void testUltimoColaVacia() {
assertEquals(cola.ultimo(),null);
}
@Test(expected=IllegalStateException.class)
public void testAvanzaColaVacia() {
cola.avanza();
}
}
src/test/java/uva/inf/parasonarqube/ColaDeAmigosCajaNegraNullTest.java 0 → 100644
+ 78
− 0
View file @ a61460d0
package uva.inf.parasonarqube;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;
/**
* Test donde pongo nulls.
*/
@Category({Unit.class})
public class ColaDeAmigosCajaNegraNullTest {
Persona manolito;
Persona joselito;
ColaDeAmigos cola;
@Before
public void setUp() {
manolito = new Persona("Manolito");
joselito = new Persona("Joselito");
Persona.creaConocimiento(manolito, joselito);
Persona.creaAmistad(manolito, joselito);
cola = new ColaDeAmigos();
cola.pideVez(manolito, 1);
}
@After
public void tearDown() {
manolito = null;
joselito = null;
cola = null;
}
@Test(expected=IllegalArgumentException.class)
public void testPideVez() {
cola.pideVez(null, 0);
}
@Test(expected=IllegalArgumentException.class)
public void testBuscaAmigosConHueco() {
cola.buscaAmigosConHueco(null);
}
@Test(expected=IllegalArgumentException.class)
public void testSeCuelaConColadoNull() {
cola.seCuelaCon(null, manolito);
}
@Test(expected=IllegalArgumentException.class)
public void testSeCuelaConColadorNull() {
cola.seCuelaCon(joselito,null);
}
@Test(expected=IllegalArgumentException.class)
public void testDameNumeroReservasInicial() {
cola.dameNumeroReservasInicial(null);
}
@Test(expected=IllegalArgumentException.class)
public void testDameNumeroReservasActual() {
cola.dameNumeroReservasActual(null);
}
@Test(expected=IllegalArgumentException.class)
public void testDameAmigosColadosDe() {
cola.dameAmigosColadosDe(null);
}
@Test(expected=IllegalArgumentException.class)
public void testDameNumeroAmigosColados() {
cola.dameNumeroAmigosColados(null);
}
}
src/test/java/uva/inf/parasonarqube/ColaDeAmigosCajaNegraOtrosTest.java 0 → 100644
+ 302
− 0
View file @ a61460d0
package uva.inf.parasonarqube;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;
/**
* Test con una fixture de cola.
*/
public class ColaDeAmigosCajaNegraOtrosTest {
Persona manolito;
Persona joselito;
Persona jorgito;
Persona luisito;
Persona fernandito;
Persona robertito;
Persona paulita;
Persona martita;
Persona inesita;
Persona sandrita;
Persona juanito;
ColaDeAmigos cola;
@Before
public void setUp() {
manolito = new Persona("Manolito");
joselito = new Persona("Joselito");
jorgito = new Persona("Jorgito");
luisito = new Persona("Luisito");
fernandito = new Persona("Fernandito");
robertito = new Persona("Robertito");
paulita = new Persona("Paulita");
martita = new Persona("Martita");
inesita = new Persona("Inesita");
sandrita = new Persona("Sandrita");
juanito = new Persona("Juanito");
Persona.creaConocimiento(luisito, manolito);
Persona.creaAmistad(luisito, manolito);
Persona.creaConocimiento(fernandito, jorgito);
Persona.creaAmistad(fernandito, jorgito);
Persona.creaConocimiento(inesita, manolito);
Persona.creaAmistad(inesita, manolito);
Persona.creaConocimiento(sandrita, paulita);
Persona.creaAmistad(sandrita, paulita);
Persona.creaConocimiento(sandrita, manolito);
Persona.creaAmistad(sandrita, manolito);
Persona.creaConocimiento(sandrita, juanito);
Persona.creaAmistad(sandrita, juanito);
Persona.creaConocimiento(juanito, martita);
Persona.creaAmistad(juanito, martita);
cola = new ColaDeAmigos();
cola.pideVez(manolito, 2);
cola.pideVez(joselito, 0);
cola.pideVez(jorgito, 1);
cola.pideVez(paulita, 1);
cola.pideVez(martita, 0);
}
@After
public void tearDown() {
manolito = null;
joselito = null;
jorgito = null;
luisito = null;
fernandito = null;
robertito = null;
paulita = null;
martita = null;
inesita = null;
sandrita = null;
juanito = null;
cola = null;
}
//PideVez*************************************************************************
@Category({Unit.class})
@Test
public void testPideVezCeroAmigos() {
cola.pideVez(juanito, 0);
assertEquals(juanito,cola.ultimo());
assertEquals(cola.longitud(),6);
}
@Category({Unit.class})
@Test
public void testPideVezDiezAmigos() {
cola.pideVez(juanito, 10);
assertEquals(juanito,cola.ultimo());
assertEquals(cola.longitud(),6);
}
@Category({Unit.class})
@Test(expected=IllegalArgumentException.class)
public void testPideVezMenosUnAmigos() {
cola.pideVez(juanito, -1);
}
@Category({Unit.class})
@Test(expected=IllegalArgumentException.class)
public void testPideVezOnceAmigos() {
cola.pideVez(juanito, 11);
}
@Category({Unit.class})
@Test(expected=IllegalArgumentException.class)
public void testPideVezAlguienYaEnCola() {
cola.pideVez(manolito, 0);
}
//BuscaAmigos*************************************************************************
@Category({Integration.class})
@Test
public void testBuscaAmigosConHuecoSiTieneHueco() {
Persona[] amigos = cola.buscaAmigosConHueco(inesita);
Persona[] expect = {manolito};
assertArrayEquals(amigos, expect);
}
@Category({Integration.class})
@Test
public void testBuscaAmigosConHuecoNoTieneHueco() {
Persona[] amigos = cola.buscaAmigosConHueco(juanito);
Persona[] expect = {};
assertArrayEquals(amigos, expect);
}
@Category({Integration.class})
@Test(expected=IllegalArgumentException.class)
public void testBuscaAmigosConHuecoYaEnLaCola() {
@SuppressWarnings("unused")
Persona[] amigos = cola.buscaAmigosConHueco(manolito);
}
//SeCuelaCon*************************************************************************
@Category({Integration.class})
@Test
public void testSeCuelaConElPrimeroEnLaCola() {
cola.seCuelaCon(luisito, manolito);
Persona[] amigos = {luisito};
assertArrayEquals(cola.dameAmigosColadosDe(manolito),amigos);
assertEquals(cola.dameNumeroReservasActual(manolito),1);
assertEquals(cola.ultimo(),martita);
assertEquals(cola.primero(),luisito);
assertEquals(cola.longitud(),6);
}
@Category({Integration.class})
@Test
public void testSeCuelaConPorElMedio() {
cola.seCuelaCon(fernandito, jorgito);
Persona[] amigos = {fernandito};
assertArrayEquals(cola.dameAmigosColadosDe(jorgito),amigos);
assertEquals(cola.dameNumeroReservasActual(jorgito),0);
assertEquals(cola.ultimo(),martita);
assertEquals(cola.primero(),manolito);
assertEquals(cola.longitud(),6);
}
@Category({Integration.class})
@Test(expected=IllegalArgumentException.class)
public void testSeCuelaConColadoYaEnCola() {
cola.seCuelaCon(joselito, manolito);
}
@Category({Integration.class})
@Test(expected=IllegalArgumentException.class)
public void testSeCuelaConColadorNoEnCola() {
cola.seCuelaCon(sandrita,juanito);
}
@Category({Integration.class})
@Test(expected=IllegalArgumentException.class)
public void testSeCuelaConNoSonAmigos() {
cola.seCuelaCon(fernandito,manolito);
}
@Category({Integration.class})
@Test(expected=IllegalStateException.class)
public void testSeCuelaConColadorNoTieneHueco() {
cola.seCuelaCon(juanito,martita);
}
@Category({Integration.class})
@Test(expected=IllegalStateException.class)
public void testSeCuelaConColado() {
cola.seCuelaCon(sandrita, paulita);
cola.seCuelaCon(juanito, sandrita);
}
//DameNumeroReservasInicial*************************************************************************
@Category({Unit.class})
@Test
public void testDameNumeroReservasInicial() {
assertEquals(cola.dameNumeroReservasInicial(manolito),2);
}
@Category({Unit.class})
@Test
public void testDameNumeroReservasInicialDespuesDeColar() {
cola.seCuelaCon(luisito, manolito);
assertEquals(cola.dameNumeroReservasInicial(manolito),2);
}
@Category({Unit.class})
@Test(expected=IllegalArgumentException.class)
public void testDameNumeroReservasInicialNoEnCola() {
cola.dameNumeroReservasInicial(juanito);
}
@Category({Unit.class})
@Test(expected=IllegalArgumentException.class)
public void testDameNumeroReservasInicialColado() {
cola.seCuelaCon(luisito, manolito);
cola.dameNumeroReservasInicial(luisito);
}
//DameNumeroReservasActual*************************************************************************
@Category({Integration.class})
@Test
public void testDameNumeroReservasActual() {
assertEquals(2,cola.dameNumeroReservasActual(manolito));
cola.seCuelaCon(luisito, manolito);
assertEquals(1,cola.dameNumeroReservasActual(manolito));
}
@Category({Unit.class})
@Test
public void testDameNumeroReservasActualSinColar() {
assertEquals(cola.dameNumeroReservasInicial(manolito),cola.dameNumeroReservasActual(manolito));
}
@Category({Unit.class})
@Test(expected=IllegalArgumentException.class)
public void testDameNumeroReservasActualNoEnCola() {
cola.dameNumeroReservasActual(juanito);
}
@Category({Integration.class})
@Test(expected=IllegalArgumentException.class)
public void testDameNumeroReservasActualColado() {
cola.seCuelaCon(luisito, manolito);
cola.dameNumeroReservasActual(luisito);
}
//DameAmigosColadosDe*************************************************************************
@Category({Unit.class})
@Test
public void testDameAmigosColadosDeSinHaberColado() {
Persona[] amigos = cola.dameAmigosColadosDe(paulita);
Persona[] expect = {};
assertArrayEquals(amigos,expect);
}
@Category({Unit.class})
@Test
public void testDameAmigosColadosDeHabiendoColado() {
cola.seCuelaCon(sandrita, paulita);
Persona[] amigos = cola.dameAmigosColadosDe(paulita);
Persona[] expect = {sandrita};
assertArrayEquals(amigos,expect);
}
@Category({Unit.class})
@Test(expected=IllegalArgumentException.class)
public void testDameAmigosColadosDeNoEnCola() {
cola.dameAmigosColadosDe(juanito);
}
@Category({Integration.class})
@Test(expected=IllegalArgumentException.class)
public void testDameAmigosColadosDeColado() {
cola.seCuelaCon(luisito, manolito);
cola.dameAmigosColadosDe(luisito);
}
//DameAmigosColadosDe*************************************************************************
@Category({Unit.class})
@Test
public void testNumeroDameAmigosColadosDeSinHaberColado() {
int amigos = cola.dameNumeroAmigosColados(paulita);
assertEquals(amigos,0);
}
@Category({Unit.class})
@Test
public void testNumeroDameAmigosColadosDeHabiendoColado() {
cola.seCuelaCon(sandrita, paulita);
int amigos = cola.dameNumeroAmigosColados(paulita);
assertEquals(amigos,1);
}
@Category({Unit.class})
@Test(expected=IllegalArgumentException.class)
public void testNumeroDameAmigosColadosDeNoEnCola() {
cola.dameNumeroAmigosColados(juanito);
}
@Category({Unit.class})
@Test(expected=IllegalArgumentException.class)
public void testNumeroDameAmigosColadosDeColado() {
cola.seCuelaCon(luisito, manolito);
cola.dameNumeroAmigosColados(luisito);
}
//Avanza*************************************************************************
@Category({Unit.class})
@Test
public void atestAvanza() {
assertEquals(cola.primero(),manolito);
assertEquals(cola.longitud(),5);
cola.avanza();
assertEquals(cola.primero(),joselito);
assertEquals(cola.longitud(),4);
}
}
src/test/java/uva/inf/parasonarqube/ColaDeAmigosInicialTest.java 0 → 100644
+ 159
− 0
View file @ a61460d0
package uva.inf.parasonarqube;
import static org.junit.Assert.*;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.experimental.categories.Category;
/**
* Tests para crear el stub de persona.
*/
@Category({TDD.class})
public class ColaDeAmigosInicialTest {
Persona manolito;
Persona joselito;
@Before
public void setUp() {
manolito = new Persona("Manolito");
joselito = new Persona("Joselito");
Persona.creaConocimiento(manolito, joselito);
Persona.creaAmistad(manolito, joselito);
}
@After
public void tearDown() {
manolito = null;
joselito = null;
}
@Category({Unit.class})
@Test
public void testColaDeAmigos() {
ColaDeAmigos cola = new ColaDeAmigos();
assertNotNull(cola);
assertEquals(cola.longitud(),0); //coincide y pasa en verde
}
@Category({Unit.class})
@Test
public void testlongitud() {
ColaDeAmigos cola = new ColaDeAmigos();
assertNotNull(cola);
assertEquals(cola.longitud(),0); //coincide y pasa en verde
}
@Category({Unit.class})
@Test
public void testPrimero() {
ColaDeAmigos cola = new ColaDeAmigos();
assertNotNull(cola);
cola.pideVez(manolito, 0);
Persona pri = cola.primero();
assertEquals(manolito,pri);
}
@Category({Unit.class})
@Test
public void testUltimo() {
ColaDeAmigos cola = new ColaDeAmigos();
assertNotNull(cola);
cola.pideVez(manolito, 0);
Persona ult = cola.ultimo();
assertEquals(manolito,ult);
}
@Category({Unit.class})
@Test
public void testPideVez() {
ColaDeAmigos cola = new ColaDeAmigos();
assertNotNull(cola);
assertEquals(cola.longitud(),0);
cola.pideVez(manolito,0);
assertEquals(cola.longitud(),1);
Persona ult = cola.ultimo();
assertEquals(manolito,ult);
}
@Category({Integration.class})
@Test
public void testBuscaAmigosConHueco() {
ColaDeAmigos cola = new ColaDeAmigos();
Persona[] amigosDeJoselitoEnCola = cola.buscaAmigosConHueco(joselito);
Persona[] expected = {};
assertArrayEquals(amigosDeJoselitoEnCola,expected);
}
@Category({Integration.class})
@Test
public void testSeCuelaCon() {
ColaDeAmigos cola = new ColaDeAmigos();
cola.pideVez(manolito, 1);
cola.seCuelaCon(joselito,manolito);
assertEquals(cola.longitud(),2);
assertEquals(joselito,cola.primero());
assertEquals(manolito,cola.ultimo());
}
@Category({Unit.class})
@Test
public void testDameNumeroReservasInicial() {
ColaDeAmigos cola = new ColaDeAmigos();
cola.pideVez(manolito, 1);
int amigosDeManolitoReservados = cola.dameNumeroReservasInicial(manolito);
assertEquals(amigosDeManolitoReservados,1);
}
@Category({Unit.class})
@Test
public void testDameNumeroReservasActual() {
ColaDeAmigos cola = new ColaDeAmigos();
cola.pideVez(manolito,1);
int amigosDeManolitoReservadosActualmente = cola.dameNumeroReservasActual(manolito);
assertEquals(cola.dameNumeroReservasActual(manolito),1);
cola.seCuelaCon(joselito, manolito);
amigosDeManolitoReservadosActualmente = cola.dameNumeroReservasActual(manolito);
assertEquals(cola.dameNumeroReservasActual(manolito),0);
}
@Category({Unit.class})
@Test
public void testDameAmigosColadosDe() {
ColaDeAmigos cola = new ColaDeAmigos();
cola.pideVez(manolito, 1);
cola.seCuelaCon(joselito, manolito);
Persona[] amigosColados = cola.dameAmigosColadosDe(manolito);
Persona[] expected = {joselito};
assertArrayEquals(amigosColados,expected);
}
@Category({Unit.class})
@Test
public void testAvanza() {
ColaDeAmigos cola =new ColaDeAmigos();
cola.pideVez(manolito, 0);
assertEquals(cola.longitud(),1);
assertEquals(cola.primero(),manolito);
cola.avanza();
assertEquals(cola.longitud(),0);
assertEquals(cola.primero(),null);
}
@Category({Unit.class})
@Test
public void testDameNumeroAmigosColados() {
ColaDeAmigos cola = new ColaDeAmigos();
cola.pideVez(manolito, 1);
int amigosDeManolitoColados = cola.dameNumeroAmigosColados(manolito);
assertEquals(amigosDeManolitoColados,0);
cola.seCuelaCon(joselito, manolito);
amigosDeManolitoColados = cola.dameNumeroAmigosColados(manolito);
assertEquals(amigosDeManolitoColados,1);
assertEquals(cola.dameAmigosColadosDe(manolito).length,amigosDeManolitoColados); //da error porque quiero mirar la length de un null
}
}
src/test/java/uva/inf/parasonarqube/ColaDeAmigosSecuenciaTest.java 0 → 100644
+ 174
− 0
View file @ a61460d0
package uva.inf.parasonarqube;
import static org.junit.Assert.*;
import org.junit.*;
import org.junit.experimental.categories.Category;
/**
* Test de secuencia
*
*/
@Category({Sequence.class, Integration.class})
public class ColaDeAmigosSecuenciaTest {
Persona manolito;
Persona joselito;
Persona jorgito;
Persona luisito;
Persona fernandito;
Persona robertito;
Persona paulita;
Persona martita;
Persona inesita;
Persona sandrita;
Persona juanito;
ColaDeAmigos cola;
@Before
public void setUp() {
manolito = new Persona("Manolito");
joselito = new Persona("Joselito");
jorgito = new Persona("Jorgito");
luisito = new Persona("Luisito");
fernandito = new Persona("Fernandito");
robertito = new Persona("Robertito");
paulita = new Persona("Paulita");
martita = new Persona("Martita");
inesita = new Persona("Inesita");
sandrita = new Persona("Sandrita");
juanito = new Persona("Juanito");
Persona.creaConocimiento(luisito, manolito);
Persona.creaAmistad(luisito, manolito);
Persona.creaConocimiento(fernandito, jorgito);
Persona.creaAmistad(fernandito, jorgito);
Persona.creaConocimiento(inesita, manolito);
Persona.creaAmistad(inesita, manolito);
Persona.creaConocimiento(sandrita, paulita);
Persona.creaAmistad(sandrita, paulita);
Persona.creaConocimiento(sandrita, manolito);
Persona.creaAmistad(sandrita, manolito);
Persona.creaConocimiento(sandrita, juanito);
Persona.creaAmistad(sandrita, juanito);
Persona.creaConocimiento(juanito, martita);
Persona.creaAmistad(juanito, martita);
cola = new ColaDeAmigos();
}
@After
public void tearDown() {
manolito = null;
joselito = null;
jorgito = null;
luisito = null;
fernandito = null;
robertito = null;
paulita = null;
martita = null;
inesita = null;
sandrita = null;
juanito = null;
cola = null;
}
@Test
public void testSecuenciaValida() {
//Llega manolito a la cola y reserva para 3 amigos
cola.pideVez(manolito, 3);
//Llega fernandito y pide vez reservando para el y un amigo
cola.pideVez(fernandito, 1);
//Llega inesita y busca amigos en la cola
Persona[] amigosDeInesita = cola.buscaAmigosConHueco(inesita);
Persona[] comprobarAmigosInesita = {manolito};
assertArrayEquals(amigosDeInesita,comprobarAmigosInesita);
//Inesita pide colarse con manolito quedando al principio de la cola
cola.seCuelaCon(inesita, manolito);
assertEquals(cola.primero(),inesita);
//Llega jorgito y se cuela con fernandito
cola.seCuelaCon(jorgito, fernandito);
//La longitud de la cola asciende a 4 personas y fernandito sigue siendo el ultimo
assertEquals(cola.longitud(),4);
assertEquals(cola.ultimo(),fernandito);
//La cola avanza e Inesita es atendida
cola.avanza();
//Manolito queda al frente de la cola
assertEquals(cola.primero(),manolito);
//La cola avanza de nuevo y manolito pasa sin haber colado a sus otros dos amigos
cola.avanza();
assertEquals(cola.primero(),jorgito);
assertEquals(cola.longitud(),2);
//Llega luisito y busca algun amigo con quien colarse (Busca a manolito)
Persona[] amigosDeLuisito = cola.buscaAmigosConHueco(luisito);
Persona[] comprobarAmigosLuisito = {};
assertArrayEquals(amigosDeLuisito,comprobarAmigosLuisito);
//Luisito pide vez
cola.pideVez(luisito, 0);
assertEquals(cola.ultimo(),luisito);
}
@Test(expected=IllegalStateException.class)
public void testSecuenciaNoValida1() {
cola.pideVez(manolito, 2);
cola.pideVez(fernandito, 1);
cola.seCuelaCon(inesita, manolito);
cola.seCuelaCon(sandrita, manolito);
cola.seCuelaCon(jorgito, fernandito);
//Juanito intenta colarse con manolito, que ha cubierto su cupo de amigos
cola.seCuelaCon(luisito, manolito);
}
@Test(expected=IllegalArgumentException.class)
public void testSecuenciaNoValida2() {
cola.pideVez(manolito, 2);
cola.pideVez(fernandito, 1);
cola.seCuelaCon(inesita, manolito);
cola.seCuelaCon(sandrita, manolito);
//Juanito intenta colarse con fernandito, que no es su amigo
cola.seCuelaCon(juanito, fernandito);
}
@Test(expected=IllegalStateException.class)
public void testSecuenciaNoValida3() {
cola.pideVez(manolito, 2);
cola.pideVez(fernandito, 1);
cola.seCuelaCon(inesita, manolito);
cola.seCuelaCon(sandrita, manolito);
cola.seCuelaCon(jorgito, fernandito);
//Juanito intenta colarse con sandrita, que ha sido colada por manolito
cola.seCuelaCon(juanito, sandrita);
}
@Test(expected=IllegalStateException.class)
public void testSecuenciaNoValida4() {
cola.pideVez(manolito, 2);
cola.pideVez(fernandito, 1);
cola.seCuelaCon(inesita, manolito);
cola.seCuelaCon(sandrita, manolito);
cola.seCuelaCon(jorgito, fernandito);
assertEquals(cola.longitud(),5);
cola.avanza();
cola.avanza();
cola.avanza();
cola.avanza();
cola.avanza();
assertEquals(cola.longitud(),0);
//La cola avanza cuando esta vacia
cola.avanza();
}
}
src/test/java/uva/inf/parasonarqube/ColaDeAmigosTest.java 0 → 100644
+ 24
− 0
View file @ a61460d0
package uva.inf.parasonarqube;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import org.junit.runners.Suite.SuiteClasses;
@RunWith(Suite.class)
@SuiteClasses({
ColaDeAmigosInicialTest.class,
ColaDeAmigosCajaNegraNullTest.class,
ColaDeAmigosCajaNegraOtrosTest.class,
ColaDeAmigosCajaNegraColaVaciaTest.class,
ColaDeAmigosSecuenciaTest.class,
ColaDeAmigosCajaBlancaTest.class,
ColaDeAmigosAislamientoTest.class
})
/**
* Suite que contiene al resto de test de ColaDeAmigos.
*
*/
public class ColaDeAmigosTest {
}
src/test/java/uva/inf/parasonarqube/Integration.java 0 → 100644
+ 5
− 0
View file @ a61460d0
package uva.inf.parasonarqube;
public interface Integration {
}
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment