Testing en Java - Test Java

COLOR

BLANCO Y NEGRO

ESTUDIO

Test Calcular Tiempo Arado

java

Copiar código

@Test

public void testCalcularTiempoArado() {

int hectareas = 50;

double tiempoArado = hectareas / maquinaria.getEficiencia();

assertEquals(0.71, tiempoArado, 0.01);

assertFalse(tiempoArado >= 1);

}

Test Añadir Horas Trabajo

java

Copiar código

@Test

public void testAnyadirHorasTrabajo() {

maquinaria.anyadirHorasTrabajo(50);

assertEquals(150, maquinaria.getHoraUso(), 0.01);

assertTrue(maquinaria.getHoraUso() > 149);

}

Test Tipo Maquinaria No Vacío

java

Copiar código

@Test(expected = IllegalArgumentException.class)

public void testTipoMaquinariaNoVacio() {

new Maquinaria("", 100, 70);

}

Test Horas Uso No Negativo

java

Copiar código

@Test(expected = IllegalArgumentException.class)

public void testHorasUsoNoNegativo() {

new Maquinaria("Tierra", -1, 70);

}

go

Copiar código

Este documento Markdown describe los diferentes tests realizados en la clase `MaquinariaTest`, junto con sus casos de prueba y las aserciones utilizadas.

Test Calcula Salario Anual

java

Copiar código

@Test

public void testCalculaSalarioAnual() {

double salarioAnual = empleado.calculaSalarioAnual();

assertEquals(18000.00, salarioAnual, 0.01);

}

Test Dar Aumento

java

Copiar código

@Test

public void testDarAumento() {

empleado.darAumento(10);

assertEquals(1650, empleado.getSalario(), 0.01);

}

Test Nombre Empleado No Vacío

java

Copiar código

@Test(expected = IllegalArgumentException.class)

public void testNombreEmpleadoNoVacio() {

new Empleado("", "Contable", 1500);

}

Test Salario Debe Ser Positivo

java

Copiar código

@Test(expected = IllegalArgumentException.class)

public void testSalarioDebeSerPositivo() {

new Empleado("Juan", "Contable", -1500);

}

go

Copiar código

Este documento Markdown describe los diferentes tests realizados en la clase `EmpleadosTest`, junto con sus casos de prueba y las aserciones utilizadas.

Test Calcular Tiempo Arado

java

Copiar código

@Test

public void testCalcularTiempoArado() {

int hectareas = 50;

double tiempoArado = hectareas / maquinaria.getEficiencia();

assertEquals(0.71, tiempoArado, 0.01);

assertFalse(tiempoArado >= 1);

}

Test Añadir Horas Trabajo

java

Copiar código

@Test

public void testAnyadirHorasTrabajo() {

maquinaria.anyadirHorasTrabajo(50);

assertEquals(150, maquinaria.getHoraUso(), 0.01);

assertTrue(maquinaria.getHoraUso() > 149);

}

Test Tipo Maquinaria No Vacío

java

Copiar código

@Test(expected = IllegalArgumentException.class)

public void testTipoMaquinariaNoVacio() {

new Maquinaria("", 100, 70);

}

Test Horas Uso No Negativo

java

Copiar código

@Test(expected = IllegalArgumentException.class)

public void testHorasUsoNoNegativo() {

new Maquinaria("Tierra", -1, 70);

}

go

Copiar código

Este Markdown describe los diferentes tests realizados en la clase `MaquinariaTest`, junto con sus casos de prueba y las aserciones utilizadas.

Test Unitarios

package org.antonio;

import org.junit.Before;

import org.junit.Test;

import static org.junit.Assert.*;

