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());

   }

}