OverviewConstruct a hierarchy of classes representing savings and checking accounts as well as a means to ‘filter’account objects.Account ClassesYour solution will consist of 4 account classes as described below. It is your responsibility to define theexact relationship among those classes and translate that relationship into source code structure. There is acorrect structure; the skeleton must be modified to reflect the correct relationships. Account – represents a general account with basic operations such as deposit, withdraw, etc. Savings – represents a savings account that must maintain a minimum balance. Checking – represents a checking account that has no minimum balance (this means a zerobalance). CappedChecking – represents a checking account that disallows a balance above a particularmaximum value.Linking AccountsA bank or credit typically allows a user the ability to link accounts together. That is, I might wish to linkmy checking account with my savings account. If I overdraw from my savings account, then the appropriateamount of money is transferred from my savings account into my checking account to prevent against theoverdraw. In this program we wish to simulate this concept with the following requirements: A checking account may only be linked to a savings account (and vice versa). An account may only be linked to one other account. An account may not be linked to itself. An account may exist without a link to another account.In this program, we consider a link to be bidirectional; that is, if account A is linked to account B, then Bis only linked to account A. If the user wishes to link account C to A, then the bidirectional link from A toB must be unlinked before A is then linked to C.Depositing / Withdrawing Funds and ExceptionsIn this program we will use the following rule for deposits: if a deposit operation is unsuccessful aLinkAccountException will be thrown. For example, if a deposit exceeds the maximum amountallowed in the account and the account is not linked, an exception will be thrown. If the account is linked,the remaining monies will be transferred to the linked account.If a withdrawal operation is unsuccessful an InsufficientFundsException will be thrown. Forexample, if a withdrawal exceeds the minimum of an account (and its linked account), an exception shallbe thrown. In the case that a withdrawal results in an account dropping below the minimum, an appropriateamount of funds shall be transferred from the linked account to the current account in order to attain theminimum balance.FilteringIn database computations, it is often necessary to filter a select set of objects from a larger set. In thisproject, each account will be labeled as Filterable. That is, you must appropriately define an abstractIn java 2:54 Sprintll 23%VOLTEclass or interface representing the filterable notion. Each such filterable class must implement the methodboolean accept () which returns true or false based on the following criteria:A checking account is deemed acceptable if it is linked to an account that is acceptable.A savings account is deemed acceptable if it maintains at least the minimum amount.BankThe Bank class will act as a repository for different accounts, both savings and checking. The classshould be a simple class that:• Maintains an ArrayList of accounts,• The ability to add an account (addAccount),The ability to acquire the filtered list of accounts (getFiltered returns an ArrayList ofAccount objects). The filtered set of accounts is based on the accept method.An accessor method (size) that returns the umber of accounts stored in the Bank.TestingA complete test suite has been provided. This includes AccountTester, BankTester, and theabstract parent class, Tester.Tester - an abstract class defining several instance variables objects used by each inheriting testing class.Account Tester - a concrete class that implements all functionality required to test the four accountclasses.BankTester - a concrete class that implements all functionality required to test the Bank class.The Main class initiates the complete test suite.RequirementsThe program must meet all the requirements as tested from main via the testing classes and describedon the first page of this document.There are also a few other requirements.• The minimum amount for a savings account is $100. There is no maximum.• The minimum amount for a checking account is $0. There is no maximum for a standardchecking account, while capped checking accounts have maximum S10000.Any method that has an object as a parameter must be checked to verify the object is not null.SpecificationsFor clarity, you will implement the following methods in the corresponding classes. You may implementaccessor methods as required.ClassMethodsBankaddAccount, getFiltered, size as described above.link - given an account acct, link this account with acct.unlink - unlinks this account with acct.Account-deposits a given amount of money into the account as describedpreviously.II withdraw - withdraw a given amount of money from the account as describedpreviously.getMinimum - returns the minimum amount of money required by the particularaccount.| Checkingaccept - as described previously.link - given an account acct, link this account with acct.CappedChecking deposit - deposits a given amount of money into the account as describedpreviously.link - given an account acct, link this account with acct.RecommendationsReview the code that has been provided in the skeleton.In the corresponding Tester (AccountTester or BankTester), you may opt to commentout any of the tests in runAll while writing / testing your code.Test all account code first and perform bank tests second.

The following Code: public class Main{public static void main(String[] args){AccountTester acctTester = new AccountTester();BankTester bankTester = new BankTester(); System.out.println("\nAccount Tests:\n");acctTester.runAll(); System.out.println("\nBank Tests:\n");bankTester.runAll();}}------------------------------------------------------------------------------public class Account implements Filterable{// current balance of this accountprotected double _balance;public double getBalance() { return _balance; } // name of this accountprotected String _name;public String getName() { return _name; } // account linked to this oneprotected Account _link;public Account getLink() { return _link; } public Account(){this("");} public Account(String name){_name = name;_balance = 0;_link = null;} public boolean link(Account linkAcct){//check for null parameterif (linkAcct == null) return false; //check if linkAcct is this accountif (this == linkAcct) return false; //undo any previous linkunlink(); //link accounts_link = linkAcct;linkAcct._link = this;return true;} //adds money to this account public void deposit(double amt) throws LinkAccountException{_balance += amt;} // removes money from this account public void withdraw(double amt) throws InsufficientFundsException{//check if there is enough money in this account to withdrawif (_balance >= amt){_balance -= amt;} //not enough money in this accountelse{//check if this account has a linked accountif (_link == null)throw new InsufficientFundsException("Overdraft with no linked account"); //check if there is enough money in this account and its linked account combinedif (_balance + _link._balance < amt)throw new InsufficientFundsException("Not enough funds in accounts"); //withdrawamt -= _balance;_balance = 0;_link.withdraw(amt);}} //removes any link from this account public void unlink(){//dont do anything if this account is not linkedif (_link == null)return; //unlink_link._link = null;_link = null;} // gets the minimum value of this account public double getMinimum(){return 0;} public boolean accept(){return true;} // provided methods @Overridepublic boolean equals(Object obj){if (obj == null)return false; if (!(obj instanceof Account))return false; Account that = (Account) obj; if (Math.abs(_balance - that._balance) > 0.001)return false; if (!_name.equals(that._name))return false; if (_link != that._link)return false; return this == obj;} @Overridepublic String toString(){String retS = ""; retS += "account: " + _name + "\n";retS += "\tBalance: " + _balance + "\n";retS += "\tLink account name: " + _link._name; return retS;}}------------------------------------------------------------------------------------------------------------import java.util.Map; public class AccountTester extends Tester{public AccountTester(){super();} public void runAll(){//// Run tests and report//_testErrorMap.put("constructor", testConstructor());_testErrorMap.put("overloaded constructor", testOverloadedConstructor());_testErrorMap.put("linking", testLinking());_testErrorMap.put("deposit", testDeposit());_testErrorMap.put("withdrawal", testWithdrawal()); //// Report results//System.out.println("\nAccount Testing Summary: ");int sum = 0;for (Map.Entry<String, Integer> entry : _testErrorMap.entrySet()){System.out.println("\tTest " + entry.getKey() + ": " + entry.getValue() + " errors.");sum += entry.getValue();} System.out.println("\tTotal number of errors: " + sum);} public int testConstructor(){System.out.println("Test constructor..."); int errors = 0; System.out.println("\tSavings");Savings s = new Savings();if (s.getLink() != null){emitError("Constructor error [savings]; link null expected");errors++;}if (s.getBalance() > 0){emitError("Constructor error [savings]; 0 balance expected");errors++;}if (!s.getName().equals("")){emitError("Constructor error [savings]; empty name (\"\") expected");errors++;} System.out.println("\tChecking");Checking c = new Checking();if (c.getLink() != null){emitError("Constructor error [checking]; link null expected");errors++;}if (c.getBalance() > 0){emitError("Constructor error [checking]; 0 balance expected");errors++;}if (!c.getName().equals("")){emitError("Constructor error [checking]; empty name (\"\") expected");errors++;} System.out.println("\tCapped Checking");c = new CappedChecking();if (c.getLink() != null){emitError("Constructor error [capped checking]; link null expected");errors++;}if (c.getBalance() > 0){emitError("Constructor error [capped checking]; 0 balance expected");errors++;}if (!c.getName().equals("")){emitError("Constructor error [capped checking]; empty name (\"\") expected");errors++;} return errors;} int testOverloadedConstructor(){System.out.println("Test overloaded constructor..."); int errors = 0; System.out.println("\tSavings");String name = "savings";Savings s = new Savings(name);if (s.getLink() != null){emitError("Overloaded constructor error [savings]; link null expected");errors++;}if (s.getBalance() > 0){emitError("Overloaded constructor error [savings]; 0 balance expected");errors++;}if (!s.getName().equals(name)){emitError("Overloaded constructor error [savings]; name (" + name + ") expected");errors++;} System.out.println("\tChecking");name = "checking";Checking c = new Checking(name);if (c.getLink() != null){emitError("Overloaded constructor error [checking]; link null expected");errors++;}if (c.getBalance() > 0){emitError("Overloaded constructor error [checking]; 0 balance expected");errors++;}if (!c.getName().equals(name)){emitError("Overloaded constructor error [checking]; name (" + name + ") expected");errors++;} System.out.println("\tCapped Checking");name = "capped-checking";c = new CappedChecking(name);if (c.getLink() != null){emitError("Overloaded constructor error [capped checking]; link null expected");errors++;}if (c.getBalance() > 0){emitError("Overloaded constructor error [capped checking]; 0 balance expected");errors++;}if (!c.getName().equals(name)){emitError("Overloaded constructor error [capped checking]; name (" + name + ") expected");errors++;} return errors;} public int testLinking(){System.out.println("Test account linking..."); int errors = 0;//// Cannot link with null//System.out.println("\tnull Savings");Savings s = new Savings();if (s.getLink() != null){emitError("Link error; null expected");errors++;}if (s.link(null)){emitError("Link error [savings]; null accepted");errors++;} System.out.println("\tnull Checking");Checking c = new Checking();if (c.getLink() != null){emitError("Link error; null expected");errors++;}if (c.link(null)){emitError("Link error [checking]; null accepted");errors++;} //// Cannot link with same type//System.out.println("\tSame Type");if (s.link(new Savings())){emitError("Link error; savings account cannot link with a savings account");errors++;} if (c.link(new Checking())){emitError("Link error; checking account cannot link with checking account");errors++;} //// Cannot link with yourself//System.out.println("\tCyclic Linking");if (s.link(s)){emitError("Link error; savings account cannot link with itself");errors++;} if (c.link(c)){emitError("Link error; checking account cannot link with itself");errors++;} //// Check unlinking of non-linked accounts//System.out.println("\tUnlinking an unlinked account"); s = new Savings();try { s.unlink(); } catch (NullPointerException e){emitError("Link error; savings account unlink on unlinked account failed.");errors++;} c = new Checking();try { c.unlink(); } catch (NullPointerException e){emitError("Link error; savings account unlink on unlinked account failed.");errors++;} //// Verify links are unlinked if new links are given//System.out.println("\tLink / Unlink");Savings s1 = new Savings();Savings s2 = new Savings();Checking c1 = new Checking();Checking c2 = new Checking(); if (!s1.link(c1)){emitError("Link error; returned false when link should be successful");errors++;}if (!s1.link(c2)){emitError("Link error; returned false when link should be successful");errors++;} if (!s1.getLink().equals(c2)){emitError("Link error; unlinking 1");errors++;}if (!c2.getLink().equals(s1)){emitError("Link error; unlinking 2");errors++;}if (c1.getLink() != null){emitError("Link error; unlinking 3");errors++;} s1 = new Savings();s2 = new Savings();c1 = new Checking();c2 = new Checking(); c1.link(s1);c1.link(s2); if (!c1.getLink().equals(s2)){emitError("Link error; unlinking 4");errors++;}if (!s2.getLink().equals(c1)){emitError("Link error; unlinking 5");errors++;}if (s1.getLink() != null){emitError("Link error; unlinking 6");errors++;} //// Long chaining test//System.out.println("\tChaining Link / Unlink test");s1 = new Savings();s2 = new Savings();c1 = new Checking();c2 = new Checking();Checking c3 = new Checking(); c1.link(s1);s1.link(c2);c2.link(s2);s2.link(c3);if (c1.getLink() != null){emitError("Link error; chain 1");errors++;}if (s1.getLink() != null){emitError("Link error; chain 2");errors++;}if (c2.getLink() != null){emitError("Link error; chain 3");errors++;}if (!s2.getLink().equals(c3)){emitError("Link error; chain 4");errors++;}if (!c3.getLink().equals(s2)){emitError("Link error; chain 5");errors++;} return errors;} public int testDeposit(){System.out.println("Testing deposit..."); int errors = 0; //// Simple test on a savings account//System.out.println("\tSimple Savings");Savings s = new Savings();double sum = 0;for (int i = 0; i < 100; i++){int randValue = _rng.nextInt(999) + 1;sum += randValue;try {s.deposit(randValue);} catch (LinkAccountException e) {e.printStackTrace();errors++;} if (s.getBalance() != sum){emitError("Simple Savings: Expected " + sum + " found " + s.getBalance());errors++;}} //// Simple test on a non-capped Checking account//System.out.println("\tSimple Checking");Checking c = new Checking();sum = 0;for (int i = 0; i < 100; i++){int randValue = _rng.nextInt(999) + 1;sum += randValue;try {c.deposit(randValue);} catch (LinkAccountException e) {e.printStackTrace();errors++;} if (c.getBalance() != sum){emitError("Simple Checking: Expected " + sum + " found " + c.getBalance());errors++;}} //// Capped checking account//System.out.println("\tCapped Checking (max not achieved)");CappedChecking cc = new CappedChecking();sum = 0;for (int i = 0; i < 100; i++){int randValue = _rng.nextInt(999) + 1; if (cc.getBalance() + randValue > CappedChecking.MAX_AMOUNT) break; sum += randValue;try {cc.deposit(randValue);} catch (LinkAccountException e) {e.printStackTrace();errors++;} if (cc.getBalance() != sum){emitError("Simple Savings: Expected " + sum + " found " + c.getBalance());errors++;}} //// Capped checking account (with exceptions)//System.out.println("\tCapped Checking Eclipsing the Max");cc = new CappedChecking();try {cc.deposit(CappedChecking.MAX_AMOUNT);} catch (LinkAccountException e1) {e1.printStackTrace();errors++;} for (int i = 0; i < 10; i++){int randValue = _rng.nextInt(999) + 1; try{cc.deposit(randValue); emitError("Capped Deposit: Expected LinkAccountError not thrown");errors++;}catch (LinkAccountException e) {}} //// Linked Savings and Checking//System.out.println("\tLinked Savings and Checking");s = new Savings();c = new Checking(); s.link(c); double sSum = 0;double cSum = 0;for (int i = 0; i < 100; i++){int cRandValue = _rng.nextInt(999) + 1;cSum += cRandValue; int sRandValue = _rng.nextInt(999) + 1;sSum += sRandValue; try {c.deposit(cRandValue);s.deposit(sRandValue);} catch (LinkAccountException e) {e.printStackTrace();errors++;} if (c.getBalance() != cSum){emitError("Linked Savings and [Checking]: Expected " + cSum + " found " + c.getBalance());errors++;} if (s.getBalance() != sSum){emitError("Linked [Savings] and Checking: Expected " + sSum + " found " + s.getBalance());errors++;}} //// Linked Savings and Checking (other direction)//System.out.println("\tLinked Savings and Checking");s = new Savings();c = new Checking(); c.link(s); sSum = 0;cSum = 0;for (int i = 0; i < 100; i++){int cRandValue = _rng.nextInt(999) + 1;cSum += cRandValue; int sRandValue = _rng.nextInt(999) + 1;sSum += sRandValue; try {c.deposit(cRandValue);s.deposit(sRandValue);} catch (LinkAccountException e) {e.printStackTrace();errors++;} if (c.getBalance() != cSum){emitError("Linked Savings and [Checking]: Expected " + cSum + " found " + c.getBalance());errors++;} if (s.getBalance() != sSum){emitError("Linked [Savings] and Checking: Expected " + sSum + " found " + s.getBalance());errors++;}} //// Linked Savings and Checking//System.out.println("\tLinked Savings and (Capped) Checking");s = new Savings();c = new CappedChecking(); s.link(c); sSum = 0;cSum = 0;for (int i = 0; i < 100; i++){int cRandValue = _rng.nextInt(999) + 1;int sRandValue = _rng.nextInt(999) + 1; if (c.getBalance() + cRandValue <= CappedChecking.MAX_AMOUNT){cSum += cRandValue;sSum += sRandValue; try {c.deposit(cRandValue);s.deposit(sRandValue);} catch (LinkAccountException e) {e.printStackTrace();errors++;} if (c.getBalance() != cSum){emitError("Linked Savings and [Checking]: Expected " + cSum + " found " + c.getBalance());errors++;} if (s.getBalance() != sSum){emitError("Linked [Savings] and Checking: Expected " + sSum + " found " + s.getBalance());errors++;}}else if (c.getBalance() + cRandValue > CappedChecking.MAX_AMOUNT){sSum += sRandValue + (c.getBalance() + cRandValue - CappedChecking.MAX_AMOUNT); try {c.deposit(cRandValue);s.deposit(sRandValue);} catch (LinkAccountException e) {e.printStackTrace();errors++;} if (c.getBalance() != CappedChecking.MAX_AMOUNT){emitError("Linked Savings and [Checking]: Expected " + cSum + " found " + c.getBalance());errors++;} if (s.getBalance() != sSum){emitError("Linked [Savings] and Checking: Expected " + sSum + " found " + s.getBalance());errors++;}}else if (c.getBalance() >= CappedChecking.MAX_AMOUNT){sSum += sRandValue + cRandValue; try {c.deposit(cRandValue);s.deposit(sRandValue);} catch (LinkAccountException e) {e.printStackTrace();errors++;} if (c.getBalance() != CappedChecking.MAX_AMOUNT){emitError("Linked Savings and [Checking]: Expected " + CappedChecking.MAX_AMOUNT + " found " + c.getBalance());errors++;} if (s.getBalance() != sSum){emitError("Linked [Savings] and Checking: Expected " + sSum + " found " + s.getBalance());errors++;}}else{System.err.println("This shouldn't happen...");}} return errors;} public int testWithdrawal(){System.out.println("Testing withdrawal..."); int errors = 0; //// Simple test on a savings account//System.out.println("\tSimple Savings");Savings s = new Savings(); double balance = 10000;try { s.deposit(balance); } catch (LinkAccountException e1) { e1.printStackTrace(); errors++; } for (int i = 0; i < 100; i++){int randValue = _rng.nextInt(999) + 1; if (balance - randValue < 0) break; balance -= randValue;try {s.withdraw(randValue);} catch (InsufficientFundsException e) {e.printStackTrace();errors++;} if (s.getBalance() != balance){emitError("Simple Savings [savings]: Expected " + balance + " found " + s.getBalance());errors++;}} //// Simple test on a checking account//System.out.println("\tSimple Checking");Checking c = new Checking(); balance = 10000;try { c.deposit(balance); } catch (LinkAccountException e) { e.printStackTrace(); errors++; } for (int i = 0; i < 100; i++){int randValue = _rng.nextInt(999) + 1; if (balance - randValue < 0) break; balance -= randValue;try {c.withdraw(randValue);} catch (InsufficientFundsException e) {e.printStackTrace();errors++;} if (c.getBalance() != balance){emitError("Simple Checking [withdraw]: Expected " + balance + " found " + s.getBalance());errors++;}} //// Simple test on capped checking account//System.out.println("\tCapped Checking");c = new CappedChecking(); balance = CappedChecking.MAX_AMOUNT;try { c.deposit(CappedChecking.MAX_AMOUNT); } catch (LinkAccountException e) { e.printStackTrace(); errors++;} for (int i = 0; i < 100; i++){int randValue = _rng.nextInt(999) + 1; if (balance - randValue < 0) break; balance -= randValue;try {c.withdraw(randValue);} catch (InsufficientFundsException e) {e.printStackTrace();errors++;} if (c.getBalance() != balance){emitError("Simple Checking [withdraw]: Expected " + balance + " found " + s.getBalance());errors++;}} //// Insufficient Funds Tests//System.out.println("\tInsufficient Funds"); // below 0 tests = new Savings();balance = 500;try { s.deposit(balance); } catch (LinkAccountException e) { e.printStackTrace(); errors++;}for (int i = 0; i < 100; i++){int randValue = _rng.nextInt(999) + 1; if (balance - randValue < 0){try{s.withdraw(randValue);emitError("Savings [withdraw]: Expected exception to be thrown");errors++;} catch (InsufficientFundsException e) {}}} // below MIN_AMOUNT tests = new Savings();balance = 500;try { s.deposit(balance); } catch (LinkAccountException e) { e.printStackTrace(); errors++;}for (int i = 0; i < 20; i++){int randValue = _rng.nextInt(999) + 1; if (balance - randValue < Savings.MIN_AMOUNT){try{s.withdraw(randValue);emitError("Savings [withdraw]: Expected exception to be thrown");errors++;} catch (InsufficientFundsException e) {}}} c = new Checking();try { c.deposit(balance); } catch (LinkAccountException e) { e.printStackTrace(); errors++;}for (int i = 0; i < 100; i++){int randValue = _rng.nextInt(999) + 1; if (balance - randValue < 0){try{c.withdraw(randValue);emitError("Checking [withdraw]: Expected exception to be thrown");errors++;} catch (InsufficientFundsException e) {}}} c = new CappedChecking();try { c.deposit(balance); } catch (LinkAccountException e) { e.printStackTrace(); errors++;}for (int i = 0; i < 100; i++){int randValue = _rng.nextInt(999) + 1; if (balance - randValue < 0){try{c.withdraw(randValue);emitError("Capped Checking [withdraw]: Expected exception to be thrown");errors++;} catch (InsufficientFundsException e) {}}} //// Linked accounts withdrawal (basic savings and checking)//System.out.println("\tLinking Accounts"); //// Test where MIN_AMOUNT maintained in Savings//s = new Savings();c = new Checking();s.link(c); try {s.deposit(100);c.deposit(1000);} catch (LinkAccountException e) { e.printStackTrace(); errors++;} try { s.withdraw(50); } catch (InsufficientFundsException e) { e.printStackTrace(); errors++;} if (!doubleEquals(s.getBalance(), 100)){emitError("Savings and Linked Checking [withdraw]: Expected " + 100 + " found " + s.getBalance());errors++;}if (!doubleEquals(c.getBalance(), 950)){emitError("Savings and Linked Checking [withdraw]: Expected " + 950 + " found " + c.getBalance());errors++;} //// Insufficient funds even when linked//s = new Savings();c = new Checking();s.link(c); try {s.deposit(1000);c.deposit(1000);} catch (LinkAccountException e) { e.printStackTrace(); errors++;} try { s.withdraw(2500); } catch (InsufficientFundsException e) { } if (!doubleEquals(s.getBalance(), 1000)){emitError("Savings and Linked Checking [withdraw]: Expected " + 1000 + " found " + s.getBalance());errors++;}if (!doubleEquals(c.getBalance(), 1000)){emitError("Savings and Linked Checking [withdraw]: Expected " + 1000 + " found " + c.getBalance());errors++;} // Insufficient 2s = new Savings();c = new Checking();s.link(c); try {s.deposit(1000);c.deposit(1000);} catch (LinkAccountException e) { e.printStackTrace(); errors++; } try { c.withdraw(2500); } catch (InsufficientFundsException e) { } if (!doubleEquals(s.getBalance(), 1000)){emitError("Savings and Linked Checking [withdraw]: Expected " + 1000 + " found " + s.getBalance());errors++;}if (!doubleEquals(c.getBalance(), 1000)){emitError("Savings and Linked Checking [withdraw]: Expected " + 1000 + " found " + c.getBalance());errors++;} //// Normal linked withdrawals (sequence)//s = new Savings();c = new Checking();s.link(c); int sBalance = 1000;int cBalance = 1000;try {s.deposit(sBalance);c.deposit(cBalance);} catch (LinkAccountException e) { e.printStackTrace(); } for (int i = 0; i < 100; i++){int cRandValue = _rng.nextInt(100); // Normal withdrawalif (cBalance - cRandValue > 0){cBalance -= cRandValue;try { c.withdraw(cRandValue); } catch (InsufficientFundsException e) { e.printStackTrace(); errors++; } if (!doubleEquals(c.getBalance(), cBalance)){emitError("Linked [withdraw] (1): Expected " + cBalance + " found " + c.getBalance());errors++;}if (!doubleEquals(s.getBalance(), sBalance)){emitError("Linked [withdraw] (2): Expected " + sBalance + " found " + s.getBalance());errors++;}}// Need to borrow from link (not exceeding the minimum)else if (cBalance - cRandValue < 0 && sBalance + (cBalance - cRandValue) >= Savings.MIN_AMOUNT){sBalance += (cBalance - cRandValue);cBalance = 0; try { c.withdraw(cRandValue); } catch (InsufficientFundsException e) { e.printStackTrace(); errors++; } if (!doubleEquals(c.getBalance(), cBalance)){emitError("Linked [withdraw] (3): Expected " + cBalance + " found " + c.getBalance());errors++;}if (!doubleEquals(s.getBalance(), sBalance)){emitError("Linked [withdraw] (4): Expected " + sBalance + " found " + s.getBalance());errors++;}}// Need to borrow from link (exceeding the minimum)else{try { c.withdraw(cRandValue); } catch (InsufficientFundsException e) { } if (!doubleEquals(c.getBalance(), 0)){emitError("Linked [withdraw] (5): Expected " + cBalance + " found " + c.getBalance());errors++;}if (!doubleEquals(s.getBalance(), sBalance)){emitError("Linked [withdraw] (6): Expected " + sBalance + " found " + s.getBalance());errors++;}}} //// Normal linked withdrawals (sequence: savings)//s = new Savings();c = new Checking();s.link(c); sBalance = 1000;cBalance = 1000;try {s.deposit(sBalance);c.deposit(cBalance);} catch (LinkAccountException e) { e.printStackTrace(); } for (int i = 0; i < 100; i++){int sRandValue = _rng.nextInt(100); // Normal withdrawalif (sBalance - sRandValue > Savings.MIN_AMOUNT){sBalance -= sRandValue;try { s.withdraw(sRandValue); } catch (InsufficientFundsException e) { e.printStackTrace(); errors++; } if (!doubleEquals(c.getBalance(), cBalance)){emitError("Linked [withdraw] (7): Expected " + cBalance + " found " + c.getBalance());errors++;}if (!doubleEquals(s.getBalance(), sBalance)){emitError("Linked [withdraw] (8): Expected " + sBalance + " found " + s.getBalance());errors++;}}// Need to borrow from link (exceeding the minimum)else if (sBalance + cBalance - sRandValue < Savings.MIN_AMOUNT){try { s.withdraw(sRandValue); } catch (InsufficientFundsException e) { } if (!doubleEquals(c.getBalance(), cBalance)){emitError("Linked [withdraw] (9): Expected " + cBalance + " found " + c.getBalance());errors++;}if (!doubleEquals(s.getBalance(), Savings.MIN_AMOUNT)){emitError("Linked [withdraw] (10): Expected " + Savings.MIN_AMOUNT + " found " + s.getBalance());errors++;}} // Need to borrow from link (not exceeding the minimum)else{cBalance -= Savings.MIN_AMOUNT - Math.abs(sBalance - sRandValue);sBalance = (int)Savings.MIN_AMOUNT; try { s.withdraw(sRandValue); } catch (InsufficientFundsException e) {e.printStackTrace(); errors++;} if (!doubleEquals(c.getBalance(), cBalance)){emitError("Linked [withdraw] (11): Expected " + cBalance + " found " + c.getBalance());errors++;}if (!doubleEquals(s.getBalance(), sBalance)){emitError("Linked [withdraw] (12): Expected " + sBalance + " found " + s.getBalance());errors++;}} } return errors;} private static boolean doubleEquals(double a, double b){return Math.abs(a - b ) < 0.0001;}}------------------------------------------------------------------------------------------------------------import java.util.ArrayList; public class Bank{private ArrayList<Account> accounts = new ArrayList<Account>(); // adds an account to this bank public boolean addAccount(Account acct){//checks for null parameterif (acct == null) return false; //check if acct is already part of this bankif (accounts.contains(acct)) return false; //adds the accountaccounts.add(acct);return true;} // filters out all accounts which are not acceptable public ArrayList<Account> getFiltered(){ArrayList<Account> filteredList = new ArrayList<Account>(); //checks each account and adds acceptable accounts to filteredListfor(Account acct : accounts){if (acct.accept()) filteredList.add(acct);} return filteredList;} // gets the size of this bank (how many accounts exist) public int size(){return accounts.size();}} ------------------------------------------------------------------------------------------------------------import java.util.ArrayList;import java.util.Map; public class BankTester extends Tester{public BankTester(){super();} public void runAll(){ _testErrorMap.put("constructor", testConstructor());_testErrorMap.put("addAccount", testAddAccount());_testErrorMap.put("filtering", testFiltered()); System.out.println("\nBank Testing Summary: ");int sum = 0;for (Map.Entry<String, Integer> entry : _testErrorMap.entrySet()){System.out.println("\tTest " + entry.getKey() + ": " + entry.getValue() + " errors.");sum += entry.getValue();} System.out.println("\tTotal number of errors: " + sum);} public int testConstructor(){System.out.println("Test constructor..."); int errors = 0; Bank b = new Bank();if (b.size() != 0){emitError("Constructor error [bank]; size should be size zero");errors++;}if (b.getFiltered().size() != 0){emitError("Constructor error [bank]; filtered should be size zero");errors++;} return errors;} private Bank constructBank(int numChecking, int numSavings, ArrayList<Account> savings, ArrayList<Account> checking, ArrayList<Account> accounts){Bank bank = new Bank(); int c = 0;int s = 0;while (c < numChecking && s < numSavings){Account newAcct = null;if (_rng.nextBoolean()){newAcct = new Checking();checking.add(newAcct);c++;}else{newAcct = new Savings();savings.add(newAcct);s++;}accounts.add(newAcct);bank.addAccount(newAcct);} for ( ; c < numChecking; c++){Account newAcct = new Checking();accounts.add(newAcct);checking.add(newAcct);bank.addAccount(newAcct);} for (; s < numSavings; s++){Account newAcct = new Savings();accounts.add(newAcct);savings.add(newAcct);bank.addAccount(newAcct);} return bank;} public int testAddAccount(){System.out.println("Add accounts..."); int errors = 0; ArrayList<Account> savings = new ArrayList<Account>();ArrayList<Account> checking = new ArrayList<Account>();ArrayList<Account> accounts = new ArrayList<Account>();Bank bank = constructBank(12, 16, savings, checking, accounts); if (bank.size() != 28){emitError("Bank size: Expected " + 28 + " found " + bank.size());errors++;} for (Account acct : accounts){if (bank.addAccount(acct)){emitError("Add account succeeded when should have failed");errors++;}} return errors;} public int testFiltered(){System.out.println("Test filtering...");int errors = 0; int numSavings = 10;int numChecking = 10;ArrayList<Account> savings = new ArrayList<Account>();ArrayList<Account> checking = new ArrayList<Account>();ArrayList<Account> accounts = new ArrayList<Account>();Bank bank = constructBank(numChecking, numSavings, savings, checking, accounts); for (Account acct : accounts){try { acct.deposit(1000); } catch (LinkAccountException e) { e.printStackTrace(); errors++; }} if (bank.size() != numSavings + numChecking){emitError("Filtering: Expected " + (numSavings + numChecking) + " found " + bank.size());errors++;}ArrayList<Account> filtered = bank.getFiltered();if (filtered.size() != numSavings){emitError("Filtering [filtered]: Expected " + numSavings + " found " + filtered.size());errors++;} for (int i = 0; i < checking.size(); i++){checking.get(i).link(savings.get(i));}filtered = bank.getFiltered();if (filtered.size() != accounts.size()){emitError("Filtering [filtered]: Expected " + accounts.size() + " found " + filtered.size());errors++;} return errors;}}------------------------------------------------------------------------------------------------------------public class CappedChecking extends Checking{ static final double MAX_AMOUNT = 10000; public CappedChecking(){super();} // overloaded constructor public CappedChecking(String name){super(name);} public void deposit(double amt) throws LinkAccountException{//check if depositing amt will pass the maximum for this accountif (_balance + amt <= MAX_AMOUNT){_balance += amt;} //cannot deposit full amount in this accountelse{//check if this account has a linked accountif (_link == null) throw new LinkAccountException("Overflowed, no linked account"); //deposit into both accountsamt -= (MAX_AMOUNT - _balance);_balance = MAX_AMOUNT;_link.deposit(amt);} } //provided methods @Overridepublic boolean equals(Object obj){if (obj == null) return false; if (!(obj instanceof CappedChecking)) return false; return super.equals(obj);} @Overridepublic String toString(){return "Capped-Checking " + super.toString();}} ------------------------------------------------------------------------------------------------------------public class Checking extends Account{public Checking(){super();} // overloaded constructor public Checking(String name){super(name);} // links this account to another account, and vice versa @Overridepublic boolean link(Account linkAcct){//check for null parameterif (linkAcct == null) return false; //check if linkAcct is another Checking accountif (linkAcct instanceof Checking) return false; return super.link(linkAcct);} @Overridepublic boolean accept(){return _link != null;} //provided methods @Overridepublic boolean equals(Object obj){if (obj == null) return false; if (!(obj instanceof Checking)) return false; return super.equals(obj);} @Overridepublic String toString(){return "Checking " + super.toString();}}------------------------------------------------------------------------------------------------------------public interface Filterable{public boolean accept();} ------------------------------------------------------------------------------------------------------------public class InsufficientFundsException extends Exception{private static final long serialVersionUID = 1L; public InsufficientFundsException() {} public InsufficientFundsException(String arg0){super(arg0);} public InsufficientFundsException(Throwable arg0){super(arg0);} public InsufficientFundsException(String arg0, Throwable arg1){super(arg0, arg1);} public InsufficientFundsException(String arg0, Throwable arg1, boolean arg2, boolean arg3){super(arg0, arg1, arg2, arg3);} }------------------------------------------------------------------------------------------------------------public class LinkAccountException extends Exception{private static final long serialVersionUID = 1L; public LinkAccountException() {} public LinkAccountException(String arg0){super(arg0);} public LinkAccountException(Throwable arg0){super(arg0);} public LinkAccountException(String arg0, Throwable arg1){super(arg0, arg1);} public LinkAccountException(String arg0, Throwable arg1, boolean arg2, boolean arg3){super(arg0, arg1, arg2, arg3);} }---------------------------------------------------------------------------------------------------------public class Savings extends Account{static final double MIN_AMOUNT = 100; public Savings(){super();} public Savings(String name){super(name);} // removes money from this account @Overridepublic void withdraw(double amt) throws InsufficientFundsException{//check if there is enough money in this accountif (_balance - getMinimum() >= amt){//withdraw from this account_balance -= amt;} //not enough money in this accountelse{//check for a linked accountif (_link == null)throw new InsufficientFundsException("Overdraft with no linked account"); //check if there is enough money in this account and linked account combinedif (_balance - getMinimum() + _link._balance < amt)throw new InsufficientFundsException("Not enough funds in accounts"); //withdraw from both accountsamt -= (_balance - getMinimum());_balance = getMinimum();_link.withdraw(amt);}} // gets the minimum value of this account public double getMinimum(){return 100;} // links this account to another account, and vice versa @Overridepublic boolean link(Account linkAcct){//check for null parameterif (linkAcct == null) return false; //check if linkAcct is another Savings accountif (linkAcct instanceof Savings) return false; return super.link(linkAcct);} @Overridepublic boolean accept(){return _balance >= getMinimum();} // provided methods @Overridepublic boolean equals(Object obj){if (obj == null)return false; if (!(obj instanceof Savings))return false; return super.equals(obj);} @Overridepublic String toString(){return "Savings " + super.toString();}}------------------------------------------------------------------------------------------------import java.util.HashMap;import java.util.Random; public abstract class Tester{protected HashMap<String, Integer> _testErrorMap;protected Random _rng; public Tester(){_testErrorMap = new HashMap<String, Integer>();_rng = new Random();_rng.setSeed(0); // consistent testing} public abstract void runAll(); public void emitError(String error){System.out.println(error);}}