Java - Ejercicio con Java y Junit, AYUDAAAA!

 
Vista:
Imágen de perfil de Marta

Ejercicio con Java y Junit, AYUDAAAA!

Publicado por Marta (13 intervenciones) el 28/01/2023 12:11:21
Hola, necesito ayuda con este ejercicio de La Junta de Andalucía en Java con JUnit. Tengo que entregarlo mañana y con el trabajo estoy muy perdida de como realizarlo con JUnit. Me han dicho que es fácil, pero alguien me podía orientar y decirme como podría hacerlo? Estoy perdidísima! Muchas gracias.

Ejercicio:

En el proyecto Java que se adjunta (en el apartado Recursos necesarios), hay definida una clase de nombre

CCuenta

Esta clase dispone de varios métodos, entre ellos ingresar y retirar.

Se pretende que partiendo de una clase con métodos ya diseñados, se utilicen herramientas de depuración para corregir errores en el código. A continuación, se deberán diseñar casos de prueba, para verificar el comportamiento de los métodos ingresar y retirar.

(Realiza una ejecución paso a paso, que verifique el correcto funcionamiento de
la aplicación. Indica los valores que marca la inspección de variables tras crear el objeto miCuenta y ejecutar la instrucción
miCuenta.retirar(2300); en la función main
Diseña un caso de prueba que permita verificar el método ingresar.
Diseña un caso de prueba que permita verificar la función retirar.
Diseña un caso de prueba que permita verificar ingresar y retirar al mismo tiempo.
Ejecuta las pruebas y comenta el resultado

Os dejo el código de los 2 archivos.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public class CCuenta {
 
 
    // Propiedades de la Clase Cuenta
    private String nombre;
    private String cuenta;
    private double saldo;
    private double tipoInterés;
 
    /* Constructor sin argumentos */
    public CCuenta ()
    {
    }
    // Constructor con parámetro para iniciar todas las propiedades de la clase
    public CCuenta (String nom, String cue, double sal, double tipo)
    {
        nombre =nom;
        cuenta=cue;
        saldo=sal;
    }
   // Método para asignar el nombre del titular de la cuenta
    public void asignarNombre(String nom)
    {
        nombre=nom;
    }
    // Método que me devuelve el nombre del titular
    public String obtenerNombre()
    {
        return nombre;
    }
 
    // Método que me devuelve el saldo disponible en cada momento
     public double estado ()
    {
        return saldo;
    }
 
    /* Método para ingresar cantidades en la cuenta. Modifica el saldo.
     * Este método va a ser probado con Junit
     */
    public void ingresar(double cantidad) throws Exception
    {
        if (cantidad<0)
            throw new Exception("No se puede ingresar una cantidad negativa");
        saldo = saldo + cantidad;
    }
 
 
 
    /* Método para retirar cantidades en la cuenta. Modifica el saldo.
     * Este método va a ser probado con Junit
     */
    public void retirar (double cantidad) throws Exception
    {
        if (cantidad < 0)
            throw new Exception ("No se puede retirar una cantidad negativa");
        if (estado()< cantidad)
            throw new Exception ("No hay suficiente saldo");
        saldo = saldo - cantidad;
    }
 
    // Método que me devuelve el número de cuenta
    public String obtenerCuenta ()
    {
        return cuenta;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
public class Tarea3 {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        CCuenta miCuenta;
        double saldoActual;
 
        miCuenta = new CCuenta("Juan López","1000-2365-85-123456789",2500,0);
        try
        {
            miCuenta.retirar(-2300);
        } catch (Exception e)
        {
            System.err.println(e.getMessage());
            System.out.println("Fallo al retirar");
        }
 
        try
        {
            System.out.println("Ingreso en cuenta");
            miCuenta.ingresar(-1695);
        } catch (Exception e)
        {
            System.err.println(e.getMessage());
            System.out.println("Fallo al ingresar");
        }
        saldoActual = miCuenta.estado();
        System.out.println("El saldo actual es"+ saldoActual );
    }
 
}
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
sin imagen de perfil
Val: 26
Ha aumentado su posición en 4 puestos en Java (en relación al último mes)
Gráfica de Java

Ejercicio con Java y Junit, AYUDAAAA!

Publicado por antonio (32 intervenciones) el 28/01/2023 14:03:29
Hola buenas no hay que hacer muchos cambios esta seria una posible opción:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
public class Tarea3 {
    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        CCuenta miCuenta;
        double saldoActual;
 
        miCuenta = new CCuenta("Juan López","1000-2365-85-123456789",2500,0);
        //Caso retirar sin posibles errores
        try
        {
            miCuenta.retirar(2300);
        } catch (Exception e)
        {
            System.err.println(e.getMessage());
            System.out.println("Fallo al retirar");
        }
        saldoActual = miCuenta.estado();
        System.out.println("El saldo actual es "+ saldoActual );
        //Caso de retirar en negativo no puedes retirar -100€
        try
        {
            miCuenta.retirar(-100);
        } catch (Exception e)
        {
            System.err.println(e.getMessage());
            System.out.println("Fallo al retirar");
        }
        saldoActual = miCuenta.estado();
        System.out.println("El saldo actual es "+ saldoActual );
        //Caso retirar mas dinero del que hay ahora mismo hay 200, asi que probar con 500
        try
        {
            miCuenta.retirar(500);
        } catch (Exception e)
        {
            System.err.println(e.getMessage());
            System.out.println("Fallo al retirar");
        }
        saldoActual = miCuenta.estado();
        System.out.println("El saldo actual es "+ saldoActual );
        //Ingreso sin fallos
        try
        {
            System.out.println("Ingreso en cuenta");
            miCuenta.ingresar(1695);
        } catch (Exception e)
        {
            System.err.println(e.getMessage());
            System.out.println("Fallo al ingresar");
        }
        saldoActual = miCuenta.estado();
        System.out.println("El saldo actual es "+ saldoActual );
        //Caso ingresar negativo, no puedes ingresar -100€
        try
        {
            System.out.println("Ingreso en cuenta");
            miCuenta.ingresar(-100);
        } catch (Exception e)
        {
            System.err.println(e.getMessage());
            System.out.println("Fallo al ingresar");
        }
        saldoActual = miCuenta.estado();
        System.out.println("El saldo actual es "+ saldoActual );
 
        //Caso ingresar y retirar sin fallos
        try
        {
            System.out.println("Ingreso en cuenta");
            miCuenta.ingresar(100);
            System.out.println("Retirar en cuenta");
            miCuenta.retirar(100);
        } catch (Exception e)
        {
            System.err.println(e.getMessage());
 
        }
        saldoActual = miCuenta.estado();
        System.out.println("El saldo actual es "+ saldoActual );
        //Caso ingresar y retirar,cantidad ingreso negativa
        try
        {
            System.out.println("Ingreso en cuenta");
            miCuenta.ingresar(-100);
            System.out.println("Retirar en cuenta");
            miCuenta.retirar(100);
        } catch (Exception e)
        {
            System.err.println(e.getMessage());
            System.out.println("Fallo al ingresar");
        }
 
        saldoActual = miCuenta.estado();
        System.out.println("El saldo actual es "+ saldoActual );
        //Caso ingresar y retirar,cantidad retirada negativa
        try
        {
            System.out.println("Ingreso en cuenta");
            miCuenta.ingresar(100);
            System.out.println("Retirar en cuenta");
            miCuenta.retirar(-100);
        } catch (Exception e)
        {
            System.err.println(e.getMessage());
            System.out.println("Fallo al retirar");
        }
 
        saldoActual = miCuenta.estado();
        System.out.println("El saldo actual es "+ saldoActual );
    }
 
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public class CCuenta {
 
 
    // Propiedades de la Clase Cuenta
    private String nombre;
    private String cuenta;
    private double saldo;
    private double tipoInteres;
 
    /* Constructor sin argumentos */
    public CCuenta ()
    {
    }
    // Constructor con parámetro para iniciar todas las propiedades de la clase
    public CCuenta (String nom, String cue, double sal, double tipo)
    {
        nombre =nom;
        cuenta=cue;
        saldo=sal;
    }
   // Método para asignar el nombre del titular de la cuenta
    public void asignarNombre(String nom)
    {
        nombre=nom;
    }
    // Método que me devuelve el nombre del titular
    public String obtenerNombre()
    {
        return nombre;
    }
 
    // Método que me devuelve el saldo disponible en cada momento
     public double estado ()
    {
        return saldo;
    }
 
    /* Método para ingresar cantidades en la cuenta. Modifica el saldo.
     * Este método va a ser probado con Junit
     */
    public void ingresar(double cantidad) throws Exception
    {
        if (cantidad<0)
            throw new Exception("No se puede ingresar una cantidad negativa");
        saldo = saldo + cantidad;
    }
 
 
 
    /* Método para retirar cantidades en la cuenta. Modifica el saldo.
     * Este método va a ser probado con Junit
     */
    public void retirar (double cantidad) throws Exception
    {
        if (cantidad < 0)
            throw new Exception ("No se puede retirar una cantidad negativa");
        if (estado()< cantidad)
            throw new Exception ("No hay suficiente saldo");
        saldo = saldo - cantidad;
    }
 
    // Método que me devuelve el número de cuenta
    public String obtenerCuenta ()
    {
        return cuenta;
    }
}

Ahora solo tienes que explicar cada caso que esta puesto, explicarte que cuando haces las dos operaciones a la vez ingresar y retirar si hay excepción en la primera operación la segunda no se realiza ya que los lenguajes de programación van ejecutando línea a línea si no hay fallos; y si da excepción se sale del try y catch a exception saltandose las otras líneas, por lo que en este caso si retirar va después de ingresar y retirar da fallo la acción retirar no se realizaría ¿esto es un fallo? depende de como quieras realizar hay programas que necesitan si o si que se ejecute algo antes para que todo vaya hacerse correcto ¿este es el caso? esto yo no lo se, porque no lo especifica el apartado, lo normal es que en cualquier banco como ves hay 2 apartados uno para retirar y otro para ingresar para que estos posibles fallos (otras transacciones de fondo que no se ven esto no tienes que decirlo) no se produzcan así que diría que no es un error per se, pero podría serlo según quien corrija este ejercicio.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
Imágen de perfil de Marta

Ejercicio con Java y Junit, AYUDAAAA!

Publicado por Marta (13 intervenciones) el 28/01/2023 14:13:38
Muchas gracias por tu ayuda y por la explicación!!!

Estoy viendo también vídeotutoriales de Junit para poner al día. Gracias!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Marta

Ejercicio con Java y Junit, AYUDAAAA!

Publicado por Marta (13 intervenciones) el 31/01/2023 13:29:53
Pues no soy capaz de hacerlo sin que pase todos los test :/
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar
Imágen de perfil de Richtofen

Ejercicio con Java y Junit, AYUDAAAA!

Publicado por Richtofen (18 intervenciones) el 01/02/2023 13:28:39
Realmente lo que se supone que tienes que hacer, por lo que entiendo del ejercicio, es usar la libreria de JUNIT, así que en tu código deberían aparecer test unitarios con @Test en vez de comprobar las cosas en un main manualmente.

Dicho esto, como tus casos son muy sencillos y los cubres todos o comprobando el número resultante o viendo que sale el mensaje de la excepción es el correcto, tus tests no irán más allá de eso. Te dejo aquí debajo unos ejemplos de tests unitarios según lo que te pide, que verifica automaticamente los numeros que salen como las excepciones que tienen que saltar en cada momento. Échale un ojo para familiarizarte con los métodos de Assert, que son los que se encargan de comporbar por ti que todo va bien

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
import org.junit.Assert;
import org.junit.Test;
 
public class TestCuenta {
 
 
  @Test
  public void testIngresar()
  {
    CCuenta miCuenta = new CCuenta("Spiderman", "Spidercuenta", 1000.0, 0.0);
    /** ++++++++++ PRIMER CASO: Ingresas dinero, no hay problema  ++++++++++ **/
    try {
      miCuenta.ingresar(2000);
      Assert.assertEquals(3000.0, miCuenta.estado(), 0.01 );
    }
    catch (Exception e) {
      // Nunca va a pasar por aqui
      e.printStackTrace();
    }
    /** ++++++++++ SEGUNDO CASO: Ingresas dinero negativo  ++++++++++ **/
    try {
      miCuenta.ingresar(-3);
    }
    catch (Exception e) {
      Assert.assertTrue( e.getMessage().contains("No se puede ingresar una cantidad negativa"));
    }
  }
 
  @Test
  public void testRetirar()
  {
    CCuenta miCuenta = new CCuenta("Spiderman", "Spidercuenta", 1000.0, 0.0);
    /** ++++++++++ PRIMER CASO: Retiras dinero y se te queda en la cuenta lo que esperabas ++++++++++ **/
    try {
      miCuenta.retirar(500);
      Assert.assertEquals(500.0, miCuenta.estado(), 0.01 );
    }
    catch (Exception e) {
      // Nunca va a pasar por aqui
      e.printStackTrace();
    }
    /**  +++++++++++++++++++++++++++ SEGUNDO CASO: Retiras dinero negativo  ++++++++++++++++++++++++++ **/
    try {
      miCuenta.retirar(-10);
    }
    catch (Exception e) {
      Assert.assertTrue( e.getMessage().contains("No se puede retirar una cantidad negativa"));
    }
    /** ++++++++++++++++++++++++ TERCER CASO: Retiras más dinero del que tienes  +++++++++++++++++++++ **/
    try {
      miCuenta.retirar(5000);
    }
    catch (Exception e) {
      Assert.assertTrue( e.getMessage().contains("No hay suficiente saldo"));
    }
  }
 
 
  @Test
  public void testIngresarYRetirar()
  {
    CCuenta miCuenta = new CCuenta("Spiderman", "Spidercuenta", 1000.0, 0.0);
    /** ++++++++++++++++++++++++ INGRESAR: CORRECTO  +++++++++++++++++++++ **/
    try {
      miCuenta.ingresar(400);
      Assert.assertEquals(1400, miCuenta.estado(), 0.01);
    }
    catch (Exception e) {
      e.printStackTrace();
    }
    /** ++++++++++++++++++++++++ RETIRAR: CORRECTO  +++++++++++++++++++++ **/
    try {
      miCuenta.retirar(400);
      Assert.assertEquals(1000, miCuenta.estado(), 0.01);
    }
    catch (Exception e) {
      e.printStackTrace();
    }
    /** ++++++++++++++++++++++++ INGRESAR: FALLO  +++++++++++++++++++++ **/
    try {
      miCuenta.ingresar(-748);
    }
    catch (Exception e) {
      Assert.assertTrue( e.getMessage().contains("No se puede ingresar una cantidad negativa"));
    }
    /** ++++++++++++++++++++++++ RETIRAR: FALLO  +++++++++++++++++++++ **/
    try {
      miCuenta.ingresar(1200);
    }
    catch (Exception e) {
      Assert.assertTrue( e.getMessage().contains("No hay suficiente saldo"));
    }
    /** ++++++++++++++++++++++++ RETIRAR: FALLO  +++++++++++++++++++++ **/
    try {
      miCuenta.retirar(-45);
    }
    catch (Exception e) {
      Assert.assertTrue( e.getMessage().contains("No se puede retirar una cantidad negativa"));
    }
 
  }
 
}

Hay mejores formas de hacerlo, ya sea con @Rule o metiendo una expectedException en @Test, pero si estás empezando esta es la forma más legible a mi parecer.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
1
Comentar
Imágen de perfil de Marta

Ejercicio con Java y Junit, AYUDAAAA!

Publicado por Marta (13 intervenciones) el 02/02/2023 10:52:41
Muchas gracias por tu tiempo y explicación! Voy a probarlo y como dices familiarizarme con JUnit poco a poco. GRACIAS!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar