android-finance-tracker/common/src/test/kotlin/MoneyTest.kt

import org.junit.jupiter.api.Assertions.assertEquals
import org.junit.jupiter.api.Assertions.assertThrows
import org.junit.jupiter.api.Test

class MoneyTest {
    @Test
    fun `Valid Money`() {
        Money(123)
        Money.fromDollarsAndCents(5, 67)
    }

    @Test
    fun `Invalid Money`() {
        assertThrows(IllegalArgumentException::class.java, { Money.fromDollarsAndCents(5, 100) })
        assertThrows(IllegalArgumentException::class.java, { Money.fromDollarsAndCents(3, -1) })
    }

    @Test
    fun `Standard Addition`() {
        val expectedResult = Money(150)
        val actualResult = Money(100) + Money(50)
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Add To Zero`() {
        val expectedResult = Money(0)
        val actualResult = Money(48) + Money(-48)
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Subtract To Zero`() {
        val expectedResult = Money(0)
        val actualResult = Money(78) - Money(78)
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Overflow Addition 1`() {
        val expectedResult = Money(175)
        val actualResult = Money(80) + Money(95)
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Overflow Addition 2`() {
        val expectedResult = Money(100)
        val actualResult = Money(50) + Money(50)
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Overflow Addition 3`() {
        val expectedResult = Money(305)
        val actualResult = Money(178) + Money(127)
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Standard Subtraction`() {
        val expectedResult = Money(101)
        val actualResult = Money(125) - Money(24)
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Overflow Subtraction 1`() {
        val expectedResult = Money(175)
        val actualResult = Money(225) - Money(50)
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Overflow Subtraction 2`() {
        val expectedResult = Money(175)
        val actualResult = Money(325) - Money(150)
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Overflow Subtraction 3`() {
        val expectedResult = Money(100)
        val actualResult = Money(150) - Money(50)
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Positive Dollars`() {
        val expectedResult = "545"
        val actualResult = Money(545).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Zero Dollars`() {
        val expectedResult = "50"
        val actualResult = Money(50).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Negative Dollars`() {
        val expectedResult = "-566"
        val actualResult = Money(-566).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Add Positive and Positive Dollars`() {
        val expectedResult = "6294"
        val actualResult = (Money(4265) + Money(2029)).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Add Positive Dollars and Negative Dollars with Positive Result`() {
        val expectedResult = "132"
        val actualResult = (Money(465) + Money(-333)).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Add Positive Dollars and Negative Dollars with Negative Result`() {
        val expectedResult = "-527"
        val actualResult = (Money(100) + Money(-627)).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Add Negative Dollars and Positive Dollars with Positive Result`() {
        val expectedResult = "132"
        val actualResult = (Money(-333) + Money(465)).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Add Negative Dollars and Positive Dollars with Negative Result`() {
        val expectedResult = "-573"
        val actualResult = (Money(-627) + Money(54)).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Add Negative Dollars and Negative Dollars with Negative Result`() {
        val expectedResult = "-1542"
        val actualResult = (Money(-983) + Money(-559)).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Subtract Positive Dollars and Positive Dollars with Positive Result`() {
        val expectedResult = "5267"
        val actualResult = (Money(10054) - Money(4787)).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Subtract Positive Dollars and Positive Dollars with Negative Result`() {
        val expectedResult = "-416"
        val actualResult = (Money(147) - Money(563)).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Subtract Negative Dollars and Negative Dollars with Positive Result`() {
        val expectedResult = "789"
        val actualResult = (Money(-563) - Money(-1352)).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Subtract Negative Dollars and Negative Dollars with Negative Result`() {
        val expectedResult = "-964"
        val actualResult = (Money(-1563) - Money(-599)).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Subtract Positive Dollars and Negative Dollars with Positive Result`() {
        val expectedResult = "17684"
        val actualResult = (Money(12354) - Money(-5330)).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `Subtract Negative Dollars and Positive Dollars with Negative Result`() {
        val expectedResult = "-568"
        val actualResult = (Money(-432) - Money(136)).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `From Positive Dollars and Cents`() {
        val expectedResult = "587"
        val actualResult = Money.fromDollarsAndCents(5, 87).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `From Negative Dollars And Cents`() {
        val expectedResult = "-1873"
        val actualResult = Money.fromDollarsAndCents(-18, 73).toString()
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `From String - Positive Dollars`() {
        val expectedResult = Money.fromDollarsAndCents(14, 43)
        val actualResult = Money.fromString("$14.43")
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `From String - Zero Dollars`() {
        val expectedResult = Money.fromDollarsAndCents(0, 99)
        val actualResult = Money.fromString("$0.99")
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `From String - Negative Dollars`() {
        val expectedResult = Money.fromDollarsAndCents(-89, 14)
        val actualResult = Money.fromString("-$89.14")
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `From String - Positive Dollars, Zero Cents`() {
        val expectedResult = Money.fromDollarsAndCents(5, 0)
        val actualResult = Money.fromString("$5.00")
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }

    @Test
    fun `From String - Negative Dollars, Zero Cents`() {
        val expectedResult = Money.fromDollarsAndCents(-89, 0)
        val actualResult = Money.fromString("-$89.00")
        assertEquals(expectedResult, actualResult, "$expectedResult is not equal to $actualResult")
    }
}