diff --git a/pom.xml b/pom.xml
index 9901415..36086c5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -7,6 +7,21 @@
     <groupId>io.zipcoder</groupId>
     <artifactId>project-2-atm</artifactId>
     <version>1.0-SNAPSHOT</version>
+    <packaging>jar</packaging>
 
+    <name>interfaces-1</name>
+    <url>http://maven.apache.org</url>
 
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.12</version>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
 </project>
\ No newline at end of file
diff --git a/src/main/java/ATM.java b/src/main/java/ATM.java
new file mode 100644
index 0000000..404622c
--- /dev/null
+++ b/src/main/java/ATM.java
@@ -0,0 +1,82 @@
+import java.util.ArrayList;
+
+public class ATM {
+    private ArrayList<User> allUsers = new ArrayList<User>();
+
+    private int numOfAccounts = 0;
+
+    private static ATM theInstance = new ATM();
+
+    private ATM() {
+    }
+
+    public ArrayList<User> getAllUsers() {
+        return allUsers;
+    }
+
+    public void clearAllUsers(){
+        allUsers.clear();
+
+    }
+
+    public static ATM getInstance() {
+        return theInstance;
+    }
+
+    public void addUser(String userName, String password) {
+        User newUser = new User(userName, password);
+        allUsers.add(newUser);
+    }
+
+    int returnAllUsersSize() {
+        return allUsers.size();
+    }
+
+    int returnNewAccountNum() {
+        numOfAccounts++;
+        return numOfAccounts;
+    }
+
+    boolean UserExist(String userName) {
+        boolean userExist = false;
+
+        for (User currentUser : allUsers) {
+
+            if (userName.equalsIgnoreCase(currentUser.getUserName())) {
+                return true;
+            }
+        }
+        return userExist;
+    }
+
+    int UserIndex(String userName){
+        int index = 0;
+        User currentUser;
+        for (int i = 0; i < allUsers.size(); i++) {
+            currentUser = (User) allUsers.get(i);
+            if (userName.equalsIgnoreCase(currentUser.getUserName())) {
+                return i;
+            }
+        }
+        return index;
+    }
+
+    boolean UserNameAndPasswordCorrect(String userName, String password) {
+        User currentUser;
+        String userPassword;
+        boolean userCorrect = false;
+        if(UserExist(userName)){
+            currentUser = EnterUser(userName);
+            userPassword= currentUser.getUserPassword();
+            userCorrect = (password.equals(userPassword));
+        }
+        return userCorrect;
+    }
+
+    User EnterUser(String userName) {
+        int index = UserIndex(userName);
+        User currentUser = (User) allUsers.get(index);
+        return currentUser;
+    }
+
+}
diff --git a/src/main/java/Account.java b/src/main/java/Account.java
new file mode 100644
index 0000000..12fc184
--- /dev/null
+++ b/src/main/java/Account.java
@@ -0,0 +1,42 @@
+import java.util.ArrayList;
+
+public class Account {
+    private int accountNum;
+    private double accountBalance;
+    private String accountType;
+    private ArrayList accountHistory = new ArrayList();
+
+    ATM atm = ATM.getInstance();
+
+    Account(String accountType){
+        this.accountType = accountType;
+    }
+
+    void setBalance(double balanceGiven) {
+        accountBalance = balanceGiven;
+    }
+
+    double getBalance() {
+        return accountBalance;
+    }
+
+    void setAccountNum() {
+        this.accountNum = atm.returnNewAccountNum();
+    }
+
+    int getAccountNum() {
+        return accountNum;
+    }
+
+    String getAccountType(){
+        return accountType;
+    }
+
+    ArrayList getAccountHistory() {
+        return accountHistory;
+    }
+
+    void addToAccountHistory(String newTransaction) {
+        accountHistory.add(newTransaction);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/CheckingAccount.java b/src/main/java/CheckingAccount.java
new file mode 100644
index 0000000..6545218
--- /dev/null
+++ b/src/main/java/CheckingAccount.java
@@ -0,0 +1,5 @@
+public class CheckingAccount extends Account {
+    public CheckingAccount(){
+        super("Checking");
+    }
+}
diff --git a/src/main/java/Console.java b/src/main/java/Console.java
new file mode 100644
index 0000000..deafd6f
--- /dev/null
+++ b/src/main/java/Console.java
@@ -0,0 +1,341 @@
+import java.util.ArrayList;
+import java.util.Scanner;
+
+public class Console {
+    ATM atm = ATM.getInstance();
+    Scanner scan = new Scanner(System.in);
+
+    void frontPage() {
+        System.out.print("\nWelcome\n 1) New User\n 2) Login\n 0) Exit\n");
+        switch (catchIntErrorInput()) {
+            case 1:
+                addUser();
+                break;
+            case 2:
+                loginPage();
+                break;
+            case 0:
+                return;
+            default:
+                System.out.println("Not a valid input");
+                frontPage();
+        }
+    }
+
+    private void userPage(User user) {
+        System.out.print(
+                "\n 1) Check balance of account\n 2) Withdraw from account\n 3) Deposit to account" +
+                        "\n 4) Transfer from one account to another\n 5) Print account transaction history" +
+                        "\n 6) Close account\n 7) Add new account\n 8) User settings\n 0) Logout\n");
+        switch (catchIntErrorInput()) {
+            case 1:
+                balancePrint(user);
+                break;
+            case 2:
+                withdrawPrint(user);
+                break;
+            case 3:
+                depositPrint(user);
+                break;
+            case 4:
+                transferPrint(user);
+                break;
+            case 5:
+                historyPrint(user);
+                break;
+            case 6:
+                closeAccount(user);
+                break;
+            case 7:
+                addAccount(user);
+                break;
+            case 8:
+                userSettingPage(user);
+                break;
+            case 0:
+                frontPage();
+                break;
+            default:
+                userPage(user);
+        }
+    }
+
+    private void userSettingPage(User user) {
+        System.out.println("\nUser Settings\n 1) Change user name\n 2) Change password\n 3) Look at all accounts\n 0) Back");
+        switch (catchIntErrorInput()) {
+            case 1:
+                changeUserNamePage(user);
+                break;
+            case 2:
+                changePasswordPage(user);
+                break;
+            case 3:
+                printAccounts(user);
+                break;
+            case 0:
+                userPage(user);
+                break;
+            default:
+                userSettingPage(user);
+        }
+    }
+
+    private void transferPrint(User user) {
+        System.out.println("Transfer funds\n 1) Transfer to own account\n 2) Transfer to other users account\n 0) Back");
+        switch (catchIntErrorInput()) {
+            case 1:
+                selfTransfer(user);
+                break;
+            case 2:
+                otherUserTransfer(user);
+                break;
+            case 0:
+                userPage(user);
+                break;
+            default:
+                transferPrint(user);
+        }
+    }
+
+    private void addAccount(User user) {
+        System.out.print("What type of account?\n 1) Checking\n 2) Savings\n 3) Investment\n");
+        String accountType;
+        switch (catchIntErrorInput()) {
+            case 1:
+                accountType = "Checking  ";
+                break;
+            case 2:
+                accountType = "Savings   ";
+                break;
+            case 3:
+                accountType = "Investment";
+                break;
+            case 0:
+                userPage(user);
+            default:
+                addAccount(user);
+                accountType = "x";
+        }
+        if (!"x".equals(accountType)) {
+            int accountNum = user.addAccount(accountType);
+            System.out.print("\nAccount added\n\nNew account number : " + accountNum + "\n");
+        }
+        userPage(user);
+    }
+
+    private int catchIntErrorInput() {
+        int output = -1;
+        while(output<0) {
+            String input = scan.next();
+            try {
+                output = Integer.parseInt(input);
+            } catch (Exception e) {
+                System.out.println("Invalid input");
+            }
+        }
+        return output;
+    }
+
+    private double catchDoubleErrorInput() {
+        double output = -1;
+        while(output<0) {
+            String input = scan.next();
+            try {
+                output = Double.parseDouble(input);
+            } catch (Exception e) {
+                System.out.println("Invalid input");
+            }
+        }
+        return output;
+    }
+
+    private void printAccounts(User user) {
+        ArrayList accounts = user.getAccountsArray();
+        for (Object account : accounts) {
+            printAccountInfo((Account) account);
+        }
+        userSettingPage(user);
+    }
+
+    private void printAccountInfo(Account account) {
+        String accountType = account.getAccountType();
+        int accountNum = account.getAccountNum();
+        double accountBalance = account.getBalance();
+        System.out.println("Account type : " + accountType + "\tAccount number : " + accountNum + "\t\tAccount balance\t: " + accountBalance);
+    }
+
+    private void historyPrint(User user) {
+        Account account = enterAccount(user);
+        ArrayList history = account.getAccountHistory();
+        System.out.println("Most recent at the bottom");
+        for (Object transaction : history) {
+            System.out.println((String) transaction);
+        }
+        userPage(user);
+    }
+
+    private void otherUserTransfer(User user) {
+        System.out.println("From account");
+        Account fromAccount = enterAccount(user);
+        System.out.println("User to transfer to");
+        User toUser = enterUser();
+        Account toAccount = enterAccount(toUser);
+        System.out.print("How mush would you like to transfer >> ");
+        double amount = catchDoubleErrorInput();
+        if (user.withdraw(amount, fromAccount) && toUser.deposit(amount, toAccount)) {
+            System.out.println("Transfer made");
+        }
+        userPage(user);
+    }
+
+    private User enterUser() {
+        User toUser = null;
+        System.out.print("User name >> ");
+        String toUserString = scan.next();
+        if (atm.UserExist(toUserString)) {
+            toUser = atm.EnterUser(toUserString);
+        }
+        return toUser;
+    }
+
+    private void loginPage() {
+        System.out.print("LOGIN PAGE\n");
+        System.out.print("User Name >> ");
+        String userName = scan.next();
+        System.out.print("Password  >> ");
+        String password = scan.next();
+        if (atm.UserNameAndPasswordCorrect(userName, password)) {
+            User user = atm.EnterUser(userName);
+            System.out.println("\nWelcome back " + user.getUserName());
+            userPage(user);
+        } else {
+            if (atm.UserExist(userName)) {
+                System.out.print("Incorrect password\n");
+            } else {
+                System.out.print("User does not exist\n");
+            }
+            frontPage();
+        }
+    }
+
+
+    private void selfTransfer(User user) {
+        System.out.print("From account\n");
+        Account fromAccount = enterAccount(user);
+        System.out.print("To account\n");
+        Account toAccount = enterAccount(user);
+        System.out.print("How much would you like to transfer >> ");
+        double amount = catchDoubleErrorInput();
+        if (user.transfer(amount, fromAccount, toAccount)) {
+            System.out.print("Transfer made\n");
+            userPage(user);
+        } else {
+            System.out.print("Transfer not possible\n");
+            userPage(user);
+        }
+
+    }
+
+
+    private void changePasswordPage(User user) {
+        System.out.print("Current password >> ");
+        String input = scan.next();
+        if (input.equalsIgnoreCase(user.getUserPassword())) {
+            System.out.print("New password >> ");
+            input = scan.next();
+            user.setUserPassword(input);
+            System.out.print("Password changed");
+        } else {
+            System.out.print("Incorrect password");
+        }
+        userSettingPage(user);
+    }
+
+    private void changeUserNamePage(User user) {
+        System.out.print("Current user name >> ");
+        String input = scan.next();
+        if (input.equalsIgnoreCase(user.getUserName())) {
+            System.out.print("New user name >> ");
+            input = scan.next();
+            user.setUserName(input);
+            System.out.print("User name changed\n");
+        } else {
+            System.out.print("Incorrect user name");
+        }
+        userSettingPage(user);
+    }
+
+    private void closeAccount(User user) {
+        Account account = enterAccount(user);
+        if (user.removeAccount(account.getAccountNum())) {
+            System.out.print("Account removed");
+            userPage(user);
+        } else {
+            System.out.print("Account is not empty");
+            userPage(user);
+        }
+    }
+
+
+    private void depositPrint(User user) {
+        Account account = enterAccount(user);
+        System.out.print("Deposit amount  >> ");
+        double amount = catchDoubleErrorInput();
+        if (user.deposit(amount, account)) {
+            System.out.print("Deposit made\n");
+            userPage(user);
+        } else {
+            System.out.print("Deposit not possible\n");
+            userPage(user);
+        }
+    }
+
+    private void withdrawPrint(User user) {
+        Account account = enterAccount(user);
+        System.out.print("Withdraw amount >> ");
+        double amount = catchDoubleErrorInput();
+        if (user.withdraw(amount, account)) {
+            System.out.print("Withdraw made\n");
+            userPage(user);
+        } else {
+            System.out.print("Withdraw not possible\n");
+            userPage(user);
+        }
+    }
+
+    private void balancePrint(User user) {
+        Account account = enterAccount(user);
+        System.out.print("\nAccount : " + account.getAccountNum() + "\nBalance : " + account.getBalance() + "\n");
+        userPage(user);
+    }
+
+    private Account enterAccount(User user) {
+        System.out.print("Account number  >> ");
+        int input = catchIntErrorInput();
+        Account account;
+        if (user.AccountExist(input)) {
+            account = user.EnterAccount(input);
+        } else {
+            System.out.print("Account does not exist");
+            account = null;
+            userPage(user);
+        }
+        return account;
+    }
+
+    private void addUser() {
+        System.out.print("New user Name >> ");
+        String userName = scan.next();
+        System.out.print("New password  >> ");
+        String password = scan.next();
+        if (atm.UserExist(userName)) {
+            System.out.println("\nUser name already exist");
+        } else {
+            atm.addUser(userName, password);
+            System.out.print("\nNew user added\n");
+        }
+        frontPage();
+    }
+
+
+}
diff --git a/src/main/java/InvestmentAccount.java b/src/main/java/InvestmentAccount.java
new file mode 100644
index 0000000..09e6e9a
--- /dev/null
+++ b/src/main/java/InvestmentAccount.java
@@ -0,0 +1,5 @@
+public class InvestmentAccount extends Account{
+    public InvestmentAccount(){
+        super("Investment");
+    }
+}
diff --git a/src/main/java/Main.java b/src/main/java/Main.java
index 05e41a9..61c495c 100644
--- a/src/main/java/Main.java
+++ b/src/main/java/Main.java
@@ -1,9 +1,21 @@
-/**
- * Created by iyasuwatts on 10/17/17.
- */
+
+
+
 public class Main {
 
     public static void main(String[] args){
-        
+        Console console = new Console();
+        console.frontPage();
+    }
+
+    public static void clearAll(){
+        ATM atm = ATM.getInstance();
+        for(User user : atm.getAllUsers()){
+            user.clearAccounts();
+        }
+        atm.clearAllUsers();
     }
+
+
+
 }
diff --git a/src/main/java/SavingAccount.java b/src/main/java/SavingAccount.java
new file mode 100644
index 0000000..5624846
--- /dev/null
+++ b/src/main/java/SavingAccount.java
@@ -0,0 +1,5 @@
+public class SavingAccount extends Account {
+    public SavingAccount(){
+        super("Savings");
+    }
+}
diff --git a/src/main/java/User.java b/src/main/java/User.java
new file mode 100644
index 0000000..4cd9f5b
--- /dev/null
+++ b/src/main/java/User.java
@@ -0,0 +1,104 @@
+import java.util.ArrayList;
+
+public class User {
+    private String userName;
+    private String password;
+    private ArrayList accountsArray = new ArrayList();
+
+    User(String userName, String password) {
+        this.userName = userName;
+        this.password = password;
+    }
+
+    public void clearAccounts(){
+        accountsArray.clear();
+    }
+
+    void setUserName(String userName) {
+        this.userName = userName;
+    }
+
+    String getUserName() {
+        return userName;
+    }
+
+    void setUserPassword(String password) {
+        this.password = password;
+    }
+
+    String getUserPassword() {
+        return password;
+    }
+
+    int addAccount(String accountType) {
+        Account newAccount = new Account(accountType);
+        newAccount.setBalance(0);
+        newAccount.setAccountNum();
+        accountsArray.add(newAccount);
+        return newAccount.getAccountNum();
+    }
+
+    ArrayList getAccountsArray() {
+        return accountsArray;
+    }
+
+    boolean removeAccount(int accountNum) {
+        boolean removedAccount = false;
+        Account removeAccount = EnterAccount(accountNum);
+        if (removeAccount.getBalance() == 0) {
+            accountsArray.remove(removeAccount);
+            removedAccount = true;
+        }
+        return removedAccount;
+    }
+
+    boolean AccountExist(int accountNum) {
+        Account currentAccount;
+        for (int i = 0; i < accountsArray.size(); i++) {
+            currentAccount = (Account) accountsArray.get(i);
+            if (currentAccount.getAccountNum() == accountNum) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    Account EnterAccount(int accountNum) {
+        Account currentAccount;
+        for (int i = 0; i < accountsArray.size(); i++) {
+            currentAccount = (Account) accountsArray.get(i);
+            if (currentAccount.getAccountNum() == accountNum) {
+                return currentAccount;
+            }
+        }
+        return null;
+
+    }
+
+    boolean withdraw(double amount, Account account) {
+        boolean withdrawMade = false;
+        double currentBalance = account.getBalance();
+        String newTransaction;
+        if (currentBalance >= amount) {
+            withdrawMade = true;
+            newTransaction = "Withdraw " + amount;
+            account.addToAccountHistory(newTransaction);
+            account.setBalance(currentBalance - amount);
+        }
+        return withdrawMade;
+    }
+
+    boolean deposit(double amount, Account account) {
+        double currentBalance = account.getBalance();
+        account.setBalance(currentBalance + amount);
+        String newTransaction = "Deposit  " + amount;
+        account.addToAccountHistory(newTransaction);
+        return true;
+    }
+
+    boolean transfer(double amount, Account fromAccount, Account toAccount) {
+        return withdraw(amount, fromAccount) && deposit(amount, toAccount);
+    }
+
+
+}
diff --git a/src/test/java/accountTest.java b/src/test/java/accountTest.java
new file mode 100644
index 0000000..35959e4
--- /dev/null
+++ b/src/test/java/accountTest.java
@@ -0,0 +1,69 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class accountTest {
+    ATM atm = ATM.getInstance();
+
+    @Test       // test getAccountBalance and setAccountBalance
+    public void AccountBalanceTest(){
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+        currentUser.addAccount("checking");
+        Account currentAccount = currentUser.EnterAccount(1);
+
+        double expected = 500;
+
+        currentAccount.setBalance(500);
+
+        double actual = currentAccount.getBalance();
+
+        Assert.assertEquals(expected,actual,0);
+    }
+
+    @Test       // test getAccountType and setAccountType
+    public void AccountTypeTest(){
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+
+        String expected = "savings";
+
+        currentUser.addAccount(expected);
+        Account currentAccount = currentUser.EnterAccount(1);
+        String actual = currentAccount.getAccountType();
+
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test       // test getAccountNum and setAccountNum
+    public void AccountNumberTest(){
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+        currentUser.addAccount("savings");
+        Account currentAccount = currentUser.EnterAccount(1);
+
+        int expected = 1;
+
+        int actual = currentAccount.getAccountNum();
+
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test       // test getAccountHistory and addToAccountHistory
+    public void accountHistoryTest(){
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+        currentUser.addAccount("savings");
+        Account account = currentUser.EnterAccount(1);
+        currentUser.deposit(50,account);
+        String expected = "Deposit  50.0";
+
+        ArrayList history = account.getAccountHistory();
+        String actual = (String)history.get(0);
+
+
+        Assert.assertEquals(expected,actual);
+    }
+
+}
diff --git a/src/test/java/atmTest.java b/src/test/java/atmTest.java
new file mode 100644
index 0000000..52bc34d
--- /dev/null
+++ b/src/test/java/atmTest.java
@@ -0,0 +1,84 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+public class atmTest {
+    ATM atm = ATM.getInstance();
+
+    @Test       //Test addUsers and returnAllUserSize
+    public void addUserTest(){
+        atm.clearAllUsers();
+        int expected = 1;
+
+        atm.addUser("wes","password");
+        int actual = atm.returnAllUsersSize();
+
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void returnNewAccountNumTest(){
+        atm.clearAllUsers();
+        int expected = 1;
+
+        int actual = atm.returnNewAccountNum();
+
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void UserExistTest(){
+        atm.clearAllUsers();
+        atm.addUser("wes","password");
+        boolean expected1 = true;
+        boolean expected2 = false;
+
+        boolean actual1 = atm.UserExist("wes");
+        boolean actual2 = atm.UserExist("bob");
+
+        Assert.assertEquals(expected1,actual1);
+        Assert.assertEquals(expected2,actual2);
+
+    }
+
+    @Test
+    public void UserIndexTest(){
+        atm.clearAllUsers();
+        int expected1 = 0;
+        int expected2 = 1;
+        atm.addUser("wes","password");
+        atm.addUser("bob","password");
+
+        int actual1 = atm.UserIndex("wes");
+        int actual2 = atm.UserIndex("bob");
+
+        Assert.assertEquals(expected1,actual1);
+        Assert.assertEquals(expected2,actual2);
+    }
+
+    @Test
+    public void UserNameAndPasswordCorrectTest(){
+        atm.clearAllUsers();
+        atm.addUser("wes","password");
+        boolean expected1 = true;
+        boolean expected2 = false;
+
+        boolean actual1 = atm.UserNameAndPasswordCorrect("wes","password");
+        boolean actual2 = atm.UserNameAndPasswordCorrect("bob","password");
+
+        Assert.assertEquals(expected1,actual1);
+        Assert.assertEquals(expected2,actual2);
+    }
+
+    @Test
+    public void EnterUserTest(){
+        atm.clearAllUsers();
+        atm.addUser("wes","password");
+        String expected = "wes";
+
+        User currentUser = atm.EnterUser("wes");
+        String actual = currentUser.getUserName();
+
+        Assert.assertEquals(expected,actual);
+
+    }
+}
diff --git a/src/test/java/userTest.java b/src/test/java/userTest.java
new file mode 100644
index 0000000..53d9c3b
--- /dev/null
+++ b/src/test/java/userTest.java
@@ -0,0 +1,201 @@
+import org.junit.Assert;
+import org.junit.Test;
+
+import java.util.ArrayList;
+
+public class userTest {
+    ATM atm = ATM.getInstance();
+
+    @Test       //Test setUserName and getUserName
+    public void setUserNameTest(){
+        Main.clearAll();
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+        String expected1 = "wes";
+        String expected2 = "bob";
+
+        String actual1 = currentUser.getUserName();
+        currentUser.setUserName("bob");
+        String actual2 = currentUser.getUserName();
+
+        Assert.assertEquals(expected1,actual1);
+        Assert.assertEquals(expected2,actual2);
+    }
+
+    @Test      //Test setUserPassword and getUserPassword
+    public void setUserPasswordTest(){
+        Main.clearAll();
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+        String expected1 = "password";
+        String expected2 = "newPassword";
+
+        String actual1 = currentUser.getUserPassword();
+        currentUser.setUserPassword("newPassword");
+        String actual2 = currentUser.getUserPassword();
+
+        Assert.assertEquals(expected1,actual1);
+        Assert.assertEquals(expected2,actual2);
+    }
+
+    @Test
+    public void addAccountTest(){
+        Main.clearAll();
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+        currentUser.addAccount("checking");
+        int expected = 1;
+
+        int actual = currentUser.getAccountsArray().size();
+
+        Assert.assertEquals(expected,actual);
+    }
+
+
+    @Test
+    public void accountArraySizeTest(){
+        Main.clearAll();
+        atm.addUser("wes","pass");
+        User currentUser = atm.EnterUser("wes");
+        int expected1 = 0;
+        int expected2 = 1;
+
+        int actual1 = currentUser.getAccountsArray().size();
+        currentUser.addAccount("checking");
+        int actual2 = currentUser.getAccountsArray().size();
+
+        Assert.assertEquals(expected1,actual1);
+        Assert.assertEquals(expected2,actual2);
+    }
+
+    @Test
+    public void getAccountArrayTest(){
+        Main.clearAll();
+        atm.addUser("wes","pass");
+        User currentUser = atm.EnterUser("wes");
+        int expected = 1;
+
+        currentUser.addAccount("Checking");
+        ArrayList accounts = currentUser.getAccountsArray();
+        Account account = (Account)accounts.get(0);
+        int actual = account.getAccountNum();
+
+        Assert.assertEquals(expected,actual);
+
+    }
+
+    @Test
+    public void removeAccountTest(){
+        Main.clearAll();
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+        currentUser.addAccount("checking");
+        currentUser.addAccount("savings");
+
+        boolean expected1 = true;
+        int expected2 = 1;
+        boolean expected3 = false;
+
+        boolean actual1 = currentUser.removeAccount(1);
+        int actual2 = currentUser.getAccountsArray().size();
+        Account currentAccount = currentUser.EnterAccount(2);
+        currentAccount.setBalance(50);
+        boolean actual3 = currentUser.removeAccount(2);
+
+        Assert.assertEquals(expected1,actual1);
+        Assert.assertEquals(expected2,actual2);
+        Assert.assertEquals(expected3,actual3);
+
+
+    }
+
+    @Test
+    public void AccountExistTest(){
+        Main.clearAll();
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+        currentUser.addAccount("checking");
+        boolean expected1 = true;
+        boolean expected2 = false;
+
+        boolean actual1 = currentUser.AccountExist(1);
+        boolean actual2 = currentUser.AccountExist(3);
+
+        Assert.assertEquals(expected1,actual1);
+        Assert.assertEquals(expected2,actual2);
+    }
+
+    @Test
+    public void EnterAccountTest(){
+        Main.clearAll();
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+        currentUser.addAccount("checking");
+        Account currentAccount = currentUser.EnterAccount(1);
+        String expected = "checking";
+
+        String actual = currentAccount.getAccountType();
+
+        Assert.assertEquals(expected,actual);
+    }
+
+    @Test
+    public void withdrawTest(){
+        Main.clearAll();
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+        currentUser.addAccount("savings");
+        Account currentAccount = currentUser.EnterAccount(1);
+        currentAccount.setBalance(100);
+
+        double expected = 50;
+        currentUser.withdraw(50,currentAccount);
+
+        double actual = currentAccount.getBalance();
+
+        Assert.assertEquals(expected,actual,0);
+
+    }
+
+    @Test
+    public void depositTest(){
+        Main.clearAll();
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+        currentUser.addAccount("savings");
+        Account currentAccount = currentUser.EnterAccount(1);
+
+        double expected = 100;
+
+        currentUser.deposit(100,currentAccount);
+
+        double actual = currentAccount.getBalance();
+
+        Assert.assertEquals(expected,actual,0);
+    }
+
+    @Test
+    public void transferTest(){
+        Main.clearAll();
+        atm.addUser("wes","password");
+        User currentUser = atm.EnterUser("wes");
+        currentUser.addAccount("savings");
+        currentUser.addAccount("checking");
+        Account firstAccount = currentUser.EnterAccount(1);
+        Account secondAccount = currentUser.EnterAccount(2);
+        firstAccount.setBalance(100);
+
+        double expected1 = 75;
+        double expected2 = 25;
+
+        currentUser.transfer(25,firstAccount,secondAccount);
+
+        double actual1 = firstAccount.getBalance();
+        double actual2 = secondAccount.getBalance();
+
+        Assert.assertEquals(expected1,actual1,0);
+        Assert.assertEquals(expected2,actual2,0);
+
+    }
+}
+