diff --git a/componenti.txt b/componenti.txt new file mode 100644 index 0000000..4b4104e --- /dev/null +++ b/componenti.txt @@ -0,0 +1 @@ +Andrea Celotto -> s4676081 \ No newline at end of file diff --git a/lib/hamcrest-core-1.3.jar b/lib/hamcrest-core-1.3.jar new file mode 100644 index 0000000..9d5fe16 Binary files /dev/null and b/lib/hamcrest-core-1.3.jar differ diff --git a/lib/junit-4.13.2.jar b/lib/junit-4.13.2.jar new file mode 100644 index 0000000..6da55d8 Binary files /dev/null and b/lib/junit-4.13.2.jar differ diff --git a/src/ATM.java b/src/code/Business_logic/ATM.java similarity index 98% rename from src/ATM.java rename to src/code/Business_logic/ATM.java index aa3d187..2c80bc1 100644 --- a/src/ATM.java +++ b/src/code/Business_logic/ATM.java @@ -1,6 +1,11 @@ +package code.Business_logic; // ATM.java // Represents an automated teller machine +import code.Database.BankDatabase; +import code.GUI.Keypad; +import code.GUI.Screen; + public class ATM { private boolean userAuthenticated; // whether user is authenticated diff --git a/src/ATMCaseStudy.java b/src/code/Business_logic/ATMCaseStudy.java similarity index 97% rename from src/ATMCaseStudy.java rename to src/code/Business_logic/ATMCaseStudy.java index b9033bd..7a4dc31 100644 --- a/src/ATMCaseStudy.java +++ b/src/code/Business_logic/ATMCaseStudy.java @@ -1,3 +1,4 @@ +package code.Business_logic; // ATMCaseStudy.java // Driver program for the ATM case study diff --git a/src/Account.java b/src/code/Business_logic/Account.java similarity index 80% rename from src/Account.java rename to src/code/Business_logic/Account.java index c308eca..dcc8e78 100644 --- a/src/Account.java +++ b/src/code/Business_logic/Account.java @@ -1,3 +1,4 @@ +package code.Business_logic; // Account.java // Represents a bank account @@ -5,12 +6,12 @@ public class Account { private int accountNumber; // account number private int pin; // PIN for authentication - private double availableBalance; // funds available for withdrawal - private double totalBalance; // funds available + pending deposits + private Euro availableBalance; // funds available for withdrawal + private Euro totalBalance; // funds available + pending deposits // Account constructor initializes attributes public Account( int theAccountNumber, int thePIN, - double theAvailableBalance, double theTotalBalance ) + Euro theAvailableBalance, Euro theTotalBalance ) { accountNumber = theAccountNumber; pin = thePIN; @@ -28,28 +29,28 @@ public boolean validatePIN( int userPIN ) } // end method validatePIN // returns available balance - public double getAvailableBalance() + public Euro getAvailableBalance() { return availableBalance; } // end getAvailableBalance // returns the total balance - public double getTotalBalance() + public Euro getTotalBalance() { return totalBalance; } // end method getTotalBalance // credits an amount to the account - public void credit( double amount ) + public void credit( Euro amount ) { - totalBalance += amount; // add to total balance + totalBalance.somma(amount); // add to total balance } // end method credit // debits an amount from the account - public void debit( double amount ) + public void debit( Euro amount ) { - availableBalance -= amount; // subtract from available balance - totalBalance -= amount; // subtract from total balance + availableBalance.sottrai(amount); // subtract from available balance + totalBalance.sottrai(amount); // subtract from total balance } // end method debit // returns account number diff --git a/src/BalanceInquiry.java b/src/code/Business_logic/BalanceInquiry.java similarity index 94% rename from src/BalanceInquiry.java rename to src/code/Business_logic/BalanceInquiry.java index d45fa6a..90f3b45 100644 --- a/src/BalanceInquiry.java +++ b/src/code/Business_logic/BalanceInquiry.java @@ -1,6 +1,10 @@ +package code.Business_logic; // BalanceInquiry.java // Represents a balance inquiry ATM transaction +import code.Database.BankDatabase; +import code.GUI.Screen; + public class BalanceInquiry extends Transaction { // BalanceInquiry constructor @@ -18,11 +22,11 @@ public void execute() Screen screen = getScreen(); // get the available balance for the account involved - double availableBalance = + Euro availableBalance = bankDatabase.getAvailableBalance( getAccountNumber() ); // get the total balance for the account involved - double totalBalance = + Euro totalBalance = bankDatabase.getTotalBalance( getAccountNumber() ); // display the balance information on the screen diff --git a/src/CashDispenser.java b/src/code/Business_logic/CashDispenser.java similarity index 98% rename from src/CashDispenser.java rename to src/code/Business_logic/CashDispenser.java index b249faf..b74b4ef 100644 --- a/src/CashDispenser.java +++ b/src/code/Business_logic/CashDispenser.java @@ -1,3 +1,4 @@ +package code.Business_logic; // CashDispenser.java // Represents the cash dispenser of the ATM diff --git a/src/Deposit.java b/src/code/Business_logic/Deposit.java similarity index 93% rename from src/Deposit.java rename to src/code/Business_logic/Deposit.java index 916ef70..59e77ca 100644 --- a/src/Deposit.java +++ b/src/code/Business_logic/Deposit.java @@ -1,6 +1,11 @@ +package code.Business_logic; // Deposit.java // Represents a deposit ATM transaction +import code.Database.BankDatabase; +import code.GUI.Keypad; +import code.GUI.Screen; + public class Deposit extends Transaction { private double amount; // amount to deposit @@ -32,10 +37,11 @@ public void execute() // check whether user entered a deposit amount or canceled if ( amount != CANCELED ) { + Euro newAmount = new Euro(amount); // request deposit envelope containing specified amount screen.displayMessage( "\nPlease insert a deposit envelope containing " ); - screen.displayDollarAmount( amount ); + screen.displayDollarAmount( newAmount ); screen.displayMessageLine( "." ); // receive deposit envelope @@ -50,7 +56,7 @@ public void execute() "enclosed cash and your checks clear." ); // credit account to reflect the deposit - bankDatabase.credit( getAccountNumber(), amount ); + bankDatabase.credit( getAccountNumber(), newAmount ); } // end if else // deposit envelope not received { diff --git a/src/DepositSlot.java b/src/code/Business_logic/DepositSlot.java similarity index 98% rename from src/DepositSlot.java rename to src/code/Business_logic/DepositSlot.java index 64e02c2..e310a6b 100644 --- a/src/DepositSlot.java +++ b/src/code/Business_logic/DepositSlot.java @@ -1,3 +1,4 @@ +package code.Business_logic; // DepositSlot.java // Represents the deposit slot of the ATM diff --git a/src/code/Business_logic/Euro.java b/src/code/Business_logic/Euro.java new file mode 100644 index 0000000..8af55ad --- /dev/null +++ b/src/code/Business_logic/Euro.java @@ -0,0 +1,49 @@ +package code.Business_logic; + +public class Euro { + + private long valore; + + public Euro (long euro, long cent){ + if (euro>=0){ + valore=euro*100+cent; + } else{ + valore=euro*100-cent; + } + } + + public Euro(double d){ + valore=(long)(d*100); + } + + public long getValore() { + return valore; + } + + public Euro somma(Euro e) { + this.valore = this.valore+e.getValore(); + return this; + } + + public Euro sottrai(Euro e) { + this.valore = this.valore-e.getValore(); + return this; + } + + public boolean ugualeA(Euro e) { + if (valore==e.getValore()) { + return true; + } else return false; + } + + public boolean minoreDi(Euro e) { + if (valore<=e.getValore()) { + return true; + } else return false; + } + + public String stampa(){ + return (double)valore/100+" euro"; + } + +} diff --git a/src/Transaction.java b/src/code/Business_logic/Transaction.java similarity index 96% rename from src/Transaction.java rename to src/code/Business_logic/Transaction.java index 508fea8..5256dca 100644 --- a/src/Transaction.java +++ b/src/code/Business_logic/Transaction.java @@ -1,6 +1,10 @@ +package code.Business_logic; // Transaction.java // Abstract superclass Transaction represents an ATM transaction +import code.Database.BankDatabase; +import code.GUI.Screen; + public abstract class Transaction { private int accountNumber; // indicates account involved diff --git a/src/Withdrawal.java b/src/code/Business_logic/Withdrawal.java similarity index 94% rename from src/Withdrawal.java rename to src/code/Business_logic/Withdrawal.java index 6e0af62..24daa58 100644 --- a/src/Withdrawal.java +++ b/src/code/Business_logic/Withdrawal.java @@ -1,6 +1,11 @@ +package code.Business_logic; // Withdrawal.java // Represents a withdrawal ATM transaction +import code.Database.BankDatabase; +import code.GUI.Keypad; +import code.GUI.Screen; + public class Withdrawal extends Transaction { private int amount; // amount to withdraw @@ -27,7 +32,7 @@ public Withdrawal( int userAccountNumber, Screen atmScreen, public void execute() { boolean cashDispensed = false; // cash was not dispensed yet - double availableBalance; // amount available for withdrawal + Euro availableBalance; // amount available for withdrawal // get references to bank database and screen BankDatabase bankDatabase = getBankDatabase(); @@ -42,18 +47,20 @@ public void execute() // check whether user chose a withdrawal amount or canceled if ( amount != CANCELED ) { + Euro newAmount = new Euro(amount); + // get available balance of account involved availableBalance = bankDatabase.getAvailableBalance( getAccountNumber() ); // check whether the user has enough money in the account - if ( amount <= availableBalance ) + if ( newAmount.minoreDi(availableBalance) ) { // check whether the cash dispenser has enough money if ( cashDispenser.isSufficientCashAvailable( amount ) ) { // update the account involved to reflect withdrawal - bankDatabase.debit( getAccountNumber(), amount ); + bankDatabase.debit( getAccountNumber(), newAmount ); cashDispenser.dispenseCash( amount ); // dispense cash cashDispensed = true; // cash was dispensed diff --git a/src/BankDatabase.java b/src/code/Database/BankDatabase.java similarity index 86% rename from src/BankDatabase.java rename to src/code/Database/BankDatabase.java index 3978497..958f4a9 100644 --- a/src/BankDatabase.java +++ b/src/code/Database/BankDatabase.java @@ -1,6 +1,10 @@ +package code.Database; // BankDatabase.java // Represents the bank account information database +import code.Business_logic.Account; +import code.Business_logic.Euro; + public class BankDatabase { private Account accounts[]; // array of Accounts @@ -9,8 +13,8 @@ public class BankDatabase public BankDatabase() { accounts = new Account[ 2 ]; // just 2 accounts for testing - accounts[ 0 ] = new Account( 12345, 54321, 1000.0, 1200.0 ); - accounts[ 1 ] = new Account( 98765, 56789, 200.0, 200.0 ); + accounts[ 0 ] = new Account( 12345, 54321, new Euro(1000,0), new Euro(1200,0) ); + accounts[ 1 ] = new Account( 98765, 56789, new Euro(200,0), new Euro(200,0) ); } // end no-argument BankDatabase constructor // retrieve Account object containing specified account number @@ -42,25 +46,25 @@ public boolean authenticateUser( int userAccountNumber, int userPIN ) } // end method authenticateUser // return available balance of Account with specified account number - public double getAvailableBalance( int userAccountNumber ) + public Euro getAvailableBalance( int userAccountNumber ) { return getAccount( userAccountNumber ).getAvailableBalance(); } // end method getAvailableBalance // return total balance of Account with specified account number - public double getTotalBalance( int userAccountNumber ) + public Euro getTotalBalance( int userAccountNumber ) { return getAccount( userAccountNumber ).getTotalBalance(); } // end method getTotalBalance // credit an amount to Account with specified account number - public void credit( int userAccountNumber, double amount ) + public void credit( int userAccountNumber, Euro amount ) { getAccount( userAccountNumber ).credit( amount ); } // end method credit // debit an amount from of Account with specified account number - public void debit( int userAccountNumber, double amount ) + public void debit( int userAccountNumber, Euro amount ) { getAccount( userAccountNumber ).debit( amount ); } // end method debit diff --git a/src/Keypad.java b/src/code/GUI/Keypad.java similarity index 98% rename from src/Keypad.java rename to src/code/GUI/Keypad.java index cd035c7..f0f716c 100644 --- a/src/Keypad.java +++ b/src/code/GUI/Keypad.java @@ -1,3 +1,4 @@ +package code.GUI; // Keypad.java // Represents the keypad of the ATM import java.util.Scanner; // program uses Scanner to obtain user input diff --git a/src/Screen.java b/src/code/GUI/Screen.java similarity index 91% rename from src/Screen.java rename to src/code/GUI/Screen.java index 44d3f30..24d8edb 100644 --- a/src/Screen.java +++ b/src/code/GUI/Screen.java @@ -1,6 +1,9 @@ +package code.GUI; // Screen.java // Represents the screen of the ATM +import code.Business_logic.Euro; + public class Screen { // displays a message without a carriage return @@ -16,9 +19,9 @@ public void displayMessageLine( String message ) } // end method displayMessageLine // display a dollar amount - public void displayDollarAmount( double amount ) + public void displayDollarAmount( Euro amount ) { - System.out.printf( "$%,.2f", amount ); + System.out.printf( amount.stampa() ); } // end method displayDollarAmount } // end class Screen diff --git a/src/test/TestAccount.java b/src/test/TestAccount.java new file mode 100644 index 0000000..b340ab0 --- /dev/null +++ b/src/test/TestAccount.java @@ -0,0 +1,80 @@ +package test; + +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 code.Business_logic.Account; +import code.Business_logic.Euro; + +public class TestAccount { + + private Account Account1; + private Account Account2; + private Account Account3; + + private Euro Euro0; + + @Before + public void init (){ + Account1 = new Account(1, 1, new Euro(1000), new Euro(1250)); + Account2 = new Account(2, 2, new Euro(2000), new Euro(2500)); + Account3 = new Account(3, 3, new Euro(5000), new Euro(5000)); + Euro0 = new Euro(250); + } + + @Test + public void testCredit(){ + Account1.credit(Euro0); + Account2.credit(Euro0); + Account3.credit(Euro0); + assertEquals(150000, Account1.getTotalBalance().getValore()); + assertEquals(275000, Account2.getTotalBalance().getValore()); + assertEquals(525000, Account3.getTotalBalance().getValore()); + } + + @Test + public void testDebit(){ + Account1.debit(Euro0); + Account2.debit(Euro0); + Account3.debit(Euro0); + assertEquals(100000, Account1.getTotalBalance().getValore()); + assertEquals(225000, Account2.getTotalBalance().getValore()); + assertEquals(475000, Account3.getTotalBalance().getValore()); + } + + @Test + public void testGetAccountNumber() { + assertEquals(1, Account1.getAccountNumber()); + assertEquals(2, Account2.getAccountNumber()); + assertEquals(3, Account3.getAccountNumber()); + } + + @Test + public void testGetTotalBalance() { + assertEquals(125000, Account1.getTotalBalance().getValore()); + assertEquals(250000, Account2.getTotalBalance().getValore()); + assertEquals(500000, Account3.getTotalBalance().getValore()); + } + + @Test + public void testGetAvailableBalance() { + assertEquals(100000, Account1.getAvailableBalance().getValore()); + assertEquals(200000, Account2.getAvailableBalance().getValore()); + assertEquals(500000, Account3.getAvailableBalance().getValore()); + } + + @Test + public void testValidatePin() { + assertTrue(Account1.validatePIN(1)); + assertTrue(Account2.validatePIN(2)); + assertTrue(Account3.validatePIN(3)); + assertFalse(Account1.validatePIN(2)); + assertFalse(Account2.validatePIN(3)); + assertFalse(Account3.validatePIN(1)); + } + +} diff --git a/src/test/TestBankDatabase.java b/src/test/TestBankDatabase.java new file mode 100644 index 0000000..34f1f14 --- /dev/null +++ b/src/test/TestBankDatabase.java @@ -0,0 +1,81 @@ +package test; + +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 code.Business_logic.Account; +import code.Business_logic.Euro; +import code.Database.BankDatabase; + +public class TestBankDatabase { + + BankDatabase Bank0; + + Account Account1; + Account Account2; + + Euro Euro0; + + @Before + public void setup() { + Bank0 = new BankDatabase(); + + Account1 = new Account( 12345, 54321, new Euro(1000,0), new Euro(1200,0) ); + Account2 = new Account( 98765, 56789, new Euro(200,0), new Euro(200,0) ); + + Euro0 = new Euro(500); + } + + @Test + public void testAuthenticateUser() { + assertTrue(Bank0.authenticateUser(12345, 54321)); + assertFalse(Bank0.authenticateUser(12345, 12345)); + + assertTrue(Bank0.authenticateUser(Account1.getAccountNumber(), 54321)); + assertFalse(Bank0.authenticateUser(Account1.getAccountNumber(), 12345)); + + assertTrue(Bank0.authenticateUser(98765, 56789)); + assertFalse(Bank0.authenticateUser(98765, 98765)); + + assertTrue(Bank0.authenticateUser(Account2.getAccountNumber(), 56789)); + assertFalse(Bank0.authenticateUser(Account2.getAccountNumber(), 98765)); + } + + @Test + public void testCredit() { + Bank0.credit(98765, Euro0); + assertEquals(70000, Bank0.getTotalBalance(98765).getValore()); + + Bank0.credit(Account1.getAccountNumber(), Euro0); + assertEquals(170000, Bank0.getTotalBalance(Account1.getAccountNumber()).getValore()); + } + + @Test + public void testDebit() { + Bank0.debit(12345, Euro0); + assertEquals(50000, Bank0.getAvailableBalance(12345).getValore()); + assertEquals(70000, Bank0.getTotalBalance(12345).getValore()); + + Bank0.debit(Account2.getAccountNumber(), Euro0); + assertEquals(-30000, Bank0.getAvailableBalance(Account2.getAccountNumber()).getValore()); + assertEquals(-30000, Bank0.getTotalBalance(Account2.getAccountNumber()).getValore()); + } + + @Test + public void testGetAvailableBalance() { + assertEquals(100000, Bank0.getAvailableBalance(12345).getValore()); + assertEquals(20000, Bank0.getAvailableBalance(Account2.getAccountNumber()).getValore()); + + } + + @Test + public void testGetTotalBalance() { + assertEquals(120000, Bank0.getTotalBalance(Account1.getAccountNumber()).getValore()); + assertEquals(20000, Bank0.getTotalBalance(98765).getValore()); + } + +} diff --git a/src/test/TestEuro.java b/src/test/TestEuro.java new file mode 100644 index 0000000..649132d --- /dev/null +++ b/src/test/TestEuro.java @@ -0,0 +1,76 @@ +package test; + +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 code.Business_logic.Euro; + +public class TestEuro { + + Euro Euro1; + Euro Euro2; + Euro Euro3; + Euro Euro4; + Euro Euro5; + + @Before + public void init(){ + Euro1 = new Euro(0,20); + Euro2 = new Euro(0.50); + Euro3 = new Euro(1,0); + Euro4 = new Euro(2); + Euro5 = new Euro(5, 0); + } + + @Test + public void testGetValore() { + assertEquals(20, Euro1.getValore()); + assertEquals(50, Euro2.getValore()); + assertEquals(100, Euro3.getValore()); + assertEquals(200, Euro4.getValore()); + assertEquals(500, Euro5.getValore()); + } + + @Test + public void testMinoreDi() { + assertTrue("Errore riscontrato in MinoreDi(Test1): Euro1 ("+Euro1.getValore()+") dovrebbe avere un valore più basso di Euro2 ("+Euro2.getValore()+")", Euro1.minoreDi(Euro2)); + assertTrue("Errore riscontrato in MinoreDi(Test2): Euro2 ("+Euro2.getValore()+") dovrebbe avere un valore più basso di Euro5 ("+Euro5.getValore()+")", Euro2.minoreDi(Euro5)); + assertTrue("Errore riscontrato in MinoreDi(Test3): Euro3 ("+Euro3.getValore()+") dovrebbe avere un valore più basso di Euro4 ("+Euro4.getValore()+")", Euro3.minoreDi(Euro4)); + assertFalse("Errore riscontrato in MinoreDi(Test4): Euro5 ("+Euro5.getValore()+") dovrebbe avere un valore più alto di Euro4 ("+Euro4.getValore()+")", Euro5.minoreDi(Euro4)); + assertFalse("Errore riscontrato in MinoreDi(Test5): Euro4 ("+Euro4.getValore()+") dovrebbe avere un valore più alto di Euro1 ("+Euro1.getValore()+")", Euro4.minoreDi(Euro1)); + assertFalse("Errore riscontrato in MinoreDi(Test6): Euro3 ("+Euro3.getValore()+") dovrebbe avere un valore più alto di Euro2 ("+Euro2.getValore()+")", Euro3.minoreDi(Euro2)); + } + + @Test + public void testSomma() { + assertEquals(250, Euro2.somma(Euro4).getValore()); + assertEquals(120, Euro1.somma(Euro3).getValore()); + assertEquals(600, Euro3.somma(Euro5).getValore()); + } + + @Test + public void testSottrai() { + assertEquals(300, Euro5.sottrai(Euro4).getValore()); + assertEquals(180, Euro4.sottrai(Euro1).getValore()); + assertEquals(50, Euro3.sottrai(Euro2).getValore()); + } + + @Test + public void testStampa() { + assertEquals("0.2 euro", Euro1.stampa()); + assertEquals("0.5 euro", Euro2.stampa()); + assertEquals("1.0 euro", Euro3.stampa()); + assertEquals("2.0 euro", Euro4.stampa()); + assertEquals("5.0 euro", Euro5.stampa()); + } + + @Test + public void testUgualeA() { + Euro Euro6 = new Euro(2, 0); + assertTrue("Errore riscontrato in UgualeA(Test1): Euro4 ("+Euro4.getValore()+") e Euro6 ("+Euro6.getValore()+") dovrebbero avere lo stesso valore", Euro4.ugualeA(Euro6)); + } +}