Merge pull request #662 from FridaTveit/BankAccountAddExercise

bank-account: add to track

config.json

       ]
     },
     {
+    	"slug": "bank-account",
+    	"difficulty": 6,
+    	"topics": [
+
+    	]
+    },
+    {
       "slug": "anagram",
       "difficulty": 7,
       "topics": [

exercises/bank-account/HINTS.md

+This exercise introduces [concurrency](https://docs.oracle.com/javase/tutorial/essential/concurrency/index.html). 
+To pass the last test you might find the 
+[`synchronized` keyword or locks](https://docs.oracle.com/javase/tutorial/essential/concurrency/locksync.html) useful.
+
+Problems arising from running code concurrently are often intermittent because they depend on the order the code is
+executed. Therefore the last test runs many [threads](https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html) 
+several times to increase the chances of catching a bug. That means this test should fail if your implementation is not
+[thread safe](https://en.wikipedia.org/wiki/Thread_safety), but there is a chance it will pass just because there was 
+no concurrent modification attempt. It is unlikely that this will occur several times 
+in a row since the order the code is executed should vary every time you run the test. So if you run the last test a 
+couple of times and it passes every time then you can be reasonably sure that your implementation is correct.

exercises/bank-account/build.gradle

+apply plugin: "java"
+apply plugin: "eclipse"
+apply plugin: "idea"
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    testCompile "junit:junit:4.12"
+}
+
+test {
+    testLogging {
+        exceptionFormat = 'full'
+        events = ["passed", "failed", "skipped"]
+    }
+}

exercises/bank-account/src/example/java/BankAccount.java

+class BankAccount {
+    private int balance = 0;
+    private boolean isClosed = true;
+
+    void open() {
+        isClosed = false;
+    }
+
+    void close() {
+        isClosed = true;
+    }
+
+    synchronized int getBalance() throws BankAccountActionInvalidException {
+        checkIfClosed();
+        return balance;
+    }
+
+    synchronized void deposit(int amount) throws BankAccountActionInvalidException {
+        checkIfClosed();
+        checkIfValidAmount(amount);
+
+        balance += amount;
+    }
+
+    synchronized void withdraw(int amount) throws BankAccountActionInvalidException {
+        checkIfClosed();
+        checkIfValidAmount(amount);
+        checkIfEnoughMoneyInAccount(amount);
+
+        balance -= amount;
+    }
+
+    private void checkIfValidAmount(int amount) throws BankAccountActionInvalidException {
+        if (amount < 0) {
+            throw new BankAccountActionInvalidException("Cannot deposit or withdraw negative amount");
+        }
+    }
+
+    private void checkIfEnoughMoneyInAccount(int amount) throws BankAccountActionInvalidException {
+        if (balance == 0) {
+            throw new BankAccountActionInvalidException("Cannot withdraw money from an empty account");
+        }
+        if (balance - amount < 0) {
+            throw new BankAccountActionInvalidException("Cannot withdraw more money than is currently in the account");
+        }
+    }
+
+    private void checkIfClosed() throws BankAccountActionInvalidException {
+        if (isClosed) {
+            throw new BankAccountActionInvalidException("Account closed");
+        }
+    }
+}

exercises/bank-account/src/example/java/BankAccountActionInvalidException.java

+class BankAccountActionInvalidException extends Exception {
+
+    BankAccountActionInvalidException(String message) {
+        super(message);
+    }
+}

exercises/bank-account/src/main/java/BankAccountActionInvalidException.java

+class BankAccountActionInvalidException extends Exception {
+
+    BankAccountActionInvalidException(String message) {
+        super(message);
+    }
+}

exercises/bank-account/src/test/java/BankAccountTest.java

+import org.junit.Before;
+import org.junit.Ignore;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+
+import java.util.Random;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
+
+public class BankAccountTest {
+    @Rule
+    public ExpectedException expectedException = ExpectedException.none();
+    private BankAccount bankAccount;
+
+    @Before
+    public void setup() {
+        bankAccount = new BankAccount();
+    }
+
+    @Test
+    public void newlyOpenedAccountHasEmptyBalance() throws BankAccountActionInvalidException {
+        bankAccount.open();
+
+        assertEquals(0, bankAccount.getBalance());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void canDepositMoney() throws BankAccountActionInvalidException {
+        bankAccount.open();
+
+        bankAccount.deposit(10);
+
+        assertEquals(10, bankAccount.getBalance());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void canDepositMoneySequentially() throws BankAccountActionInvalidException {
+        bankAccount.open();
+
+        bankAccount.deposit(5);
+        bankAccount.deposit(23);
+
+        assertEquals(28, bankAccount.getBalance());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void canWithdrawMoney() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.deposit(10);
+
+        bankAccount.withdraw(5);
+
+        assertEquals(5, bankAccount.getBalance());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void canWithdrawMoneySequentially() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.deposit(23);
+
+        bankAccount.withdraw(10);
+        bankAccount.withdraw(13);
+
+        assertEquals(0, bankAccount.getBalance());
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotWithdrawMoneyFromEmptyAccount() throws BankAccountActionInvalidException {
+        bankAccount.open();
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Cannot withdraw money from an empty account");
+
+        bankAccount.withdraw(5);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotWithdrawMoreMoneyThanYouHave() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.deposit(6);
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Cannot withdraw more money than is currently in the account");
+
+        bankAccount.withdraw(7);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotDepositNegativeAmount() throws BankAccountActionInvalidException {
+        bankAccount.open();
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Cannot deposit or withdraw negative amount");
+
+        bankAccount.deposit(-1);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotWithdrawNegativeAmount() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.deposit(105);
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Cannot deposit or withdraw negative amount");
+
+        bankAccount.withdraw(-5);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotGetBalanceOfClosedAccount() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.deposit(10);
+        bankAccount.close();
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Account closed");
+
+        bankAccount.getBalance();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotDepositMoneyIntoClosedAccount() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.close();
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Account closed");
+
+        bankAccount.deposit(5);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void cannotWithdrawMoneyFromClosedAccount() throws BankAccountActionInvalidException {
+        bankAccount.open();
+        bankAccount.deposit(20);
+        bankAccount.close();
+
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Account closed");
+
+        bankAccount.withdraw(5);
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void bankAccountIsClosedBeforeItIsOpened() throws BankAccountActionInvalidException {
+        expectedException.expect(BankAccountActionInvalidException.class);
+        expectedException.expectMessage("Account closed");
+
+        bankAccount.getBalance();
+    }
+
+    @Ignore("Remove to run test")
+    @Test
+    public void canAdjustBalanceConcurrently() throws BankAccountActionInvalidException, InterruptedException {
+        bankAccount.open();
+        bankAccount.deposit(1000);
+
+        for (int i = 0; i < 10; i++) {
+            adjustBalanceConcurrently();
+        }
+    }
+
+    private void adjustBalanceConcurrently() throws BankAccountActionInvalidException, InterruptedException {
+        Random random = new Random();
+
+        Thread[] threads = new Thread[1000];
+        for (int i = 0; i < 1000; i++) {
+            threads[i] = new Thread(() -> {
+                try {
+                    bankAccount.deposit(5);
+                    Thread.sleep(random.nextInt(10));
+                    bankAccount.withdraw(5);
+                } catch (BankAccountActionInvalidException e) {
+                    fail("Exception should not be thrown: " + e.getMessage());
+                } catch (InterruptedException ignored) {
+                }
+            });
+            threads[i].start();
+        }
+
+        for (Thread thread : threads) {
+            thread.join();
+        }
+
+        assertEquals(1000, bankAccount.getBalance());
+    }
+}

exercises/settings.gradle

 include 'allergies'
 include 'anagram'
 include 'atbash-cipher'
+include 'bank-account'
 include 'beer-song'
 include 'binary'
 include 'binary-search'