1
exercism fetch kotlin say

src/test/kotlin/NumberSpellerTest.kt

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
import org.junit.Ignore
import org.junit.Rule
import org.junit.Test
import org.junit.rules.ExpectedException
import java.math.BigInteger
import kotlin.test.assertEquals

class NumberSpellerTest {

    @Rule
    @JvmField
    var expectedException: ExpectedException = ExpectedException.none()

    @Test
    fun test0IsSpelledCorrectly() {
        assertEquals(
                "zero",
                NumberSpeller().say(0))
    }

    @Ignore
    @Test
    fun test1IsSpelledCorrectly() {
        assertEquals(
                "one",
                NumberSpeller().say(1))
    }

    @Ignore
    @Test
    fun test14IsSpelledCorrectly() {
        assertEquals(
                "fourteen",
                NumberSpeller().say(14))
    }

    @Ignore
    @Test
    fun test20IsSpelledCorrectly() {
        assertEquals(
                "twenty",
                NumberSpeller().say(20))
    }

    @Ignore
    @Test
    fun test22IsSpelledCorrectly() {
        assertEquals(
                "twenty-two",
                NumberSpeller().say(22))
    }

    @Ignore
    @Test
    fun test100IsSpelledCorrectly() {
        assertEquals(
                "one hundred",
                NumberSpeller().say(100))
    }

    @Ignore
    @Test
    fun test123IsSpelledCorrectly() {
        assertEquals(
                "one hundred twenty-three",
                NumberSpeller().say(123))
    }

    @Ignore
    @Test
    fun test1000IsSpelledCorrectly() {
        assertEquals(
                "one thousand",
                NumberSpeller().say(1000))
    }

    @Ignore
    @Test
    fun test1234IsSpelledCorrectly() {
        assertEquals(
                "one thousand two hundred thirty-four",
                NumberSpeller().say(1234))
    }

    @Ignore
    @Test
    fun test1000000IsSpelledCorrectly() {
        assertEquals(
                "one million",
                NumberSpeller().say(1000000))
    }

    @Ignore
    @Test
    fun test1002345IsSpelledCorrectly() {
        assertEquals(
                "one million two thousand three hundred forty-five",
                NumberSpeller().say(1002345))
    }

    @Ignore
    @Test
    fun test1000000000IsSpelledCorrectly() {
        assertEquals(
                "one billion",
                NumberSpeller().say(1000000000))
    }

    @Ignore
    @Test
    fun test987654321123IsSpelledCorrectly() {
        assertEquals(
                "nine hundred eighty-seven billion six hundred fifty-four million three hundred twenty-one thousand one hundred twenty-three",
                NumberSpeller().say(987654321123))
    }

    @Ignore
    @Test
    fun testNegativeNumbersAreOutOfRange() {
        expectedException.expect(IllegalArgumentException::class.java)
        expectedException.expectMessage("Input must be non-negative")

        NumberSpeller().say(-1)
    }

    @Ignore
    @Test
    fun testNumbersAbove1000000000000AreOutOfRange() {
        expectedException.expect(IllegalArgumentException::class.java)
        expectedException.expectMessage("Input must be less than 1000000000000")

        NumberSpeller().say(1000000000000)
    }

}