diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..524f096 --- /dev/null +++ b/.gitignore @@ -0,0 +1,24 @@ +# Compiled class file +*.class + +# Log file +*.log + +# BlueJ files +*.ctxt + +# Mobile Tools for Java (J2ME) +.mtj.tmp/ + +# Package Files # +*.jar +*.war +*.nar +*.ear +*.zip +*.tar.gz +*.rar + +# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml +hs_err_pid* +replay_pid* diff --git a/bin/ATM.class b/bin/ATM.class deleted file mode 100644 index 76543bf..0000000 Binary files a/bin/ATM.class and /dev/null differ diff --git a/bin/ATMCaseStudy.class b/bin/ATMCaseStudy.class deleted file mode 100644 index 607c10d..0000000 Binary files a/bin/ATMCaseStudy.class and /dev/null differ diff --git a/bin/Account.class b/bin/Account.class deleted file mode 100644 index 5d2d636..0000000 Binary files a/bin/Account.class and /dev/null differ diff --git a/bin/BalanceInquiry.class b/bin/BalanceInquiry.class deleted file mode 100644 index 48f8e6a..0000000 Binary files a/bin/BalanceInquiry.class and /dev/null differ diff --git a/bin/BankDatabase.class b/bin/BankDatabase.class deleted file mode 100644 index 429aec1..0000000 Binary files a/bin/BankDatabase.class and /dev/null differ diff --git a/bin/CashDispenser.class b/bin/CashDispenser.class deleted file mode 100644 index b8cedba..0000000 Binary files a/bin/CashDispenser.class and /dev/null differ diff --git a/bin/Deposit.class b/bin/Deposit.class deleted file mode 100644 index 57b0c3f..0000000 Binary files a/bin/Deposit.class and /dev/null differ diff --git a/bin/DepositSlot.class b/bin/DepositSlot.class deleted file mode 100644 index a2664ad..0000000 Binary files a/bin/DepositSlot.class and /dev/null differ diff --git a/bin/Keypad.class b/bin/Keypad.class deleted file mode 100644 index 9b066e2..0000000 Binary files a/bin/Keypad.class and /dev/null differ diff --git a/bin/Screen.class b/bin/Screen.class deleted file mode 100644 index a036758..0000000 Binary files a/bin/Screen.class and /dev/null differ diff --git a/bin/Transaction.class b/bin/Transaction.class deleted file mode 100644 index 1330b55..0000000 Binary files a/bin/Transaction.class and /dev/null differ diff --git a/bin/Withdrawal.class b/bin/Withdrawal.class deleted file mode 100644 index 291d645..0000000 Binary files a/bin/Withdrawal.class and /dev/null differ diff --git a/componenti.txt b/componenti.txt new file mode 100644 index 0000000..bff3267 --- /dev/null +++ b/componenti.txt @@ -0,0 +1,4 @@ +Thomas Ghione 5254284 +Simone Tomasella 5311626 + +Abbiamo avuto un merge conflict da feature a main, ma non siamo sicuri sia evidente nel DAG, se vuole possiamo mostrarglielo direttamente a lezione se lo ritiene necessario diff --git a/src/ATMCaseStudy.java b/src/code/Business_Logic/ATMCaseStudy.java similarity index 96% rename from src/ATMCaseStudy.java rename to src/code/Business_Logic/ATMCaseStudy.java index b9033bd..f79f75a 100644 --- a/src/ATMCaseStudy.java +++ b/src/code/Business_Logic/ATMCaseStudy.java @@ -1,3 +1,6 @@ +package code.Business_Logic; + +import code.GUI.ATM; // ATMCaseStudy.java // Driver program for the ATM case study 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..ce7614b 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/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..ed3addf 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/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..056734a 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/Account.java b/src/code/Database/Account.java similarity index 80% rename from src/Account.java rename to src/code/Database/Account.java index c308eca..e6fbc3c 100644 --- a/src/Account.java +++ b/src/code/Database/Account.java @@ -1,3 +1,4 @@ +package code.Database; // 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/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..8a5c7ac 100644 --- a/src/BankDatabase.java +++ b/src/code/Database/BankDatabase.java @@ -1,3 +1,4 @@ +package code.Database; // BankDatabase.java // Represents the bank account information database @@ -9,12 +10,12 @@ 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 - private Account getAccount( int accountNumber ) + public Account getAccount( int accountNumber ) { // loop through accounts searching for matching account number for ( Account currentAccount : accounts ) @@ -42,25 +43,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/code/Database/Euro.java b/src/code/Database/Euro.java new file mode 100644 index 0000000..869b952 --- /dev/null +++ b/src/code/Database/Euro.java @@ -0,0 +1,48 @@ +package code.Database; + +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/ATM.java b/src/code/GUI/ATM.java similarity index 97% rename from src/ATM.java rename to src/code/GUI/ATM.java index aa3d187..7e4ea9e 100644 --- a/src/ATM.java +++ b/src/code/GUI/ATM.java @@ -1,6 +1,12 @@ +package code.GUI; // ATM.java // Represents an automated teller machine +import code.Business_Logic.CashDispenser; +import code.Business_Logic.DepositSlot; +import code.Business_Logic.Transaction; +import code.Database.BankDatabase; + public class ATM { private boolean userAuthenticated; // whether user is authenticated diff --git a/src/BalanceInquiry.java b/src/code/GUI/BalanceInquiry.java similarity index 92% rename from src/BalanceInquiry.java rename to src/code/GUI/BalanceInquiry.java index d45fa6a..fc5da7c 100644 --- a/src/BalanceInquiry.java +++ b/src/code/GUI/BalanceInquiry.java @@ -1,6 +1,11 @@ +package code.GUI; // BalanceInquiry.java // Represents a balance inquiry ATM transaction +import code.Business_Logic.Transaction; +import code.Database.BankDatabase; +import code.Database.Euro; + public class BalanceInquiry extends Transaction { // BalanceInquiry constructor @@ -18,11 +23,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/Deposit.java b/src/code/GUI/Deposit.java similarity index 91% rename from src/Deposit.java rename to src/code/GUI/Deposit.java index 916ef70..29f756a 100644 --- a/src/Deposit.java +++ b/src/code/GUI/Deposit.java @@ -1,9 +1,15 @@ +package code.GUI; // Deposit.java // Represents a deposit ATM transaction +import code.Business_Logic.DepositSlot; +import code.Business_Logic.Transaction; +import code.Database.BankDatabase; +import code.Database.Euro; + public class Deposit extends Transaction { - private double amount; // amount to deposit + private Euro amount; // amount to deposit private Keypad keypad; // reference to keypad private DepositSlot depositSlot; // reference to deposit slot private final static int CANCELED = 0; // constant for cancel option @@ -30,7 +36,7 @@ public void execute() amount = promptForDepositAmount(); // get deposit amount from user // check whether user entered a deposit amount or canceled - if ( amount != CANCELED ) + if ( amount.getValore() != CANCELED ) { // request deposit envelope containing specified amount screen.displayMessage( @@ -65,7 +71,7 @@ public void execute() } // end method execute // prompt user to enter a deposit amount in cents - private double promptForDepositAmount() + private Euro promptForDepositAmount() { Screen screen = getScreen(); // get reference to screen @@ -76,10 +82,10 @@ private double promptForDepositAmount() // check whether the user canceled or entered a valid amount if ( input == CANCELED ) - return CANCELED; + return new Euro(0); else { - return ( double ) input / 100; // return dollar amount + return new Euro(input / 100); // return dollar amount } // end else } // end method promptForDepositAmount } // end class Deposit 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..404dab9 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.Database.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/Withdrawal.java b/src/code/GUI/Withdrawal.java similarity index 94% rename from src/Withdrawal.java rename to src/code/GUI/Withdrawal.java index 6e0af62..fe2dddf 100644 --- a/src/Withdrawal.java +++ b/src/code/GUI/Withdrawal.java @@ -1,6 +1,12 @@ +package code.GUI; // Withdrawal.java // Represents a withdrawal ATM transaction +import code.Business_Logic.CashDispenser; +import code.Business_Logic.Transaction; +import code.Database.BankDatabase; +import code.Database.Euro; + public class Withdrawal extends Transaction { private int amount; // amount to withdraw @@ -27,7 +33,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(); @@ -47,13 +53,13 @@ public void execute() bankDatabase.getAvailableBalance( getAccountNumber() ); // check whether the user has enough money in the account - if ( amount <= availableBalance ) + if ( amount <= availableBalance.getValore() ) { // 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(), new Euro(amount) ); cashDispenser.dispenseCash( amount ); // dispense cash cashDispensed = true; // cash was dispensed diff --git a/src/test/TestAccount.java b/src/test/TestAccount.java new file mode 100644 index 0000000..8665289 --- /dev/null +++ b/src/test/TestAccount.java @@ -0,0 +1,103 @@ +package test; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +import code.Database.Account; +import code.Database.Euro; + +public class TestAccount { + Account account; + + @Before + public void setUp () { + account = new Account(12345,54321, new Euro(1000.0), new Euro(1200.0)); + } + + + // Test for validatePIN // + + @Test + public void validatePINOKTest () { + assertTrue( account.validatePIN( 54321 ) ); + } + + @Test + public void validatePINFAILURETest () { + assertFalse( account.validatePIN( 123213 ) ); + } + + + // Test for getAvailableBalace // + + @Test + public void getAvailableBalanceOKTest () { + assertTrue( new Euro(1000).ugualeA(account.getAvailableBalance()) ); + } + + @Test + public void getAvailableBalanceFAILURETest () { + assertFalse( new Euro(100).ugualeA(account.getAvailableBalance()) ); + } + + + // Test for getTotalBalance // + + @Test + public void getTotalBalanceOKTest () { + assertTrue( new Euro(1200).ugualeA(account.getTotalBalance()) ); + } + + @Test + public void getTotalBalanceFAILURETest () { + assertFalse( new Euro(100).ugualeA(account.getTotalBalance()) ); + } + + + // Test for credit // + + @Test + public void creditOKTest () { + account.credit(new Euro(200)); + assertTrue(new Euro(1400).ugualeA(account.getTotalBalance())); + } + + @Test + public void CreditNegativeOKtest () { + account.credit(new Euro(-200)); + assertTrue(new Euro(1000).ugualeA(account.getTotalBalance())); + } + + + // Test for debit // + + @Test + public void debitOKTest () { + account.debit(new Euro(200)); + assertTrue(new Euro(800).ugualeA(account.getAvailableBalance())); + assertTrue(new Euro(1000).ugualeA(account.getTotalBalance())); + } + + @Test + public void debitNegativeOKTest () { + account.debit(new Euro(2000)); + assertTrue(new Euro(-1000).ugualeA(account.getAvailableBalance())); + assertTrue(new Euro(-800).ugualeA(account.getTotalBalance())); + } + + + // Test for getAccountNumber // + + @Test + public void getAccountNumberOKTest () { + assertEquals(12345, account.getAccountNumber()); + } + + @Test + public void GetAccountNumberFAILURETest () { + assertNotEquals(123145, account.getAccountNumber()); + } + +} diff --git a/src/test/TestBankDatabase.java b/src/test/TestBankDatabase.java new file mode 100644 index 0000000..8a3cb80 --- /dev/null +++ b/src/test/TestBankDatabase.java @@ -0,0 +1,147 @@ +package test; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +import code.Database.BankDatabase; +import code.Database.Euro; +import code.Database.Account; + +public class TestBankDatabase { + + BankDatabase database; + Account acc1; + Account acc2; + + + @Before + public void setUp() { + database = new BankDatabase(); + } + + // Tests for getAccount // + + @Test + public void getAccountOKTest1() { + acc1 = new Account(12345,54321, new Euro(1000.0), new Euro(1200.0)); + assertEquals(acc1.getAccountNumber(), database.getAccount(12345).getAccountNumber()); + } + + @Test + public void getAccountOKTest2() { + acc2 = new Account(98765,56789, new Euro(500.0), new Euro(520.0)); + assertEquals(acc2.getAccountNumber(), database.getAccount(98765).getAccountNumber()); + } + + @Test + public void getAccountFAILURETest() { + assertThrows(java.lang.NullPointerException.class, () -> + database.getAccount(123213).getAccountNumber()); + } + + + // Tests for authenticateUser // + + @Test + public void authenticateUserOKTest1() { + assertTrue(database.authenticateUser(12345, 54321)); + } + + @Test + public void authenticateUserOKTest2() { + assertTrue(database.authenticateUser(98765, 56789)); + } + + @Test + public void authenticateUserFAILURETest() { + assertFalse(database.authenticateUser(12712, 19922)); + } + + // Tests for getAvailableBalance // + + @Test + public void getAvailableBalanceOKTest1() { + assertEquals(100000, database.getAvailableBalance(12345).getValore()); + } + + @Test + public void getAvailableBalanceOKTest2() { + assertEquals(20000, database.getAvailableBalance(98765).getValore()); + } + + @Test + public void getAvailableBalanceFAILURETest() { + assertThrows(java.lang.NullPointerException.class, () -> + database.getAvailableBalance(123213).getValore()); + } + + + // Tests for getTotalBalance // + + @Test + public void getTotalBalanceOKTest1() { + assertEquals(120000, database.getTotalBalance(12345).getValore()); + } + + @Test + public void getTotalBalanceOKTest2() { + assertEquals(20000, database.getTotalBalance(98765).getValore()); + } + + @Test + public void getTotalBalanceFAILURETest() { + assertThrows(java.lang.NullPointerException.class, () -> + database.getTotalBalance(123213).getValore()); + } + + + // Tests for credit // + + @Test + public void creditOKTest1() { + Euro initialBalance = database.getTotalBalance(12345); + database.credit(12345, new Euro(200)); + assertTrue(initialBalance.somma(new Euro(200)).ugualeA(database.getTotalBalance(12345))); + } + + @Test + public void creditOKTest2() { + Euro initialBalance = database.getTotalBalance(98765); + database.credit(98765, new Euro(500)); + assertTrue(initialBalance.somma(new Euro(500)).ugualeA(database.getTotalBalance(98765))); + } + + // Ci aspettiamo che il saldo totale aumenti se l'importo da accreditare è negativo + @Test + public void creditFAILURETest() { + Euro initialBalance = database.getTotalBalance(12345); + database.credit(12345, new Euro(-200)); + assertTrue(initialBalance.sottrai(new Euro(200)).ugualeA(database.getTotalBalance(12345))); + } + + // Tests for debit // + + @Test + public void debitOKTest1() { + Euro initialBalance = database.getAvailableBalance(12345); + database.debit(12345, new Euro(200)); + assertTrue(initialBalance.sottrai(new Euro(200)).ugualeA(database.getAvailableBalance(12345))); + } + + @Test + public void debitOKTest2() { + Euro initialBalance = database.getAvailableBalance(98765); + database.debit(98765, new Euro(500)); + assertTrue(initialBalance.sottrai(new Euro(500)).ugualeA(database.getAvailableBalance(98765))); + } + + // Ci aspettiamo che il saldo disponibile aumenti se l'importo da addebitare è negativo + @Test + public void debitFAILURETest() { + Euro initialBalance = database.getAvailableBalance(12345); + database.debit(12345, new Euro(-200)); + assertTrue(initialBalance.somma(new Euro(200)).ugualeA(database.getAvailableBalance(12345))); + } +} \ No newline at end of file diff --git a/src/test/TestEuro.java b/src/test/TestEuro.java new file mode 100644 index 0000000..26907a2 --- /dev/null +++ b/src/test/TestEuro.java @@ -0,0 +1,269 @@ +package test; + +import static org.junit.Assert.*; + +import org.junit.Before; +import org.junit.Test; + +import code.Database.Euro; + +public class TestEuro { + + // Single argument (Double Values) + Euro value1; + Euro value2; + Euro negativeValue1; + Euro negativeValue2; + Euro doubleValue; + Euro negativeDoubleValue1; + Euro negativeDoubleValue2; + + // Two arguments (long euro, long cent) + Euro value3; + Euro value4; + Euro negativeEuroT; + Euro negativeCentT; + Euro negativeEuroAndCentT; + + @Before + public void setUp() { + value1 = new Euro(35); + value2 = new Euro(15); + negativeValue1 = new Euro(-11); + negativeValue2 = new Euro(-33); + doubleValue = new Euro(42.75); + negativeDoubleValue1 = new Euro(-12.33); + negativeDoubleValue2 = new Euro(-24.52); + + value3 = new Euro(25, 10); + value4 = new Euro(72, 54); + negativeEuroT = new Euro(-50,30); + negativeCentT = new Euro(50, -30); + negativeEuroAndCentT = new Euro(-50, -30); + } + + + // Tests for initialize Euro // + @Test + public void InitOneArgumentOKTest() { + assertEquals(3500, value1.getValore()); + } + + @Test + public void InitDoubleValueOKTest() { + assertEquals(4275, doubleValue.getValore()); + } + + @Test + public void InitNegativeDoubleValueOKTest() { + assertEquals(-1233, negativeDoubleValue1.getValore()); + } + + @Test + public void InitTwoArgumentsOKTest() { + assertEquals(2510, value3.getValore()); + } + + @Test + public void InitNegativeEuroOKTest() { + assertEquals(-5030, negativeEuroT.getValore()); + } + + @Test + public void InitNegativeCentOKTest() { + assertEquals(4970, negativeCentT.getValore()); + } + + @Test + public void InitNegativeEuroAndCentOKTest() { + assertEquals(-4970, negativeEuroAndCentT.getValore()); + } + + + + // Tests for sum // + @Test + public void SommaOneArgumentBothPositiveOKTest() { + Euro result = value1.somma(value2); + assertEquals(5000, result.getValore()); + } + + @Test + public void SommaOneArgumentOneNegativeOKTest() { + Euro result = value1.somma(negativeValue1); + assertEquals(2400, result.getValore()); + } + + @Test + public void SommaOneArgumentBothNegativeOKTest() { + Euro result = negativeValue1.somma(negativeValue2); + assertEquals(-4400, result.getValore()); + } + + @Test + public void SommaOneArgumentOneNegativeDoubleOKTest() { + Euro result = negativeDoubleValue1.somma(value1); + assertEquals(2267, result.getValore()); + } + + @Test + public void SommaOneArgumentBothNegativeDoubleOKTest(){ + Euro result = negativeDoubleValue1.somma(negativeDoubleValue2); + assertEquals(-3685, result.getValore()); + } + + + @Test + public void SommaTwoArgumentsBothPositiveOKTest() { + Euro result = value3.somma(value4); + assertEquals(9764, result.getValore()); + } + + @Test + public void SommaTwoArgumentsOneNegativeOKTest() { + Euro result = value3.somma(negativeEuroT); + assertEquals(-2520, result.getValore()); + } + + @Test + public void SommaTwoArgumentBothNegativeOKTest() { + Euro result = negativeEuroT.somma(negativeCentT); + assertEquals(-60, result.getValore()); + } + + + @Test + public void SommaMixedArgumentsOKTest() { + Euro result = value1.somma(value3); + assertEquals(6010, result.getValore()); + } + + + + + // Tests for sub // + + @Test + public void SottraiOneArgumentBothPositiveOKTest() { + Euro result = value1.sottrai(value2); + assertEquals(2000, result.getValore()); + } + + @Test + public void SottraiOneArgumentOneNegativeOKTest() { + Euro result = value1.sottrai(negativeValue1); + assertEquals(4600, result.getValore()); + } + + @Test + public void SottraiOneArgumentBothNegativeOKTest() { + Euro result = negativeValue1.sottrai(negativeValue2); + assertEquals(2200, result.getValore()); + } + + @Test + public void SottraiOneArgumentOneNegativeDoubleOKTest() { + Euro result = negativeDoubleValue1.sottrai(value1); + assertEquals(-4733, result.getValore()); + } + + @Test + public void SottraiOneArgumentBothNegativeDoubleOKTest(){ + Euro result = negativeDoubleValue1.sottrai(negativeDoubleValue2); + assertEquals(1219, result.getValore()); + } + + + @Test + public void SottraiTwoArgumentsBothPositiveOKTest() { + Euro result = value3.sottrai(value4); + assertEquals(-4744, result.getValore()); + } + + @Test + public void SottraiTwoArgumentsOneNegativeOKTest() { + Euro result = value3.sottrai(negativeEuroT); + assertEquals(7540, result.getValore()); + } + + @Test + public void SottraiTwoArgumentBothNegativeOKTest() { + Euro result = negativeEuroT.sottrai(negativeCentT); + assertEquals(-10000, result.getValore()); + } + + + @Test + public void SottraiMixedArgumentsOKTest() { + Euro result = value1.sottrai(value3); + assertEquals(990, result.getValore()); + } + + + + // Tests EqualsTo // + + @Test + public void UgualeA1OKTest() { + assertTrue(value1.ugualeA(new Euro (35, 0))); + } + + @Test + public void UgualeA2OKTest() { + Euro val1 = new Euro(10); + Euro val2 = new Euro(5); + Euro result = val1.somma(val2); + assertTrue(value2.ugualeA(result)); + } + + @Test + public void NotUgualeAFAILURETest() { + assertFalse(value4.ugualeA(negativeDoubleValue1)); + } + + + // Tests LessThan // + + @Test + public void MinoreDi1OKTest() { + assertTrue(value2.minoreDi(value1)); + } + + @Test + public void MinoreDi2OKTest() { + assertTrue(doubleValue.minoreDi(new Euro(60))); + } + + @Test + public void MinoreDi3FAILURETest() { + assertFalse(negativeDoubleValue1.minoreDi(negativeDoubleValue2)); + } + + + // Tests Print // + + @Test + public void StampaOneArgument1OKTest() { + assertEquals("35.0 euro", value1.stampa()); + } + + @Test + public void StampaOneArgument2OKTest() { + assertEquals("15.0 euro", value2.stampa()); + } + + @Test + public void StampaTwoArguments1OKTest() { + assertEquals("25.1 euro", value3.stampa()); + } + + @Test + public void StampaTwoArguments2OKTest() { + assertEquals("72.54 euro", value4.stampa()); + } + + @Test + public void StampaFalseOKTest() { + assertNotEquals("128.44 euro", negativeDoubleValue1.stampa()); + } +} \ No newline at end of file