Kotlin - Bank Account Complete

kotlin/bank-account/README.md

@@ -0,0 +1,33 @@
+# Bank Account
+
+Simulate a bank account supporting opening/closing, withdrawals, and deposits
+of money. Watch out for concurrent transactions!
+
+A bank account can be accessed in multiple ways. Clients can make
+deposits and withdrawals using the internet, mobile phones, etc. Shops
+can charge against the account.
+
+Create an account that can be accessed from multiple threads/processes
+(terminology depends on your programming language).
+
+It should be possible to close an account; operations against a closed
+account must fail.
+
+## Instructions
+
+Run the test file, and fix each of the errors in turn. When you get the
+first test to pass, go to the first pending or skipped test, and make
+that pass as well. When all of the tests are passing, feel free to
+submit.
+
+Remember that passing code is just the first step. The goal is to work
+towards a solution that is as readable and expressive as you can make
+it.
+
+Have fun!
+
+
+
+
+## Submitting Incomplete Solutions
+It's possible to submit an incomplete solution so you can see how others have completed the exercise.

kotlin/bank-account/src/main/kotlin/BankAccount.kt

@@ -0,0 +1,40 @@
+import kotlin.reflect.KProperty
+
+class BankAccount() {
+    var balance: Int by Delegate()
+    private var isClosed = false
+    internal val lock = Any()
+
+    fun adjustBalance(x: Int): Unit {
+        synchronized(lock) {
+            if (!isClosed) {
+                balance += x
+            } else throw IllegalStateException()
+        }
+    }
+
+    fun close(): Unit {
+        isClosed = true
+    }
+
+    class Delegate() {
+        private var balance = 0
+        operator fun getValue(thisRef: BankAccount, property: KProperty<*>): Int {
+            synchronized(thisRef.lock) {
+                if (thisRef.isClosed) {
+                    throw IllegalStateException()
+                }
+                return balance
+            }
+        }
+
+        operator fun setValue(thisRef: BankAccount, property: KProperty<*>, value: Int) {
+            synchronized(thisRef.lock) {
+                if (thisRef.isClosed) {
+                    throw IllegalStateException()
+                } else balance = value
+            }
+        }
+    }
+
+}

kotlin/bank-account/src/test/kotlin/BankAccountTest.kt

@@ -0,0 +1,69 @@
+import org.junit.Ignore
+import org.junit.Test
+import java.util.*
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+import kotlinx.coroutines.experimental.*
+
+class BankAccountTest {
+
+    @Test
+    fun zeroBalanceWhenOpened() {
+        val account = BankAccount()
+        assertEquals(0, account.balance)
+    }
+
+    @Test
+    fun sequentialBalanceAdjustments() {
+        val account = BankAccount()
+
+        account.adjustBalance(1000)
+        assertEquals(1000, account.balance)
+
+        account.adjustBalance(-958)
+        assertEquals(42, account.balance)
+    }
+
+    @Test
+    fun closedAccountHasNoBalance() {
+        val account = BankAccount()
+        account.close()
+
+        assertFailsWith(IllegalStateException::class, { account.balance })
+    }
+
+    @Test
+    fun closedAccountCannotBeAdjusted() {
+        val account = BankAccount()
+        account.close()
+
+        assertFailsWith(IllegalStateException::class, { account.adjustBalance(1000) })
+    }
+
+    @Test
+    fun concurrentBalanceAdjustments() {
+        val threads = 1000
+        val iterations = 500
+        val random = Random()
+
+        val account = BankAccount()
+
+        val jobs = List(threads) {
+            launch(CommonPool) {
+                repeat(iterations) {
+                    account.adjustBalance(1)
+                    delay(random.nextInt(10).toLong())
+                    account.adjustBalance(-1)
+                }
+            }
+        }
+
+        runBlocking {
+            jobs.forEach { it.join() }
+        }
+
+        assertEquals(0, account.balance)
+    }
+
+}
+