Zadanie 1


Napisz klasę o nazwie Bank posiadającą trzy metody zwrotne typu double o nazwach wyplata, wplata oraz saldo. Metody te powinny operować na polu klasowym stan (typ double) zwracając za każdym razem jego wartość. Wykonaj odpowiednie testy jednostkowe.


---------------------------------------------------------------------------------

package labq;

public class Bank {
private double stan;
Bank (){
stan=0;
}

Bank (double kwota){
stan=kwota;
}

public double wyplata (double kwota) throws Exception {
if (stan>kwota){
stan=stan-kwota;
return stan;
} else throw new Exception("Wypłata przekraczająca stan konta");

}

public double wplata (double kwota){
stan=stan+kwota;
return stan;
}

public double saldo (){
return stan;
}

}

-----------------------------------------------------------------------

package labq;

import org.junit.Test;
import static org.junit.Assert.*;

public class BankTest {

public BankTest() {
}

/**
* Test of wyplata method, of class Bank.
*/
@Test
public void testWyplata() throws Exception {
System.out.println("wyplata");
double kwota = 10.0;
Bank instance = new Bank(15.0);
double expResult = 5.0;
try {
double result = instance.wyplata(kwota);
assertEquals("Blad podczas wyplaty.", expResult, result, 0.0);
result = instance.wyplata(kwota);
} catch (Exception e) {
System.out.println("Wyjatki sa obslugiwane.");
}
}

/**
* Test of wplata method, of class Bank.
*/
@Test
public void testWplata() {
System.out.println("wplata");
double kwota = 10.0;
Bank instance = new Bank(10.0);
double expResult = 20.0;
double result = instance.wplata(kwota);
assertEquals("Blad podczas wplaty.",expResult, result, 0.0);
}

/**
* Test of saldo method, of class Bank.
*/
@Test
public void testSaldo() {
System.out.println("saldo");
Bank instance = new Bank();
double expResult = 0.0;
double result = instance.saldo();
assertEquals("Blad w saldzie.",expResult, result, 0.0);
}
}
---------------------------------------------------------------------------

Wnioski:

Głównym problemem było znalezienie sposobu jak poradzić sobie z testowaniem funkcji rzucającej wyjątek. Problem rozwiązałem stosując w metodzie klasy testowej standardową procedurę obsługi wyjątku (try - catch).
Zadanie 2
------------------------------------------------------------------------------------

Napisz implementację klasy zawierającej implementację następujących metod oraz wykonaj dla niej odpowiednie testy jednostkowe:


------------------------------------------------------------------------------------
package labq;

import java.util.EmptyStackException;

public interface StackExercise {

public String pop() throws EmptyStackException;

public void push(String item);


public String top() throws EmptyStackException;


public boolean isEmpty();
}

2) Kod klasy testowanej:

package labq;

import java.util.LinkedList;
import java.util.EmptyStackException;

public class Stos implements StackExercise {

private LinkedList lista;

public Stos() {
this.lista = new LinkedList();//lista elementów typu String
}

public String pop() throws EmptyStackException {
if (!lista.isEmpty()) {
String ostatniString = lista.getLast();
lista.removeLast();
return ostatniString;
} else {
throw new EmptyStackException();
}
}

public void push(String item) {
lista.addLast(item);
}

public String top() throws EmptyStackException {
if (!lista.isEmpty()) {
return lista.getLast();
}else {
throw new EmptyStackException();
}
}

public boolean isEmpty() {
return lista.isEmpty();
}
}}



--------------------------------------------------------------------------------

package labq;

import java.util.EmptyStackException;
import org.junit.Test;
import static org.junit.Assert.*;

public class StosTest {

public StosTest() {
}

/**
* Test of pop method, of class Stos.
*/
@Test
public void testPop() {
System.out.println("pop");
Stos instance = new Stos();
instance.push("testPop");
String expResult = "testPop";
try {
String result = instance.pop();
assertEquals("Blad wykonania Pop()", expResult, result);
result = instance.pop();
} catch (EmptyStackException e) {
System.out.println("wyjatek EmptyStackException jest obslugiwany przez Pop()");
}
}

/**
* Test of push method, of class Stos.
*/
@Test
public void testPush() {
System.out.println("push");
String item = "testPush";
Stos instance = new Stos();
String expResult = "testPush";
instance.push(item);
String result = instance.pop();
assertEquals("Blad wykonania Push()", expResult, result);
}

/**
* Test of top method, of class Stos.
*/
@Test
public void testTop() {
System.out.println("top");
String item = "testTop";
Stos instance = new Stos();
String expResult = "testTop";
try {
instance.push(item);
String result = instance.top();
assertEquals("Blad wykonania Top()", expResult, result);
instance.pop();
result = instance.top();
} catch (EmptyStackException e) {
System.out.println("wyjatek EmptyStackException jest obslugiwany przez Top()");
}
}

/**
* Test of isEmpty method, of class Stos.
*/
@Test
public void testIsEmpty() {
System.out.println("isEmpty");
Stos instance = new Stos();
boolean expResult = true;
boolean result = instance.isEmpty();
assertEquals("Blad wykonania IsEmpty()", expResult, result);
}
}

--------------------------------------------------------------------------------------

Wnioski:

Głównym problemem była taka konstrukcja klasy żeby nie miała ograniczeń co do wielkości stosu. Wynikało to z wymagań w interfejsie dotyczących metody push() która wg interfejsu nie miała ani żadnych wyjątków w stylu przepełnienie stosu.
W celu rozwiązania tego problemu, został użyty typowany kontener LinkedList do użycia z typem String.
W testach problemem zdawało się, że użycie metod klasy testowanej (np Push()) w celu testowania innych metod tej klasy jak Pop() czy Top() nie jest najwłaściwszym rozwiązaniem, ale w związku z tym że nigdzie nie znalazłem informacji że nie wolno tego robić, pozostawiłem takie rozwiązanie.