public class TestUnitarios {

Luffy luffy = null;

Zoro zoro = null;

@Before

public void setUp() {

luffy = new Luffy ("Luffy", 100);

zoro = new Zoro ("Zoro", 80);

}

@Test

public void testSettersLuffy() {

luffy.setNombre("Luffy");

luffy.setPoder(100);

assertEquals("Luffy", luffy.getNombre());

assertEquals(100, luffy.getPoder());

}

@Test

public void testSettersZoro() {

zoro.setNombre("Zoro");

zoro.setPoder(80);

assertEquals("Zoro", zoro.getNombre());

assertEquals(80, zoro.getPoder());

assertNotEquals("luffy", zoro.getNombre());

assertNotEquals(100, zoro.getPoder());

assertTrue(zoro.getPoder()<100);

assertFalse(zoro.getPoder() == 8);

}

package org.antonio;

import org.junit.Test;

import static org.junit.Assert.*;

public class TestBarco {

@Test

public void testAgregarTripulante() {

// Creamos la clase Barco con su nombre y su capacidad inicial de 5.

Barco barco = new Barco("Thousand Sunny", 5);

// Agregamos tripulantes

boolean resultado = barco.agregarTripulante();

// Verificamos que los tripulantes han sido agregados

assertTrue(resultado);

assertEquals(6, barco.getCapacidad());

}

@Test

public void testAgregarTripulanteMaximo() {

// Volvemos a crear la clase Barco pero esta vez la capacidad será de 10

Barco barco = new Barco("Going Merry", 10);

// Agregamos tripulantes

boolean resultado = barco.agregarTripulante();

// Verifaremos que ya no se pueda agrgar más tripulantes.

assertFalse(resultado);

assertEquals(10, barco.getCapacidad());

}

package org.antonio;

import org.junit.Test;

import static org.junit.Assert.*;

public class TestBatalla {

@Test

public void testAtaqueLuffy() {

// Con esto creamo las clases que nos piden de luffy y zoro con el nombre y el poder.

Personaje luffy = new Luffy("Monkey D. Luffy", 100);

Personaje zoro = new Zoro("Roronoa Zoro", 80);

// Luffy ataca a Zoro

luffy.atacar(zoro);

// Verificaremos que el poder de Zoro se reduzca a -20

assertEquals(-20, zoro.getPoder());

}

@Test

public void testAtaqueZoro() {

// Crearemos nuevamente las clases.

Personaje luffy = new Luffy("Monkey D. Luffy", 100);

Personaje zoro = new Zoro("Roronoa Zoro", 80);

// Zoro ataca a Luffy

zoro.atacar(luffy);

// Verificaremos que el poder de Luffy se reduzca a 20

assertEquals(20, luffy.getPoder());

}

package com.acalabuig;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotEquals;

import static org.junit.Assert.assertTrue;

import org.junit.Before;

import org.junit.Test;

import com.acalabuig.model.Cultivo;

public class CultivoTest

{

Cultivo cultivo = null;

Cultivo area = null;

Cultivo rendimiento = null;

Cultivo precioPorTonelada = null;

Cultivo exception = null;

@Before

public void setUp() {

cultivo = new Cultivo ("Trigo", 100.00, 5.00);

}

@Test

public void testSetters()

{

cultivo.setNombre("Trigo");

cultivo.setArea(100.00);

cultivo.setRendimiento(5.00);

assertEquals("Trigo", cultivo.getNombre());

assertEquals(100.00, cultivo.getArea(),0.01);

assertEquals(5.00, cultivo.getRendimiento(),0.01);

}

@Test

public void testCalcularRendimientoTotal()

{

assertEquals(500, cultivo.calcularRendimientoTotal(),0.01);

assertNotEquals(400, cultivo.calcularRendimientoTotal(),0.01);

assertTrue(cultivo.calcularRendimientoTotal() > 499);

}

@Test

public void testCalcularIngresos()

{

double precioPorTonelada = 100.00;

double ingresos = cultivo.calcularRendimientoTotal() * precioPorTonelada;

assertEquals(50000, ingresos,0.01);

assertTrue(ingresos > 0);

}

@Test (expected = IllegalArgumentException.class)

public void testNombreCultivoNoPuedeSerVacio()

{

new Cultivo("", 100, 5);

}

@Test (expected = IllegalArgumentException.class)

public void testNombreCultivoNoPuedeSerNull()

{

new Cultivo(null , 100, 5);

}

@Test (expected = IllegalArgumentException.class)

public void testAreaDebeSerPositivo()

{

new Cultivo("Trigo", -5, 5);

}

package com.acalabuig;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotEquals;

import static org.junit.Assert.assertTrue;

import org.junit.Before;

import org.junit.Test;

import com.acalabuig.model.Empleado;

public class EmpleadosTest {

Empleado nombre = null;

Empleado cargo = null;

Empleado salario = null;

Empleado empleado = null;

Empleado salarioAnual = null;

Empleado porcentaje = null;

@Before

public void setUp() {

empleado = new Empleado ("Juan", "Contable", 1500);

}

@Test

public void testSetters()

{

empleado.setNombre("Juan");

empleado.setCargo("Contable");

empleado.setSalario(1500);

assertEquals("Juan", empleado.getNombre());

assertEquals("Contable", empleado.getCargo());

assertEquals(1500, empleado.getSalario(),0.01);

}

@Test

public void testCalculaSalarioAnual()

{

double salarioAnual = empleado.calculaSalarioAnual();

assertEquals(18000.00, salarioAnual, 0.01);

}

@Test

public void testDarAumento()

{

empleado.darAumento(10);

assertEquals(1650, empleado.getSalario(), 0.01);

}

@Test (expected = IllegalArgumentException.class)

public void testNombreEmpleadoNoVacio()

{

new Empleado("","Contable",1500);

}

@Test (expected = IllegalArgumentException.class)

public void testSalarioDebeSerPositivo()

{

new Empleado("Juan","Contable",-1500);

}

package com.acalabuig;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertTrue;

import org.junit.Before;

import org.junit.Test;

import com.acalabuig.model.Empleado;

import com.acalabuig.model.Maquinaria;

public class MaquinariaTest {

Maquinaria tipo = null;

Maquinaria horaUso = null;

Maquinaria eficiencia = null;

Maquinaria hectaresa = null;

Maquinaria horasAdicionales = null;

Maquinaria maquinaria = null;

Maquinaria tiempoArado = null;

@Before

public void setUp() {

maquinaria = new Maquinaria ("Tierra", 100, 70);

}

@Test

public void testSetters()

{

maquinaria.setTipo("Juan");

maquinaria.setHoraUso(100);

maquinaria.setEficiencia(70);

assertEquals("Juan", maquinaria.getTipo());

assertEquals(100, maquinaria.getHoraUso(),0.01);

assertEquals(70, maquinaria.getEficiencia(),0.01);

}

@Test

public void testCalcularTiempoArado()

{

int hectareas = 50;

double tiempoArado = hectareas / maquinaria.getEficiencia();

assertEquals(0.71, tiempoArado,0.01);

assertFalse(tiempoArado >= 1);

}

@Test

public void testAnyadirHorasTrabajo()

{

maquinaria.anyadirHorasTrabajo(50);

assertEquals(150, maquinaria.getHoraUso(),0.01);

assertTrue( maquinaria.getHoraUso() > 149);

}

@Test (expected = IllegalArgumentException.class)

public void testTipoMaquinariaNoVacio()

{

new Maquinaria ("", 100, 70);

}

@Test (expected = IllegalArgumentException.class)

public void testHorasUsoNoNegativo()

{

new Maquinaria ("Tierra", -1, 70);

}

package com.acalabuig;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertFalse;

import static org.junit.Assert.assertNotEquals;

import static org.junit.Assert.assertTrue;

import org.junit.Before;

import org.junit.Test;

import com.acalabuig.model.Cultivo;

import com.acalabuig.model.Producto;

public class ProductoTest

{

Producto nombre = null;

Producto precio = null;

Producto producto = null;

Producto precioConDescuento = null;

Producto porcentajeDescuento = null;

@Before

public void setUp() {

producto = new Producto ("Trigo", 100.00);

}

@Test

public void testSetters()

{

producto.setNombre("Trigo");

producto.setPrecio(100.00);

assertEquals("Trigo", producto.getNombre());

assertEquals(100.00, producto.getPrecio(),0.01);

}

@Test

public void testCalcularPrecioConDescuento()

{

assertFalse(producto.calcularPrecioConDescuent(50) > 5);

}

@Test (expected = IllegalArgumentException.class)

public void testNombreProductoNoVacio()

{

producto = new Producto ("", 100.00);

}

@Test (expected = IllegalArgumentException.class)

public void testPrecioDebeSerPositivo()

{

producto = new Producto ("Trigo", -5);

}

@Test (expected = IllegalArgumentException.class)

public void testProductoDescuentoInvalidoPorAbajoException()

{

producto.calcularPrecioConDescuento(-1);

}

@Test (expected = IllegalArgumentException.class)

public void testProductoDescuentoInvalidoPorArribaException()

{

producto.calcularPrecioConDescuento(101);

}

package org.antonio;

import org.junit.Before;

import org.junit.Test;

import static org.junit.Assert.*;

import java.util.ArrayList;

import java.util.List;

import org.antonio.Exception.HeroeNoEncontradoException;

import org.antonio.Model.GestorHeroes;

import org.antonio.Model.Heroe;

public class TestHeroes {

Heroe ironman = null;

Heroe spiderman = null;

Heroe capitanAmeria = null;

GestorHeroes gh = null;

@Before

public void setUp() {

ironman = new Heroe ("Iron Man", "Traje de alta tecnología", "Millonario y filántropo", "Es alto");

spiderman= new Heroe("Spider-Man", "Sentido arácnido, trepador", "Tímido estudiante de secundaria", "Es adolecente");

capitanAmeria = new Heroe ("Capitán América", "Superfuerza, agilidad, resistencia", "Soldado de la Segunda Guerra Mundial","Es de otra época");

gh = new GestorHeroes();

gh.agregarHeroe(ironman);

gh.agregarHeroe(spiderman);

gh.agregarHeroe(capitanAmeria);

}

@Test

public void testSettersHeroe() {

Heroe catWoman = new Heroe(null, null,null,null);

catWoman.setNombre("Cat Woman");

catWoman.setSuperpoderes("Trepar y arañar");

catWoman.setBiografia("Es la amiga de Batman");

assertEquals("Cat Woman", catWoman.getNombre());

assertEquals("Trepar y arañar", catWoman.getSuperpoderes());

assertEquals("Es la amiga de Batman", catWoman.getBiografia());

assertNotEquals("Iron Man", catWoman.getNombre());

assertNotEquals("Traje de alta tecnología", catWoman.getSuperpoderes());

assertNotEquals("Millonario y filántropo", catWoman.getBiografia());

}

@Test

public void testGestorHeroes() throws HeroeNoEncontradoException {

List<Heroe>GestorHeroes = new ArrayList<Heroe>();

assertEquals("Iron Man", ironman.getNombre());

}

@Test

public void testagregarHeroe() {

Heroe catWoman = new Heroe("Catwoman", "Trepa y araña", "No es de Marvel","Es de DC");

List<Heroe> gestorHeroes = new ArrayList<Heroe>();

gestorHeroes.add(catWoman); // con esto agrego a la lista

// Con este test estoy comparando que Catwoman se ha agregado correctamente a su lista mencionado arriba

assertEquals("Catwoman", gestorHeroes.get(0).getNombre());

}

@Test

public void testbuscarHeroe() throws HeroeNoEncontradoException {

Heroe catWoman = new Heroe("Catwoman", "Trepa y araña", "No es de Marvel","Es de DC");

List<Heroe> gestorHeroes = new ArrayList<Heroe>();

gestorHeroes.add(ironman);

assertEquals("Iron Man", ironman.getNombre());

}

@Test(expected = HeroeNoEncontradoException.class)

public void testbuscarHeroeNoEncontrado() throws HeroeNoEncontradoException {

Heroe catWoman = new Heroe("Catwoman", "Trepa y araña", "No es de Marvel","Es de DC");

GestorHeroes gh = new GestorHeroes(); // me creo una clase llamada gh

gh.agregarHeroe(ironman);

gh.buscarHeroe("Catwoman");

}

// Tests de integración: Debes crear un test de integración que compruebe que

//la clase `GestorHeroes` funciona correctamente al agregar y buscar

//héroes.

@Test

public void testAgregarYBuscarHeroe() throws HeroeNoEncontradoException {

Heroe ironMan = new Heroe("Iron Man", "Traje de alta tecnología", "Millonario y filántropo","Es alto");

Heroe spiderMan = new Heroe("Spider-Man", "Sentido arácnido, trepador", "Tímido estudiante de secundaria","Es adolecente");

Heroe capitanAmerica = new Heroe("Capitán América", "Superfuerza, agilidad, resistencia", "Soldado de la Segunda Guerra Mundial","Es de otra época");

GestorHeroes gh = new GestorHeroes();

// con esto agregamos los héroes

gh.agregarHeroe(ironMan);

gh.agregarHeroe(spiderMan);

gh.agregarHeroe(capitanAmerica);

// Verificamos que los héroes se buscan correctamente, primero lo que esperamos que haga la función luego su super poder

assertEquals("Traje de alta tecnología", gh.buscarHeroe("Iron Man").getSuperpoderes());

assertEquals("Sentido arácnido, trepador", gh.buscarHeroe("Spider-Man").getSuperpoderes());

assertEquals("Superfuerza, agilidad, resistencia", gh.buscarHeroe("Capitán América").getSuperpoderes());

assertNotEquals("Superfuerza, agilidad, resistencia", gh.buscarHeroe("Spider-Man").getSuperpoderes());

}

@Test(expected = HeroeNoEncontradoException.class)

public void testBuscarHeroeNoEncontrado() throws HeroeNoEncontradoException {

GestorHeroes gh = new GestorHeroes();

// Buscaremos un heroe que no existe

gh.buscarHeroe("Catwoman");

}

// Test de actualización de héroe existente

@Test

public void testActualizarDescripcionHeroeExistente() throws HeroeNoEncontradoException {

// Creamos un héroe

Heroe capitanAmerica = new Heroe("Capitán América", "Superfuerza, agilidad, resistencia", "Soldado de la Segunda Guerra Mundial","Es de otra época");

GestorHeroes gh = new GestorHeroes();

// Agregamos el héroe

gh.agregarHeroe(capitanAmerica);

// Actualizamos la descripción del héroe

String nuevaDescripcion = "Líder de los Vengadores";

gh.actualizarDescripcionHeroe("Capitán América", nuevaDescripcion);

// Verificamos que la descripción se haya actualizado correctamente

assertEquals(nuevaDescripcion, gh.buscarHeroe("Capitán América").getDescripcion());

}

@Test

public void testEliminarHeroe() throws HeroeNoEncontradoException {

GestorHeroes gh= new GestorHeroes();

Heroe spiderman = new Heroe("Spider-Man", "Sentido arácnido, trepador", "Tímido estudiante de secundaria","Es adolecente");

gh.agregarHeroe(spiderman);

// Eliminamos al heroe

gh.eliminarHeroe("Spider-Man");

// Verificar que el héroe ha sido eliminado correctamente

assertTrue(gh.getHeroes().isEmpty());

assertEquals(0, gh.getHeroes().size());

}

@Test

public void testAgregarHeroe() throws HeroeNoEncontradoException {

GestorHeroes gh = new GestorHeroes();

// Agregamos a los heroes

gh.agregarHeroe(new Heroe("Iron Man", "Traje de alta tecnología", "Millonario y filántropo","Es alto"));

gh.agregarHeroe(new Heroe("Spider-Man", "Sentido arácnido, trepador", "Tímido estudiante de secundaria","Es adolecente"));

gh.agregarHeroe(new Heroe("Capitán América", "Superfuerza, agilidad, resistencia", "Soldado de la Segunda Guerra Mundial","Es de otra época"));

// Comprobamos que hemos agregado a los heroes

assertEquals(3, gh.getHeroes().size()); // el 3 son los heroes que esperamos

// con esto comprobamos que los heroes cumplen con sus atributos.

Heroe ironMan = gh.buscarHeroe("Iron Man");

assertEquals("Iron Man", ironMan.getNombre());

assertEquals("Traje de alta tecnología", ironMan.getSuperpoderes());

assertEquals("Millonario y filántropo", ironMan.getBiografia());

Heroe spiderMan = gh.buscarHeroe("Capitán América");

assertNotEquals("Spider-Man", spiderMan.getNombre());

assertNotEquals("Sentido arácnido, trepador", spiderMan.getSuperpoderes());

assertNotEquals("Tímido estudiante de secundaria", spiderMan.getBiografia());

Heroe capitanAmerica = gh.buscarHeroe("Capitán América");

assertEquals("Capitán América", capitanAmerica.getNombre());

assertEquals("Superfuerza, agilidad, resistencia", capitanAmerica.getSuperpoderes());

assertEquals("Soldado de la Segunda Guerra Mundial", capitanAmerica.getBiografia());

}

@Test

public void testBuscarHeroePorSuperpoder() throws HeroeNoEncontradoException {

GestorHeroes gh = new GestorHeroes();

// Agregar héroes

gh.agregarHeroe(new Heroe("Iron Man", "Traje de alta tecnología", "Millonario y filántropo","Es alto"));

// Buscamos al heroe por su superpoderes

Heroe heroeIronMan = gh.buscarHeroePorSuperpoder("Traje de alta tecnología"); //

assertNotNull(heroeIronMan); // con el asserNotNull comprombamos que el heroe "heroeIronMan" está agregado

assertEquals("Iron Man", heroeIronMan.getNombre()); // Iron Man es lo que queremos que sea correcto, en el getnombre.

}

@Test

public void testActualizarHeroe() throws HeroeNoEncontradoException {

GestorHeroes gh = new GestorHeroes();

gh.agregarHeroe(new Heroe("Iron Man", "Traje de alta tecnología", "Millonario y filántropo","Es alto"));

gh.agregarHeroe(new Heroe("Spider-Man", "Sentido arácnido, trepador", "Tímido estudiante de secundaria","Es adolecente"));

gh.agregarHeroe(new Heroe("Capitán América", "Superfuerza, agilidad, resistencia", "Soldado de la Segunda Guerra Mundial","Es de otra época"));

gh.agregarHeroe(new Heroe("Thor", "Superfuerza, agilidad, trueno", "Dios del trueno","Es un dios"));

// He creado a Thor como nuevo heroe, actualizando sus atributos

Heroe Thor= new Heroe("Thor", "Superfuerza, agilidad, trueno", "Dios del trueno","Es un dios ");

// Actualizamos al nuevo heroe Thor

gh.actualizarHeroe(Thor);

// comprobamos que se han realizado los cambios

assertEquals("Superfuerza, agilidad, trueno", gh.buscarHeroe("Thor").getSuperpoderes());

assertEquals("Dios del trueno", gh.buscarHeroe("Thor").getBiografia());

}

@Test

public void testListarHeroes() {

GestorHeroes gh= new GestorHeroes();

gh.agregarHeroe(new Heroe("Iron Man", "Traje de alta tecnología", "Millonario y filántropo","Es alto"));

gh.agregarHeroe(new Heroe("Spider-Man", "Sentido arácnido, trepador", "Tímido estudiante de secundaria","Es adolecente"));

gh.agregarHeroe(new Heroe("Capitán América", "Superfuerza, agilidad, resistencia", "Soldado de la Segunda Guerra Mundial","Es de otra época"));

String listaEsperada = "Iron Man, Spider-Man, Capitán América";

assertEquals(listaEsperada, gh.listarHeroes());

}

package org.antonio;

import org.junit.Assert.*;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotEquals;

import static org.junit.Assert.assertTrue;

import org.junit.Before;

import org.junit.Test;

public class CancionTest {

private Cancion cancion;

@Before

public void setUp() {

cancion = new Cancion("Bohemian Rhapsody", "Queen", 355);

}

@Test

public void TestTitulo(){

assertEquals("Bohemian Rhapsody", cancion.getTitulo());

assertNotEquals("Novenber rain", cancion.getTitulo());

}

@Test

public void TestArtista(){

assertEquals("Queen", cancion.getArtista());

assertNotEquals("Guns and Roser", cancion.getArtista());

}

@Test

public void TestDuracion(){

assertEquals(355, cancion.getDuracion());

assertTrue(0< cancion.getDuracion());

}

package org.antonio;

import org.junit.Assert.*;

import org.junit.Before;

import org.junit.Test;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertTrue;

import java.util.ArrayList;

import java.util.List;

import javax.swing.text.PlainDocument;

public class PlaylistTest {

private Cancion cancion1;

private Cancion cancion2;

private Cancion cancion3;

private Cancion cancion4;

private Playlist playlist;

@Before

public void setUp() {

cancion1 = new Cancion("Bohemian Rhapsody", "Queen", 355);

cancion2 = new Cancion("Imagine", "John Lennon", 180);

cancion3 = new Cancion("Hotel California", "Eagles", 390);

playlist = new Playlist("Mis Favoritas");

}

@Test

public void TestSetterPlaylist(){

assertEquals("Bohemian Rhapsody", cancion1.getTitulo());

assertEquals("Queen", cancion1.getArtista());

assertEquals(355, cancion1.getDuracion());

assertEquals("Imagine", cancion2.getTitulo());

assertEquals("John Lennon", cancion2.getArtista());

assertEquals(180, cancion2.getDuracion());

assertEquals("Hotel California", cancion3.getTitulo());

assertEquals("Eagles", cancion3.getArtista());

assertEquals(390, cancion3.getDuracion());

}

@Test

public void TestAgregarCancion(){

cancion1 = new Cancion("Bohemian Rhapsody", "Queen", 355);

Playlist.agregarCancion(cancion1);

Playlist.agregarCancion(cancion2);

assertEquals(2, Playlist.getCanciones().size());

}

@Test

public void testAgregarMultiplesCanciones(){

Playlist.agregarCancion(cancion1);

Playlist.agregarCancion(cancion2);

Playlist.agregarCancion(cancion3);

assertEquals(3, Playlist.getCanciones().size());

assertEquals("Bohemian Rhapsody", Playlist.getCanciones().get(0).getTitulo());

assertEquals(355, Playlist.getCanciones().get(0).getDuracion());

assertTrue(0< Playlist.getCanciones().get(0).getDuracion());

}

@Test

public void testEliminarCancion(){

Playlist.agregarCancion(cancion1);

Playlist.agregarCancion(cancion2);

Playlist.agregarCancion(cancion3);

Playlist.eliminarCancion(cancion1);

assertEquals(2, Playlist.getCanciones().size());

assertEquals("Imagine", Playlist.getCanciones().get(0).getTitulo());

assertEquals(180, Playlist.getCanciones().get(0).getDuracion());

assertTrue(0< Playlist.getCanciones().get(0).getDuracion());

}

@Test

public void testDuracionTotalPlaylist(){

Playlist.agregarCancion(cancion1);

Playlist.agregarCancion(cancion2);

assertEquals(535, Playlist.getDuracionTotal());

assertTrue(0 < Playlist.getDuracionTotal());

}

@Test

public void TestMostrarCanciones(){

Playlist.agregarCancion(cancion1);

String salida_canciones = Playlist.mostrarCanciones();

assertEquals(salida_canciones,Playlist.mostrarCanciones());

}

package org.antonio;

import org.junit.Assert.*;

import usuario.buscarCancionEnPlaylists;

import org.junit.Before;

import org.junit.Test;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotEquals;

import static org.junit.Assert.assertTrue;

import java.util.ArrayList;

import java.util.List;

import javax.swing.text.PlainDocument;

public class UsuarioTest {

private Usuario usuario;

private Playlist playlist1;

private Playlist playlist2;

private Playlist playlist3;

private Cancion cancion1;

private Cancion cancion2;

@Before

public void setUp() {

usuario = new Usuario("Juan");

playlist1 = new Playlist("Mis Favoritas");

playlist2 = new Playlist("Rock Clásico");

cancion1 = new Cancion("Bohemian Rhapsody", "Queen", 355);

cancion2 = new Cancion("Imagine", "John Lennon", 180);

}

@Test

public void TestSetterUsuarios(){

assertEquals("Juan", usuario.getNombre());

assertEquals("Rock Clásico", playlist1.getNombre());

assertEquals("Rock Clásico", playlist2.getNombre());

}

@Test

public void TestCrearPlaylist(){

playlist3 = new Playlist("nueva");

Usuario.agregarPlaylist(playlist3);

assertEquals("nueva", usuario.getPlaylists().get(0).getNombre());

}

@Test

public void TestEliminarPlaylist(){

playlist3 = new Playlist("nueva");

Usuario.agregarPlaylist(playlist3);

Usuario.eliminarPlaylist(playlist3);

assertEquals(0, Playlist.getCanciones().size());

assertTrue(usuario.getPlaylists().isEmpty());

}

@Test

public void TestMostrarPlaylist(){

Playlist.agregarPlaylist(playlist1);

String salida_canciones = Playlist.agregarPlaylist();

assertEquals(salida_canciones,Playlist.getPlaylists());

}

@Test

public void TestBuscarCancionesEnPlaylist(){

Playlist.agregarCancion(cancion1);

Playlist.agregarCancion(cancion2);

Usuario.agregarPlaylist(playlist1);

Usuario.eliminarPlaylist(playlist1);

buscarCancionEnPlaylists tituloCancion = new usuario.buscarCancionEnPlaylists("Bohemian Rhapsody");

assertEquals("Bohemian Rhapsody",playlist1.buscarCancionEnPlaylists("Bohemian Rhapsody"));

}

import static org.junit.Assert.*;

import org.acalabuig.Model.Hechizo;

import org.acalabuig.Model.Personaje;

import org.acalabuig.Model.Pocion;

import org.junit.Before;

import org.junit.Test;

public class praTestpersonaje {

private Personaje personaje;

private Personaje personaje2;

private Hechizo hechizo;

private Pocion pocion;

@Before

public void setUp() {

personaje = new Personaje("Harry Potter", "Gryffindor", 5);

personaje2 = new Personaje("Hermione Granger", "Gryffindor", 7);

hechizo = new Hechizo("Expelliarmus", "Encanto", 5);

pocion = new Pocion("Poción Multijugos", "Cambio de formas", 8);

}

@Test

public void testGetPersonajes(){

assertEquals("Harry Potter", personaje.getNombre());

assertEquals("Hermione Granger", personaje2.getNombre());

assertEquals("Gryffindor", personaje.getCasa());

assertEquals("Gryffindor", personaje2.getCasa());

assertEquals(5, personaje.getCurso());

assertEquals(7, personaje2.getCurso());

assertTrue(4< personaje.getCurso());

}

@Test

public void testSetPersonaje(){

personaje.setNombre("Rom");

personaje.setCasa("Hufflepuff");

personaje.setCurso(3);

assertEquals("Rom", personaje.getNombre());

assertEquals("Hufflepuff", personaje.getCasa());

assertEquals(3, personaje.getCurso());

}

@Test

public void testAvanzarCurso(){

personaje.avanzaCurso();

assertEquals(6, personaje.getCurso());

}

@Test

public void testEstaEnElUltimoCurso(){

assertTrue(personaje2.estaEnUltimoCurso());

assertFalse(personaje.estaEnUltimoCurso());

}

@Test

public void aprendeHechizo(){

hechizo = new Hechizo("Expelliarmus", "Encanto", 5);

personaje.aprendeHechizo(hechizo);

assertEquals(1, personaje.getHechizos().size());

assertEquals("Expelliarmus", personaje.getHechizos().get(0).getNombre());

assertTrue(personaje.getHechizos().contains(hechizo));

}

@Test

public void prepararPocion(){

personaje.preparaPocion(pocion);

assertEquals(1, personaje.getPociones().size());

assertEquals("Poción Multijugos", personaje.getPociones().get(0).getNombre());

assertTrue(personaje.getPociones().contains(pocion));

}

@Test (expected = IllegalArgumentException.class )

public void testNombrePersonajeNoPuedeSerVacio (){

new Personaje("", "Gryffindor", 5);

}

@Test (expected = IllegalArgumentException.class)

public void testCasaPersonajeNoPuedeSerVacio (){

new Personaje("Harry Potter", "", 5);

}

@Test(expected = IllegalArgumentException.class)

public void testCursoDebeSerValido() {

new Personaje("Ron Weasley", "Gryffindor", 8);

}

@Test (expected = IllegalStateException.class )

public void testNoAvanzaMasAllaDelUltimoCurso (){

personaje2.avanzaCurso();

}

import static org.junit.Assert.*;

import org.acalabuig.Model.Personaje;

import org.acalabuig.Model.Pocion;

import org.acalabuig.Model.Hechizo;

import org.junit.Test;

public class IntegrationTest {

@Test

public void testHogwartsManagementIntegration() {

Personaje harry = new Personaje("Harry Potter", "Gryffindor", 5);

Hechizo expelliarmus = new Hechizo("Expelliarmus", "Charm", 5);

Pocion polyjuice = new Pocion("Polyjuice Potion", "Shape-shifting", 8);

harry.aprendeHechizo(expelliarmus);

harry.preparaPocion(polyjuice);

assertEquals("Harry Potter", harry.getNombre());

assertEquals("Gryffindor", harry.getCasa());

assertEquals(5, harry.getCurso());

assertEquals(1, harry.getHechizos().size());

assertEquals("Expelliarmus", harry.getHechizos().get(0).getNombre());

assertEquals(1, harry.getPociones().size());

assertEquals("Polyjuice Potion", harry.getPociones().get(0).getNombre());

harry.avanzaCurso();

assertEquals(6, harry.getCurso());

assertFalse(harry.estaEnUltimoCurso());

assertEquals("Expelliarmus", expelliarmus.getNombre());

assertEquals("Charm", expelliarmus.getTipo());

assertEquals(5, expelliarmus.getDificultad());

expelliarmus.aumentarDificultad(3);

assertEquals(8, expelliarmus.getDificultad());

assertTrue(expelliarmus.esAvanzado());

assertEquals("Polyjuice Potion", polyjuice.getNombre());

assertEquals("Shape-shifting", polyjuice.getEfecto());

assertEquals(8, polyjuice.getTiempoElaboracion());

polyjuice.ampliarTiempoPreparacion(2);

assertEquals(10, polyjuice.getTiempoElaboracion());

assertFalse(polyjuice.preparacionRapida());

}