├── src
    └── index.js
├── .prettierrc
├── .editorconfig
├── .eslintrc.js
├── extensions
    └── it-optional.js
├── package.json
├── LICENSE
├── .gitignore
├── README.md
└── test
    └── test.js


/src/index.js:
--------------------------------------------------------------------------------
1 | module.exports = function toReadable(/* number */) {
2 |   throw new Error('Not implemented');
3 | };
4 | 


--------------------------------------------------------------------------------
/.prettierrc:
--------------------------------------------------------------------------------
1 | {
2 |   "trailingComma": "es5",
3 |   "tabWidth": 2,
4 |   "semi": true,
5 |   "singleQuote": true,
6 |   "printWidth": 80,
7 |   "endOfLine": "auto"
8 | }
9 | 


--------------------------------------------------------------------------------
/.editorconfig:
--------------------------------------------------------------------------------
 1 | root = true
 2 | 
 3 | [*]
 4 | charset = utf-8
 5 | indent_style = space
 6 | indent_size = 2
 7 | end_of_line = lf
 8 | trim_trailing_whitespace = true
 9 | insert_final_newline = true
10 | 
11 | [*.js]
12 | quote_type = single
13 | 
14 | [*.md]
15 | trim_trailing_whitespace = false
16 | 
17 | [*.json]
18 | insert_final_newline = false
19 | 


--------------------------------------------------------------------------------
/.eslintrc.js:
--------------------------------------------------------------------------------
 1 | module.exports = {
 2 |   root: true,
 3 |   env: {
 4 |     commonjs: true,
 5 |     es2024: true,
 6 |     node: true,
 7 |     mocha: true,
 8 |   },
 9 |   extends: ['airbnb-base', 'plugin:prettier/recommended'],
10 |   globals: {
11 |     Atomics: 'readonly',
12 |     SharedArrayBuffer: 'readonly',
13 |   },
14 |   parserOptions: {
15 |     ecmaVersion: 2024,
16 |   },
17 |   noInlineConfig: true,
18 | };
19 | 


--------------------------------------------------------------------------------
/extensions/it-optional.js:
--------------------------------------------------------------------------------
 1 | function testOptional(title, fn, isAsyncTest) {
 2 |   if (isAsyncTest) {
 3 |     it(title, function test(done) {
 4 |       try {
 5 |         fn.call(this, done);
 6 |       } catch (err) {
 7 |         if (err.message === 'Not implemented') {
 8 |           this.test.skip();
 9 |         } else {
10 |           throw err;
11 |         }
12 |       }
13 |     });
14 |   } else {
15 |     it(title, function test() {
16 |       try {
17 |         fn.call(this);
18 |       } catch (err) {
19 |         if (err.message === 'Not implemented') {
20 |           this.test.skip();
21 |         } else {
22 |           throw err;
23 |         }
24 |       }
25 |     });
26 |   }
27 | }
28 | 
29 | module.exports = testOptional;
30 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "human-readable-number",
 3 |   "version": "1.0.0",
 4 |   "description": "Human Readable Number",
 5 |   "main": "index.js",
 6 |   "scripts": {
 7 |     "test": "npm run lint && mocha",
 8 |     "lint": "node node_modules/eslint/bin/eslint.js ./src",
 9 |     "lint:fix": "node node_modules/eslint/bin/eslint.js ./src --fix"
10 |   },
11 |   "repository": {
12 |     "type": "git",
13 |     "url": "git+https://github.com/rolling-scopes-school/human-readable-number.git"
14 |   },
15 |   "author": "max@shas.tel",
16 |   "license": "MIT",
17 |   "homepage": "https://github.com/rolling-scopes-school/human-readable-number",
18 |   "devDependencies": {
19 |     "eslint": "^8.57.1",
20 |     "eslint-config-airbnb-base": "^15.0.0",
21 |     "eslint-config-prettier": "^10.1.1",
22 |     "eslint-plugin-prettier": "^5.2.3",
23 |     "mocha": "^10.8.2",
24 |     "prettier": "^3.5.3"
25 |   }
26 | }
27 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2019
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | # Logs
  2 | logs
  3 | *.log
  4 | npm-debug.log*
  5 | yarn-debug.log*
  6 | yarn-error.log*
  7 | lerna-debug.log*
  8 | .pnpm-debug.log*
  9 | 
 10 | # Diagnostic reports (https://nodejs.org/api/report.html)
 11 | report.[0-9]*.[0-9]*.[0-9]*.[0-9]*.json
 12 | 
 13 | # Runtime data
 14 | pids
 15 | *.pid
 16 | *.seed
 17 | *.pid.lock
 18 | 
 19 | # Directory for instrumented libs generated by jscoverage/JSCover
 20 | lib-cov
 21 | 
 22 | # Coverage directory used by tools like istanbul
 23 | coverage
 24 | *.lcov
 25 | 
 26 | # nyc test coverage
 27 | .nyc_output
 28 | 
 29 | # Grunt intermediate storage (https://gruntjs.com/creating-plugins#storing-task-files)
 30 | .grunt
 31 | 
 32 | # Bower dependency directory (https://bower.io/)
 33 | bower_components
 34 | 
 35 | # node-waf configuration
 36 | .lock-wscript
 37 | 
 38 | # Compiled binary addons (https://nodejs.org/api/addons.html)
 39 | build/Release
 40 | 
 41 | # Dependency directories
 42 | node_modules/
 43 | jspm_packages/
 44 | 
 45 | # Snowpack dependency directory (https://snowpack.dev/)
 46 | web_modules/
 47 | 
 48 | # TypeScript cache
 49 | *.tsbuildinfo
 50 | 
 51 | # Optional npm cache directory
 52 | .npm
 53 | 
 54 | # Optional eslint cache
 55 | .eslintcache
 56 | 
 57 | # Optional stylelint cache
 58 | .stylelintcache
 59 | 
 60 | # Microbundle cache
 61 | .rpt2_cache/
 62 | .rts2_cache_cjs/
 63 | .rts2_cache_es/
 64 | .rts2_cache_umd/
 65 | 
 66 | # Optional REPL history
 67 | .node_repl_history
 68 | 
 69 | # Output of 'npm pack'
 70 | *.tgz
 71 | 
 72 | # Yarn Integrity file
 73 | .yarn-integrity
 74 | 
 75 | # dotenv environment variable files
 76 | .env
 77 | .env.development.local
 78 | .env.test.local
 79 | .env.production.local
 80 | .env.local
 81 | 
 82 | # parcel-bundler cache (https://parceljs.org/)
 83 | .cache
 84 | .parcel-cache
 85 | 
 86 | # Next.js build output
 87 | .next
 88 | out
 89 | 
 90 | # Nuxt.js build / generate output
 91 | .nuxt
 92 | dist
 93 | 
 94 | # Gatsby files
 95 | .cache/
 96 | # Comment in the public line in if your project uses Gatsby and not Next.js
 97 | # https://nextjs.org/blog/next-9-1#public-directory-support
 98 | # public
 99 | 
100 | # vuepress build output
101 | .vuepress/dist
102 | 
103 | # vuepress v2.x temp and cache directory
104 | .temp
105 | .cache
106 | 
107 | # Docusaurus cache and generated files
108 | .docusaurus
109 | 
110 | # Serverless directories
111 | .serverless/
112 | 
113 | # FuseBox cache
114 | .fusebox/
115 | 
116 | # DynamoDB Local files
117 | .dynamodb/
118 | 
119 | # TernJS port file
120 | .tern-port
121 | 
122 | # Stores VSCode versions used for testing VSCode extensions
123 | .vscode-test
124 | 
125 | # yarn v2
126 | .yarn/cache
127 | .yarn/unplugged
128 | .yarn/build-state.yml
129 | .yarn/install-state.gz
130 | .pnp.*
131 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Human Readable Number
 2 | 
 3 | :warning: **Please note that you mustn't open PRs that contains the answers to this repo!**
 4 | 
 5 | However, PRs with the fixes or proposals are welcomed!
 6 | 
 7 | ## Task
 8 | Your task is to implement function `toReadable` that converts given number, to readable string.
 9 | 
10 | For example:
11 | ```js
12 | toReadable(1);   // Will return 'one'
13 | toReadable(997); // will return 'nine hundred ninety seven'
14 | ```
15 | 
16 | You can find even more examples in `test.js`
17 | 
18 | **Active usage of [documentation](https://developer.mozilla.org/en-US/) is strongly recommended!**
19 | 
20 | ## Prepare and test
21 | 1. Install Node.js
22 | 2. Fork this repository: https://github.com/rolling-scopes-school/human-readable-number/
23 | 3. Clone your newly created repo: `https://github.com/<%your_github_username%>/human-readable-number/`
24 | 4. Go to folder `human-readable-number`
25 | 5. To install all dependencies use `npm install`
26 | 6. Read the task description. Try to understand the idea. You can see the tests prepared if you don't understand it.
27 | 7. Write your code in `src/index.js`.
28 | 
29 |     Uncomment the incoming parameters:
30 | 
31 |     ```javascript
32 |         function toReadable(/* number */)
33 |     ```
34 | 
35 |     Remove the throwing error line from function body:
36 |     ```javascript
37 |         throw new Error('Not implemented'); 
38 |     ```
39 |     Implement the function by any way and verify your solution by running tests until the failed test become passed (green).
40 | 8. Save the solution and run `npm test` in command line.
41 | 9. You will see the number of passing and pending tests.
42 | 
43 | ## Submit to [rs app](https://app.rs.school/)
44 | 1. Commit and push your solutions to your fork
45 | 2. Open rs app and login
46 | 3. Go to submit task page
47 | 4. Select your task (Human Readable Number)
48 | 5. Press submit button and enjoy
49 | 
50 | ## Notes
51 | * We recommend you to use nodejs of version 22. If you using any of features that does not supported by node `v22`, score won't be submitted.
52 | * Installing nodejs `v22` is optional, you can run jobs using your version and not use methods that are not in nodejs `v22`.
53 | * Please be sure that each of your test in limit of 30sec.
54 | * You will get 0 (zero) if you have any eslint's errors or warnings.
55 | 
56 | ## FAQ
57 | **Question:** I use Windows machine and have received a lot of errors like "Expected linebreaks to be 'LF' but found 'CRLF'". How to handle it?
58 | 
59 | **Answer**:
60 | - First, you need to install Gitbash properly: you need to choose option "Checkout as-is, commit as-is" in section "Configuring the line ending conversions". It'll let you download repos with line endings set "as-is" as well as commit. In other words, not to change them at all, because by default it converts them.
61 | - Second, install `editorconfig` plugin to your editor. For VS Code you can find it here:
62 | https://marketplace.visualstudio.com/items?itemName=EditorConfig.EditorConfig
63 | 
64 |   I'll let you apply some rules when you saving your files in the repo. This plugin will use config-file `.editorconfig` that you can see in the root folder. It lets you save the file with needed line endings, trim whitespaces, etc.
65 | - Finally, you need to apply linter's autofix feature in order to fix all linebreaks that was already changed to "CLRF":
66 | ```
67 | $ npm run lint -- --fix
68 | ``` 
69 | 
70 | **Question:** Execution of tests "hangs" on one of them and does not display the result. What to do?<br>
71 | **Answer**: Check your solution for an infinite loop, fix it, and rerun the test.
72 | 
73 | **Question:** The solution in the local repository succeeds and all tests are "green", but in the application some tests don't count. What to do?<br>
74 | **Answer**: [Update your repository fork](https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/working-with-forks/syncing-a-fork), update the local repository from the fork, run tests and fix your solution. After fixing, resubmit your solution for testing.
75 | 
76 | ___
77 | The task based on https://github.com/rolling-scopes-school/js-assignments.
78 | 


--------------------------------------------------------------------------------
/test/test.js:
--------------------------------------------------------------------------------
   1 | const assert = require('assert');
   2 | const toReadable = require('../src');
   3 | it.optional = require('../extensions/it-optional');
   4 | 
   5 | it.optional("Should return 'zero' when 0 given", () => {
   6 |   const readable = toReadable(0);
   7 | 
   8 |   assert.equal(readable, 'zero');
   9 | });
  10 | 
  11 | it.optional("Should return 'one' when 1 given", () => {
  12 |   const readable = toReadable(1);
  13 | 
  14 |   assert.equal(readable, 'one');
  15 | });
  16 | 
  17 | it.optional("Should return 'two' when 2 given", () => {
  18 |   const readable = toReadable(2);
  19 | 
  20 |   assert.equal(readable, 'two');
  21 | });
  22 | 
  23 | it.optional("Should return 'three' when 3 given", () => {
  24 |   const readable = toReadable(3);
  25 | 
  26 |   assert.equal(readable, 'three');
  27 | });
  28 | 
  29 | it.optional("Should return 'four' when 4 given", () => {
  30 |   const readable = toReadable(4);
  31 | 
  32 |   assert.equal(readable, 'four');
  33 | });
  34 | 
  35 | it.optional("Should return 'five' when 5 given", () => {
  36 |   const readable = toReadable(5);
  37 | 
  38 |   assert.equal(readable, 'five');
  39 | });
  40 | 
  41 | it.optional("Should return 'six' when 6 given", () => {
  42 |   const readable = toReadable(6);
  43 | 
  44 |   assert.equal(readable, 'six');
  45 | });
  46 | 
  47 | it.optional("Should return 'seven' when 7 given", () => {
  48 |   const readable = toReadable(7);
  49 | 
  50 |   assert.equal(readable, 'seven');
  51 | });
  52 | 
  53 | it.optional("Should return 'eight' when 8 given", () => {
  54 |   const readable = toReadable(8);
  55 | 
  56 |   assert.equal(readable, 'eight');
  57 | });
  58 | 
  59 | it.optional("Should return 'nine' when 9 given", () => {
  60 |   const readable = toReadable(9);
  61 | 
  62 |   assert.equal(readable, 'nine');
  63 | });
  64 | 
  65 | it.optional("Should return 'ten' when 10 given", () => {
  66 |   const readable = toReadable(10);
  67 | 
  68 |   assert.equal(readable, 'ten');
  69 | });
  70 | 
  71 | it.optional("Should return 'eleven' when 11 given", () => {
  72 |   const readable = toReadable(11);
  73 | 
  74 |   assert.equal(readable, 'eleven');
  75 | });
  76 | 
  77 | it.optional("Should return 'twelve' when 12 given", () => {
  78 |   const readable = toReadable(12);
  79 | 
  80 |   assert.equal(readable, 'twelve');
  81 | });
  82 | 
  83 | it.optional("Should return 'thirteen' when 13 given", () => {
  84 |   const readable = toReadable(13);
  85 | 
  86 |   assert.equal(readable, 'thirteen');
  87 | });
  88 | 
  89 | it.optional("Should return 'fourteen' when 14 given", () => {
  90 |   const readable = toReadable(14);
  91 | 
  92 |   assert.equal(readable, 'fourteen');
  93 | });
  94 | 
  95 | it.optional("Should return 'fifteen' when 15 given", () => {
  96 |   const readable = toReadable(15);
  97 | 
  98 |   assert.equal(readable, 'fifteen');
  99 | });
 100 | 
 101 | it.optional("Should return 'sixteen' when 16 given", () => {
 102 |   const readable = toReadable(16);
 103 | 
 104 |   assert.equal(readable, 'sixteen');
 105 | });
 106 | 
 107 | it.optional("Should return 'seventeen' when 17 given", () => {
 108 |   const readable = toReadable(17);
 109 | 
 110 |   assert.equal(readable, 'seventeen');
 111 | });
 112 | 
 113 | it.optional("Should return 'eighteen' when 18 given", () => {
 114 |   const readable = toReadable(18);
 115 | 
 116 |   assert.equal(readable, 'eighteen');
 117 | });
 118 | 
 119 | it.optional("Should return 'nineteen' when 19 given", () => {
 120 |   const readable = toReadable(19);
 121 | 
 122 |   assert.equal(readable, 'nineteen');
 123 | });
 124 | 
 125 | it.optional("Should return 'twenty' when 20 given", () => {
 126 |   const readable = toReadable(20);
 127 | 
 128 |   assert.equal(readable, 'twenty');
 129 | });
 130 | 
 131 | it.optional("Should return 'twenty one' when 21 given", () => {
 132 |   const readable = toReadable(21);
 133 | 
 134 |   assert.equal(readable, 'twenty one');
 135 | });
 136 | 
 137 | it.optional("Should return 'twenty two' when 22 given", () => {
 138 |   const readable = toReadable(22);
 139 | 
 140 |   assert.equal(readable, 'twenty two');
 141 | });
 142 | 
 143 | it.optional("Should return 'twenty three' when 23 given", () => {
 144 |   const readable = toReadable(23);
 145 | 
 146 |   assert.equal(readable, 'twenty three');
 147 | });
 148 | 
 149 | it.optional("Should return 'twenty four' when 24 given", () => {
 150 |   const readable = toReadable(24);
 151 | 
 152 |   assert.equal(readable, 'twenty four');
 153 | });
 154 | 
 155 | it.optional("Should return 'twenty five' when 25 given", () => {
 156 |   const readable = toReadable(25);
 157 | 
 158 |   assert.equal(readable, 'twenty five');
 159 | });
 160 | 
 161 | it.optional("Should return 'twenty six' when 26 given", () => {
 162 |   const readable = toReadable(26);
 163 | 
 164 |   assert.equal(readable, 'twenty six');
 165 | });
 166 | 
 167 | it.optional("Should return 'twenty seven' when 27 given", () => {
 168 |   const readable = toReadable(27);
 169 | 
 170 |   assert.equal(readable, 'twenty seven');
 171 | });
 172 | 
 173 | it.optional("Should return 'twenty eight' when 28 given", () => {
 174 |   const readable = toReadable(28);
 175 | 
 176 |   assert.equal(readable, 'twenty eight');
 177 | });
 178 | 
 179 | it.optional("Should return 'twenty nine' when 29 given", () => {
 180 |   const readable = toReadable(29);
 181 | 
 182 |   assert.equal(readable, 'twenty nine');
 183 | });
 184 | 
 185 | it.optional("Should return 'thirty' when 30 given", () => {
 186 |   const readable = toReadable(30);
 187 | 
 188 |   assert.equal(readable, 'thirty');
 189 | });
 190 | 
 191 | it.optional("Should return 'thirty one' when 31 given", () => {
 192 |   const readable = toReadable(31);
 193 | 
 194 |   assert.equal(readable, 'thirty one');
 195 | });
 196 | 
 197 | it.optional("Should return 'thirty two' when 32 given", () => {
 198 |   const readable = toReadable(32);
 199 | 
 200 |   assert.equal(readable, 'thirty two');
 201 | });
 202 | 
 203 | it.optional("Should return 'thirty three' when 33 given", () => {
 204 |   const readable = toReadable(33);
 205 | 
 206 |   assert.equal(readable, 'thirty three');
 207 | });
 208 | 
 209 | it.optional("Should return 'thirty four' when 34 given", () => {
 210 |   const readable = toReadable(34);
 211 | 
 212 |   assert.equal(readable, 'thirty four');
 213 | });
 214 | 
 215 | it.optional("Should return 'thirty five' when 35 given", () => {
 216 |   const readable = toReadable(35);
 217 | 
 218 |   assert.equal(readable, 'thirty five');
 219 | });
 220 | 
 221 | it.optional("Should return 'thirty six' when 36 given", () => {
 222 |   const readable = toReadable(36);
 223 | 
 224 |   assert.equal(readable, 'thirty six');
 225 | });
 226 | 
 227 | it.optional("Should return 'thirty seven' when 37 given", () => {
 228 |   const readable = toReadable(37);
 229 | 
 230 |   assert.equal(readable, 'thirty seven');
 231 | });
 232 | 
 233 | it.optional("Should return 'thirty eight' when 38 given", () => {
 234 |   const readable = toReadable(38);
 235 | 
 236 |   assert.equal(readable, 'thirty eight');
 237 | });
 238 | 
 239 | it.optional("Should return 'thirty nine' when 39 given", () => {
 240 |   const readable = toReadable(39);
 241 | 
 242 |   assert.equal(readable, 'thirty nine');
 243 | });
 244 | 
 245 | it.optional("Should return 'forty' when 40 given", () => {
 246 |   const readable = toReadable(40);
 247 | 
 248 |   assert.equal(readable, 'forty');
 249 | });
 250 | 
 251 | it.optional("Should return 'forty one' when 41 given", () => {
 252 |   const readable = toReadable(41);
 253 | 
 254 |   assert.equal(readable, 'forty one');
 255 | });
 256 | 
 257 | it.optional("Should return 'forty two' when 42 given", () => {
 258 |   const readable = toReadable(42);
 259 | 
 260 |   assert.equal(readable, 'forty two');
 261 | });
 262 | 
 263 | it.optional("Should return 'forty three' when 43 given", () => {
 264 |   const readable = toReadable(43);
 265 | 
 266 |   assert.equal(readable, 'forty three');
 267 | });
 268 | 
 269 | it.optional("Should return 'forty four' when 44 given", () => {
 270 |   const readable = toReadable(44);
 271 | 
 272 |   assert.equal(readable, 'forty four');
 273 | });
 274 | 
 275 | it.optional("Should return 'forty five' when 45 given", () => {
 276 |   const readable = toReadable(45);
 277 | 
 278 |   assert.equal(readable, 'forty five');
 279 | });
 280 | 
 281 | it.optional("Should return 'forty six' when 46 given", () => {
 282 |   const readable = toReadable(46);
 283 | 
 284 |   assert.equal(readable, 'forty six');
 285 | });
 286 | 
 287 | it.optional("Should return 'forty seven' when 47 given", () => {
 288 |   const readable = toReadable(47);
 289 | 
 290 |   assert.equal(readable, 'forty seven');
 291 | });
 292 | 
 293 | it.optional("Should return 'forty eight' when 48 given", () => {
 294 |   const readable = toReadable(48);
 295 | 
 296 |   assert.equal(readable, 'forty eight');
 297 | });
 298 | 
 299 | it.optional("Should return 'forty nine' when 49 given", () => {
 300 |   const readable = toReadable(49);
 301 | 
 302 |   assert.equal(readable, 'forty nine');
 303 | });
 304 | 
 305 | it.optional("Should return 'fifty' when 50 given", () => {
 306 |   const readable = toReadable(50);
 307 | 
 308 |   assert.equal(readable, 'fifty');
 309 | });
 310 | 
 311 | it.optional("Should return 'fifty one' when 51 given", () => {
 312 |   const readable = toReadable(51);
 313 | 
 314 |   assert.equal(readable, 'fifty one');
 315 | });
 316 | 
 317 | it.optional("Should return 'fifty two' when 52 given", () => {
 318 |   const readable = toReadable(52);
 319 | 
 320 |   assert.equal(readable, 'fifty two');
 321 | });
 322 | 
 323 | it.optional("Should return 'fifty three' when 53 given", () => {
 324 |   const readable = toReadable(53);
 325 | 
 326 |   assert.equal(readable, 'fifty three');
 327 | });
 328 | 
 329 | it.optional("Should return 'fifty four' when 54 given", () => {
 330 |   const readable = toReadable(54);
 331 | 
 332 |   assert.equal(readable, 'fifty four');
 333 | });
 334 | 
 335 | it.optional("Should return 'fifty five' when 55 given", () => {
 336 |   const readable = toReadable(55);
 337 | 
 338 |   assert.equal(readable, 'fifty five');
 339 | });
 340 | 
 341 | it.optional("Should return 'fifty six' when 56 given", () => {
 342 |   const readable = toReadable(56);
 343 | 
 344 |   assert.equal(readable, 'fifty six');
 345 | });
 346 | 
 347 | it.optional("Should return 'fifty seven' when 57 given", () => {
 348 |   const readable = toReadable(57);
 349 | 
 350 |   assert.equal(readable, 'fifty seven');
 351 | });
 352 | 
 353 | it.optional("Should return 'fifty eight' when 58 given", () => {
 354 |   const readable = toReadable(58);
 355 | 
 356 |   assert.equal(readable, 'fifty eight');
 357 | });
 358 | 
 359 | it.optional("Should return 'fifty nine' when 59 given", () => {
 360 |   const readable = toReadable(59);
 361 | 
 362 |   assert.equal(readable, 'fifty nine');
 363 | });
 364 | 
 365 | it.optional("Should return 'sixty' when 60 given", () => {
 366 |   const readable = toReadable(60);
 367 | 
 368 |   assert.equal(readable, 'sixty');
 369 | });
 370 | 
 371 | it.optional("Should return 'sixty one' when 61 given", () => {
 372 |   const readable = toReadable(61);
 373 | 
 374 |   assert.equal(readable, 'sixty one');
 375 | });
 376 | 
 377 | it.optional("Should return 'sixty two' when 62 given", () => {
 378 |   const readable = toReadable(62);
 379 | 
 380 |   assert.equal(readable, 'sixty two');
 381 | });
 382 | 
 383 | it.optional("Should return 'sixty three' when 63 given", () => {
 384 |   const readable = toReadable(63);
 385 | 
 386 |   assert.equal(readable, 'sixty three');
 387 | });
 388 | 
 389 | it.optional("Should return 'sixty four' when 64 given", () => {
 390 |   const readable = toReadable(64);
 391 | 
 392 |   assert.equal(readable, 'sixty four');
 393 | });
 394 | 
 395 | it.optional("Should return 'sixty five' when 65 given", () => {
 396 |   const readable = toReadable(65);
 397 | 
 398 |   assert.equal(readable, 'sixty five');
 399 | });
 400 | 
 401 | it.optional("Should return 'sixty six' when 66 given", () => {
 402 |   const readable = toReadable(66);
 403 | 
 404 |   assert.equal(readable, 'sixty six');
 405 | });
 406 | 
 407 | it.optional("Should return 'sixty seven' when 67 given", () => {
 408 |   const readable = toReadable(67);
 409 | 
 410 |   assert.equal(readable, 'sixty seven');
 411 | });
 412 | 
 413 | it.optional("Should return 'sixty eight' when 68 given", () => {
 414 |   const readable = toReadable(68);
 415 | 
 416 |   assert.equal(readable, 'sixty eight');
 417 | });
 418 | 
 419 | it.optional("Should return 'sixty nine' when 69 given", () => {
 420 |   const readable = toReadable(69);
 421 | 
 422 |   assert.equal(readable, 'sixty nine');
 423 | });
 424 | 
 425 | it.optional("Should return 'seventy' when 70 given", () => {
 426 |   const readable = toReadable(70);
 427 | 
 428 |   assert.equal(readable, 'seventy');
 429 | });
 430 | 
 431 | it.optional("Should return 'seventy one' when 71 given", () => {
 432 |   const readable = toReadable(71);
 433 | 
 434 |   assert.equal(readable, 'seventy one');
 435 | });
 436 | 
 437 | it.optional("Should return 'seventy two' when 72 given", () => {
 438 |   const readable = toReadable(72);
 439 | 
 440 |   assert.equal(readable, 'seventy two');
 441 | });
 442 | 
 443 | it.optional("Should return 'seventy three' when 73 given", () => {
 444 |   const readable = toReadable(73);
 445 | 
 446 |   assert.equal(readable, 'seventy three');
 447 | });
 448 | 
 449 | it.optional("Should return 'seventy four' when 74 given", () => {
 450 |   const readable = toReadable(74);
 451 | 
 452 |   assert.equal(readable, 'seventy four');
 453 | });
 454 | 
 455 | it.optional("Should return 'seventy five' when 75 given", () => {
 456 |   const readable = toReadable(75);
 457 | 
 458 |   assert.equal(readable, 'seventy five');
 459 | });
 460 | 
 461 | it.optional("Should return 'seventy six' when 76 given", () => {
 462 |   const readable = toReadable(76);
 463 | 
 464 |   assert.equal(readable, 'seventy six');
 465 | });
 466 | 
 467 | it.optional("Should return 'seventy seven' when 77 given", () => {
 468 |   const readable = toReadable(77);
 469 | 
 470 |   assert.equal(readable, 'seventy seven');
 471 | });
 472 | 
 473 | it.optional("Should return 'seventy eight' when 78 given", () => {
 474 |   const readable = toReadable(78);
 475 | 
 476 |   assert.equal(readable, 'seventy eight');
 477 | });
 478 | 
 479 | it.optional("Should return 'seventy nine' when 79 given", () => {
 480 |   const readable = toReadable(79);
 481 | 
 482 |   assert.equal(readable, 'seventy nine');
 483 | });
 484 | 
 485 | it.optional("Should return 'eighty' when 80 given", () => {
 486 |   const readable = toReadable(80);
 487 | 
 488 |   assert.equal(readable, 'eighty');
 489 | });
 490 | 
 491 | it.optional("Should return 'eighty one' when 81 given", () => {
 492 |   const readable = toReadable(81);
 493 | 
 494 |   assert.equal(readable, 'eighty one');
 495 | });
 496 | 
 497 | it.optional("Should return 'eighty two' when 82 given", () => {
 498 |   const readable = toReadable(82);
 499 | 
 500 |   assert.equal(readable, 'eighty two');
 501 | });
 502 | 
 503 | it.optional("Should return 'eighty three' when 83 given", () => {
 504 |   const readable = toReadable(83);
 505 | 
 506 |   assert.equal(readable, 'eighty three');
 507 | });
 508 | 
 509 | it.optional("Should return 'eighty four' when 84 given", () => {
 510 |   const readable = toReadable(84);
 511 | 
 512 |   assert.equal(readable, 'eighty four');
 513 | });
 514 | 
 515 | it.optional("Should return 'eighty five' when 85 given", () => {
 516 |   const readable = toReadable(85);
 517 | 
 518 |   assert.equal(readable, 'eighty five');
 519 | });
 520 | 
 521 | it.optional("Should return 'eighty six' when 86 given", () => {
 522 |   const readable = toReadable(86);
 523 | 
 524 |   assert.equal(readable, 'eighty six');
 525 | });
 526 | 
 527 | it.optional("Should return 'eighty seven' when 87 given", () => {
 528 |   const readable = toReadable(87);
 529 | 
 530 |   assert.equal(readable, 'eighty seven');
 531 | });
 532 | 
 533 | it.optional("Should return 'eighty eight' when 88 given", () => {
 534 |   const readable = toReadable(88);
 535 | 
 536 |   assert.equal(readable, 'eighty eight');
 537 | });
 538 | 
 539 | it.optional("Should return 'eighty nine' when 89 given", () => {
 540 |   const readable = toReadable(89);
 541 | 
 542 |   assert.equal(readable, 'eighty nine');
 543 | });
 544 | 
 545 | it.optional("Should return 'ninety' when 90 given", () => {
 546 |   const readable = toReadable(90);
 547 | 
 548 |   assert.equal(readable, 'ninety');
 549 | });
 550 | 
 551 | it.optional("Should return 'ninety one' when 91 given", () => {
 552 |   const readable = toReadable(91);
 553 | 
 554 |   assert.equal(readable, 'ninety one');
 555 | });
 556 | 
 557 | it.optional("Should return 'ninety two' when 92 given", () => {
 558 |   const readable = toReadable(92);
 559 | 
 560 |   assert.equal(readable, 'ninety two');
 561 | });
 562 | 
 563 | it.optional("Should return 'ninety three' when 93 given", () => {
 564 |   const readable = toReadable(93);
 565 | 
 566 |   assert.equal(readable, 'ninety three');
 567 | });
 568 | 
 569 | it.optional("Should return 'ninety four' when 94 given", () => {
 570 |   const readable = toReadable(94);
 571 | 
 572 |   assert.equal(readable, 'ninety four');
 573 | });
 574 | 
 575 | it.optional("Should return 'ninety five' when 95 given", () => {
 576 |   const readable = toReadable(95);
 577 | 
 578 |   assert.equal(readable, 'ninety five');
 579 | });
 580 | 
 581 | it.optional("Should return 'ninety six' when 96 given", () => {
 582 |   const readable = toReadable(96);
 583 | 
 584 |   assert.equal(readable, 'ninety six');
 585 | });
 586 | 
 587 | it.optional("Should return 'ninety seven' when 97 given", () => {
 588 |   const readable = toReadable(97);
 589 | 
 590 |   assert.equal(readable, 'ninety seven');
 591 | });
 592 | 
 593 | it.optional("Should return 'ninety eight' when 98 given", () => {
 594 |   const readable = toReadable(98);
 595 | 
 596 |   assert.equal(readable, 'ninety eight');
 597 | });
 598 | 
 599 | it.optional("Should return 'ninety nine' when 99 given", () => {
 600 |   const readable = toReadable(99);
 601 | 
 602 |   assert.equal(readable, 'ninety nine');
 603 | });
 604 | 
 605 | it.optional("Should return 'one hundred' when 100 given", () => {
 606 |   const readable = toReadable(100);
 607 | 
 608 |   assert.equal(readable, 'one hundred');
 609 | });
 610 | 
 611 | it.optional("Should return 'one hundred one' when 101 given", () => {
 612 |   const readable = toReadable(101);
 613 | 
 614 |   assert.equal(readable, 'one hundred one');
 615 | });
 616 | 
 617 | it.optional("Should return 'one hundred two' when 102 given", () => {
 618 |   const readable = toReadable(102);
 619 | 
 620 |   assert.equal(readable, 'one hundred two');
 621 | });
 622 | 
 623 | it.optional("Should return 'one hundred three' when 103 given", () => {
 624 |   const readable = toReadable(103);
 625 | 
 626 |   assert.equal(readable, 'one hundred three');
 627 | });
 628 | 
 629 | it.optional("Should return 'one hundred four' when 104 given", () => {
 630 |   const readable = toReadable(104);
 631 | 
 632 |   assert.equal(readable, 'one hundred four');
 633 | });
 634 | 
 635 | it.optional("Should return 'one hundred five' when 105 given", () => {
 636 |   const readable = toReadable(105);
 637 | 
 638 |   assert.equal(readable, 'one hundred five');
 639 | });
 640 | 
 641 | it.optional("Should return 'one hundred six' when 106 given", () => {
 642 |   const readable = toReadable(106);
 643 | 
 644 |   assert.equal(readable, 'one hundred six');
 645 | });
 646 | 
 647 | it.optional("Should return 'one hundred seven' when 107 given", () => {
 648 |   const readable = toReadable(107);
 649 | 
 650 |   assert.equal(readable, 'one hundred seven');
 651 | });
 652 | 
 653 | it.optional("Should return 'one hundred eight' when 108 given", () => {
 654 |   const readable = toReadable(108);
 655 | 
 656 |   assert.equal(readable, 'one hundred eight');
 657 | });
 658 | 
 659 | it.optional("Should return 'one hundred nine' when 109 given", () => {
 660 |   const readable = toReadable(109);
 661 | 
 662 |   assert.equal(readable, 'one hundred nine');
 663 | });
 664 | 
 665 | it.optional("Should return 'one hundred ten' when 110 given", () => {
 666 |   const readable = toReadable(110);
 667 | 
 668 |   assert.equal(readable, 'one hundred ten');
 669 | });
 670 | 
 671 | it.optional("Should return 'one hundred eleven' when 111 given", () => {
 672 |   const readable = toReadable(111);
 673 | 
 674 |   assert.equal(readable, 'one hundred eleven');
 675 | });
 676 | 
 677 | it.optional("Should return 'one hundred twelve' when 112 given", () => {
 678 |   const readable = toReadable(112);
 679 | 
 680 |   assert.equal(readable, 'one hundred twelve');
 681 | });
 682 | 
 683 | it.optional("Should return 'one hundred thirteen' when 113 given", () => {
 684 |   const readable = toReadable(113);
 685 | 
 686 |   assert.equal(readable, 'one hundred thirteen');
 687 | });
 688 | 
 689 | it.optional("Should return 'one hundred fourteen' when 114 given", () => {
 690 |   const readable = toReadable(114);
 691 | 
 692 |   assert.equal(readable, 'one hundred fourteen');
 693 | });
 694 | 
 695 | it.optional("Should return 'one hundred fifteen' when 115 given", () => {
 696 |   const readable = toReadable(115);
 697 | 
 698 |   assert.equal(readable, 'one hundred fifteen');
 699 | });
 700 | 
 701 | it.optional("Should return 'one hundred sixteen' when 116 given", () => {
 702 |   const readable = toReadable(116);
 703 | 
 704 |   assert.equal(readable, 'one hundred sixteen');
 705 | });
 706 | 
 707 | it.optional("Should return 'one hundred seventeen' when 117 given", () => {
 708 |   const readable = toReadable(117);
 709 | 
 710 |   assert.equal(readable, 'one hundred seventeen');
 711 | });
 712 | 
 713 | it.optional("Should return 'one hundred eighteen' when 118 given", () => {
 714 |   const readable = toReadable(118);
 715 | 
 716 |   assert.equal(readable, 'one hundred eighteen');
 717 | });
 718 | 
 719 | it.optional("Should return 'one hundred nineteen' when 119 given", () => {
 720 |   const readable = toReadable(119);
 721 | 
 722 |   assert.equal(readable, 'one hundred nineteen');
 723 | });
 724 | 
 725 | it.optional("Should return 'one hundred twenty' when 120 given", () => {
 726 |   const readable = toReadable(120);
 727 | 
 728 |   assert.equal(readable, 'one hundred twenty');
 729 | });
 730 | 
 731 | it.optional("Should return 'one hundred twenty one' when 121 given", () => {
 732 |   const readable = toReadable(121);
 733 | 
 734 |   assert.equal(readable, 'one hundred twenty one');
 735 | });
 736 | 
 737 | it.optional("Should return 'one hundred twenty two' when 122 given", () => {
 738 |   const readable = toReadable(122);
 739 | 
 740 |   assert.equal(readable, 'one hundred twenty two');
 741 | });
 742 | 
 743 | it.optional("Should return 'one hundred twenty three' when 123 given", () => {
 744 |   const readable = toReadable(123);
 745 | 
 746 |   assert.equal(readable, 'one hundred twenty three');
 747 | });
 748 | 
 749 | it.optional("Should return 'one hundred twenty four' when 124 given", () => {
 750 |   const readable = toReadable(124);
 751 | 
 752 |   assert.equal(readable, 'one hundred twenty four');
 753 | });
 754 | 
 755 | it.optional("Should return 'one hundred twenty five' when 125 given", () => {
 756 |   const readable = toReadable(125);
 757 | 
 758 |   assert.equal(readable, 'one hundred twenty five');
 759 | });
 760 | 
 761 | it.optional("Should return 'one hundred twenty six' when 126 given", () => {
 762 |   const readable = toReadable(126);
 763 | 
 764 |   assert.equal(readable, 'one hundred twenty six');
 765 | });
 766 | 
 767 | it.optional("Should return 'one hundred twenty seven' when 127 given", () => {
 768 |   const readable = toReadable(127);
 769 | 
 770 |   assert.equal(readable, 'one hundred twenty seven');
 771 | });
 772 | 
 773 | it.optional("Should return 'one hundred twenty eight' when 128 given", () => {
 774 |   const readable = toReadable(128);
 775 | 
 776 |   assert.equal(readable, 'one hundred twenty eight');
 777 | });
 778 | 
 779 | it.optional("Should return 'one hundred twenty nine' when 129 given", () => {
 780 |   const readable = toReadable(129);
 781 | 
 782 |   assert.equal(readable, 'one hundred twenty nine');
 783 | });
 784 | 
 785 | it.optional("Should return 'one hundred thirty' when 130 given", () => {
 786 |   const readable = toReadable(130);
 787 | 
 788 |   assert.equal(readable, 'one hundred thirty');
 789 | });
 790 | 
 791 | it.optional("Should return 'one hundred thirty one' when 131 given", () => {
 792 |   const readable = toReadable(131);
 793 | 
 794 |   assert.equal(readable, 'one hundred thirty one');
 795 | });
 796 | 
 797 | it.optional("Should return 'one hundred thirty two' when 132 given", () => {
 798 |   const readable = toReadable(132);
 799 | 
 800 |   assert.equal(readable, 'one hundred thirty two');
 801 | });
 802 | 
 803 | it.optional("Should return 'one hundred thirty three' when 133 given", () => {
 804 |   const readable = toReadable(133);
 805 | 
 806 |   assert.equal(readable, 'one hundred thirty three');
 807 | });
 808 | 
 809 | it.optional("Should return 'one hundred thirty four' when 134 given", () => {
 810 |   const readable = toReadable(134);
 811 | 
 812 |   assert.equal(readable, 'one hundred thirty four');
 813 | });
 814 | 
 815 | it.optional("Should return 'one hundred thirty five' when 135 given", () => {
 816 |   const readable = toReadable(135);
 817 | 
 818 |   assert.equal(readable, 'one hundred thirty five');
 819 | });
 820 | 
 821 | it.optional("Should return 'one hundred thirty six' when 136 given", () => {
 822 |   const readable = toReadable(136);
 823 | 
 824 |   assert.equal(readable, 'one hundred thirty six');
 825 | });
 826 | 
 827 | it.optional("Should return 'one hundred thirty seven' when 137 given", () => {
 828 |   const readable = toReadable(137);
 829 | 
 830 |   assert.equal(readable, 'one hundred thirty seven');
 831 | });
 832 | 
 833 | it.optional("Should return 'one hundred thirty eight' when 138 given", () => {
 834 |   const readable = toReadable(138);
 835 | 
 836 |   assert.equal(readable, 'one hundred thirty eight');
 837 | });
 838 | 
 839 | it.optional("Should return 'one hundred thirty nine' when 139 given", () => {
 840 |   const readable = toReadable(139);
 841 | 
 842 |   assert.equal(readable, 'one hundred thirty nine');
 843 | });
 844 | 
 845 | it.optional("Should return 'one hundred forty' when 140 given", () => {
 846 |   const readable = toReadable(140);
 847 | 
 848 |   assert.equal(readable, 'one hundred forty');
 849 | });
 850 | 
 851 | it.optional("Should return 'one hundred forty one' when 141 given", () => {
 852 |   const readable = toReadable(141);
 853 | 
 854 |   assert.equal(readable, 'one hundred forty one');
 855 | });
 856 | 
 857 | it.optional("Should return 'one hundred forty two' when 142 given", () => {
 858 |   const readable = toReadable(142);
 859 | 
 860 |   assert.equal(readable, 'one hundred forty two');
 861 | });
 862 | 
 863 | it.optional("Should return 'one hundred forty three' when 143 given", () => {
 864 |   const readable = toReadable(143);
 865 | 
 866 |   assert.equal(readable, 'one hundred forty three');
 867 | });
 868 | 
 869 | it.optional("Should return 'one hundred forty four' when 144 given", () => {
 870 |   const readable = toReadable(144);
 871 | 
 872 |   assert.equal(readable, 'one hundred forty four');
 873 | });
 874 | 
 875 | it.optional("Should return 'one hundred forty five' when 145 given", () => {
 876 |   const readable = toReadable(145);
 877 | 
 878 |   assert.equal(readable, 'one hundred forty five');
 879 | });
 880 | 
 881 | it.optional("Should return 'one hundred forty six' when 146 given", () => {
 882 |   const readable = toReadable(146);
 883 | 
 884 |   assert.equal(readable, 'one hundred forty six');
 885 | });
 886 | 
 887 | it.optional("Should return 'one hundred forty seven' when 147 given", () => {
 888 |   const readable = toReadable(147);
 889 | 
 890 |   assert.equal(readable, 'one hundred forty seven');
 891 | });
 892 | 
 893 | it.optional("Should return 'one hundred forty eight' when 148 given", () => {
 894 |   const readable = toReadable(148);
 895 | 
 896 |   assert.equal(readable, 'one hundred forty eight');
 897 | });
 898 | 
 899 | it.optional("Should return 'one hundred forty nine' when 149 given", () => {
 900 |   const readable = toReadable(149);
 901 | 
 902 |   assert.equal(readable, 'one hundred forty nine');
 903 | });
 904 | 
 905 | it.optional("Should return 'one hundred fifty' when 150 given", () => {
 906 |   const readable = toReadable(150);
 907 | 
 908 |   assert.equal(readable, 'one hundred fifty');
 909 | });
 910 | 
 911 | it.optional("Should return 'one hundred fifty one' when 151 given", () => {
 912 |   const readable = toReadable(151);
 913 | 
 914 |   assert.equal(readable, 'one hundred fifty one');
 915 | });
 916 | 
 917 | it.optional("Should return 'one hundred fifty two' when 152 given", () => {
 918 |   const readable = toReadable(152);
 919 | 
 920 |   assert.equal(readable, 'one hundred fifty two');
 921 | });
 922 | 
 923 | it.optional("Should return 'one hundred fifty three' when 153 given", () => {
 924 |   const readable = toReadable(153);
 925 | 
 926 |   assert.equal(readable, 'one hundred fifty three');
 927 | });
 928 | 
 929 | it.optional("Should return 'one hundred fifty four' when 154 given", () => {
 930 |   const readable = toReadable(154);
 931 | 
 932 |   assert.equal(readable, 'one hundred fifty four');
 933 | });
 934 | 
 935 | it.optional("Should return 'one hundred fifty five' when 155 given", () => {
 936 |   const readable = toReadable(155);
 937 | 
 938 |   assert.equal(readable, 'one hundred fifty five');
 939 | });
 940 | 
 941 | it.optional("Should return 'one hundred fifty six' when 156 given", () => {
 942 |   const readable = toReadable(156);
 943 | 
 944 |   assert.equal(readable, 'one hundred fifty six');
 945 | });
 946 | 
 947 | it.optional("Should return 'one hundred fifty seven' when 157 given", () => {
 948 |   const readable = toReadable(157);
 949 | 
 950 |   assert.equal(readable, 'one hundred fifty seven');
 951 | });
 952 | 
 953 | it.optional("Should return 'one hundred fifty eight' when 158 given", () => {
 954 |   const readable = toReadable(158);
 955 | 
 956 |   assert.equal(readable, 'one hundred fifty eight');
 957 | });
 958 | 
 959 | it.optional("Should return 'one hundred fifty nine' when 159 given", () => {
 960 |   const readable = toReadable(159);
 961 | 
 962 |   assert.equal(readable, 'one hundred fifty nine');
 963 | });
 964 | 
 965 | it.optional("Should return 'one hundred sixty' when 160 given", () => {
 966 |   const readable = toReadable(160);
 967 | 
 968 |   assert.equal(readable, 'one hundred sixty');
 969 | });
 970 | 
 971 | it.optional("Should return 'one hundred sixty one' when 161 given", () => {
 972 |   const readable = toReadable(161);
 973 | 
 974 |   assert.equal(readable, 'one hundred sixty one');
 975 | });
 976 | 
 977 | it.optional("Should return 'one hundred sixty two' when 162 given", () => {
 978 |   const readable = toReadable(162);
 979 | 
 980 |   assert.equal(readable, 'one hundred sixty two');
 981 | });
 982 | 
 983 | it.optional("Should return 'one hundred sixty three' when 163 given", () => {
 984 |   const readable = toReadable(163);
 985 | 
 986 |   assert.equal(readable, 'one hundred sixty three');
 987 | });
 988 | 
 989 | it.optional("Should return 'one hundred sixty four' when 164 given", () => {
 990 |   const readable = toReadable(164);
 991 | 
 992 |   assert.equal(readable, 'one hundred sixty four');
 993 | });
 994 | 
 995 | it.optional("Should return 'one hundred sixty five' when 165 given", () => {
 996 |   const readable = toReadable(165);
 997 | 
 998 |   assert.equal(readable, 'one hundred sixty five');
 999 | });
1000 | 
1001 | it.optional("Should return 'one hundred sixty six' when 166 given", () => {
1002 |   const readable = toReadable(166);
1003 | 
1004 |   assert.equal(readable, 'one hundred sixty six');
1005 | });
1006 | 
1007 | it.optional("Should return 'one hundred sixty seven' when 167 given", () => {
1008 |   const readable = toReadable(167);
1009 | 
1010 |   assert.equal(readable, 'one hundred sixty seven');
1011 | });
1012 | 
1013 | it.optional("Should return 'one hundred sixty eight' when 168 given", () => {
1014 |   const readable = toReadable(168);
1015 | 
1016 |   assert.equal(readable, 'one hundred sixty eight');
1017 | });
1018 | 
1019 | it.optional("Should return 'one hundred sixty nine' when 169 given", () => {
1020 |   const readable = toReadable(169);
1021 | 
1022 |   assert.equal(readable, 'one hundred sixty nine');
1023 | });
1024 | 
1025 | it.optional("Should return 'one hundred seventy' when 170 given", () => {
1026 |   const readable = toReadable(170);
1027 | 
1028 |   assert.equal(readable, 'one hundred seventy');
1029 | });
1030 | 
1031 | it.optional("Should return 'one hundred seventy one' when 171 given", () => {
1032 |   const readable = toReadable(171);
1033 | 
1034 |   assert.equal(readable, 'one hundred seventy one');
1035 | });
1036 | 
1037 | it.optional("Should return 'one hundred seventy two' when 172 given", () => {
1038 |   const readable = toReadable(172);
1039 | 
1040 |   assert.equal(readable, 'one hundred seventy two');
1041 | });
1042 | 
1043 | it.optional("Should return 'one hundred seventy three' when 173 given", () => {
1044 |   const readable = toReadable(173);
1045 | 
1046 |   assert.equal(readable, 'one hundred seventy three');
1047 | });
1048 | 
1049 | it.optional("Should return 'one hundred seventy four' when 174 given", () => {
1050 |   const readable = toReadable(174);
1051 | 
1052 |   assert.equal(readable, 'one hundred seventy four');
1053 | });
1054 | 
1055 | it.optional("Should return 'one hundred seventy five' when 175 given", () => {
1056 |   const readable = toReadable(175);
1057 | 
1058 |   assert.equal(readable, 'one hundred seventy five');
1059 | });
1060 | 
1061 | it.optional("Should return 'one hundred seventy six' when 176 given", () => {
1062 |   const readable = toReadable(176);
1063 | 
1064 |   assert.equal(readable, 'one hundred seventy six');
1065 | });
1066 | 
1067 | it.optional("Should return 'one hundred seventy seven' when 177 given", () => {
1068 |   const readable = toReadable(177);
1069 | 
1070 |   assert.equal(readable, 'one hundred seventy seven');
1071 | });
1072 | 
1073 | it.optional("Should return 'one hundred seventy eight' when 178 given", () => {
1074 |   const readable = toReadable(178);
1075 | 
1076 |   assert.equal(readable, 'one hundred seventy eight');
1077 | });
1078 | 
1079 | it.optional("Should return 'one hundred seventy nine' when 179 given", () => {
1080 |   const readable = toReadable(179);
1081 | 
1082 |   assert.equal(readable, 'one hundred seventy nine');
1083 | });
1084 | 
1085 | it.optional("Should return 'one hundred eighty' when 180 given", () => {
1086 |   const readable = toReadable(180);
1087 | 
1088 |   assert.equal(readable, 'one hundred eighty');
1089 | });
1090 | 
1091 | it.optional("Should return 'one hundred eighty one' when 181 given", () => {
1092 |   const readable = toReadable(181);
1093 | 
1094 |   assert.equal(readable, 'one hundred eighty one');
1095 | });
1096 | 
1097 | it.optional("Should return 'one hundred eighty two' when 182 given", () => {
1098 |   const readable = toReadable(182);
1099 | 
1100 |   assert.equal(readable, 'one hundred eighty two');
1101 | });
1102 | 
1103 | it.optional("Should return 'one hundred eighty three' when 183 given", () => {
1104 |   const readable = toReadable(183);
1105 | 
1106 |   assert.equal(readable, 'one hundred eighty three');
1107 | });
1108 | 
1109 | it.optional("Should return 'one hundred eighty four' when 184 given", () => {
1110 |   const readable = toReadable(184);
1111 | 
1112 |   assert.equal(readable, 'one hundred eighty four');
1113 | });
1114 | 
1115 | it.optional("Should return 'one hundred eighty five' when 185 given", () => {
1116 |   const readable = toReadable(185);
1117 | 
1118 |   assert.equal(readable, 'one hundred eighty five');
1119 | });
1120 | 
1121 | it.optional("Should return 'one hundred eighty six' when 186 given", () => {
1122 |   const readable = toReadable(186);
1123 | 
1124 |   assert.equal(readable, 'one hundred eighty six');
1125 | });
1126 | 
1127 | it.optional("Should return 'one hundred eighty seven' when 187 given", () => {
1128 |   const readable = toReadable(187);
1129 | 
1130 |   assert.equal(readable, 'one hundred eighty seven');
1131 | });
1132 | 
1133 | it.optional("Should return 'one hundred eighty eight' when 188 given", () => {
1134 |   const readable = toReadable(188);
1135 | 
1136 |   assert.equal(readable, 'one hundred eighty eight');
1137 | });
1138 | 
1139 | it.optional("Should return 'one hundred eighty nine' when 189 given", () => {
1140 |   const readable = toReadable(189);
1141 | 
1142 |   assert.equal(readable, 'one hundred eighty nine');
1143 | });
1144 | 
1145 | it.optional("Should return 'one hundred ninety' when 190 given", () => {
1146 |   const readable = toReadable(190);
1147 | 
1148 |   assert.equal(readable, 'one hundred ninety');
1149 | });
1150 | 
1151 | it.optional("Should return 'one hundred ninety one' when 191 given", () => {
1152 |   const readable = toReadable(191);
1153 | 
1154 |   assert.equal(readable, 'one hundred ninety one');
1155 | });
1156 | 
1157 | it.optional("Should return 'one hundred ninety two' when 192 given", () => {
1158 |   const readable = toReadable(192);
1159 | 
1160 |   assert.equal(readable, 'one hundred ninety two');
1161 | });
1162 | 
1163 | it.optional("Should return 'one hundred ninety three' when 193 given", () => {
1164 |   const readable = toReadable(193);
1165 | 
1166 |   assert.equal(readable, 'one hundred ninety three');
1167 | });
1168 | 
1169 | it.optional("Should return 'one hundred ninety four' when 194 given", () => {
1170 |   const readable = toReadable(194);
1171 | 
1172 |   assert.equal(readable, 'one hundred ninety four');
1173 | });
1174 | 
1175 | it.optional("Should return 'one hundred ninety five' when 195 given", () => {
1176 |   const readable = toReadable(195);
1177 | 
1178 |   assert.equal(readable, 'one hundred ninety five');
1179 | });
1180 | 
1181 | it.optional("Should return 'one hundred ninety six' when 196 given", () => {
1182 |   const readable = toReadable(196);
1183 | 
1184 |   assert.equal(readable, 'one hundred ninety six');
1185 | });
1186 | 
1187 | it.optional("Should return 'one hundred ninety seven' when 197 given", () => {
1188 |   const readable = toReadable(197);
1189 | 
1190 |   assert.equal(readable, 'one hundred ninety seven');
1191 | });
1192 | 
1193 | it.optional("Should return 'one hundred ninety eight' when 198 given", () => {
1194 |   const readable = toReadable(198);
1195 | 
1196 |   assert.equal(readable, 'one hundred ninety eight');
1197 | });
1198 | 
1199 | it.optional("Should return 'one hundred ninety nine' when 199 given", () => {
1200 |   const readable = toReadable(199);
1201 | 
1202 |   assert.equal(readable, 'one hundred ninety nine');
1203 | });
1204 | 
1205 | it.optional("Should return 'two hundred' when 200 given", () => {
1206 |   const readable = toReadable(200);
1207 | 
1208 |   assert.equal(readable, 'two hundred');
1209 | });
1210 | 
1211 | it.optional("Should return 'two hundred one' when 201 given", () => {
1212 |   const readable = toReadable(201);
1213 | 
1214 |   assert.equal(readable, 'two hundred one');
1215 | });
1216 | 
1217 | it.optional("Should return 'two hundred two' when 202 given", () => {
1218 |   const readable = toReadable(202);
1219 | 
1220 |   assert.equal(readable, 'two hundred two');
1221 | });
1222 | 
1223 | it.optional("Should return 'two hundred three' when 203 given", () => {
1224 |   const readable = toReadable(203);
1225 | 
1226 |   assert.equal(readable, 'two hundred three');
1227 | });
1228 | 
1229 | it.optional("Should return 'two hundred four' when 204 given", () => {
1230 |   const readable = toReadable(204);
1231 | 
1232 |   assert.equal(readable, 'two hundred four');
1233 | });
1234 | 
1235 | it.optional("Should return 'two hundred five' when 205 given", () => {
1236 |   const readable = toReadable(205);
1237 | 
1238 |   assert.equal(readable, 'two hundred five');
1239 | });
1240 | 
1241 | it.optional("Should return 'two hundred six' when 206 given", () => {
1242 |   const readable = toReadable(206);
1243 | 
1244 |   assert.equal(readable, 'two hundred six');
1245 | });
1246 | 
1247 | it.optional("Should return 'two hundred seven' when 207 given", () => {
1248 |   const readable = toReadable(207);
1249 | 
1250 |   assert.equal(readable, 'two hundred seven');
1251 | });
1252 | 
1253 | it.optional("Should return 'two hundred eight' when 208 given", () => {
1254 |   const readable = toReadable(208);
1255 | 
1256 |   assert.equal(readable, 'two hundred eight');
1257 | });
1258 | 
1259 | it.optional("Should return 'two hundred nine' when 209 given", () => {
1260 |   const readable = toReadable(209);
1261 | 
1262 |   assert.equal(readable, 'two hundred nine');
1263 | });
1264 | 
1265 | it.optional("Should return 'two hundred ten' when 210 given", () => {
1266 |   const readable = toReadable(210);
1267 | 
1268 |   assert.equal(readable, 'two hundred ten');
1269 | });
1270 | 
1271 | it.optional("Should return 'two hundred eleven' when 211 given", () => {
1272 |   const readable = toReadable(211);
1273 | 
1274 |   assert.equal(readable, 'two hundred eleven');
1275 | });
1276 | 
1277 | it.optional("Should return 'two hundred twelve' when 212 given", () => {
1278 |   const readable = toReadable(212);
1279 | 
1280 |   assert.equal(readable, 'two hundred twelve');
1281 | });
1282 | 
1283 | it.optional("Should return 'two hundred thirteen' when 213 given", () => {
1284 |   const readable = toReadable(213);
1285 | 
1286 |   assert.equal(readable, 'two hundred thirteen');
1287 | });
1288 | 
1289 | it.optional("Should return 'two hundred fourteen' when 214 given", () => {
1290 |   const readable = toReadable(214);
1291 | 
1292 |   assert.equal(readable, 'two hundred fourteen');
1293 | });
1294 | 
1295 | it.optional("Should return 'two hundred fifteen' when 215 given", () => {
1296 |   const readable = toReadable(215);
1297 | 
1298 |   assert.equal(readable, 'two hundred fifteen');
1299 | });
1300 | 
1301 | it.optional("Should return 'two hundred sixteen' when 216 given", () => {
1302 |   const readable = toReadable(216);
1303 | 
1304 |   assert.equal(readable, 'two hundred sixteen');
1305 | });
1306 | 
1307 | it.optional("Should return 'two hundred seventeen' when 217 given", () => {
1308 |   const readable = toReadable(217);
1309 | 
1310 |   assert.equal(readable, 'two hundred seventeen');
1311 | });
1312 | 
1313 | it.optional("Should return 'two hundred eighteen' when 218 given", () => {
1314 |   const readable = toReadable(218);
1315 | 
1316 |   assert.equal(readable, 'two hundred eighteen');
1317 | });
1318 | 
1319 | it.optional("Should return 'two hundred nineteen' when 219 given", () => {
1320 |   const readable = toReadable(219);
1321 | 
1322 |   assert.equal(readable, 'two hundred nineteen');
1323 | });
1324 | 
1325 | it.optional("Should return 'two hundred twenty' when 220 given", () => {
1326 |   const readable = toReadable(220);
1327 | 
1328 |   assert.equal(readable, 'two hundred twenty');
1329 | });
1330 | 
1331 | it.optional("Should return 'two hundred twenty one' when 221 given", () => {
1332 |   const readable = toReadable(221);
1333 | 
1334 |   assert.equal(readable, 'two hundred twenty one');
1335 | });
1336 | 
1337 | it.optional("Should return 'two hundred twenty two' when 222 given", () => {
1338 |   const readable = toReadable(222);
1339 | 
1340 |   assert.equal(readable, 'two hundred twenty two');
1341 | });
1342 | 
1343 | it.optional("Should return 'two hundred twenty three' when 223 given", () => {
1344 |   const readable = toReadable(223);
1345 | 
1346 |   assert.equal(readable, 'two hundred twenty three');
1347 | });
1348 | 
1349 | it.optional("Should return 'two hundred twenty four' when 224 given", () => {
1350 |   const readable = toReadable(224);
1351 | 
1352 |   assert.equal(readable, 'two hundred twenty four');
1353 | });
1354 | 
1355 | it.optional("Should return 'two hundred twenty five' when 225 given", () => {
1356 |   const readable = toReadable(225);
1357 | 
1358 |   assert.equal(readable, 'two hundred twenty five');
1359 | });
1360 | 
1361 | it.optional("Should return 'two hundred twenty six' when 226 given", () => {
1362 |   const readable = toReadable(226);
1363 | 
1364 |   assert.equal(readable, 'two hundred twenty six');
1365 | });
1366 | 
1367 | it.optional("Should return 'two hundred twenty seven' when 227 given", () => {
1368 |   const readable = toReadable(227);
1369 | 
1370 |   assert.equal(readable, 'two hundred twenty seven');
1371 | });
1372 | 
1373 | it.optional("Should return 'two hundred twenty eight' when 228 given", () => {
1374 |   const readable = toReadable(228);
1375 | 
1376 |   assert.equal(readable, 'two hundred twenty eight');
1377 | });
1378 | 
1379 | it.optional("Should return 'two hundred twenty nine' when 229 given", () => {
1380 |   const readable = toReadable(229);
1381 | 
1382 |   assert.equal(readable, 'two hundred twenty nine');
1383 | });
1384 | 
1385 | it.optional("Should return 'two hundred thirty' when 230 given", () => {
1386 |   const readable = toReadable(230);
1387 | 
1388 |   assert.equal(readable, 'two hundred thirty');
1389 | });
1390 | 
1391 | it.optional("Should return 'two hundred thirty one' when 231 given", () => {
1392 |   const readable = toReadable(231);
1393 | 
1394 |   assert.equal(readable, 'two hundred thirty one');
1395 | });
1396 | 
1397 | it.optional("Should return 'two hundred thirty two' when 232 given", () => {
1398 |   const readable = toReadable(232);
1399 | 
1400 |   assert.equal(readable, 'two hundred thirty two');
1401 | });
1402 | 
1403 | it.optional("Should return 'two hundred thirty three' when 233 given", () => {
1404 |   const readable = toReadable(233);
1405 | 
1406 |   assert.equal(readable, 'two hundred thirty three');
1407 | });
1408 | 
1409 | it.optional("Should return 'two hundred thirty four' when 234 given", () => {
1410 |   const readable = toReadable(234);
1411 | 
1412 |   assert.equal(readable, 'two hundred thirty four');
1413 | });
1414 | 
1415 | it.optional("Should return 'two hundred thirty five' when 235 given", () => {
1416 |   const readable = toReadable(235);
1417 | 
1418 |   assert.equal(readable, 'two hundred thirty five');
1419 | });
1420 | 
1421 | it.optional("Should return 'two hundred thirty six' when 236 given", () => {
1422 |   const readable = toReadable(236);
1423 | 
1424 |   assert.equal(readable, 'two hundred thirty six');
1425 | });
1426 | 
1427 | it.optional("Should return 'two hundred thirty seven' when 237 given", () => {
1428 |   const readable = toReadable(237);
1429 | 
1430 |   assert.equal(readable, 'two hundred thirty seven');
1431 | });
1432 | 
1433 | it.optional("Should return 'two hundred thirty eight' when 238 given", () => {
1434 |   const readable = toReadable(238);
1435 | 
1436 |   assert.equal(readable, 'two hundred thirty eight');
1437 | });
1438 | 
1439 | it.optional("Should return 'two hundred thirty nine' when 239 given", () => {
1440 |   const readable = toReadable(239);
1441 | 
1442 |   assert.equal(readable, 'two hundred thirty nine');
1443 | });
1444 | 
1445 | it.optional("Should return 'two hundred forty' when 240 given", () => {
1446 |   const readable = toReadable(240);
1447 | 
1448 |   assert.equal(readable, 'two hundred forty');
1449 | });
1450 | 
1451 | it.optional("Should return 'two hundred forty one' when 241 given", () => {
1452 |   const readable = toReadable(241);
1453 | 
1454 |   assert.equal(readable, 'two hundred forty one');
1455 | });
1456 | 
1457 | it.optional("Should return 'two hundred forty two' when 242 given", () => {
1458 |   const readable = toReadable(242);
1459 | 
1460 |   assert.equal(readable, 'two hundred forty two');
1461 | });
1462 | 
1463 | it.optional("Should return 'two hundred forty three' when 243 given", () => {
1464 |   const readable = toReadable(243);
1465 | 
1466 |   assert.equal(readable, 'two hundred forty three');
1467 | });
1468 | 
1469 | it.optional("Should return 'two hundred forty four' when 244 given", () => {
1470 |   const readable = toReadable(244);
1471 | 
1472 |   assert.equal(readable, 'two hundred forty four');
1473 | });
1474 | 
1475 | it.optional("Should return 'two hundred forty five' when 245 given", () => {
1476 |   const readable = toReadable(245);
1477 | 
1478 |   assert.equal(readable, 'two hundred forty five');
1479 | });
1480 | 
1481 | it.optional("Should return 'two hundred forty six' when 246 given", () => {
1482 |   const readable = toReadable(246);
1483 | 
1484 |   assert.equal(readable, 'two hundred forty six');
1485 | });
1486 | 
1487 | it.optional("Should return 'two hundred forty seven' when 247 given", () => {
1488 |   const readable = toReadable(247);
1489 | 
1490 |   assert.equal(readable, 'two hundred forty seven');
1491 | });
1492 | 
1493 | it.optional("Should return 'two hundred forty eight' when 248 given", () => {
1494 |   const readable = toReadable(248);
1495 | 
1496 |   assert.equal(readable, 'two hundred forty eight');
1497 | });
1498 | 
1499 | it.optional("Should return 'two hundred forty nine' when 249 given", () => {
1500 |   const readable = toReadable(249);
1501 | 
1502 |   assert.equal(readable, 'two hundred forty nine');
1503 | });
1504 | 
1505 | it.optional("Should return 'two hundred fifty' when 250 given", () => {
1506 |   const readable = toReadable(250);
1507 | 
1508 |   assert.equal(readable, 'two hundred fifty');
1509 | });
1510 | 
1511 | it.optional("Should return 'two hundred fifty one' when 251 given", () => {
1512 |   const readable = toReadable(251);
1513 | 
1514 |   assert.equal(readable, 'two hundred fifty one');
1515 | });
1516 | 
1517 | it.optional("Should return 'two hundred fifty two' when 252 given", () => {
1518 |   const readable = toReadable(252);
1519 | 
1520 |   assert.equal(readable, 'two hundred fifty two');
1521 | });
1522 | 
1523 | it.optional("Should return 'two hundred fifty three' when 253 given", () => {
1524 |   const readable = toReadable(253);
1525 | 
1526 |   assert.equal(readable, 'two hundred fifty three');
1527 | });
1528 | 
1529 | it.optional("Should return 'two hundred fifty four' when 254 given", () => {
1530 |   const readable = toReadable(254);
1531 | 
1532 |   assert.equal(readable, 'two hundred fifty four');
1533 | });
1534 | 
1535 | it.optional("Should return 'two hundred fifty five' when 255 given", () => {
1536 |   const readable = toReadable(255);
1537 | 
1538 |   assert.equal(readable, 'two hundred fifty five');
1539 | });
1540 | 
1541 | it.optional("Should return 'two hundred fifty six' when 256 given", () => {
1542 |   const readable = toReadable(256);
1543 | 
1544 |   assert.equal(readable, 'two hundred fifty six');
1545 | });
1546 | 
1547 | it.optional("Should return 'two hundred fifty seven' when 257 given", () => {
1548 |   const readable = toReadable(257);
1549 | 
1550 |   assert.equal(readable, 'two hundred fifty seven');
1551 | });
1552 | 
1553 | it.optional("Should return 'two hundred fifty eight' when 258 given", () => {
1554 |   const readable = toReadable(258);
1555 | 
1556 |   assert.equal(readable, 'two hundred fifty eight');
1557 | });
1558 | 
1559 | it.optional("Should return 'two hundred fifty nine' when 259 given", () => {
1560 |   const readable = toReadable(259);
1561 | 
1562 |   assert.equal(readable, 'two hundred fifty nine');
1563 | });
1564 | 
1565 | it.optional("Should return 'two hundred sixty' when 260 given", () => {
1566 |   const readable = toReadable(260);
1567 | 
1568 |   assert.equal(readable, 'two hundred sixty');
1569 | });
1570 | 
1571 | it.optional("Should return 'two hundred sixty one' when 261 given", () => {
1572 |   const readable = toReadable(261);
1573 | 
1574 |   assert.equal(readable, 'two hundred sixty one');
1575 | });
1576 | 
1577 | it.optional("Should return 'two hundred sixty two' when 262 given", () => {
1578 |   const readable = toReadable(262);
1579 | 
1580 |   assert.equal(readable, 'two hundred sixty two');
1581 | });
1582 | 
1583 | it.optional("Should return 'two hundred sixty three' when 263 given", () => {
1584 |   const readable = toReadable(263);
1585 | 
1586 |   assert.equal(readable, 'two hundred sixty three');
1587 | });
1588 | 
1589 | it.optional("Should return 'two hundred sixty four' when 264 given", () => {
1590 |   const readable = toReadable(264);
1591 | 
1592 |   assert.equal(readable, 'two hundred sixty four');
1593 | });
1594 | 
1595 | it.optional("Should return 'two hundred sixty five' when 265 given", () => {
1596 |   const readable = toReadable(265);
1597 | 
1598 |   assert.equal(readable, 'two hundred sixty five');
1599 | });
1600 | 
1601 | it.optional("Should return 'two hundred sixty six' when 266 given", () => {
1602 |   const readable = toReadable(266);
1603 | 
1604 |   assert.equal(readable, 'two hundred sixty six');
1605 | });
1606 | 
1607 | it.optional("Should return 'two hundred sixty seven' when 267 given", () => {
1608 |   const readable = toReadable(267);
1609 | 
1610 |   assert.equal(readable, 'two hundred sixty seven');
1611 | });
1612 | 
1613 | it.optional("Should return 'two hundred sixty eight' when 268 given", () => {
1614 |   const readable = toReadable(268);
1615 | 
1616 |   assert.equal(readable, 'two hundred sixty eight');
1617 | });
1618 | 
1619 | it.optional("Should return 'two hundred sixty nine' when 269 given", () => {
1620 |   const readable = toReadable(269);
1621 | 
1622 |   assert.equal(readable, 'two hundred sixty nine');
1623 | });
1624 | 
1625 | it.optional("Should return 'two hundred seventy' when 270 given", () => {
1626 |   const readable = toReadable(270);
1627 | 
1628 |   assert.equal(readable, 'two hundred seventy');
1629 | });
1630 | 
1631 | it.optional("Should return 'two hundred seventy one' when 271 given", () => {
1632 |   const readable = toReadable(271);
1633 | 
1634 |   assert.equal(readable, 'two hundred seventy one');
1635 | });
1636 | 
1637 | it.optional("Should return 'two hundred seventy two' when 272 given", () => {
1638 |   const readable = toReadable(272);
1639 | 
1640 |   assert.equal(readable, 'two hundred seventy two');
1641 | });
1642 | 
1643 | it.optional("Should return 'two hundred seventy three' when 273 given", () => {
1644 |   const readable = toReadable(273);
1645 | 
1646 |   assert.equal(readable, 'two hundred seventy three');
1647 | });
1648 | 
1649 | it.optional("Should return 'two hundred seventy four' when 274 given", () => {
1650 |   const readable = toReadable(274);
1651 | 
1652 |   assert.equal(readable, 'two hundred seventy four');
1653 | });
1654 | 
1655 | it.optional("Should return 'two hundred seventy five' when 275 given", () => {
1656 |   const readable = toReadable(275);
1657 | 
1658 |   assert.equal(readable, 'two hundred seventy five');
1659 | });
1660 | 
1661 | it.optional("Should return 'two hundred seventy six' when 276 given", () => {
1662 |   const readable = toReadable(276);
1663 | 
1664 |   assert.equal(readable, 'two hundred seventy six');
1665 | });
1666 | 
1667 | it.optional("Should return 'two hundred seventy seven' when 277 given", () => {
1668 |   const readable = toReadable(277);
1669 | 
1670 |   assert.equal(readable, 'two hundred seventy seven');
1671 | });
1672 | 
1673 | it.optional("Should return 'two hundred seventy eight' when 278 given", () => {
1674 |   const readable = toReadable(278);
1675 | 
1676 |   assert.equal(readable, 'two hundred seventy eight');
1677 | });
1678 | 
1679 | it.optional("Should return 'two hundred seventy nine' when 279 given", () => {
1680 |   const readable = toReadable(279);
1681 | 
1682 |   assert.equal(readable, 'two hundred seventy nine');
1683 | });
1684 | 
1685 | it.optional("Should return 'two hundred eighty' when 280 given", () => {
1686 |   const readable = toReadable(280);
1687 | 
1688 |   assert.equal(readable, 'two hundred eighty');
1689 | });
1690 | 
1691 | it.optional("Should return 'two hundred eighty one' when 281 given", () => {
1692 |   const readable = toReadable(281);
1693 | 
1694 |   assert.equal(readable, 'two hundred eighty one');
1695 | });
1696 | 
1697 | it.optional("Should return 'two hundred eighty two' when 282 given", () => {
1698 |   const readable = toReadable(282);
1699 | 
1700 |   assert.equal(readable, 'two hundred eighty two');
1701 | });
1702 | 
1703 | it.optional("Should return 'two hundred eighty three' when 283 given", () => {
1704 |   const readable = toReadable(283);
1705 | 
1706 |   assert.equal(readable, 'two hundred eighty three');
1707 | });
1708 | 
1709 | it.optional("Should return 'two hundred eighty four' when 284 given", () => {
1710 |   const readable = toReadable(284);
1711 | 
1712 |   assert.equal(readable, 'two hundred eighty four');
1713 | });
1714 | 
1715 | it.optional("Should return 'two hundred eighty five' when 285 given", () => {
1716 |   const readable = toReadable(285);
1717 | 
1718 |   assert.equal(readable, 'two hundred eighty five');
1719 | });
1720 | 
1721 | it.optional("Should return 'two hundred eighty six' when 286 given", () => {
1722 |   const readable = toReadable(286);
1723 | 
1724 |   assert.equal(readable, 'two hundred eighty six');
1725 | });
1726 | 
1727 | it.optional("Should return 'two hundred eighty seven' when 287 given", () => {
1728 |   const readable = toReadable(287);
1729 | 
1730 |   assert.equal(readable, 'two hundred eighty seven');
1731 | });
1732 | 
1733 | it.optional("Should return 'two hundred eighty eight' when 288 given", () => {
1734 |   const readable = toReadable(288);
1735 | 
1736 |   assert.equal(readable, 'two hundred eighty eight');
1737 | });
1738 | 
1739 | it.optional("Should return 'two hundred eighty nine' when 289 given", () => {
1740 |   const readable = toReadable(289);
1741 | 
1742 |   assert.equal(readable, 'two hundred eighty nine');
1743 | });
1744 | 
1745 | it.optional("Should return 'two hundred ninety' when 290 given", () => {
1746 |   const readable = toReadable(290);
1747 | 
1748 |   assert.equal(readable, 'two hundred ninety');
1749 | });
1750 | 
1751 | it.optional("Should return 'two hundred ninety one' when 291 given", () => {
1752 |   const readable = toReadable(291);
1753 | 
1754 |   assert.equal(readable, 'two hundred ninety one');
1755 | });
1756 | 
1757 | it.optional("Should return 'two hundred ninety two' when 292 given", () => {
1758 |   const readable = toReadable(292);
1759 | 
1760 |   assert.equal(readable, 'two hundred ninety two');
1761 | });
1762 | 
1763 | it.optional("Should return 'two hundred ninety three' when 293 given", () => {
1764 |   const readable = toReadable(293);
1765 | 
1766 |   assert.equal(readable, 'two hundred ninety three');
1767 | });
1768 | 
1769 | it.optional("Should return 'two hundred ninety four' when 294 given", () => {
1770 |   const readable = toReadable(294);
1771 | 
1772 |   assert.equal(readable, 'two hundred ninety four');
1773 | });
1774 | 
1775 | it.optional("Should return 'two hundred ninety five' when 295 given", () => {
1776 |   const readable = toReadable(295);
1777 | 
1778 |   assert.equal(readable, 'two hundred ninety five');
1779 | });
1780 | 
1781 | it.optional("Should return 'two hundred ninety six' when 296 given", () => {
1782 |   const readable = toReadable(296);
1783 | 
1784 |   assert.equal(readable, 'two hundred ninety six');
1785 | });
1786 | 
1787 | it.optional("Should return 'two hundred ninety seven' when 297 given", () => {
1788 |   const readable = toReadable(297);
1789 | 
1790 |   assert.equal(readable, 'two hundred ninety seven');
1791 | });
1792 | 
1793 | it.optional("Should return 'two hundred ninety eight' when 298 given", () => {
1794 |   const readable = toReadable(298);
1795 | 
1796 |   assert.equal(readable, 'two hundred ninety eight');
1797 | });
1798 | 
1799 | it.optional("Should return 'two hundred ninety nine' when 299 given", () => {
1800 |   const readable = toReadable(299);
1801 | 
1802 |   assert.equal(readable, 'two hundred ninety nine');
1803 | });
1804 | 
1805 | it.optional("Should return 'three hundred' when 300 given", () => {
1806 |   const readable = toReadable(300);
1807 | 
1808 |   assert.equal(readable, 'three hundred');
1809 | });
1810 | 
1811 | it.optional("Should return 'three hundred one' when 301 given", () => {
1812 |   const readable = toReadable(301);
1813 | 
1814 |   assert.equal(readable, 'three hundred one');
1815 | });
1816 | 
1817 | it.optional("Should return 'three hundred two' when 302 given", () => {
1818 |   const readable = toReadable(302);
1819 | 
1820 |   assert.equal(readable, 'three hundred two');
1821 | });
1822 | 
1823 | it.optional("Should return 'three hundred three' when 303 given", () => {
1824 |   const readable = toReadable(303);
1825 | 
1826 |   assert.equal(readable, 'three hundred three');
1827 | });
1828 | 
1829 | it.optional("Should return 'three hundred four' when 304 given", () => {
1830 |   const readable = toReadable(304);
1831 | 
1832 |   assert.equal(readable, 'three hundred four');
1833 | });
1834 | 
1835 | it.optional("Should return 'three hundred five' when 305 given", () => {
1836 |   const readable = toReadable(305);
1837 | 
1838 |   assert.equal(readable, 'three hundred five');
1839 | });
1840 | 
1841 | it.optional("Should return 'three hundred six' when 306 given", () => {
1842 |   const readable = toReadable(306);
1843 | 
1844 |   assert.equal(readable, 'three hundred six');
1845 | });
1846 | 
1847 | it.optional("Should return 'three hundred seven' when 307 given", () => {
1848 |   const readable = toReadable(307);
1849 | 
1850 |   assert.equal(readable, 'three hundred seven');
1851 | });
1852 | 
1853 | it.optional("Should return 'three hundred eight' when 308 given", () => {
1854 |   const readable = toReadable(308);
1855 | 
1856 |   assert.equal(readable, 'three hundred eight');
1857 | });
1858 | 
1859 | it.optional("Should return 'three hundred nine' when 309 given", () => {
1860 |   const readable = toReadable(309);
1861 | 
1862 |   assert.equal(readable, 'three hundred nine');
1863 | });
1864 | 
1865 | it.optional("Should return 'three hundred ten' when 310 given", () => {
1866 |   const readable = toReadable(310);
1867 | 
1868 |   assert.equal(readable, 'three hundred ten');
1869 | });
1870 | 
1871 | it.optional("Should return 'three hundred eleven' when 311 given", () => {
1872 |   const readable = toReadable(311);
1873 | 
1874 |   assert.equal(readable, 'three hundred eleven');
1875 | });
1876 | 
1877 | it.optional("Should return 'three hundred twelve' when 312 given", () => {
1878 |   const readable = toReadable(312);
1879 | 
1880 |   assert.equal(readable, 'three hundred twelve');
1881 | });
1882 | 
1883 | it.optional("Should return 'three hundred thirteen' when 313 given", () => {
1884 |   const readable = toReadable(313);
1885 | 
1886 |   assert.equal(readable, 'three hundred thirteen');
1887 | });
1888 | 
1889 | it.optional("Should return 'three hundred fourteen' when 314 given", () => {
1890 |   const readable = toReadable(314);
1891 | 
1892 |   assert.equal(readable, 'three hundred fourteen');
1893 | });
1894 | 
1895 | it.optional("Should return 'three hundred fifteen' when 315 given", () => {
1896 |   const readable = toReadable(315);
1897 | 
1898 |   assert.equal(readable, 'three hundred fifteen');
1899 | });
1900 | 
1901 | it.optional("Should return 'three hundred sixteen' when 316 given", () => {
1902 |   const readable = toReadable(316);
1903 | 
1904 |   assert.equal(readable, 'three hundred sixteen');
1905 | });
1906 | 
1907 | it.optional("Should return 'three hundred seventeen' when 317 given", () => {
1908 |   const readable = toReadable(317);
1909 | 
1910 |   assert.equal(readable, 'three hundred seventeen');
1911 | });
1912 | 
1913 | it.optional("Should return 'three hundred eighteen' when 318 given", () => {
1914 |   const readable = toReadable(318);
1915 | 
1916 |   assert.equal(readable, 'three hundred eighteen');
1917 | });
1918 | 
1919 | it.optional("Should return 'three hundred nineteen' when 319 given", () => {
1920 |   const readable = toReadable(319);
1921 | 
1922 |   assert.equal(readable, 'three hundred nineteen');
1923 | });
1924 | 
1925 | it.optional("Should return 'three hundred twenty' when 320 given", () => {
1926 |   const readable = toReadable(320);
1927 | 
1928 |   assert.equal(readable, 'three hundred twenty');
1929 | });
1930 | 
1931 | it.optional("Should return 'three hundred twenty one' when 321 given", () => {
1932 |   const readable = toReadable(321);
1933 | 
1934 |   assert.equal(readable, 'three hundred twenty one');
1935 | });
1936 | 
1937 | it.optional("Should return 'three hundred twenty two' when 322 given", () => {
1938 |   const readable = toReadable(322);
1939 | 
1940 |   assert.equal(readable, 'three hundred twenty two');
1941 | });
1942 | 
1943 | it.optional("Should return 'three hundred twenty three' when 323 given", () => {
1944 |   const readable = toReadable(323);
1945 | 
1946 |   assert.equal(readable, 'three hundred twenty three');
1947 | });
1948 | 
1949 | it.optional("Should return 'three hundred twenty four' when 324 given", () => {
1950 |   const readable = toReadable(324);
1951 | 
1952 |   assert.equal(readable, 'three hundred twenty four');
1953 | });
1954 | 
1955 | it.optional("Should return 'three hundred twenty five' when 325 given", () => {
1956 |   const readable = toReadable(325);
1957 | 
1958 |   assert.equal(readable, 'three hundred twenty five');
1959 | });
1960 | 
1961 | it.optional("Should return 'three hundred twenty six' when 326 given", () => {
1962 |   const readable = toReadable(326);
1963 | 
1964 |   assert.equal(readable, 'three hundred twenty six');
1965 | });
1966 | 
1967 | it.optional("Should return 'three hundred twenty seven' when 327 given", () => {
1968 |   const readable = toReadable(327);
1969 | 
1970 |   assert.equal(readable, 'three hundred twenty seven');
1971 | });
1972 | 
1973 | it.optional("Should return 'three hundred twenty eight' when 328 given", () => {
1974 |   const readable = toReadable(328);
1975 | 
1976 |   assert.equal(readable, 'three hundred twenty eight');
1977 | });
1978 | 
1979 | it.optional("Should return 'three hundred twenty nine' when 329 given", () => {
1980 |   const readable = toReadable(329);
1981 | 
1982 |   assert.equal(readable, 'three hundred twenty nine');
1983 | });
1984 | 
1985 | it.optional("Should return 'three hundred thirty' when 330 given", () => {
1986 |   const readable = toReadable(330);
1987 | 
1988 |   assert.equal(readable, 'three hundred thirty');
1989 | });
1990 | 
1991 | it.optional("Should return 'three hundred thirty one' when 331 given", () => {
1992 |   const readable = toReadable(331);
1993 | 
1994 |   assert.equal(readable, 'three hundred thirty one');
1995 | });
1996 | 
1997 | it.optional("Should return 'three hundred thirty two' when 332 given", () => {
1998 |   const readable = toReadable(332);
1999 | 
2000 |   assert.equal(readable, 'three hundred thirty two');
2001 | });
2002 | 
2003 | it.optional("Should return 'three hundred thirty three' when 333 given", () => {
2004 |   const readable = toReadable(333);
2005 | 
2006 |   assert.equal(readable, 'three hundred thirty three');
2007 | });
2008 | 
2009 | it.optional("Should return 'three hundred thirty four' when 334 given", () => {
2010 |   const readable = toReadable(334);
2011 | 
2012 |   assert.equal(readable, 'three hundred thirty four');
2013 | });
2014 | 
2015 | it.optional("Should return 'three hundred thirty five' when 335 given", () => {
2016 |   const readable = toReadable(335);
2017 | 
2018 |   assert.equal(readable, 'three hundred thirty five');
2019 | });
2020 | 
2021 | it.optional("Should return 'three hundred thirty six' when 336 given", () => {
2022 |   const readable = toReadable(336);
2023 | 
2024 |   assert.equal(readable, 'three hundred thirty six');
2025 | });
2026 | 
2027 | it.optional("Should return 'three hundred thirty seven' when 337 given", () => {
2028 |   const readable = toReadable(337);
2029 | 
2030 |   assert.equal(readable, 'three hundred thirty seven');
2031 | });
2032 | 
2033 | it.optional("Should return 'three hundred thirty eight' when 338 given", () => {
2034 |   const readable = toReadable(338);
2035 | 
2036 |   assert.equal(readable, 'three hundred thirty eight');
2037 | });
2038 | 
2039 | it.optional("Should return 'three hundred thirty nine' when 339 given", () => {
2040 |   const readable = toReadable(339);
2041 | 
2042 |   assert.equal(readable, 'three hundred thirty nine');
2043 | });
2044 | 
2045 | it.optional("Should return 'three hundred forty' when 340 given", () => {
2046 |   const readable = toReadable(340);
2047 | 
2048 |   assert.equal(readable, 'three hundred forty');
2049 | });
2050 | 
2051 | it.optional("Should return 'three hundred forty one' when 341 given", () => {
2052 |   const readable = toReadable(341);
2053 | 
2054 |   assert.equal(readable, 'three hundred forty one');
2055 | });
2056 | 
2057 | it.optional("Should return 'three hundred forty two' when 342 given", () => {
2058 |   const readable = toReadable(342);
2059 | 
2060 |   assert.equal(readable, 'three hundred forty two');
2061 | });
2062 | 
2063 | it.optional("Should return 'three hundred forty three' when 343 given", () => {
2064 |   const readable = toReadable(343);
2065 | 
2066 |   assert.equal(readable, 'three hundred forty three');
2067 | });
2068 | 
2069 | it.optional("Should return 'three hundred forty four' when 344 given", () => {
2070 |   const readable = toReadable(344);
2071 | 
2072 |   assert.equal(readable, 'three hundred forty four');
2073 | });
2074 | 
2075 | it.optional("Should return 'three hundred forty five' when 345 given", () => {
2076 |   const readable = toReadable(345);
2077 | 
2078 |   assert.equal(readable, 'three hundred forty five');
2079 | });
2080 | 
2081 | it.optional("Should return 'three hundred forty six' when 346 given", () => {
2082 |   const readable = toReadable(346);
2083 | 
2084 |   assert.equal(readable, 'three hundred forty six');
2085 | });
2086 | 
2087 | it.optional("Should return 'three hundred forty seven' when 347 given", () => {
2088 |   const readable = toReadable(347);
2089 | 
2090 |   assert.equal(readable, 'three hundred forty seven');
2091 | });
2092 | 
2093 | it.optional("Should return 'three hundred forty eight' when 348 given", () => {
2094 |   const readable = toReadable(348);
2095 | 
2096 |   assert.equal(readable, 'three hundred forty eight');
2097 | });
2098 | 
2099 | it.optional("Should return 'three hundred forty nine' when 349 given", () => {
2100 |   const readable = toReadable(349);
2101 | 
2102 |   assert.equal(readable, 'three hundred forty nine');
2103 | });
2104 | 
2105 | it.optional("Should return 'three hundred fifty' when 350 given", () => {
2106 |   const readable = toReadable(350);
2107 | 
2108 |   assert.equal(readable, 'three hundred fifty');
2109 | });
2110 | 
2111 | it.optional("Should return 'three hundred fifty one' when 351 given", () => {
2112 |   const readable = toReadable(351);
2113 | 
2114 |   assert.equal(readable, 'three hundred fifty one');
2115 | });
2116 | 
2117 | it.optional("Should return 'three hundred fifty two' when 352 given", () => {
2118 |   const readable = toReadable(352);
2119 | 
2120 |   assert.equal(readable, 'three hundred fifty two');
2121 | });
2122 | 
2123 | it.optional("Should return 'three hundred fifty three' when 353 given", () => {
2124 |   const readable = toReadable(353);
2125 | 
2126 |   assert.equal(readable, 'three hundred fifty three');
2127 | });
2128 | 
2129 | it.optional("Should return 'three hundred fifty four' when 354 given", () => {
2130 |   const readable = toReadable(354);
2131 | 
2132 |   assert.equal(readable, 'three hundred fifty four');
2133 | });
2134 | 
2135 | it.optional("Should return 'three hundred fifty five' when 355 given", () => {
2136 |   const readable = toReadable(355);
2137 | 
2138 |   assert.equal(readable, 'three hundred fifty five');
2139 | });
2140 | 
2141 | it.optional("Should return 'three hundred fifty six' when 356 given", () => {
2142 |   const readable = toReadable(356);
2143 | 
2144 |   assert.equal(readable, 'three hundred fifty six');
2145 | });
2146 | 
2147 | it.optional("Should return 'three hundred fifty seven' when 357 given", () => {
2148 |   const readable = toReadable(357);
2149 | 
2150 |   assert.equal(readable, 'three hundred fifty seven');
2151 | });
2152 | 
2153 | it.optional("Should return 'three hundred fifty eight' when 358 given", () => {
2154 |   const readable = toReadable(358);
2155 | 
2156 |   assert.equal(readable, 'three hundred fifty eight');
2157 | });
2158 | 
2159 | it.optional("Should return 'three hundred fifty nine' when 359 given", () => {
2160 |   const readable = toReadable(359);
2161 | 
2162 |   assert.equal(readable, 'three hundred fifty nine');
2163 | });
2164 | 
2165 | it.optional("Should return 'three hundred sixty' when 360 given", () => {
2166 |   const readable = toReadable(360);
2167 | 
2168 |   assert.equal(readable, 'three hundred sixty');
2169 | });
2170 | 
2171 | it.optional("Should return 'three hundred sixty one' when 361 given", () => {
2172 |   const readable = toReadable(361);
2173 | 
2174 |   assert.equal(readable, 'three hundred sixty one');
2175 | });
2176 | 
2177 | it.optional("Should return 'three hundred sixty two' when 362 given", () => {
2178 |   const readable = toReadable(362);
2179 | 
2180 |   assert.equal(readable, 'three hundred sixty two');
2181 | });
2182 | 
2183 | it.optional("Should return 'three hundred sixty three' when 363 given", () => {
2184 |   const readable = toReadable(363);
2185 | 
2186 |   assert.equal(readable, 'three hundred sixty three');
2187 | });
2188 | 
2189 | it.optional("Should return 'three hundred sixty four' when 364 given", () => {
2190 |   const readable = toReadable(364);
2191 | 
2192 |   assert.equal(readable, 'three hundred sixty four');
2193 | });
2194 | 
2195 | it.optional("Should return 'three hundred sixty five' when 365 given", () => {
2196 |   const readable = toReadable(365);
2197 | 
2198 |   assert.equal(readable, 'three hundred sixty five');
2199 | });
2200 | 
2201 | it.optional("Should return 'three hundred sixty six' when 366 given", () => {
2202 |   const readable = toReadable(366);
2203 | 
2204 |   assert.equal(readable, 'three hundred sixty six');
2205 | });
2206 | 
2207 | it.optional("Should return 'three hundred sixty seven' when 367 given", () => {
2208 |   const readable = toReadable(367);
2209 | 
2210 |   assert.equal(readable, 'three hundred sixty seven');
2211 | });
2212 | 
2213 | it.optional("Should return 'three hundred sixty eight' when 368 given", () => {
2214 |   const readable = toReadable(368);
2215 | 
2216 |   assert.equal(readable, 'three hundred sixty eight');
2217 | });
2218 | 
2219 | it.optional("Should return 'three hundred sixty nine' when 369 given", () => {
2220 |   const readable = toReadable(369);
2221 | 
2222 |   assert.equal(readable, 'three hundred sixty nine');
2223 | });
2224 | 
2225 | it.optional("Should return 'three hundred seventy' when 370 given", () => {
2226 |   const readable = toReadable(370);
2227 | 
2228 |   assert.equal(readable, 'three hundred seventy');
2229 | });
2230 | 
2231 | it.optional("Should return 'three hundred seventy one' when 371 given", () => {
2232 |   const readable = toReadable(371);
2233 | 
2234 |   assert.equal(readable, 'three hundred seventy one');
2235 | });
2236 | 
2237 | it.optional("Should return 'three hundred seventy two' when 372 given", () => {
2238 |   const readable = toReadable(372);
2239 | 
2240 |   assert.equal(readable, 'three hundred seventy two');
2241 | });
2242 | 
2243 | it.optional(
2244 |   "Should return 'three hundred seventy three' when 373 given",
2245 |   () => {
2246 |     const readable = toReadable(373);
2247 | 
2248 |     assert.equal(readable, 'three hundred seventy three');
2249 |   }
2250 | );
2251 | 
2252 | it.optional("Should return 'three hundred seventy four' when 374 given", () => {
2253 |   const readable = toReadable(374);
2254 | 
2255 |   assert.equal(readable, 'three hundred seventy four');
2256 | });
2257 | 
2258 | it.optional("Should return 'three hundred seventy five' when 375 given", () => {
2259 |   const readable = toReadable(375);
2260 | 
2261 |   assert.equal(readable, 'three hundred seventy five');
2262 | });
2263 | 
2264 | it.optional("Should return 'three hundred seventy six' when 376 given", () => {
2265 |   const readable = toReadable(376);
2266 | 
2267 |   assert.equal(readable, 'three hundred seventy six');
2268 | });
2269 | 
2270 | it.optional(
2271 |   "Should return 'three hundred seventy seven' when 377 given",
2272 |   () => {
2273 |     const readable = toReadable(377);
2274 | 
2275 |     assert.equal(readable, 'three hundred seventy seven');
2276 |   }
2277 | );
2278 | 
2279 | it.optional(
2280 |   "Should return 'three hundred seventy eight' when 378 given",
2281 |   () => {
2282 |     const readable = toReadable(378);
2283 | 
2284 |     assert.equal(readable, 'three hundred seventy eight');
2285 |   }
2286 | );
2287 | 
2288 | it.optional("Should return 'three hundred seventy nine' when 379 given", () => {
2289 |   const readable = toReadable(379);
2290 | 
2291 |   assert.equal(readable, 'three hundred seventy nine');
2292 | });
2293 | 
2294 | it.optional("Should return 'three hundred eighty' when 380 given", () => {
2295 |   const readable = toReadable(380);
2296 | 
2297 |   assert.equal(readable, 'three hundred eighty');
2298 | });
2299 | 
2300 | it.optional("Should return 'three hundred eighty one' when 381 given", () => {
2301 |   const readable = toReadable(381);
2302 | 
2303 |   assert.equal(readable, 'three hundred eighty one');
2304 | });
2305 | 
2306 | it.optional("Should return 'three hundred eighty two' when 382 given", () => {
2307 |   const readable = toReadable(382);
2308 | 
2309 |   assert.equal(readable, 'three hundred eighty two');
2310 | });
2311 | 
2312 | it.optional("Should return 'three hundred eighty three' when 383 given", () => {
2313 |   const readable = toReadable(383);
2314 | 
2315 |   assert.equal(readable, 'three hundred eighty three');
2316 | });
2317 | 
2318 | it.optional("Should return 'three hundred eighty four' when 384 given", () => {
2319 |   const readable = toReadable(384);
2320 | 
2321 |   assert.equal(readable, 'three hundred eighty four');
2322 | });
2323 | 
2324 | it.optional("Should return 'three hundred eighty five' when 385 given", () => {
2325 |   const readable = toReadable(385);
2326 | 
2327 |   assert.equal(readable, 'three hundred eighty five');
2328 | });
2329 | 
2330 | it.optional("Should return 'three hundred eighty six' when 386 given", () => {
2331 |   const readable = toReadable(386);
2332 | 
2333 |   assert.equal(readable, 'three hundred eighty six');
2334 | });
2335 | 
2336 | it.optional("Should return 'three hundred eighty seven' when 387 given", () => {
2337 |   const readable = toReadable(387);
2338 | 
2339 |   assert.equal(readable, 'three hundred eighty seven');
2340 | });
2341 | 
2342 | it.optional("Should return 'three hundred eighty eight' when 388 given", () => {
2343 |   const readable = toReadable(388);
2344 | 
2345 |   assert.equal(readable, 'three hundred eighty eight');
2346 | });
2347 | 
2348 | it.optional("Should return 'three hundred eighty nine' when 389 given", () => {
2349 |   const readable = toReadable(389);
2350 | 
2351 |   assert.equal(readable, 'three hundred eighty nine');
2352 | });
2353 | 
2354 | it.optional("Should return 'three hundred ninety' when 390 given", () => {
2355 |   const readable = toReadable(390);
2356 | 
2357 |   assert.equal(readable, 'three hundred ninety');
2358 | });
2359 | 
2360 | it.optional("Should return 'three hundred ninety one' when 391 given", () => {
2361 |   const readable = toReadable(391);
2362 | 
2363 |   assert.equal(readable, 'three hundred ninety one');
2364 | });
2365 | 
2366 | it.optional("Should return 'three hundred ninety two' when 392 given", () => {
2367 |   const readable = toReadable(392);
2368 | 
2369 |   assert.equal(readable, 'three hundred ninety two');
2370 | });
2371 | 
2372 | it.optional("Should return 'three hundred ninety three' when 393 given", () => {
2373 |   const readable = toReadable(393);
2374 | 
2375 |   assert.equal(readable, 'three hundred ninety three');
2376 | });
2377 | 
2378 | it.optional("Should return 'three hundred ninety four' when 394 given", () => {
2379 |   const readable = toReadable(394);
2380 | 
2381 |   assert.equal(readable, 'three hundred ninety four');
2382 | });
2383 | 
2384 | it.optional("Should return 'three hundred ninety five' when 395 given", () => {
2385 |   const readable = toReadable(395);
2386 | 
2387 |   assert.equal(readable, 'three hundred ninety five');
2388 | });
2389 | 
2390 | it.optional("Should return 'three hundred ninety six' when 396 given", () => {
2391 |   const readable = toReadable(396);
2392 | 
2393 |   assert.equal(readable, 'three hundred ninety six');
2394 | });
2395 | 
2396 | it.optional("Should return 'three hundred ninety seven' when 397 given", () => {
2397 |   const readable = toReadable(397);
2398 | 
2399 |   assert.equal(readable, 'three hundred ninety seven');
2400 | });
2401 | 
2402 | it.optional("Should return 'three hundred ninety eight' when 398 given", () => {
2403 |   const readable = toReadable(398);
2404 | 
2405 |   assert.equal(readable, 'three hundred ninety eight');
2406 | });
2407 | 
2408 | it.optional("Should return 'three hundred ninety nine' when 399 given", () => {
2409 |   const readable = toReadable(399);
2410 | 
2411 |   assert.equal(readable, 'three hundred ninety nine');
2412 | });
2413 | 
2414 | it.optional("Should return 'four hundred' when 400 given", () => {
2415 |   const readable = toReadable(400);
2416 | 
2417 |   assert.equal(readable, 'four hundred');
2418 | });
2419 | 
2420 | it.optional("Should return 'four hundred one' when 401 given", () => {
2421 |   const readable = toReadable(401);
2422 | 
2423 |   assert.equal(readable, 'four hundred one');
2424 | });
2425 | 
2426 | it.optional("Should return 'four hundred two' when 402 given", () => {
2427 |   const readable = toReadable(402);
2428 | 
2429 |   assert.equal(readable, 'four hundred two');
2430 | });
2431 | 
2432 | it.optional("Should return 'four hundred three' when 403 given", () => {
2433 |   const readable = toReadable(403);
2434 | 
2435 |   assert.equal(readable, 'four hundred three');
2436 | });
2437 | 
2438 | it.optional("Should return 'four hundred four' when 404 given", () => {
2439 |   const readable = toReadable(404);
2440 | 
2441 |   assert.equal(readable, 'four hundred four');
2442 | });
2443 | 
2444 | it.optional("Should return 'four hundred five' when 405 given", () => {
2445 |   const readable = toReadable(405);
2446 | 
2447 |   assert.equal(readable, 'four hundred five');
2448 | });
2449 | 
2450 | it.optional("Should return 'four hundred six' when 406 given", () => {
2451 |   const readable = toReadable(406);
2452 | 
2453 |   assert.equal(readable, 'four hundred six');
2454 | });
2455 | 
2456 | it.optional("Should return 'four hundred seven' when 407 given", () => {
2457 |   const readable = toReadable(407);
2458 | 
2459 |   assert.equal(readable, 'four hundred seven');
2460 | });
2461 | 
2462 | it.optional("Should return 'four hundred eight' when 408 given", () => {
2463 |   const readable = toReadable(408);
2464 | 
2465 |   assert.equal(readable, 'four hundred eight');
2466 | });
2467 | 
2468 | it.optional("Should return 'four hundred nine' when 409 given", () => {
2469 |   const readable = toReadable(409);
2470 | 
2471 |   assert.equal(readable, 'four hundred nine');
2472 | });
2473 | 
2474 | it.optional("Should return 'four hundred ten' when 410 given", () => {
2475 |   const readable = toReadable(410);
2476 | 
2477 |   assert.equal(readable, 'four hundred ten');
2478 | });
2479 | 
2480 | it.optional("Should return 'four hundred eleven' when 411 given", () => {
2481 |   const readable = toReadable(411);
2482 | 
2483 |   assert.equal(readable, 'four hundred eleven');
2484 | });
2485 | 
2486 | it.optional("Should return 'four hundred twelve' when 412 given", () => {
2487 |   const readable = toReadable(412);
2488 | 
2489 |   assert.equal(readable, 'four hundred twelve');
2490 | });
2491 | 
2492 | it.optional("Should return 'four hundred thirteen' when 413 given", () => {
2493 |   const readable = toReadable(413);
2494 | 
2495 |   assert.equal(readable, 'four hundred thirteen');
2496 | });
2497 | 
2498 | it.optional("Should return 'four hundred fourteen' when 414 given", () => {
2499 |   const readable = toReadable(414);
2500 | 
2501 |   assert.equal(readable, 'four hundred fourteen');
2502 | });
2503 | 
2504 | it.optional("Should return 'four hundred fifteen' when 415 given", () => {
2505 |   const readable = toReadable(415);
2506 | 
2507 |   assert.equal(readable, 'four hundred fifteen');
2508 | });
2509 | 
2510 | it.optional("Should return 'four hundred sixteen' when 416 given", () => {
2511 |   const readable = toReadable(416);
2512 | 
2513 |   assert.equal(readable, 'four hundred sixteen');
2514 | });
2515 | 
2516 | it.optional("Should return 'four hundred seventeen' when 417 given", () => {
2517 |   const readable = toReadable(417);
2518 | 
2519 |   assert.equal(readable, 'four hundred seventeen');
2520 | });
2521 | 
2522 | it.optional("Should return 'four hundred eighteen' when 418 given", () => {
2523 |   const readable = toReadable(418);
2524 | 
2525 |   assert.equal(readable, 'four hundred eighteen');
2526 | });
2527 | 
2528 | it.optional("Should return 'four hundred nineteen' when 419 given", () => {
2529 |   const readable = toReadable(419);
2530 | 
2531 |   assert.equal(readable, 'four hundred nineteen');
2532 | });
2533 | 
2534 | it.optional("Should return 'four hundred twenty' when 420 given", () => {
2535 |   const readable = toReadable(420);
2536 | 
2537 |   assert.equal(readable, 'four hundred twenty');
2538 | });
2539 | 
2540 | it.optional("Should return 'four hundred twenty one' when 421 given", () => {
2541 |   const readable = toReadable(421);
2542 | 
2543 |   assert.equal(readable, 'four hundred twenty one');
2544 | });
2545 | 
2546 | it.optional("Should return 'four hundred twenty two' when 422 given", () => {
2547 |   const readable = toReadable(422);
2548 | 
2549 |   assert.equal(readable, 'four hundred twenty two');
2550 | });
2551 | 
2552 | it.optional("Should return 'four hundred twenty three' when 423 given", () => {
2553 |   const readable = toReadable(423);
2554 | 
2555 |   assert.equal(readable, 'four hundred twenty three');
2556 | });
2557 | 
2558 | it.optional("Should return 'four hundred twenty four' when 424 given", () => {
2559 |   const readable = toReadable(424);
2560 | 
2561 |   assert.equal(readable, 'four hundred twenty four');
2562 | });
2563 | 
2564 | it.optional("Should return 'four hundred twenty five' when 425 given", () => {
2565 |   const readable = toReadable(425);
2566 | 
2567 |   assert.equal(readable, 'four hundred twenty five');
2568 | });
2569 | 
2570 | it.optional("Should return 'four hundred twenty six' when 426 given", () => {
2571 |   const readable = toReadable(426);
2572 | 
2573 |   assert.equal(readable, 'four hundred twenty six');
2574 | });
2575 | 
2576 | it.optional("Should return 'four hundred twenty seven' when 427 given", () => {
2577 |   const readable = toReadable(427);
2578 | 
2579 |   assert.equal(readable, 'four hundred twenty seven');
2580 | });
2581 | 
2582 | it.optional("Should return 'four hundred twenty eight' when 428 given", () => {
2583 |   const readable = toReadable(428);
2584 | 
2585 |   assert.equal(readable, 'four hundred twenty eight');
2586 | });
2587 | 
2588 | it.optional("Should return 'four hundred twenty nine' when 429 given", () => {
2589 |   const readable = toReadable(429);
2590 | 
2591 |   assert.equal(readable, 'four hundred twenty nine');
2592 | });
2593 | 
2594 | it.optional("Should return 'four hundred thirty' when 430 given", () => {
2595 |   const readable = toReadable(430);
2596 | 
2597 |   assert.equal(readable, 'four hundred thirty');
2598 | });
2599 | 
2600 | it.optional("Should return 'four hundred thirty one' when 431 given", () => {
2601 |   const readable = toReadable(431);
2602 | 
2603 |   assert.equal(readable, 'four hundred thirty one');
2604 | });
2605 | 
2606 | it.optional("Should return 'four hundred thirty two' when 432 given", () => {
2607 |   const readable = toReadable(432);
2608 | 
2609 |   assert.equal(readable, 'four hundred thirty two');
2610 | });
2611 | 
2612 | it.optional("Should return 'four hundred thirty three' when 433 given", () => {
2613 |   const readable = toReadable(433);
2614 | 
2615 |   assert.equal(readable, 'four hundred thirty three');
2616 | });
2617 | 
2618 | it.optional("Should return 'four hundred thirty four' when 434 given", () => {
2619 |   const readable = toReadable(434);
2620 | 
2621 |   assert.equal(readable, 'four hundred thirty four');
2622 | });
2623 | 
2624 | it.optional("Should return 'four hundred thirty five' when 435 given", () => {
2625 |   const readable = toReadable(435);
2626 | 
2627 |   assert.equal(readable, 'four hundred thirty five');
2628 | });
2629 | 
2630 | it.optional("Should return 'four hundred thirty six' when 436 given", () => {
2631 |   const readable = toReadable(436);
2632 | 
2633 |   assert.equal(readable, 'four hundred thirty six');
2634 | });
2635 | 
2636 | it.optional("Should return 'four hundred thirty seven' when 437 given", () => {
2637 |   const readable = toReadable(437);
2638 | 
2639 |   assert.equal(readable, 'four hundred thirty seven');
2640 | });
2641 | 
2642 | it.optional("Should return 'four hundred thirty eight' when 438 given", () => {
2643 |   const readable = toReadable(438);
2644 | 
2645 |   assert.equal(readable, 'four hundred thirty eight');
2646 | });
2647 | 
2648 | it.optional("Should return 'four hundred thirty nine' when 439 given", () => {
2649 |   const readable = toReadable(439);
2650 | 
2651 |   assert.equal(readable, 'four hundred thirty nine');
2652 | });
2653 | 
2654 | it.optional("Should return 'four hundred forty' when 440 given", () => {
2655 |   const readable = toReadable(440);
2656 | 
2657 |   assert.equal(readable, 'four hundred forty');
2658 | });
2659 | 
2660 | it.optional("Should return 'four hundred forty one' when 441 given", () => {
2661 |   const readable = toReadable(441);
2662 | 
2663 |   assert.equal(readable, 'four hundred forty one');
2664 | });
2665 | 
2666 | it.optional("Should return 'four hundred forty two' when 442 given", () => {
2667 |   const readable = toReadable(442);
2668 | 
2669 |   assert.equal(readable, 'four hundred forty two');
2670 | });
2671 | 
2672 | it.optional("Should return 'four hundred forty three' when 443 given", () => {
2673 |   const readable = toReadable(443);
2674 | 
2675 |   assert.equal(readable, 'four hundred forty three');
2676 | });
2677 | 
2678 | it.optional("Should return 'four hundred forty four' when 444 given", () => {
2679 |   const readable = toReadable(444);
2680 | 
2681 |   assert.equal(readable, 'four hundred forty four');
2682 | });
2683 | 
2684 | it.optional("Should return 'four hundred forty five' when 445 given", () => {
2685 |   const readable = toReadable(445);
2686 | 
2687 |   assert.equal(readable, 'four hundred forty five');
2688 | });
2689 | 
2690 | it.optional("Should return 'four hundred forty six' when 446 given", () => {
2691 |   const readable = toReadable(446);
2692 | 
2693 |   assert.equal(readable, 'four hundred forty six');
2694 | });
2695 | 
2696 | it.optional("Should return 'four hundred forty seven' when 447 given", () => {
2697 |   const readable = toReadable(447);
2698 | 
2699 |   assert.equal(readable, 'four hundred forty seven');
2700 | });
2701 | 
2702 | it.optional("Should return 'four hundred forty eight' when 448 given", () => {
2703 |   const readable = toReadable(448);
2704 | 
2705 |   assert.equal(readable, 'four hundred forty eight');
2706 | });
2707 | 
2708 | it.optional("Should return 'four hundred forty nine' when 449 given", () => {
2709 |   const readable = toReadable(449);
2710 | 
2711 |   assert.equal(readable, 'four hundred forty nine');
2712 | });
2713 | 
2714 | it.optional("Should return 'four hundred fifty' when 450 given", () => {
2715 |   const readable = toReadable(450);
2716 | 
2717 |   assert.equal(readable, 'four hundred fifty');
2718 | });
2719 | 
2720 | it.optional("Should return 'four hundred fifty one' when 451 given", () => {
2721 |   const readable = toReadable(451);
2722 | 
2723 |   assert.equal(readable, 'four hundred fifty one');
2724 | });
2725 | 
2726 | it.optional("Should return 'four hundred fifty two' when 452 given", () => {
2727 |   const readable = toReadable(452);
2728 | 
2729 |   assert.equal(readable, 'four hundred fifty two');
2730 | });
2731 | 
2732 | it.optional("Should return 'four hundred fifty three' when 453 given", () => {
2733 |   const readable = toReadable(453);
2734 | 
2735 |   assert.equal(readable, 'four hundred fifty three');
2736 | });
2737 | 
2738 | it.optional("Should return 'four hundred fifty four' when 454 given", () => {
2739 |   const readable = toReadable(454);
2740 | 
2741 |   assert.equal(readable, 'four hundred fifty four');
2742 | });
2743 | 
2744 | it.optional("Should return 'four hundred fifty five' when 455 given", () => {
2745 |   const readable = toReadable(455);
2746 | 
2747 |   assert.equal(readable, 'four hundred fifty five');
2748 | });
2749 | 
2750 | it.optional("Should return 'four hundred fifty six' when 456 given", () => {
2751 |   const readable = toReadable(456);
2752 | 
2753 |   assert.equal(readable, 'four hundred fifty six');
2754 | });
2755 | 
2756 | it.optional("Should return 'four hundred fifty seven' when 457 given", () => {
2757 |   const readable = toReadable(457);
2758 | 
2759 |   assert.equal(readable, 'four hundred fifty seven');
2760 | });
2761 | 
2762 | it.optional("Should return 'four hundred fifty eight' when 458 given", () => {
2763 |   const readable = toReadable(458);
2764 | 
2765 |   assert.equal(readable, 'four hundred fifty eight');
2766 | });
2767 | 
2768 | it.optional("Should return 'four hundred fifty nine' when 459 given", () => {
2769 |   const readable = toReadable(459);
2770 | 
2771 |   assert.equal(readable, 'four hundred fifty nine');
2772 | });
2773 | 
2774 | it.optional("Should return 'four hundred sixty' when 460 given", () => {
2775 |   const readable = toReadable(460);
2776 | 
2777 |   assert.equal(readable, 'four hundred sixty');
2778 | });
2779 | 
2780 | it.optional("Should return 'four hundred sixty one' when 461 given", () => {
2781 |   const readable = toReadable(461);
2782 | 
2783 |   assert.equal(readable, 'four hundred sixty one');
2784 | });
2785 | 
2786 | it.optional("Should return 'four hundred sixty two' when 462 given", () => {
2787 |   const readable = toReadable(462);
2788 | 
2789 |   assert.equal(readable, 'four hundred sixty two');
2790 | });
2791 | 
2792 | it.optional("Should return 'four hundred sixty three' when 463 given", () => {
2793 |   const readable = toReadable(463);
2794 | 
2795 |   assert.equal(readable, 'four hundred sixty three');
2796 | });
2797 | 
2798 | it.optional("Should return 'four hundred sixty four' when 464 given", () => {
2799 |   const readable = toReadable(464);
2800 | 
2801 |   assert.equal(readable, 'four hundred sixty four');
2802 | });
2803 | 
2804 | it.optional("Should return 'four hundred sixty five' when 465 given", () => {
2805 |   const readable = toReadable(465);
2806 | 
2807 |   assert.equal(readable, 'four hundred sixty five');
2808 | });
2809 | 
2810 | it.optional("Should return 'four hundred sixty six' when 466 given", () => {
2811 |   const readable = toReadable(466);
2812 | 
2813 |   assert.equal(readable, 'four hundred sixty six');
2814 | });
2815 | 
2816 | it.optional("Should return 'four hundred sixty seven' when 467 given", () => {
2817 |   const readable = toReadable(467);
2818 | 
2819 |   assert.equal(readable, 'four hundred sixty seven');
2820 | });
2821 | 
2822 | it.optional("Should return 'four hundred sixty eight' when 468 given", () => {
2823 |   const readable = toReadable(468);
2824 | 
2825 |   assert.equal(readable, 'four hundred sixty eight');
2826 | });
2827 | 
2828 | it.optional("Should return 'four hundred sixty nine' when 469 given", () => {
2829 |   const readable = toReadable(469);
2830 | 
2831 |   assert.equal(readable, 'four hundred sixty nine');
2832 | });
2833 | 
2834 | it.optional("Should return 'four hundred seventy' when 470 given", () => {
2835 |   const readable = toReadable(470);
2836 | 
2837 |   assert.equal(readable, 'four hundred seventy');
2838 | });
2839 | 
2840 | it.optional("Should return 'four hundred seventy one' when 471 given", () => {
2841 |   const readable = toReadable(471);
2842 | 
2843 |   assert.equal(readable, 'four hundred seventy one');
2844 | });
2845 | 
2846 | it.optional("Should return 'four hundred seventy two' when 472 given", () => {
2847 |   const readable = toReadable(472);
2848 | 
2849 |   assert.equal(readable, 'four hundred seventy two');
2850 | });
2851 | 
2852 | it.optional("Should return 'four hundred seventy three' when 473 given", () => {
2853 |   const readable = toReadable(473);
2854 | 
2855 |   assert.equal(readable, 'four hundred seventy three');
2856 | });
2857 | 
2858 | it.optional("Should return 'four hundred seventy four' when 474 given", () => {
2859 |   const readable = toReadable(474);
2860 | 
2861 |   assert.equal(readable, 'four hundred seventy four');
2862 | });
2863 | 
2864 | it.optional("Should return 'four hundred seventy five' when 475 given", () => {
2865 |   const readable = toReadable(475);
2866 | 
2867 |   assert.equal(readable, 'four hundred seventy five');
2868 | });
2869 | 
2870 | it.optional("Should return 'four hundred seventy six' when 476 given", () => {
2871 |   const readable = toReadable(476);
2872 | 
2873 |   assert.equal(readable, 'four hundred seventy six');
2874 | });
2875 | 
2876 | it.optional("Should return 'four hundred seventy seven' when 477 given", () => {
2877 |   const readable = toReadable(477);
2878 | 
2879 |   assert.equal(readable, 'four hundred seventy seven');
2880 | });
2881 | 
2882 | it.optional("Should return 'four hundred seventy eight' when 478 given", () => {
2883 |   const readable = toReadable(478);
2884 | 
2885 |   assert.equal(readable, 'four hundred seventy eight');
2886 | });
2887 | 
2888 | it.optional("Should return 'four hundred seventy nine' when 479 given", () => {
2889 |   const readable = toReadable(479);
2890 | 
2891 |   assert.equal(readable, 'four hundred seventy nine');
2892 | });
2893 | 
2894 | it.optional("Should return 'four hundred eighty' when 480 given", () => {
2895 |   const readable = toReadable(480);
2896 | 
2897 |   assert.equal(readable, 'four hundred eighty');
2898 | });
2899 | 
2900 | it.optional("Should return 'four hundred eighty one' when 481 given", () => {
2901 |   const readable = toReadable(481);
2902 | 
2903 |   assert.equal(readable, 'four hundred eighty one');
2904 | });
2905 | 
2906 | it.optional("Should return 'four hundred eighty two' when 482 given", () => {
2907 |   const readable = toReadable(482);
2908 | 
2909 |   assert.equal(readable, 'four hundred eighty two');
2910 | });
2911 | 
2912 | it.optional("Should return 'four hundred eighty three' when 483 given", () => {
2913 |   const readable = toReadable(483);
2914 | 
2915 |   assert.equal(readable, 'four hundred eighty three');
2916 | });
2917 | 
2918 | it.optional("Should return 'four hundred eighty four' when 484 given", () => {
2919 |   const readable = toReadable(484);
2920 | 
2921 |   assert.equal(readable, 'four hundred eighty four');
2922 | });
2923 | 
2924 | it.optional("Should return 'four hundred eighty five' when 485 given", () => {
2925 |   const readable = toReadable(485);
2926 | 
2927 |   assert.equal(readable, 'four hundred eighty five');
2928 | });
2929 | 
2930 | it.optional("Should return 'four hundred eighty six' when 486 given", () => {
2931 |   const readable = toReadable(486);
2932 | 
2933 |   assert.equal(readable, 'four hundred eighty six');
2934 | });
2935 | 
2936 | it.optional("Should return 'four hundred eighty seven' when 487 given", () => {
2937 |   const readable = toReadable(487);
2938 | 
2939 |   assert.equal(readable, 'four hundred eighty seven');
2940 | });
2941 | 
2942 | it.optional("Should return 'four hundred eighty eight' when 488 given", () => {
2943 |   const readable = toReadable(488);
2944 | 
2945 |   assert.equal(readable, 'four hundred eighty eight');
2946 | });
2947 | 
2948 | it.optional("Should return 'four hundred eighty nine' when 489 given", () => {
2949 |   const readable = toReadable(489);
2950 | 
2951 |   assert.equal(readable, 'four hundred eighty nine');
2952 | });
2953 | 
2954 | it.optional("Should return 'four hundred ninety' when 490 given", () => {
2955 |   const readable = toReadable(490);
2956 | 
2957 |   assert.equal(readable, 'four hundred ninety');
2958 | });
2959 | 
2960 | it.optional("Should return 'four hundred ninety one' when 491 given", () => {
2961 |   const readable = toReadable(491);
2962 | 
2963 |   assert.equal(readable, 'four hundred ninety one');
2964 | });
2965 | 
2966 | it.optional("Should return 'four hundred ninety two' when 492 given", () => {
2967 |   const readable = toReadable(492);
2968 | 
2969 |   assert.equal(readable, 'four hundred ninety two');
2970 | });
2971 | 
2972 | it.optional("Should return 'four hundred ninety three' when 493 given", () => {
2973 |   const readable = toReadable(493);
2974 | 
2975 |   assert.equal(readable, 'four hundred ninety three');
2976 | });
2977 | 
2978 | it.optional("Should return 'four hundred ninety four' when 494 given", () => {
2979 |   const readable = toReadable(494);
2980 | 
2981 |   assert.equal(readable, 'four hundred ninety four');
2982 | });
2983 | 
2984 | it.optional("Should return 'four hundred ninety five' when 495 given", () => {
2985 |   const readable = toReadable(495);
2986 | 
2987 |   assert.equal(readable, 'four hundred ninety five');
2988 | });
2989 | 
2990 | it.optional("Should return 'four hundred ninety six' when 496 given", () => {
2991 |   const readable = toReadable(496);
2992 | 
2993 |   assert.equal(readable, 'four hundred ninety six');
2994 | });
2995 | 
2996 | it.optional("Should return 'four hundred ninety seven' when 497 given", () => {
2997 |   const readable = toReadable(497);
2998 | 
2999 |   assert.equal(readable, 'four hundred ninety seven');
3000 | });
3001 | 
3002 | it.optional("Should return 'four hundred ninety eight' when 498 given", () => {
3003 |   const readable = toReadable(498);
3004 | 
3005 |   assert.equal(readable, 'four hundred ninety eight');
3006 | });
3007 | 
3008 | it.optional("Should return 'four hundred ninety nine' when 499 given", () => {
3009 |   const readable = toReadable(499);
3010 | 
3011 |   assert.equal(readable, 'four hundred ninety nine');
3012 | });
3013 | 
3014 | it.optional("Should return 'five hundred' when 500 given", () => {
3015 |   const readable = toReadable(500);
3016 | 
3017 |   assert.equal(readable, 'five hundred');
3018 | });
3019 | 
3020 | it.optional("Should return 'five hundred one' when 501 given", () => {
3021 |   const readable = toReadable(501);
3022 | 
3023 |   assert.equal(readable, 'five hundred one');
3024 | });
3025 | 
3026 | it.optional("Should return 'five hundred two' when 502 given", () => {
3027 |   const readable = toReadable(502);
3028 | 
3029 |   assert.equal(readable, 'five hundred two');
3030 | });
3031 | 
3032 | it.optional("Should return 'five hundred three' when 503 given", () => {
3033 |   const readable = toReadable(503);
3034 | 
3035 |   assert.equal(readable, 'five hundred three');
3036 | });
3037 | 
3038 | it.optional("Should return 'five hundred four' when 504 given", () => {
3039 |   const readable = toReadable(504);
3040 | 
3041 |   assert.equal(readable, 'five hundred four');
3042 | });
3043 | 
3044 | it.optional("Should return 'five hundred five' when 505 given", () => {
3045 |   const readable = toReadable(505);
3046 | 
3047 |   assert.equal(readable, 'five hundred five');
3048 | });
3049 | 
3050 | it.optional("Should return 'five hundred six' when 506 given", () => {
3051 |   const readable = toReadable(506);
3052 | 
3053 |   assert.equal(readable, 'five hundred six');
3054 | });
3055 | 
3056 | it.optional("Should return 'five hundred seven' when 507 given", () => {
3057 |   const readable = toReadable(507);
3058 | 
3059 |   assert.equal(readable, 'five hundred seven');
3060 | });
3061 | 
3062 | it.optional("Should return 'five hundred eight' when 508 given", () => {
3063 |   const readable = toReadable(508);
3064 | 
3065 |   assert.equal(readable, 'five hundred eight');
3066 | });
3067 | 
3068 | it.optional("Should return 'five hundred nine' when 509 given", () => {
3069 |   const readable = toReadable(509);
3070 | 
3071 |   assert.equal(readable, 'five hundred nine');
3072 | });
3073 | 
3074 | it.optional("Should return 'five hundred ten' when 510 given", () => {
3075 |   const readable = toReadable(510);
3076 | 
3077 |   assert.equal(readable, 'five hundred ten');
3078 | });
3079 | 
3080 | it.optional("Should return 'five hundred eleven' when 511 given", () => {
3081 |   const readable = toReadable(511);
3082 | 
3083 |   assert.equal(readable, 'five hundred eleven');
3084 | });
3085 | 
3086 | it.optional("Should return 'five hundred twelve' when 512 given", () => {
3087 |   const readable = toReadable(512);
3088 | 
3089 |   assert.equal(readable, 'five hundred twelve');
3090 | });
3091 | 
3092 | it.optional("Should return 'five hundred thirteen' when 513 given", () => {
3093 |   const readable = toReadable(513);
3094 | 
3095 |   assert.equal(readable, 'five hundred thirteen');
3096 | });
3097 | 
3098 | it.optional("Should return 'five hundred fourteen' when 514 given", () => {
3099 |   const readable = toReadable(514);
3100 | 
3101 |   assert.equal(readable, 'five hundred fourteen');
3102 | });
3103 | 
3104 | it.optional("Should return 'five hundred fifteen' when 515 given", () => {
3105 |   const readable = toReadable(515);
3106 | 
3107 |   assert.equal(readable, 'five hundred fifteen');
3108 | });
3109 | 
3110 | it.optional("Should return 'five hundred sixteen' when 516 given", () => {
3111 |   const readable = toReadable(516);
3112 | 
3113 |   assert.equal(readable, 'five hundred sixteen');
3114 | });
3115 | 
3116 | it.optional("Should return 'five hundred seventeen' when 517 given", () => {
3117 |   const readable = toReadable(517);
3118 | 
3119 |   assert.equal(readable, 'five hundred seventeen');
3120 | });
3121 | 
3122 | it.optional("Should return 'five hundred eighteen' when 518 given", () => {
3123 |   const readable = toReadable(518);
3124 | 
3125 |   assert.equal(readable, 'five hundred eighteen');
3126 | });
3127 | 
3128 | it.optional("Should return 'five hundred nineteen' when 519 given", () => {
3129 |   const readable = toReadable(519);
3130 | 
3131 |   assert.equal(readable, 'five hundred nineteen');
3132 | });
3133 | 
3134 | it.optional("Should return 'five hundred twenty' when 520 given", () => {
3135 |   const readable = toReadable(520);
3136 | 
3137 |   assert.equal(readable, 'five hundred twenty');
3138 | });
3139 | 
3140 | it.optional("Should return 'five hundred twenty one' when 521 given", () => {
3141 |   const readable = toReadable(521);
3142 | 
3143 |   assert.equal(readable, 'five hundred twenty one');
3144 | });
3145 | 
3146 | it.optional("Should return 'five hundred twenty two' when 522 given", () => {
3147 |   const readable = toReadable(522);
3148 | 
3149 |   assert.equal(readable, 'five hundred twenty two');
3150 | });
3151 | 
3152 | it.optional("Should return 'five hundred twenty three' when 523 given", () => {
3153 |   const readable = toReadable(523);
3154 | 
3155 |   assert.equal(readable, 'five hundred twenty three');
3156 | });
3157 | 
3158 | it.optional("Should return 'five hundred twenty four' when 524 given", () => {
3159 |   const readable = toReadable(524);
3160 | 
3161 |   assert.equal(readable, 'five hundred twenty four');
3162 | });
3163 | 
3164 | it.optional("Should return 'five hundred twenty five' when 525 given", () => {
3165 |   const readable = toReadable(525);
3166 | 
3167 |   assert.equal(readable, 'five hundred twenty five');
3168 | });
3169 | 
3170 | it.optional("Should return 'five hundred twenty six' when 526 given", () => {
3171 |   const readable = toReadable(526);
3172 | 
3173 |   assert.equal(readable, 'five hundred twenty six');
3174 | });
3175 | 
3176 | it.optional("Should return 'five hundred twenty seven' when 527 given", () => {
3177 |   const readable = toReadable(527);
3178 | 
3179 |   assert.equal(readable, 'five hundred twenty seven');
3180 | });
3181 | 
3182 | it.optional("Should return 'five hundred twenty eight' when 528 given", () => {
3183 |   const readable = toReadable(528);
3184 | 
3185 |   assert.equal(readable, 'five hundred twenty eight');
3186 | });
3187 | 
3188 | it.optional("Should return 'five hundred twenty nine' when 529 given", () => {
3189 |   const readable = toReadable(529);
3190 | 
3191 |   assert.equal(readable, 'five hundred twenty nine');
3192 | });
3193 | 
3194 | it.optional("Should return 'five hundred thirty' when 530 given", () => {
3195 |   const readable = toReadable(530);
3196 | 
3197 |   assert.equal(readable, 'five hundred thirty');
3198 | });
3199 | 
3200 | it.optional("Should return 'five hundred thirty one' when 531 given", () => {
3201 |   const readable = toReadable(531);
3202 | 
3203 |   assert.equal(readable, 'five hundred thirty one');
3204 | });
3205 | 
3206 | it.optional("Should return 'five hundred thirty two' when 532 given", () => {
3207 |   const readable = toReadable(532);
3208 | 
3209 |   assert.equal(readable, 'five hundred thirty two');
3210 | });
3211 | 
3212 | it.optional("Should return 'five hundred thirty three' when 533 given", () => {
3213 |   const readable = toReadable(533);
3214 | 
3215 |   assert.equal(readable, 'five hundred thirty three');
3216 | });
3217 | 
3218 | it.optional("Should return 'five hundred thirty four' when 534 given", () => {
3219 |   const readable = toReadable(534);
3220 | 
3221 |   assert.equal(readable, 'five hundred thirty four');
3222 | });
3223 | 
3224 | it.optional("Should return 'five hundred thirty five' when 535 given", () => {
3225 |   const readable = toReadable(535);
3226 | 
3227 |   assert.equal(readable, 'five hundred thirty five');
3228 | });
3229 | 
3230 | it.optional("Should return 'five hundred thirty six' when 536 given", () => {
3231 |   const readable = toReadable(536);
3232 | 
3233 |   assert.equal(readable, 'five hundred thirty six');
3234 | });
3235 | 
3236 | it.optional("Should return 'five hundred thirty seven' when 537 given", () => {
3237 |   const readable = toReadable(537);
3238 | 
3239 |   assert.equal(readable, 'five hundred thirty seven');
3240 | });
3241 | 
3242 | it.optional("Should return 'five hundred thirty eight' when 538 given", () => {
3243 |   const readable = toReadable(538);
3244 | 
3245 |   assert.equal(readable, 'five hundred thirty eight');
3246 | });
3247 | 
3248 | it.optional("Should return 'five hundred thirty nine' when 539 given", () => {
3249 |   const readable = toReadable(539);
3250 | 
3251 |   assert.equal(readable, 'five hundred thirty nine');
3252 | });
3253 | 
3254 | it.optional("Should return 'five hundred forty' when 540 given", () => {
3255 |   const readable = toReadable(540);
3256 | 
3257 |   assert.equal(readable, 'five hundred forty');
3258 | });
3259 | 
3260 | it.optional("Should return 'five hundred forty one' when 541 given", () => {
3261 |   const readable = toReadable(541);
3262 | 
3263 |   assert.equal(readable, 'five hundred forty one');
3264 | });
3265 | 
3266 | it.optional("Should return 'five hundred forty two' when 542 given", () => {
3267 |   const readable = toReadable(542);
3268 | 
3269 |   assert.equal(readable, 'five hundred forty two');
3270 | });
3271 | 
3272 | it.optional("Should return 'five hundred forty three' when 543 given", () => {
3273 |   const readable = toReadable(543);
3274 | 
3275 |   assert.equal(readable, 'five hundred forty three');
3276 | });
3277 | 
3278 | it.optional("Should return 'five hundred forty four' when 544 given", () => {
3279 |   const readable = toReadable(544);
3280 | 
3281 |   assert.equal(readable, 'five hundred forty four');
3282 | });
3283 | 
3284 | it.optional("Should return 'five hundred forty five' when 545 given", () => {
3285 |   const readable = toReadable(545);
3286 | 
3287 |   assert.equal(readable, 'five hundred forty five');
3288 | });
3289 | 
3290 | it.optional("Should return 'five hundred forty six' when 546 given", () => {
3291 |   const readable = toReadable(546);
3292 | 
3293 |   assert.equal(readable, 'five hundred forty six');
3294 | });
3295 | 
3296 | it.optional("Should return 'five hundred forty seven' when 547 given", () => {
3297 |   const readable = toReadable(547);
3298 | 
3299 |   assert.equal(readable, 'five hundred forty seven');
3300 | });
3301 | 
3302 | it.optional("Should return 'five hundred forty eight' when 548 given", () => {
3303 |   const readable = toReadable(548);
3304 | 
3305 |   assert.equal(readable, 'five hundred forty eight');
3306 | });
3307 | 
3308 | it.optional("Should return 'five hundred forty nine' when 549 given", () => {
3309 |   const readable = toReadable(549);
3310 | 
3311 |   assert.equal(readable, 'five hundred forty nine');
3312 | });
3313 | 
3314 | it.optional("Should return 'five hundred fifty' when 550 given", () => {
3315 |   const readable = toReadable(550);
3316 | 
3317 |   assert.equal(readable, 'five hundred fifty');
3318 | });
3319 | 
3320 | it.optional("Should return 'five hundred fifty one' when 551 given", () => {
3321 |   const readable = toReadable(551);
3322 | 
3323 |   assert.equal(readable, 'five hundred fifty one');
3324 | });
3325 | 
3326 | it.optional("Should return 'five hundred fifty two' when 552 given", () => {
3327 |   const readable = toReadable(552);
3328 | 
3329 |   assert.equal(readable, 'five hundred fifty two');
3330 | });
3331 | 
3332 | it.optional("Should return 'five hundred fifty three' when 553 given", () => {
3333 |   const readable = toReadable(553);
3334 | 
3335 |   assert.equal(readable, 'five hundred fifty three');
3336 | });
3337 | 
3338 | it.optional("Should return 'five hundred fifty four' when 554 given", () => {
3339 |   const readable = toReadable(554);
3340 | 
3341 |   assert.equal(readable, 'five hundred fifty four');
3342 | });
3343 | 
3344 | it.optional("Should return 'five hundred fifty five' when 555 given", () => {
3345 |   const readable = toReadable(555);
3346 | 
3347 |   assert.equal(readable, 'five hundred fifty five');
3348 | });
3349 | 
3350 | it.optional("Should return 'five hundred fifty six' when 556 given", () => {
3351 |   const readable = toReadable(556);
3352 | 
3353 |   assert.equal(readable, 'five hundred fifty six');
3354 | });
3355 | 
3356 | it.optional("Should return 'five hundred fifty seven' when 557 given", () => {
3357 |   const readable = toReadable(557);
3358 | 
3359 |   assert.equal(readable, 'five hundred fifty seven');
3360 | });
3361 | 
3362 | it.optional("Should return 'five hundred fifty eight' when 558 given", () => {
3363 |   const readable = toReadable(558);
3364 | 
3365 |   assert.equal(readable, 'five hundred fifty eight');
3366 | });
3367 | 
3368 | it.optional("Should return 'five hundred fifty nine' when 559 given", () => {
3369 |   const readable = toReadable(559);
3370 | 
3371 |   assert.equal(readable, 'five hundred fifty nine');
3372 | });
3373 | 
3374 | it.optional("Should return 'five hundred sixty' when 560 given", () => {
3375 |   const readable = toReadable(560);
3376 | 
3377 |   assert.equal(readable, 'five hundred sixty');
3378 | });
3379 | 
3380 | it.optional("Should return 'five hundred sixty one' when 561 given", () => {
3381 |   const readable = toReadable(561);
3382 | 
3383 |   assert.equal(readable, 'five hundred sixty one');
3384 | });
3385 | 
3386 | it.optional("Should return 'five hundred sixty two' when 562 given", () => {
3387 |   const readable = toReadable(562);
3388 | 
3389 |   assert.equal(readable, 'five hundred sixty two');
3390 | });
3391 | 
3392 | it.optional("Should return 'five hundred sixty three' when 563 given", () => {
3393 |   const readable = toReadable(563);
3394 | 
3395 |   assert.equal(readable, 'five hundred sixty three');
3396 | });
3397 | 
3398 | it.optional("Should return 'five hundred sixty four' when 564 given", () => {
3399 |   const readable = toReadable(564);
3400 | 
3401 |   assert.equal(readable, 'five hundred sixty four');
3402 | });
3403 | 
3404 | it.optional("Should return 'five hundred sixty five' when 565 given", () => {
3405 |   const readable = toReadable(565);
3406 | 
3407 |   assert.equal(readable, 'five hundred sixty five');
3408 | });
3409 | 
3410 | it.optional("Should return 'five hundred sixty six' when 566 given", () => {
3411 |   const readable = toReadable(566);
3412 | 
3413 |   assert.equal(readable, 'five hundred sixty six');
3414 | });
3415 | 
3416 | it.optional("Should return 'five hundred sixty seven' when 567 given", () => {
3417 |   const readable = toReadable(567);
3418 | 
3419 |   assert.equal(readable, 'five hundred sixty seven');
3420 | });
3421 | 
3422 | it.optional("Should return 'five hundred sixty eight' when 568 given", () => {
3423 |   const readable = toReadable(568);
3424 | 
3425 |   assert.equal(readable, 'five hundred sixty eight');
3426 | });
3427 | 
3428 | it.optional("Should return 'five hundred sixty nine' when 569 given", () => {
3429 |   const readable = toReadable(569);
3430 | 
3431 |   assert.equal(readable, 'five hundred sixty nine');
3432 | });
3433 | 
3434 | it.optional("Should return 'five hundred seventy' when 570 given", () => {
3435 |   const readable = toReadable(570);
3436 | 
3437 |   assert.equal(readable, 'five hundred seventy');
3438 | });
3439 | 
3440 | it.optional("Should return 'five hundred seventy one' when 571 given", () => {
3441 |   const readable = toReadable(571);
3442 | 
3443 |   assert.equal(readable, 'five hundred seventy one');
3444 | });
3445 | 
3446 | it.optional("Should return 'five hundred seventy two' when 572 given", () => {
3447 |   const readable = toReadable(572);
3448 | 
3449 |   assert.equal(readable, 'five hundred seventy two');
3450 | });
3451 | 
3452 | it.optional("Should return 'five hundred seventy three' when 573 given", () => {
3453 |   const readable = toReadable(573);
3454 | 
3455 |   assert.equal(readable, 'five hundred seventy three');
3456 | });
3457 | 
3458 | it.optional("Should return 'five hundred seventy four' when 574 given", () => {
3459 |   const readable = toReadable(574);
3460 | 
3461 |   assert.equal(readable, 'five hundred seventy four');
3462 | });
3463 | 
3464 | it.optional("Should return 'five hundred seventy five' when 575 given", () => {
3465 |   const readable = toReadable(575);
3466 | 
3467 |   assert.equal(readable, 'five hundred seventy five');
3468 | });
3469 | 
3470 | it.optional("Should return 'five hundred seventy six' when 576 given", () => {
3471 |   const readable = toReadable(576);
3472 | 
3473 |   assert.equal(readable, 'five hundred seventy six');
3474 | });
3475 | 
3476 | it.optional("Should return 'five hundred seventy seven' when 577 given", () => {
3477 |   const readable = toReadable(577);
3478 | 
3479 |   assert.equal(readable, 'five hundred seventy seven');
3480 | });
3481 | 
3482 | it.optional("Should return 'five hundred seventy eight' when 578 given", () => {
3483 |   const readable = toReadable(578);
3484 | 
3485 |   assert.equal(readable, 'five hundred seventy eight');
3486 | });
3487 | 
3488 | it.optional("Should return 'five hundred seventy nine' when 579 given", () => {
3489 |   const readable = toReadable(579);
3490 | 
3491 |   assert.equal(readable, 'five hundred seventy nine');
3492 | });
3493 | 
3494 | it.optional("Should return 'five hundred eighty' when 580 given", () => {
3495 |   const readable = toReadable(580);
3496 | 
3497 |   assert.equal(readable, 'five hundred eighty');
3498 | });
3499 | 
3500 | it.optional("Should return 'five hundred eighty one' when 581 given", () => {
3501 |   const readable = toReadable(581);
3502 | 
3503 |   assert.equal(readable, 'five hundred eighty one');
3504 | });
3505 | 
3506 | it.optional("Should return 'five hundred eighty two' when 582 given", () => {
3507 |   const readable = toReadable(582);
3508 | 
3509 |   assert.equal(readable, 'five hundred eighty two');
3510 | });
3511 | 
3512 | it.optional("Should return 'five hundred eighty three' when 583 given", () => {
3513 |   const readable = toReadable(583);
3514 | 
3515 |   assert.equal(readable, 'five hundred eighty three');
3516 | });
3517 | 
3518 | it.optional("Should return 'five hundred eighty four' when 584 given", () => {
3519 |   const readable = toReadable(584);
3520 | 
3521 |   assert.equal(readable, 'five hundred eighty four');
3522 | });
3523 | 
3524 | it.optional("Should return 'five hundred eighty five' when 585 given", () => {
3525 |   const readable = toReadable(585);
3526 | 
3527 |   assert.equal(readable, 'five hundred eighty five');
3528 | });
3529 | 
3530 | it.optional("Should return 'five hundred eighty six' when 586 given", () => {
3531 |   const readable = toReadable(586);
3532 | 
3533 |   assert.equal(readable, 'five hundred eighty six');
3534 | });
3535 | 
3536 | it.optional("Should return 'five hundred eighty seven' when 587 given", () => {
3537 |   const readable = toReadable(587);
3538 | 
3539 |   assert.equal(readable, 'five hundred eighty seven');
3540 | });
3541 | 
3542 | it.optional("Should return 'five hundred eighty eight' when 588 given", () => {
3543 |   const readable = toReadable(588);
3544 | 
3545 |   assert.equal(readable, 'five hundred eighty eight');
3546 | });
3547 | 
3548 | it.optional("Should return 'five hundred eighty nine' when 589 given", () => {
3549 |   const readable = toReadable(589);
3550 | 
3551 |   assert.equal(readable, 'five hundred eighty nine');
3552 | });
3553 | 
3554 | it.optional("Should return 'five hundred ninety' when 590 given", () => {
3555 |   const readable = toReadable(590);
3556 | 
3557 |   assert.equal(readable, 'five hundred ninety');
3558 | });
3559 | 
3560 | it.optional("Should return 'five hundred ninety one' when 591 given", () => {
3561 |   const readable = toReadable(591);
3562 | 
3563 |   assert.equal(readable, 'five hundred ninety one');
3564 | });
3565 | 
3566 | it.optional("Should return 'five hundred ninety two' when 592 given", () => {
3567 |   const readable = toReadable(592);
3568 | 
3569 |   assert.equal(readable, 'five hundred ninety two');
3570 | });
3571 | 
3572 | it.optional("Should return 'five hundred ninety three' when 593 given", () => {
3573 |   const readable = toReadable(593);
3574 | 
3575 |   assert.equal(readable, 'five hundred ninety three');
3576 | });
3577 | 
3578 | it.optional("Should return 'five hundred ninety four' when 594 given", () => {
3579 |   const readable = toReadable(594);
3580 | 
3581 |   assert.equal(readable, 'five hundred ninety four');
3582 | });
3583 | 
3584 | it.optional("Should return 'five hundred ninety five' when 595 given", () => {
3585 |   const readable = toReadable(595);
3586 | 
3587 |   assert.equal(readable, 'five hundred ninety five');
3588 | });
3589 | 
3590 | it.optional("Should return 'five hundred ninety six' when 596 given", () => {
3591 |   const readable = toReadable(596);
3592 | 
3593 |   assert.equal(readable, 'five hundred ninety six');
3594 | });
3595 | 
3596 | it.optional("Should return 'five hundred ninety seven' when 597 given", () => {
3597 |   const readable = toReadable(597);
3598 | 
3599 |   assert.equal(readable, 'five hundred ninety seven');
3600 | });
3601 | 
3602 | it.optional("Should return 'five hundred ninety eight' when 598 given", () => {
3603 |   const readable = toReadable(598);
3604 | 
3605 |   assert.equal(readable, 'five hundred ninety eight');
3606 | });
3607 | 
3608 | it.optional("Should return 'five hundred ninety nine' when 599 given", () => {
3609 |   const readable = toReadable(599);
3610 | 
3611 |   assert.equal(readable, 'five hundred ninety nine');
3612 | });
3613 | 
3614 | it.optional("Should return 'six hundred' when 600 given", () => {
3615 |   const readable = toReadable(600);
3616 | 
3617 |   assert.equal(readable, 'six hundred');
3618 | });
3619 | 
3620 | it.optional("Should return 'six hundred one' when 601 given", () => {
3621 |   const readable = toReadable(601);
3622 | 
3623 |   assert.equal(readable, 'six hundred one');
3624 | });
3625 | 
3626 | it.optional("Should return 'six hundred two' when 602 given", () => {
3627 |   const readable = toReadable(602);
3628 | 
3629 |   assert.equal(readable, 'six hundred two');
3630 | });
3631 | 
3632 | it.optional("Should return 'six hundred three' when 603 given", () => {
3633 |   const readable = toReadable(603);
3634 | 
3635 |   assert.equal(readable, 'six hundred three');
3636 | });
3637 | 
3638 | it.optional("Should return 'six hundred four' when 604 given", () => {
3639 |   const readable = toReadable(604);
3640 | 
3641 |   assert.equal(readable, 'six hundred four');
3642 | });
3643 | 
3644 | it.optional("Should return 'six hundred five' when 605 given", () => {
3645 |   const readable = toReadable(605);
3646 | 
3647 |   assert.equal(readable, 'six hundred five');
3648 | });
3649 | 
3650 | it.optional("Should return 'six hundred six' when 606 given", () => {
3651 |   const readable = toReadable(606);
3652 | 
3653 |   assert.equal(readable, 'six hundred six');
3654 | });
3655 | 
3656 | it.optional("Should return 'six hundred seven' when 607 given", () => {
3657 |   const readable = toReadable(607);
3658 | 
3659 |   assert.equal(readable, 'six hundred seven');
3660 | });
3661 | 
3662 | it.optional("Should return 'six hundred eight' when 608 given", () => {
3663 |   const readable = toReadable(608);
3664 | 
3665 |   assert.equal(readable, 'six hundred eight');
3666 | });
3667 | 
3668 | it.optional("Should return 'six hundred nine' when 609 given", () => {
3669 |   const readable = toReadable(609);
3670 | 
3671 |   assert.equal(readable, 'six hundred nine');
3672 | });
3673 | 
3674 | it.optional("Should return 'six hundred ten' when 610 given", () => {
3675 |   const readable = toReadable(610);
3676 | 
3677 |   assert.equal(readable, 'six hundred ten');
3678 | });
3679 | 
3680 | it.optional("Should return 'six hundred eleven' when 611 given", () => {
3681 |   const readable = toReadable(611);
3682 | 
3683 |   assert.equal(readable, 'six hundred eleven');
3684 | });
3685 | 
3686 | it.optional("Should return 'six hundred twelve' when 612 given", () => {
3687 |   const readable = toReadable(612);
3688 | 
3689 |   assert.equal(readable, 'six hundred twelve');
3690 | });
3691 | 
3692 | it.optional("Should return 'six hundred thirteen' when 613 given", () => {
3693 |   const readable = toReadable(613);
3694 | 
3695 |   assert.equal(readable, 'six hundred thirteen');
3696 | });
3697 | 
3698 | it.optional("Should return 'six hundred fourteen' when 614 given", () => {
3699 |   const readable = toReadable(614);
3700 | 
3701 |   assert.equal(readable, 'six hundred fourteen');
3702 | });
3703 | 
3704 | it.optional("Should return 'six hundred fifteen' when 615 given", () => {
3705 |   const readable = toReadable(615);
3706 | 
3707 |   assert.equal(readable, 'six hundred fifteen');
3708 | });
3709 | 
3710 | it.optional("Should return 'six hundred sixteen' when 616 given", () => {
3711 |   const readable = toReadable(616);
3712 | 
3713 |   assert.equal(readable, 'six hundred sixteen');
3714 | });
3715 | 
3716 | it.optional("Should return 'six hundred seventeen' when 617 given", () => {
3717 |   const readable = toReadable(617);
3718 | 
3719 |   assert.equal(readable, 'six hundred seventeen');
3720 | });
3721 | 
3722 | it.optional("Should return 'six hundred eighteen' when 618 given", () => {
3723 |   const readable = toReadable(618);
3724 | 
3725 |   assert.equal(readable, 'six hundred eighteen');
3726 | });
3727 | 
3728 | it.optional("Should return 'six hundred nineteen' when 619 given", () => {
3729 |   const readable = toReadable(619);
3730 | 
3731 |   assert.equal(readable, 'six hundred nineteen');
3732 | });
3733 | 
3734 | it.optional("Should return 'six hundred twenty' when 620 given", () => {
3735 |   const readable = toReadable(620);
3736 | 
3737 |   assert.equal(readable, 'six hundred twenty');
3738 | });
3739 | 
3740 | it.optional("Should return 'six hundred twenty one' when 621 given", () => {
3741 |   const readable = toReadable(621);
3742 | 
3743 |   assert.equal(readable, 'six hundred twenty one');
3744 | });
3745 | 
3746 | it.optional("Should return 'six hundred twenty two' when 622 given", () => {
3747 |   const readable = toReadable(622);
3748 | 
3749 |   assert.equal(readable, 'six hundred twenty two');
3750 | });
3751 | 
3752 | it.optional("Should return 'six hundred twenty three' when 623 given", () => {
3753 |   const readable = toReadable(623);
3754 | 
3755 |   assert.equal(readable, 'six hundred twenty three');
3756 | });
3757 | 
3758 | it.optional("Should return 'six hundred twenty four' when 624 given", () => {
3759 |   const readable = toReadable(624);
3760 | 
3761 |   assert.equal(readable, 'six hundred twenty four');
3762 | });
3763 | 
3764 | it.optional("Should return 'six hundred twenty five' when 625 given", () => {
3765 |   const readable = toReadable(625);
3766 | 
3767 |   assert.equal(readable, 'six hundred twenty five');
3768 | });
3769 | 
3770 | it.optional("Should return 'six hundred twenty six' when 626 given", () => {
3771 |   const readable = toReadable(626);
3772 | 
3773 |   assert.equal(readable, 'six hundred twenty six');
3774 | });
3775 | 
3776 | it.optional("Should return 'six hundred twenty seven' when 627 given", () => {
3777 |   const readable = toReadable(627);
3778 | 
3779 |   assert.equal(readable, 'six hundred twenty seven');
3780 | });
3781 | 
3782 | it.optional("Should return 'six hundred twenty eight' when 628 given", () => {
3783 |   const readable = toReadable(628);
3784 | 
3785 |   assert.equal(readable, 'six hundred twenty eight');
3786 | });
3787 | 
3788 | it.optional("Should return 'six hundred twenty nine' when 629 given", () => {
3789 |   const readable = toReadable(629);
3790 | 
3791 |   assert.equal(readable, 'six hundred twenty nine');
3792 | });
3793 | 
3794 | it.optional("Should return 'six hundred thirty' when 630 given", () => {
3795 |   const readable = toReadable(630);
3796 | 
3797 |   assert.equal(readable, 'six hundred thirty');
3798 | });
3799 | 
3800 | it.optional("Should return 'six hundred thirty one' when 631 given", () => {
3801 |   const readable = toReadable(631);
3802 | 
3803 |   assert.equal(readable, 'six hundred thirty one');
3804 | });
3805 | 
3806 | it.optional("Should return 'six hundred thirty two' when 632 given", () => {
3807 |   const readable = toReadable(632);
3808 | 
3809 |   assert.equal(readable, 'six hundred thirty two');
3810 | });
3811 | 
3812 | it.optional("Should return 'six hundred thirty three' when 633 given", () => {
3813 |   const readable = toReadable(633);
3814 | 
3815 |   assert.equal(readable, 'six hundred thirty three');
3816 | });
3817 | 
3818 | it.optional("Should return 'six hundred thirty four' when 634 given", () => {
3819 |   const readable = toReadable(634);
3820 | 
3821 |   assert.equal(readable, 'six hundred thirty four');
3822 | });
3823 | 
3824 | it.optional("Should return 'six hundred thirty five' when 635 given", () => {
3825 |   const readable = toReadable(635);
3826 | 
3827 |   assert.equal(readable, 'six hundred thirty five');
3828 | });
3829 | 
3830 | it.optional("Should return 'six hundred thirty six' when 636 given", () => {
3831 |   const readable = toReadable(636);
3832 | 
3833 |   assert.equal(readable, 'six hundred thirty six');
3834 | });
3835 | 
3836 | it.optional("Should return 'six hundred thirty seven' when 637 given", () => {
3837 |   const readable = toReadable(637);
3838 | 
3839 |   assert.equal(readable, 'six hundred thirty seven');
3840 | });
3841 | 
3842 | it.optional("Should return 'six hundred thirty eight' when 638 given", () => {
3843 |   const readable = toReadable(638);
3844 | 
3845 |   assert.equal(readable, 'six hundred thirty eight');
3846 | });
3847 | 
3848 | it.optional("Should return 'six hundred thirty nine' when 639 given", () => {
3849 |   const readable = toReadable(639);
3850 | 
3851 |   assert.equal(readable, 'six hundred thirty nine');
3852 | });
3853 | 
3854 | it.optional("Should return 'six hundred forty' when 640 given", () => {
3855 |   const readable = toReadable(640);
3856 | 
3857 |   assert.equal(readable, 'six hundred forty');
3858 | });
3859 | 
3860 | it.optional("Should return 'six hundred forty one' when 641 given", () => {
3861 |   const readable = toReadable(641);
3862 | 
3863 |   assert.equal(readable, 'six hundred forty one');
3864 | });
3865 | 
3866 | it.optional("Should return 'six hundred forty two' when 642 given", () => {
3867 |   const readable = toReadable(642);
3868 | 
3869 |   assert.equal(readable, 'six hundred forty two');
3870 | });
3871 | 
3872 | it.optional("Should return 'six hundred forty three' when 643 given", () => {
3873 |   const readable = toReadable(643);
3874 | 
3875 |   assert.equal(readable, 'six hundred forty three');
3876 | });
3877 | 
3878 | it.optional("Should return 'six hundred forty four' when 644 given", () => {
3879 |   const readable = toReadable(644);
3880 | 
3881 |   assert.equal(readable, 'six hundred forty four');
3882 | });
3883 | 
3884 | it.optional("Should return 'six hundred forty five' when 645 given", () => {
3885 |   const readable = toReadable(645);
3886 | 
3887 |   assert.equal(readable, 'six hundred forty five');
3888 | });
3889 | 
3890 | it.optional("Should return 'six hundred forty six' when 646 given", () => {
3891 |   const readable = toReadable(646);
3892 | 
3893 |   assert.equal(readable, 'six hundred forty six');
3894 | });
3895 | 
3896 | it.optional("Should return 'six hundred forty seven' when 647 given", () => {
3897 |   const readable = toReadable(647);
3898 | 
3899 |   assert.equal(readable, 'six hundred forty seven');
3900 | });
3901 | 
3902 | it.optional("Should return 'six hundred forty eight' when 648 given", () => {
3903 |   const readable = toReadable(648);
3904 | 
3905 |   assert.equal(readable, 'six hundred forty eight');
3906 | });
3907 | 
3908 | it.optional("Should return 'six hundred forty nine' when 649 given", () => {
3909 |   const readable = toReadable(649);
3910 | 
3911 |   assert.equal(readable, 'six hundred forty nine');
3912 | });
3913 | 
3914 | it.optional("Should return 'six hundred fifty' when 650 given", () => {
3915 |   const readable = toReadable(650);
3916 | 
3917 |   assert.equal(readable, 'six hundred fifty');
3918 | });
3919 | 
3920 | it.optional("Should return 'six hundred fifty one' when 651 given", () => {
3921 |   const readable = toReadable(651);
3922 | 
3923 |   assert.equal(readable, 'six hundred fifty one');
3924 | });
3925 | 
3926 | it.optional("Should return 'six hundred fifty two' when 652 given", () => {
3927 |   const readable = toReadable(652);
3928 | 
3929 |   assert.equal(readable, 'six hundred fifty two');
3930 | });
3931 | 
3932 | it.optional("Should return 'six hundred fifty three' when 653 given", () => {
3933 |   const readable = toReadable(653);
3934 | 
3935 |   assert.equal(readable, 'six hundred fifty three');
3936 | });
3937 | 
3938 | it.optional("Should return 'six hundred fifty four' when 654 given", () => {
3939 |   const readable = toReadable(654);
3940 | 
3941 |   assert.equal(readable, 'six hundred fifty four');
3942 | });
3943 | 
3944 | it.optional("Should return 'six hundred fifty five' when 655 given", () => {
3945 |   const readable = toReadable(655);
3946 | 
3947 |   assert.equal(readable, 'six hundred fifty five');
3948 | });
3949 | 
3950 | it.optional("Should return 'six hundred fifty six' when 656 given", () => {
3951 |   const readable = toReadable(656);
3952 | 
3953 |   assert.equal(readable, 'six hundred fifty six');
3954 | });
3955 | 
3956 | it.optional("Should return 'six hundred fifty seven' when 657 given", () => {
3957 |   const readable = toReadable(657);
3958 | 
3959 |   assert.equal(readable, 'six hundred fifty seven');
3960 | });
3961 | 
3962 | it.optional("Should return 'six hundred fifty eight' when 658 given", () => {
3963 |   const readable = toReadable(658);
3964 | 
3965 |   assert.equal(readable, 'six hundred fifty eight');
3966 | });
3967 | 
3968 | it.optional("Should return 'six hundred fifty nine' when 659 given", () => {
3969 |   const readable = toReadable(659);
3970 | 
3971 |   assert.equal(readable, 'six hundred fifty nine');
3972 | });
3973 | 
3974 | it.optional("Should return 'six hundred sixty' when 660 given", () => {
3975 |   const readable = toReadable(660);
3976 | 
3977 |   assert.equal(readable, 'six hundred sixty');
3978 | });
3979 | 
3980 | it.optional("Should return 'six hundred sixty one' when 661 given", () => {
3981 |   const readable = toReadable(661);
3982 | 
3983 |   assert.equal(readable, 'six hundred sixty one');
3984 | });
3985 | 
3986 | it.optional("Should return 'six hundred sixty two' when 662 given", () => {
3987 |   const readable = toReadable(662);
3988 | 
3989 |   assert.equal(readable, 'six hundred sixty two');
3990 | });
3991 | 
3992 | it.optional("Should return 'six hundred sixty three' when 663 given", () => {
3993 |   const readable = toReadable(663);
3994 | 
3995 |   assert.equal(readable, 'six hundred sixty three');
3996 | });
3997 | 
3998 | it.optional("Should return 'six hundred sixty four' when 664 given", () => {
3999 |   const readable = toReadable(664);
4000 | 
4001 |   assert.equal(readable, 'six hundred sixty four');
4002 | });
4003 | 
4004 | it.optional("Should return 'six hundred sixty five' when 665 given", () => {
4005 |   const readable = toReadable(665);
4006 | 
4007 |   assert.equal(readable, 'six hundred sixty five');
4008 | });
4009 | 
4010 | it.optional("Should return 'six hundred sixty six' when 666 given", () => {
4011 |   const readable = toReadable(666);
4012 | 
4013 |   assert.equal(readable, 'six hundred sixty six');
4014 | });
4015 | 
4016 | it.optional("Should return 'six hundred sixty seven' when 667 given", () => {
4017 |   const readable = toReadable(667);
4018 | 
4019 |   assert.equal(readable, 'six hundred sixty seven');
4020 | });
4021 | 
4022 | it.optional("Should return 'six hundred sixty eight' when 668 given", () => {
4023 |   const readable = toReadable(668);
4024 | 
4025 |   assert.equal(readable, 'six hundred sixty eight');
4026 | });
4027 | 
4028 | it.optional("Should return 'six hundred sixty nine' when 669 given", () => {
4029 |   const readable = toReadable(669);
4030 | 
4031 |   assert.equal(readable, 'six hundred sixty nine');
4032 | });
4033 | 
4034 | it.optional("Should return 'six hundred seventy' when 670 given", () => {
4035 |   const readable = toReadable(670);
4036 | 
4037 |   assert.equal(readable, 'six hundred seventy');
4038 | });
4039 | 
4040 | it.optional("Should return 'six hundred seventy one' when 671 given", () => {
4041 |   const readable = toReadable(671);
4042 | 
4043 |   assert.equal(readable, 'six hundred seventy one');
4044 | });
4045 | 
4046 | it.optional("Should return 'six hundred seventy two' when 672 given", () => {
4047 |   const readable = toReadable(672);
4048 | 
4049 |   assert.equal(readable, 'six hundred seventy two');
4050 | });
4051 | 
4052 | it.optional("Should return 'six hundred seventy three' when 673 given", () => {
4053 |   const readable = toReadable(673);
4054 | 
4055 |   assert.equal(readable, 'six hundred seventy three');
4056 | });
4057 | 
4058 | it.optional("Should return 'six hundred seventy four' when 674 given", () => {
4059 |   const readable = toReadable(674);
4060 | 
4061 |   assert.equal(readable, 'six hundred seventy four');
4062 | });
4063 | 
4064 | it.optional("Should return 'six hundred seventy five' when 675 given", () => {
4065 |   const readable = toReadable(675);
4066 | 
4067 |   assert.equal(readable, 'six hundred seventy five');
4068 | });
4069 | 
4070 | it.optional("Should return 'six hundred seventy six' when 676 given", () => {
4071 |   const readable = toReadable(676);
4072 | 
4073 |   assert.equal(readable, 'six hundred seventy six');
4074 | });
4075 | 
4076 | it.optional("Should return 'six hundred seventy seven' when 677 given", () => {
4077 |   const readable = toReadable(677);
4078 | 
4079 |   assert.equal(readable, 'six hundred seventy seven');
4080 | });
4081 | 
4082 | it.optional("Should return 'six hundred seventy eight' when 678 given", () => {
4083 |   const readable = toReadable(678);
4084 | 
4085 |   assert.equal(readable, 'six hundred seventy eight');
4086 | });
4087 | 
4088 | it.optional("Should return 'six hundred seventy nine' when 679 given", () => {
4089 |   const readable = toReadable(679);
4090 | 
4091 |   assert.equal(readable, 'six hundred seventy nine');
4092 | });
4093 | 
4094 | it.optional("Should return 'six hundred eighty' when 680 given", () => {
4095 |   const readable = toReadable(680);
4096 | 
4097 |   assert.equal(readable, 'six hundred eighty');
4098 | });
4099 | 
4100 | it.optional("Should return 'six hundred eighty one' when 681 given", () => {
4101 |   const readable = toReadable(681);
4102 | 
4103 |   assert.equal(readable, 'six hundred eighty one');
4104 | });
4105 | 
4106 | it.optional("Should return 'six hundred eighty two' when 682 given", () => {
4107 |   const readable = toReadable(682);
4108 | 
4109 |   assert.equal(readable, 'six hundred eighty two');
4110 | });
4111 | 
4112 | it.optional("Should return 'six hundred eighty three' when 683 given", () => {
4113 |   const readable = toReadable(683);
4114 | 
4115 |   assert.equal(readable, 'six hundred eighty three');
4116 | });
4117 | 
4118 | it.optional("Should return 'six hundred eighty four' when 684 given", () => {
4119 |   const readable = toReadable(684);
4120 | 
4121 |   assert.equal(readable, 'six hundred eighty four');
4122 | });
4123 | 
4124 | it.optional("Should return 'six hundred eighty five' when 685 given", () => {
4125 |   const readable = toReadable(685);
4126 | 
4127 |   assert.equal(readable, 'six hundred eighty five');
4128 | });
4129 | 
4130 | it.optional("Should return 'six hundred eighty six' when 686 given", () => {
4131 |   const readable = toReadable(686);
4132 | 
4133 |   assert.equal(readable, 'six hundred eighty six');
4134 | });
4135 | 
4136 | it.optional("Should return 'six hundred eighty seven' when 687 given", () => {
4137 |   const readable = toReadable(687);
4138 | 
4139 |   assert.equal(readable, 'six hundred eighty seven');
4140 | });
4141 | 
4142 | it.optional("Should return 'six hundred eighty eight' when 688 given", () => {
4143 |   const readable = toReadable(688);
4144 | 
4145 |   assert.equal(readable, 'six hundred eighty eight');
4146 | });
4147 | 
4148 | it.optional("Should return 'six hundred eighty nine' when 689 given", () => {
4149 |   const readable = toReadable(689);
4150 | 
4151 |   assert.equal(readable, 'six hundred eighty nine');
4152 | });
4153 | 
4154 | it.optional("Should return 'six hundred ninety' when 690 given", () => {
4155 |   const readable = toReadable(690);
4156 | 
4157 |   assert.equal(readable, 'six hundred ninety');
4158 | });
4159 | 
4160 | it.optional("Should return 'six hundred ninety one' when 691 given", () => {
4161 |   const readable = toReadable(691);
4162 | 
4163 |   assert.equal(readable, 'six hundred ninety one');
4164 | });
4165 | 
4166 | it.optional("Should return 'six hundred ninety two' when 692 given", () => {
4167 |   const readable = toReadable(692);
4168 | 
4169 |   assert.equal(readable, 'six hundred ninety two');
4170 | });
4171 | 
4172 | it.optional("Should return 'six hundred ninety three' when 693 given", () => {
4173 |   const readable = toReadable(693);
4174 | 
4175 |   assert.equal(readable, 'six hundred ninety three');
4176 | });
4177 | 
4178 | it.optional("Should return 'six hundred ninety four' when 694 given", () => {
4179 |   const readable = toReadable(694);
4180 | 
4181 |   assert.equal(readable, 'six hundred ninety four');
4182 | });
4183 | 
4184 | it.optional("Should return 'six hundred ninety five' when 695 given", () => {
4185 |   const readable = toReadable(695);
4186 | 
4187 |   assert.equal(readable, 'six hundred ninety five');
4188 | });
4189 | 
4190 | it.optional("Should return 'six hundred ninety six' when 696 given", () => {
4191 |   const readable = toReadable(696);
4192 | 
4193 |   assert.equal(readable, 'six hundred ninety six');
4194 | });
4195 | 
4196 | it.optional("Should return 'six hundred ninety seven' when 697 given", () => {
4197 |   const readable = toReadable(697);
4198 | 
4199 |   assert.equal(readable, 'six hundred ninety seven');
4200 | });
4201 | 
4202 | it.optional("Should return 'six hundred ninety eight' when 698 given", () => {
4203 |   const readable = toReadable(698);
4204 | 
4205 |   assert.equal(readable, 'six hundred ninety eight');
4206 | });
4207 | 
4208 | it.optional("Should return 'six hundred ninety nine' when 699 given", () => {
4209 |   const readable = toReadable(699);
4210 | 
4211 |   assert.equal(readable, 'six hundred ninety nine');
4212 | });
4213 | 
4214 | it.optional("Should return 'seven hundred' when 700 given", () => {
4215 |   const readable = toReadable(700);
4216 | 
4217 |   assert.equal(readable, 'seven hundred');
4218 | });
4219 | 
4220 | it.optional("Should return 'seven hundred one' when 701 given", () => {
4221 |   const readable = toReadable(701);
4222 | 
4223 |   assert.equal(readable, 'seven hundred one');
4224 | });
4225 | 
4226 | it.optional("Should return 'seven hundred two' when 702 given", () => {
4227 |   const readable = toReadable(702);
4228 | 
4229 |   assert.equal(readable, 'seven hundred two');
4230 | });
4231 | 
4232 | it.optional("Should return 'seven hundred three' when 703 given", () => {
4233 |   const readable = toReadable(703);
4234 | 
4235 |   assert.equal(readable, 'seven hundred three');
4236 | });
4237 | 
4238 | it.optional("Should return 'seven hundred four' when 704 given", () => {
4239 |   const readable = toReadable(704);
4240 | 
4241 |   assert.equal(readable, 'seven hundred four');
4242 | });
4243 | 
4244 | it.optional("Should return 'seven hundred five' when 705 given", () => {
4245 |   const readable = toReadable(705);
4246 | 
4247 |   assert.equal(readable, 'seven hundred five');
4248 | });
4249 | 
4250 | it.optional("Should return 'seven hundred six' when 706 given", () => {
4251 |   const readable = toReadable(706);
4252 | 
4253 |   assert.equal(readable, 'seven hundred six');
4254 | });
4255 | 
4256 | it.optional("Should return 'seven hundred seven' when 707 given", () => {
4257 |   const readable = toReadable(707);
4258 | 
4259 |   assert.equal(readable, 'seven hundred seven');
4260 | });
4261 | 
4262 | it.optional("Should return 'seven hundred eight' when 708 given", () => {
4263 |   const readable = toReadable(708);
4264 | 
4265 |   assert.equal(readable, 'seven hundred eight');
4266 | });
4267 | 
4268 | it.optional("Should return 'seven hundred nine' when 709 given", () => {
4269 |   const readable = toReadable(709);
4270 | 
4271 |   assert.equal(readable, 'seven hundred nine');
4272 | });
4273 | 
4274 | it.optional("Should return 'seven hundred ten' when 710 given", () => {
4275 |   const readable = toReadable(710);
4276 | 
4277 |   assert.equal(readable, 'seven hundred ten');
4278 | });
4279 | 
4280 | it.optional("Should return 'seven hundred eleven' when 711 given", () => {
4281 |   const readable = toReadable(711);
4282 | 
4283 |   assert.equal(readable, 'seven hundred eleven');
4284 | });
4285 | 
4286 | it.optional("Should return 'seven hundred twelve' when 712 given", () => {
4287 |   const readable = toReadable(712);
4288 | 
4289 |   assert.equal(readable, 'seven hundred twelve');
4290 | });
4291 | 
4292 | it.optional("Should return 'seven hundred thirteen' when 713 given", () => {
4293 |   const readable = toReadable(713);
4294 | 
4295 |   assert.equal(readable, 'seven hundred thirteen');
4296 | });
4297 | 
4298 | it.optional("Should return 'seven hundred fourteen' when 714 given", () => {
4299 |   const readable = toReadable(714);
4300 | 
4301 |   assert.equal(readable, 'seven hundred fourteen');
4302 | });
4303 | 
4304 | it.optional("Should return 'seven hundred fifteen' when 715 given", () => {
4305 |   const readable = toReadable(715);
4306 | 
4307 |   assert.equal(readable, 'seven hundred fifteen');
4308 | });
4309 | 
4310 | it.optional("Should return 'seven hundred sixteen' when 716 given", () => {
4311 |   const readable = toReadable(716);
4312 | 
4313 |   assert.equal(readable, 'seven hundred sixteen');
4314 | });
4315 | 
4316 | it.optional("Should return 'seven hundred seventeen' when 717 given", () => {
4317 |   const readable = toReadable(717);
4318 | 
4319 |   assert.equal(readable, 'seven hundred seventeen');
4320 | });
4321 | 
4322 | it.optional("Should return 'seven hundred eighteen' when 718 given", () => {
4323 |   const readable = toReadable(718);
4324 | 
4325 |   assert.equal(readable, 'seven hundred eighteen');
4326 | });
4327 | 
4328 | it.optional("Should return 'seven hundred nineteen' when 719 given", () => {
4329 |   const readable = toReadable(719);
4330 | 
4331 |   assert.equal(readable, 'seven hundred nineteen');
4332 | });
4333 | 
4334 | it.optional("Should return 'seven hundred twenty' when 720 given", () => {
4335 |   const readable = toReadable(720);
4336 | 
4337 |   assert.equal(readable, 'seven hundred twenty');
4338 | });
4339 | 
4340 | it.optional("Should return 'seven hundred twenty one' when 721 given", () => {
4341 |   const readable = toReadable(721);
4342 | 
4343 |   assert.equal(readable, 'seven hundred twenty one');
4344 | });
4345 | 
4346 | it.optional("Should return 'seven hundred twenty two' when 722 given", () => {
4347 |   const readable = toReadable(722);
4348 | 
4349 |   assert.equal(readable, 'seven hundred twenty two');
4350 | });
4351 | 
4352 | it.optional("Should return 'seven hundred twenty three' when 723 given", () => {
4353 |   const readable = toReadable(723);
4354 | 
4355 |   assert.equal(readable, 'seven hundred twenty three');
4356 | });
4357 | 
4358 | it.optional("Should return 'seven hundred twenty four' when 724 given", () => {
4359 |   const readable = toReadable(724);
4360 | 
4361 |   assert.equal(readable, 'seven hundred twenty four');
4362 | });
4363 | 
4364 | it.optional("Should return 'seven hundred twenty five' when 725 given", () => {
4365 |   const readable = toReadable(725);
4366 | 
4367 |   assert.equal(readable, 'seven hundred twenty five');
4368 | });
4369 | 
4370 | it.optional("Should return 'seven hundred twenty six' when 726 given", () => {
4371 |   const readable = toReadable(726);
4372 | 
4373 |   assert.equal(readable, 'seven hundred twenty six');
4374 | });
4375 | 
4376 | it.optional("Should return 'seven hundred twenty seven' when 727 given", () => {
4377 |   const readable = toReadable(727);
4378 | 
4379 |   assert.equal(readable, 'seven hundred twenty seven');
4380 | });
4381 | 
4382 | it.optional("Should return 'seven hundred twenty eight' when 728 given", () => {
4383 |   const readable = toReadable(728);
4384 | 
4385 |   assert.equal(readable, 'seven hundred twenty eight');
4386 | });
4387 | 
4388 | it.optional("Should return 'seven hundred twenty nine' when 729 given", () => {
4389 |   const readable = toReadable(729);
4390 | 
4391 |   assert.equal(readable, 'seven hundred twenty nine');
4392 | });
4393 | 
4394 | it.optional("Should return 'seven hundred thirty' when 730 given", () => {
4395 |   const readable = toReadable(730);
4396 | 
4397 |   assert.equal(readable, 'seven hundred thirty');
4398 | });
4399 | 
4400 | it.optional("Should return 'seven hundred thirty one' when 731 given", () => {
4401 |   const readable = toReadable(731);
4402 | 
4403 |   assert.equal(readable, 'seven hundred thirty one');
4404 | });
4405 | 
4406 | it.optional("Should return 'seven hundred thirty two' when 732 given", () => {
4407 |   const readable = toReadable(732);
4408 | 
4409 |   assert.equal(readable, 'seven hundred thirty two');
4410 | });
4411 | 
4412 | it.optional("Should return 'seven hundred thirty three' when 733 given", () => {
4413 |   const readable = toReadable(733);
4414 | 
4415 |   assert.equal(readable, 'seven hundred thirty three');
4416 | });
4417 | 
4418 | it.optional("Should return 'seven hundred thirty four' when 734 given", () => {
4419 |   const readable = toReadable(734);
4420 | 
4421 |   assert.equal(readable, 'seven hundred thirty four');
4422 | });
4423 | 
4424 | it.optional("Should return 'seven hundred thirty five' when 735 given", () => {
4425 |   const readable = toReadable(735);
4426 | 
4427 |   assert.equal(readable, 'seven hundred thirty five');
4428 | });
4429 | 
4430 | it.optional("Should return 'seven hundred thirty six' when 736 given", () => {
4431 |   const readable = toReadable(736);
4432 | 
4433 |   assert.equal(readable, 'seven hundred thirty six');
4434 | });
4435 | 
4436 | it.optional("Should return 'seven hundred thirty seven' when 737 given", () => {
4437 |   const readable = toReadable(737);
4438 | 
4439 |   assert.equal(readable, 'seven hundred thirty seven');
4440 | });
4441 | 
4442 | it.optional("Should return 'seven hundred thirty eight' when 738 given", () => {
4443 |   const readable = toReadable(738);
4444 | 
4445 |   assert.equal(readable, 'seven hundred thirty eight');
4446 | });
4447 | 
4448 | it.optional("Should return 'seven hundred thirty nine' when 739 given", () => {
4449 |   const readable = toReadable(739);
4450 | 
4451 |   assert.equal(readable, 'seven hundred thirty nine');
4452 | });
4453 | 
4454 | it.optional("Should return 'seven hundred forty' when 740 given", () => {
4455 |   const readable = toReadable(740);
4456 | 
4457 |   assert.equal(readable, 'seven hundred forty');
4458 | });
4459 | 
4460 | it.optional("Should return 'seven hundred forty one' when 741 given", () => {
4461 |   const readable = toReadable(741);
4462 | 
4463 |   assert.equal(readable, 'seven hundred forty one');
4464 | });
4465 | 
4466 | it.optional("Should return 'seven hundred forty two' when 742 given", () => {
4467 |   const readable = toReadable(742);
4468 | 
4469 |   assert.equal(readable, 'seven hundred forty two');
4470 | });
4471 | 
4472 | it.optional("Should return 'seven hundred forty three' when 743 given", () => {
4473 |   const readable = toReadable(743);
4474 | 
4475 |   assert.equal(readable, 'seven hundred forty three');
4476 | });
4477 | 
4478 | it.optional("Should return 'seven hundred forty four' when 744 given", () => {
4479 |   const readable = toReadable(744);
4480 | 
4481 |   assert.equal(readable, 'seven hundred forty four');
4482 | });
4483 | 
4484 | it.optional("Should return 'seven hundred forty five' when 745 given", () => {
4485 |   const readable = toReadable(745);
4486 | 
4487 |   assert.equal(readable, 'seven hundred forty five');
4488 | });
4489 | 
4490 | it.optional("Should return 'seven hundred forty six' when 746 given", () => {
4491 |   const readable = toReadable(746);
4492 | 
4493 |   assert.equal(readable, 'seven hundred forty six');
4494 | });
4495 | 
4496 | it.optional("Should return 'seven hundred forty seven' when 747 given", () => {
4497 |   const readable = toReadable(747);
4498 | 
4499 |   assert.equal(readable, 'seven hundred forty seven');
4500 | });
4501 | 
4502 | it.optional("Should return 'seven hundred forty eight' when 748 given", () => {
4503 |   const readable = toReadable(748);
4504 | 
4505 |   assert.equal(readable, 'seven hundred forty eight');
4506 | });
4507 | 
4508 | it.optional("Should return 'seven hundred forty nine' when 749 given", () => {
4509 |   const readable = toReadable(749);
4510 | 
4511 |   assert.equal(readable, 'seven hundred forty nine');
4512 | });
4513 | 
4514 | it.optional("Should return 'seven hundred fifty' when 750 given", () => {
4515 |   const readable = toReadable(750);
4516 | 
4517 |   assert.equal(readable, 'seven hundred fifty');
4518 | });
4519 | 
4520 | it.optional("Should return 'seven hundred fifty one' when 751 given", () => {
4521 |   const readable = toReadable(751);
4522 | 
4523 |   assert.equal(readable, 'seven hundred fifty one');
4524 | });
4525 | 
4526 | it.optional("Should return 'seven hundred fifty two' when 752 given", () => {
4527 |   const readable = toReadable(752);
4528 | 
4529 |   assert.equal(readable, 'seven hundred fifty two');
4530 | });
4531 | 
4532 | it.optional("Should return 'seven hundred fifty three' when 753 given", () => {
4533 |   const readable = toReadable(753);
4534 | 
4535 |   assert.equal(readable, 'seven hundred fifty three');
4536 | });
4537 | 
4538 | it.optional("Should return 'seven hundred fifty four' when 754 given", () => {
4539 |   const readable = toReadable(754);
4540 | 
4541 |   assert.equal(readable, 'seven hundred fifty four');
4542 | });
4543 | 
4544 | it.optional("Should return 'seven hundred fifty five' when 755 given", () => {
4545 |   const readable = toReadable(755);
4546 | 
4547 |   assert.equal(readable, 'seven hundred fifty five');
4548 | });
4549 | 
4550 | it.optional("Should return 'seven hundred fifty six' when 756 given", () => {
4551 |   const readable = toReadable(756);
4552 | 
4553 |   assert.equal(readable, 'seven hundred fifty six');
4554 | });
4555 | 
4556 | it.optional("Should return 'seven hundred fifty seven' when 757 given", () => {
4557 |   const readable = toReadable(757);
4558 | 
4559 |   assert.equal(readable, 'seven hundred fifty seven');
4560 | });
4561 | 
4562 | it.optional("Should return 'seven hundred fifty eight' when 758 given", () => {
4563 |   const readable = toReadable(758);
4564 | 
4565 |   assert.equal(readable, 'seven hundred fifty eight');
4566 | });
4567 | 
4568 | it.optional("Should return 'seven hundred fifty nine' when 759 given", () => {
4569 |   const readable = toReadable(759);
4570 | 
4571 |   assert.equal(readable, 'seven hundred fifty nine');
4572 | });
4573 | 
4574 | it.optional("Should return 'seven hundred sixty' when 760 given", () => {
4575 |   const readable = toReadable(760);
4576 | 
4577 |   assert.equal(readable, 'seven hundred sixty');
4578 | });
4579 | 
4580 | it.optional("Should return 'seven hundred sixty one' when 761 given", () => {
4581 |   const readable = toReadable(761);
4582 | 
4583 |   assert.equal(readable, 'seven hundred sixty one');
4584 | });
4585 | 
4586 | it.optional("Should return 'seven hundred sixty two' when 762 given", () => {
4587 |   const readable = toReadable(762);
4588 | 
4589 |   assert.equal(readable, 'seven hundred sixty two');
4590 | });
4591 | 
4592 | it.optional("Should return 'seven hundred sixty three' when 763 given", () => {
4593 |   const readable = toReadable(763);
4594 | 
4595 |   assert.equal(readable, 'seven hundred sixty three');
4596 | });
4597 | 
4598 | it.optional("Should return 'seven hundred sixty four' when 764 given", () => {
4599 |   const readable = toReadable(764);
4600 | 
4601 |   assert.equal(readable, 'seven hundred sixty four');
4602 | });
4603 | 
4604 | it.optional("Should return 'seven hundred sixty five' when 765 given", () => {
4605 |   const readable = toReadable(765);
4606 | 
4607 |   assert.equal(readable, 'seven hundred sixty five');
4608 | });
4609 | 
4610 | it.optional("Should return 'seven hundred sixty six' when 766 given", () => {
4611 |   const readable = toReadable(766);
4612 | 
4613 |   assert.equal(readable, 'seven hundred sixty six');
4614 | });
4615 | 
4616 | it.optional("Should return 'seven hundred sixty seven' when 767 given", () => {
4617 |   const readable = toReadable(767);
4618 | 
4619 |   assert.equal(readable, 'seven hundred sixty seven');
4620 | });
4621 | 
4622 | it.optional("Should return 'seven hundred sixty eight' when 768 given", () => {
4623 |   const readable = toReadable(768);
4624 | 
4625 |   assert.equal(readable, 'seven hundred sixty eight');
4626 | });
4627 | 
4628 | it.optional("Should return 'seven hundred sixty nine' when 769 given", () => {
4629 |   const readable = toReadable(769);
4630 | 
4631 |   assert.equal(readable, 'seven hundred sixty nine');
4632 | });
4633 | 
4634 | it.optional("Should return 'seven hundred seventy' when 770 given", () => {
4635 |   const readable = toReadable(770);
4636 | 
4637 |   assert.equal(readable, 'seven hundred seventy');
4638 | });
4639 | 
4640 | it.optional("Should return 'seven hundred seventy one' when 771 given", () => {
4641 |   const readable = toReadable(771);
4642 | 
4643 |   assert.equal(readable, 'seven hundred seventy one');
4644 | });
4645 | 
4646 | it.optional("Should return 'seven hundred seventy two' when 772 given", () => {
4647 |   const readable = toReadable(772);
4648 | 
4649 |   assert.equal(readable, 'seven hundred seventy two');
4650 | });
4651 | 
4652 | it.optional(
4653 |   "Should return 'seven hundred seventy three' when 773 given",
4654 |   () => {
4655 |     const readable = toReadable(773);
4656 | 
4657 |     assert.equal(readable, 'seven hundred seventy three');
4658 |   }
4659 | );
4660 | 
4661 | it.optional("Should return 'seven hundred seventy four' when 774 given", () => {
4662 |   const readable = toReadable(774);
4663 | 
4664 |   assert.equal(readable, 'seven hundred seventy four');
4665 | });
4666 | 
4667 | it.optional("Should return 'seven hundred seventy five' when 775 given", () => {
4668 |   const readable = toReadable(775);
4669 | 
4670 |   assert.equal(readable, 'seven hundred seventy five');
4671 | });
4672 | 
4673 | it.optional("Should return 'seven hundred seventy six' when 776 given", () => {
4674 |   const readable = toReadable(776);
4675 | 
4676 |   assert.equal(readable, 'seven hundred seventy six');
4677 | });
4678 | 
4679 | it.optional(
4680 |   "Should return 'seven hundred seventy seven' when 777 given",
4681 |   () => {
4682 |     const readable = toReadable(777);
4683 | 
4684 |     assert.equal(readable, 'seven hundred seventy seven');
4685 |   }
4686 | );
4687 | 
4688 | it.optional(
4689 |   "Should return 'seven hundred seventy eight' when 778 given",
4690 |   () => {
4691 |     const readable = toReadable(778);
4692 | 
4693 |     assert.equal(readable, 'seven hundred seventy eight');
4694 |   }
4695 | );
4696 | 
4697 | it.optional("Should return 'seven hundred seventy nine' when 779 given", () => {
4698 |   const readable = toReadable(779);
4699 | 
4700 |   assert.equal(readable, 'seven hundred seventy nine');
4701 | });
4702 | 
4703 | it.optional("Should return 'seven hundred eighty' when 780 given", () => {
4704 |   const readable = toReadable(780);
4705 | 
4706 |   assert.equal(readable, 'seven hundred eighty');
4707 | });
4708 | 
4709 | it.optional("Should return 'seven hundred eighty one' when 781 given", () => {
4710 |   const readable = toReadable(781);
4711 | 
4712 |   assert.equal(readable, 'seven hundred eighty one');
4713 | });
4714 | 
4715 | it.optional("Should return 'seven hundred eighty two' when 782 given", () => {
4716 |   const readable = toReadable(782);
4717 | 
4718 |   assert.equal(readable, 'seven hundred eighty two');
4719 | });
4720 | 
4721 | it.optional("Should return 'seven hundred eighty three' when 783 given", () => {
4722 |   const readable = toReadable(783);
4723 | 
4724 |   assert.equal(readable, 'seven hundred eighty three');
4725 | });
4726 | 
4727 | it.optional("Should return 'seven hundred eighty four' when 784 given", () => {
4728 |   const readable = toReadable(784);
4729 | 
4730 |   assert.equal(readable, 'seven hundred eighty four');
4731 | });
4732 | 
4733 | it.optional("Should return 'seven hundred eighty five' when 785 given", () => {
4734 |   const readable = toReadable(785);
4735 | 
4736 |   assert.equal(readable, 'seven hundred eighty five');
4737 | });
4738 | 
4739 | it.optional("Should return 'seven hundred eighty six' when 786 given", () => {
4740 |   const readable = toReadable(786);
4741 | 
4742 |   assert.equal(readable, 'seven hundred eighty six');
4743 | });
4744 | 
4745 | it.optional("Should return 'seven hundred eighty seven' when 787 given", () => {
4746 |   const readable = toReadable(787);
4747 | 
4748 |   assert.equal(readable, 'seven hundred eighty seven');
4749 | });
4750 | 
4751 | it.optional("Should return 'seven hundred eighty eight' when 788 given", () => {
4752 |   const readable = toReadable(788);
4753 | 
4754 |   assert.equal(readable, 'seven hundred eighty eight');
4755 | });
4756 | 
4757 | it.optional("Should return 'seven hundred eighty nine' when 789 given", () => {
4758 |   const readable = toReadable(789);
4759 | 
4760 |   assert.equal(readable, 'seven hundred eighty nine');
4761 | });
4762 | 
4763 | it.optional("Should return 'seven hundred ninety' when 790 given", () => {
4764 |   const readable = toReadable(790);
4765 | 
4766 |   assert.equal(readable, 'seven hundred ninety');
4767 | });
4768 | 
4769 | it.optional("Should return 'seven hundred ninety one' when 791 given", () => {
4770 |   const readable = toReadable(791);
4771 | 
4772 |   assert.equal(readable, 'seven hundred ninety one');
4773 | });
4774 | 
4775 | it.optional("Should return 'seven hundred ninety two' when 792 given", () => {
4776 |   const readable = toReadable(792);
4777 | 
4778 |   assert.equal(readable, 'seven hundred ninety two');
4779 | });
4780 | 
4781 | it.optional("Should return 'seven hundred ninety three' when 793 given", () => {
4782 |   const readable = toReadable(793);
4783 | 
4784 |   assert.equal(readable, 'seven hundred ninety three');
4785 | });
4786 | 
4787 | it.optional("Should return 'seven hundred ninety four' when 794 given", () => {
4788 |   const readable = toReadable(794);
4789 | 
4790 |   assert.equal(readable, 'seven hundred ninety four');
4791 | });
4792 | 
4793 | it.optional("Should return 'seven hundred ninety five' when 795 given", () => {
4794 |   const readable = toReadable(795);
4795 | 
4796 |   assert.equal(readable, 'seven hundred ninety five');
4797 | });
4798 | 
4799 | it.optional("Should return 'seven hundred ninety six' when 796 given", () => {
4800 |   const readable = toReadable(796);
4801 | 
4802 |   assert.equal(readable, 'seven hundred ninety six');
4803 | });
4804 | 
4805 | it.optional("Should return 'seven hundred ninety seven' when 797 given", () => {
4806 |   const readable = toReadable(797);
4807 | 
4808 |   assert.equal(readable, 'seven hundred ninety seven');
4809 | });
4810 | 
4811 | it.optional("Should return 'seven hundred ninety eight' when 798 given", () => {
4812 |   const readable = toReadable(798);
4813 | 
4814 |   assert.equal(readable, 'seven hundred ninety eight');
4815 | });
4816 | 
4817 | it.optional("Should return 'seven hundred ninety nine' when 799 given", () => {
4818 |   const readable = toReadable(799);
4819 | 
4820 |   assert.equal(readable, 'seven hundred ninety nine');
4821 | });
4822 | 
4823 | it.optional("Should return 'eight hundred' when 800 given", () => {
4824 |   const readable = toReadable(800);
4825 | 
4826 |   assert.equal(readable, 'eight hundred');
4827 | });
4828 | 
4829 | it.optional("Should return 'eight hundred one' when 801 given", () => {
4830 |   const readable = toReadable(801);
4831 | 
4832 |   assert.equal(readable, 'eight hundred one');
4833 | });
4834 | 
4835 | it.optional("Should return 'eight hundred two' when 802 given", () => {
4836 |   const readable = toReadable(802);
4837 | 
4838 |   assert.equal(readable, 'eight hundred two');
4839 | });
4840 | 
4841 | it.optional("Should return 'eight hundred three' when 803 given", () => {
4842 |   const readable = toReadable(803);
4843 | 
4844 |   assert.equal(readable, 'eight hundred three');
4845 | });
4846 | 
4847 | it.optional("Should return 'eight hundred four' when 804 given", () => {
4848 |   const readable = toReadable(804);
4849 | 
4850 |   assert.equal(readable, 'eight hundred four');
4851 | });
4852 | 
4853 | it.optional("Should return 'eight hundred five' when 805 given", () => {
4854 |   const readable = toReadable(805);
4855 | 
4856 |   assert.equal(readable, 'eight hundred five');
4857 | });
4858 | 
4859 | it.optional("Should return 'eight hundred six' when 806 given", () => {
4860 |   const readable = toReadable(806);
4861 | 
4862 |   assert.equal(readable, 'eight hundred six');
4863 | });
4864 | 
4865 | it.optional("Should return 'eight hundred seven' when 807 given", () => {
4866 |   const readable = toReadable(807);
4867 | 
4868 |   assert.equal(readable, 'eight hundred seven');
4869 | });
4870 | 
4871 | it.optional("Should return 'eight hundred eight' when 808 given", () => {
4872 |   const readable = toReadable(808);
4873 | 
4874 |   assert.equal(readable, 'eight hundred eight');
4875 | });
4876 | 
4877 | it.optional("Should return 'eight hundred nine' when 809 given", () => {
4878 |   const readable = toReadable(809);
4879 | 
4880 |   assert.equal(readable, 'eight hundred nine');
4881 | });
4882 | 
4883 | it.optional("Should return 'eight hundred ten' when 810 given", () => {
4884 |   const readable = toReadable(810);
4885 | 
4886 |   assert.equal(readable, 'eight hundred ten');
4887 | });
4888 | 
4889 | it.optional("Should return 'eight hundred eleven' when 811 given", () => {
4890 |   const readable = toReadable(811);
4891 | 
4892 |   assert.equal(readable, 'eight hundred eleven');
4893 | });
4894 | 
4895 | it.optional("Should return 'eight hundred twelve' when 812 given", () => {
4896 |   const readable = toReadable(812);
4897 | 
4898 |   assert.equal(readable, 'eight hundred twelve');
4899 | });
4900 | 
4901 | it.optional("Should return 'eight hundred thirteen' when 813 given", () => {
4902 |   const readable = toReadable(813);
4903 | 
4904 |   assert.equal(readable, 'eight hundred thirteen');
4905 | });
4906 | 
4907 | it.optional("Should return 'eight hundred fourteen' when 814 given", () => {
4908 |   const readable = toReadable(814);
4909 | 
4910 |   assert.equal(readable, 'eight hundred fourteen');
4911 | });
4912 | 
4913 | it.optional("Should return 'eight hundred fifteen' when 815 given", () => {
4914 |   const readable = toReadable(815);
4915 | 
4916 |   assert.equal(readable, 'eight hundred fifteen');
4917 | });
4918 | 
4919 | it.optional("Should return 'eight hundred sixteen' when 816 given", () => {
4920 |   const readable = toReadable(816);
4921 | 
4922 |   assert.equal(readable, 'eight hundred sixteen');
4923 | });
4924 | 
4925 | it.optional("Should return 'eight hundred seventeen' when 817 given", () => {
4926 |   const readable = toReadable(817);
4927 | 
4928 |   assert.equal(readable, 'eight hundred seventeen');
4929 | });
4930 | 
4931 | it.optional("Should return 'eight hundred eighteen' when 818 given", () => {
4932 |   const readable = toReadable(818);
4933 | 
4934 |   assert.equal(readable, 'eight hundred eighteen');
4935 | });
4936 | 
4937 | it.optional("Should return 'eight hundred nineteen' when 819 given", () => {
4938 |   const readable = toReadable(819);
4939 | 
4940 |   assert.equal(readable, 'eight hundred nineteen');
4941 | });
4942 | 
4943 | it.optional("Should return 'eight hundred twenty' when 820 given", () => {
4944 |   const readable = toReadable(820);
4945 | 
4946 |   assert.equal(readable, 'eight hundred twenty');
4947 | });
4948 | 
4949 | it.optional("Should return 'eight hundred twenty one' when 821 given", () => {
4950 |   const readable = toReadable(821);
4951 | 
4952 |   assert.equal(readable, 'eight hundred twenty one');
4953 | });
4954 | 
4955 | it.optional("Should return 'eight hundred twenty two' when 822 given", () => {
4956 |   const readable = toReadable(822);
4957 | 
4958 |   assert.equal(readable, 'eight hundred twenty two');
4959 | });
4960 | 
4961 | it.optional("Should return 'eight hundred twenty three' when 823 given", () => {
4962 |   const readable = toReadable(823);
4963 | 
4964 |   assert.equal(readable, 'eight hundred twenty three');
4965 | });
4966 | 
4967 | it.optional("Should return 'eight hundred twenty four' when 824 given", () => {
4968 |   const readable = toReadable(824);
4969 | 
4970 |   assert.equal(readable, 'eight hundred twenty four');
4971 | });
4972 | 
4973 | it.optional("Should return 'eight hundred twenty five' when 825 given", () => {
4974 |   const readable = toReadable(825);
4975 | 
4976 |   assert.equal(readable, 'eight hundred twenty five');
4977 | });
4978 | 
4979 | it.optional("Should return 'eight hundred twenty six' when 826 given", () => {
4980 |   const readable = toReadable(826);
4981 | 
4982 |   assert.equal(readable, 'eight hundred twenty six');
4983 | });
4984 | 
4985 | it.optional("Should return 'eight hundred twenty seven' when 827 given", () => {
4986 |   const readable = toReadable(827);
4987 | 
4988 |   assert.equal(readable, 'eight hundred twenty seven');
4989 | });
4990 | 
4991 | it.optional("Should return 'eight hundred twenty eight' when 828 given", () => {
4992 |   const readable = toReadable(828);
4993 | 
4994 |   assert.equal(readable, 'eight hundred twenty eight');
4995 | });
4996 | 
4997 | it.optional("Should return 'eight hundred twenty nine' when 829 given", () => {
4998 |   const readable = toReadable(829);
4999 | 
5000 |   assert.equal(readable, 'eight hundred twenty nine');
5001 | });
5002 | 
5003 | it.optional("Should return 'eight hundred thirty' when 830 given", () => {
5004 |   const readable = toReadable(830);
5005 | 
5006 |   assert.equal(readable, 'eight hundred thirty');
5007 | });
5008 | 
5009 | it.optional("Should return 'eight hundred thirty one' when 831 given", () => {
5010 |   const readable = toReadable(831);
5011 | 
5012 |   assert.equal(readable, 'eight hundred thirty one');
5013 | });
5014 | 
5015 | it.optional("Should return 'eight hundred thirty two' when 832 given", () => {
5016 |   const readable = toReadable(832);
5017 | 
5018 |   assert.equal(readable, 'eight hundred thirty two');
5019 | });
5020 | 
5021 | it.optional("Should return 'eight hundred thirty three' when 833 given", () => {
5022 |   const readable = toReadable(833);
5023 | 
5024 |   assert.equal(readable, 'eight hundred thirty three');
5025 | });
5026 | 
5027 | it.optional("Should return 'eight hundred thirty four' when 834 given", () => {
5028 |   const readable = toReadable(834);
5029 | 
5030 |   assert.equal(readable, 'eight hundred thirty four');
5031 | });
5032 | 
5033 | it.optional("Should return 'eight hundred thirty five' when 835 given", () => {
5034 |   const readable = toReadable(835);
5035 | 
5036 |   assert.equal(readable, 'eight hundred thirty five');
5037 | });
5038 | 
5039 | it.optional("Should return 'eight hundred thirty six' when 836 given", () => {
5040 |   const readable = toReadable(836);
5041 | 
5042 |   assert.equal(readable, 'eight hundred thirty six');
5043 | });
5044 | 
5045 | it.optional("Should return 'eight hundred thirty seven' when 837 given", () => {
5046 |   const readable = toReadable(837);
5047 | 
5048 |   assert.equal(readable, 'eight hundred thirty seven');
5049 | });
5050 | 
5051 | it.optional("Should return 'eight hundred thirty eight' when 838 given", () => {
5052 |   const readable = toReadable(838);
5053 | 
5054 |   assert.equal(readable, 'eight hundred thirty eight');
5055 | });
5056 | 
5057 | it.optional("Should return 'eight hundred thirty nine' when 839 given", () => {
5058 |   const readable = toReadable(839);
5059 | 
5060 |   assert.equal(readable, 'eight hundred thirty nine');
5061 | });
5062 | 
5063 | it.optional("Should return 'eight hundred forty' when 840 given", () => {
5064 |   const readable = toReadable(840);
5065 | 
5066 |   assert.equal(readable, 'eight hundred forty');
5067 | });
5068 | 
5069 | it.optional("Should return 'eight hundred forty one' when 841 given", () => {
5070 |   const readable = toReadable(841);
5071 | 
5072 |   assert.equal(readable, 'eight hundred forty one');
5073 | });
5074 | 
5075 | it.optional("Should return 'eight hundred forty two' when 842 given", () => {
5076 |   const readable = toReadable(842);
5077 | 
5078 |   assert.equal(readable, 'eight hundred forty two');
5079 | });
5080 | 
5081 | it.optional("Should return 'eight hundred forty three' when 843 given", () => {
5082 |   const readable = toReadable(843);
5083 | 
5084 |   assert.equal(readable, 'eight hundred forty three');
5085 | });
5086 | 
5087 | it.optional("Should return 'eight hundred forty four' when 844 given", () => {
5088 |   const readable = toReadable(844);
5089 | 
5090 |   assert.equal(readable, 'eight hundred forty four');
5091 | });
5092 | 
5093 | it.optional("Should return 'eight hundred forty five' when 845 given", () => {
5094 |   const readable = toReadable(845);
5095 | 
5096 |   assert.equal(readable, 'eight hundred forty five');
5097 | });
5098 | 
5099 | it.optional("Should return 'eight hundred forty six' when 846 given", () => {
5100 |   const readable = toReadable(846);
5101 | 
5102 |   assert.equal(readable, 'eight hundred forty six');
5103 | });
5104 | 
5105 | it.optional("Should return 'eight hundred forty seven' when 847 given", () => {
5106 |   const readable = toReadable(847);
5107 | 
5108 |   assert.equal(readable, 'eight hundred forty seven');
5109 | });
5110 | 
5111 | it.optional("Should return 'eight hundred forty eight' when 848 given", () => {
5112 |   const readable = toReadable(848);
5113 | 
5114 |   assert.equal(readable, 'eight hundred forty eight');
5115 | });
5116 | 
5117 | it.optional("Should return 'eight hundred forty nine' when 849 given", () => {
5118 |   const readable = toReadable(849);
5119 | 
5120 |   assert.equal(readable, 'eight hundred forty nine');
5121 | });
5122 | 
5123 | it.optional("Should return 'eight hundred fifty' when 850 given", () => {
5124 |   const readable = toReadable(850);
5125 | 
5126 |   assert.equal(readable, 'eight hundred fifty');
5127 | });
5128 | 
5129 | it.optional("Should return 'eight hundred fifty one' when 851 given", () => {
5130 |   const readable = toReadable(851);
5131 | 
5132 |   assert.equal(readable, 'eight hundred fifty one');
5133 | });
5134 | 
5135 | it.optional("Should return 'eight hundred fifty two' when 852 given", () => {
5136 |   const readable = toReadable(852);
5137 | 
5138 |   assert.equal(readable, 'eight hundred fifty two');
5139 | });
5140 | 
5141 | it.optional("Should return 'eight hundred fifty three' when 853 given", () => {
5142 |   const readable = toReadable(853);
5143 | 
5144 |   assert.equal(readable, 'eight hundred fifty three');
5145 | });
5146 | 
5147 | it.optional("Should return 'eight hundred fifty four' when 854 given", () => {
5148 |   const readable = toReadable(854);
5149 | 
5150 |   assert.equal(readable, 'eight hundred fifty four');
5151 | });
5152 | 
5153 | it.optional("Should return 'eight hundred fifty five' when 855 given", () => {
5154 |   const readable = toReadable(855);
5155 | 
5156 |   assert.equal(readable, 'eight hundred fifty five');
5157 | });
5158 | 
5159 | it.optional("Should return 'eight hundred fifty six' when 856 given", () => {
5160 |   const readable = toReadable(856);
5161 | 
5162 |   assert.equal(readable, 'eight hundred fifty six');
5163 | });
5164 | 
5165 | it.optional("Should return 'eight hundred fifty seven' when 857 given", () => {
5166 |   const readable = toReadable(857);
5167 | 
5168 |   assert.equal(readable, 'eight hundred fifty seven');
5169 | });
5170 | 
5171 | it.optional("Should return 'eight hundred fifty eight' when 858 given", () => {
5172 |   const readable = toReadable(858);
5173 | 
5174 |   assert.equal(readable, 'eight hundred fifty eight');
5175 | });
5176 | 
5177 | it.optional("Should return 'eight hundred fifty nine' when 859 given", () => {
5178 |   const readable = toReadable(859);
5179 | 
5180 |   assert.equal(readable, 'eight hundred fifty nine');
5181 | });
5182 | 
5183 | it.optional("Should return 'eight hundred sixty' when 860 given", () => {
5184 |   const readable = toReadable(860);
5185 | 
5186 |   assert.equal(readable, 'eight hundred sixty');
5187 | });
5188 | 
5189 | it.optional("Should return 'eight hundred sixty one' when 861 given", () => {
5190 |   const readable = toReadable(861);
5191 | 
5192 |   assert.equal(readable, 'eight hundred sixty one');
5193 | });
5194 | 
5195 | it.optional("Should return 'eight hundred sixty two' when 862 given", () => {
5196 |   const readable = toReadable(862);
5197 | 
5198 |   assert.equal(readable, 'eight hundred sixty two');
5199 | });
5200 | 
5201 | it.optional("Should return 'eight hundred sixty three' when 863 given", () => {
5202 |   const readable = toReadable(863);
5203 | 
5204 |   assert.equal(readable, 'eight hundred sixty three');
5205 | });
5206 | 
5207 | it.optional("Should return 'eight hundred sixty four' when 864 given", () => {
5208 |   const readable = toReadable(864);
5209 | 
5210 |   assert.equal(readable, 'eight hundred sixty four');
5211 | });
5212 | 
5213 | it.optional("Should return 'eight hundred sixty five' when 865 given", () => {
5214 |   const readable = toReadable(865);
5215 | 
5216 |   assert.equal(readable, 'eight hundred sixty five');
5217 | });
5218 | 
5219 | it.optional("Should return 'eight hundred sixty six' when 866 given", () => {
5220 |   const readable = toReadable(866);
5221 | 
5222 |   assert.equal(readable, 'eight hundred sixty six');
5223 | });
5224 | 
5225 | it.optional("Should return 'eight hundred sixty seven' when 867 given", () => {
5226 |   const readable = toReadable(867);
5227 | 
5228 |   assert.equal(readable, 'eight hundred sixty seven');
5229 | });
5230 | 
5231 | it.optional("Should return 'eight hundred sixty eight' when 868 given", () => {
5232 |   const readable = toReadable(868);
5233 | 
5234 |   assert.equal(readable, 'eight hundred sixty eight');
5235 | });
5236 | 
5237 | it.optional("Should return 'eight hundred sixty nine' when 869 given", () => {
5238 |   const readable = toReadable(869);
5239 | 
5240 |   assert.equal(readable, 'eight hundred sixty nine');
5241 | });
5242 | 
5243 | it.optional("Should return 'eight hundred seventy' when 870 given", () => {
5244 |   const readable = toReadable(870);
5245 | 
5246 |   assert.equal(readable, 'eight hundred seventy');
5247 | });
5248 | 
5249 | it.optional("Should return 'eight hundred seventy one' when 871 given", () => {
5250 |   const readable = toReadable(871);
5251 | 
5252 |   assert.equal(readable, 'eight hundred seventy one');
5253 | });
5254 | 
5255 | it.optional("Should return 'eight hundred seventy two' when 872 given", () => {
5256 |   const readable = toReadable(872);
5257 | 
5258 |   assert.equal(readable, 'eight hundred seventy two');
5259 | });
5260 | 
5261 | it.optional(
5262 |   "Should return 'eight hundred seventy three' when 873 given",
5263 |   () => {
5264 |     const readable = toReadable(873);
5265 | 
5266 |     assert.equal(readable, 'eight hundred seventy three');
5267 |   }
5268 | );
5269 | 
5270 | it.optional("Should return 'eight hundred seventy four' when 874 given", () => {
5271 |   const readable = toReadable(874);
5272 | 
5273 |   assert.equal(readable, 'eight hundred seventy four');
5274 | });
5275 | 
5276 | it.optional("Should return 'eight hundred seventy five' when 875 given", () => {
5277 |   const readable = toReadable(875);
5278 | 
5279 |   assert.equal(readable, 'eight hundred seventy five');
5280 | });
5281 | 
5282 | it.optional("Should return 'eight hundred seventy six' when 876 given", () => {
5283 |   const readable = toReadable(876);
5284 | 
5285 |   assert.equal(readable, 'eight hundred seventy six');
5286 | });
5287 | 
5288 | it.optional(
5289 |   "Should return 'eight hundred seventy seven' when 877 given",
5290 |   () => {
5291 |     const readable = toReadable(877);
5292 | 
5293 |     assert.equal(readable, 'eight hundred seventy seven');
5294 |   }
5295 | );
5296 | 
5297 | it.optional(
5298 |   "Should return 'eight hundred seventy eight' when 878 given",
5299 |   () => {
5300 |     const readable = toReadable(878);
5301 | 
5302 |     assert.equal(readable, 'eight hundred seventy eight');
5303 |   }
5304 | );
5305 | 
5306 | it.optional("Should return 'eight hundred seventy nine' when 879 given", () => {
5307 |   const readable = toReadable(879);
5308 | 
5309 |   assert.equal(readable, 'eight hundred seventy nine');
5310 | });
5311 | 
5312 | it.optional("Should return 'eight hundred eighty' when 880 given", () => {
5313 |   const readable = toReadable(880);
5314 | 
5315 |   assert.equal(readable, 'eight hundred eighty');
5316 | });
5317 | 
5318 | it.optional("Should return 'eight hundred eighty one' when 881 given", () => {
5319 |   const readable = toReadable(881);
5320 | 
5321 |   assert.equal(readable, 'eight hundred eighty one');
5322 | });
5323 | 
5324 | it.optional("Should return 'eight hundred eighty two' when 882 given", () => {
5325 |   const readable = toReadable(882);
5326 | 
5327 |   assert.equal(readable, 'eight hundred eighty two');
5328 | });
5329 | 
5330 | it.optional("Should return 'eight hundred eighty three' when 883 given", () => {
5331 |   const readable = toReadable(883);
5332 | 
5333 |   assert.equal(readable, 'eight hundred eighty three');
5334 | });
5335 | 
5336 | it.optional("Should return 'eight hundred eighty four' when 884 given", () => {
5337 |   const readable = toReadable(884);
5338 | 
5339 |   assert.equal(readable, 'eight hundred eighty four');
5340 | });
5341 | 
5342 | it.optional("Should return 'eight hundred eighty five' when 885 given", () => {
5343 |   const readable = toReadable(885);
5344 | 
5345 |   assert.equal(readable, 'eight hundred eighty five');
5346 | });
5347 | 
5348 | it.optional("Should return 'eight hundred eighty six' when 886 given", () => {
5349 |   const readable = toReadable(886);
5350 | 
5351 |   assert.equal(readable, 'eight hundred eighty six');
5352 | });
5353 | 
5354 | it.optional("Should return 'eight hundred eighty seven' when 887 given", () => {
5355 |   const readable = toReadable(887);
5356 | 
5357 |   assert.equal(readable, 'eight hundred eighty seven');
5358 | });
5359 | 
5360 | it.optional("Should return 'eight hundred eighty eight' when 888 given", () => {
5361 |   const readable = toReadable(888);
5362 | 
5363 |   assert.equal(readable, 'eight hundred eighty eight');
5364 | });
5365 | 
5366 | it.optional("Should return 'eight hundred eighty nine' when 889 given", () => {
5367 |   const readable = toReadable(889);
5368 | 
5369 |   assert.equal(readable, 'eight hundred eighty nine');
5370 | });
5371 | 
5372 | it.optional("Should return 'eight hundred ninety' when 890 given", () => {
5373 |   const readable = toReadable(890);
5374 | 
5375 |   assert.equal(readable, 'eight hundred ninety');
5376 | });
5377 | 
5378 | it.optional("Should return 'eight hundred ninety one' when 891 given", () => {
5379 |   const readable = toReadable(891);
5380 | 
5381 |   assert.equal(readable, 'eight hundred ninety one');
5382 | });
5383 | 
5384 | it.optional("Should return 'eight hundred ninety two' when 892 given", () => {
5385 |   const readable = toReadable(892);
5386 | 
5387 |   assert.equal(readable, 'eight hundred ninety two');
5388 | });
5389 | 
5390 | it.optional("Should return 'eight hundred ninety three' when 893 given", () => {
5391 |   const readable = toReadable(893);
5392 | 
5393 |   assert.equal(readable, 'eight hundred ninety three');
5394 | });
5395 | 
5396 | it.optional("Should return 'eight hundred ninety four' when 894 given", () => {
5397 |   const readable = toReadable(894);
5398 | 
5399 |   assert.equal(readable, 'eight hundred ninety four');
5400 | });
5401 | 
5402 | it.optional("Should return 'eight hundred ninety five' when 895 given", () => {
5403 |   const readable = toReadable(895);
5404 | 
5405 |   assert.equal(readable, 'eight hundred ninety five');
5406 | });
5407 | 
5408 | it.optional("Should return 'eight hundred ninety six' when 896 given", () => {
5409 |   const readable = toReadable(896);
5410 | 
5411 |   assert.equal(readable, 'eight hundred ninety six');
5412 | });
5413 | 
5414 | it.optional("Should return 'eight hundred ninety seven' when 897 given", () => {
5415 |   const readable = toReadable(897);
5416 | 
5417 |   assert.equal(readable, 'eight hundred ninety seven');
5418 | });
5419 | 
5420 | it.optional("Should return 'eight hundred ninety eight' when 898 given", () => {
5421 |   const readable = toReadable(898);
5422 | 
5423 |   assert.equal(readable, 'eight hundred ninety eight');
5424 | });
5425 | 
5426 | it.optional("Should return 'eight hundred ninety nine' when 899 given", () => {
5427 |   const readable = toReadable(899);
5428 | 
5429 |   assert.equal(readable, 'eight hundred ninety nine');
5430 | });
5431 | 
5432 | it.optional("Should return 'nine hundred' when 900 given", () => {
5433 |   const readable = toReadable(900);
5434 | 
5435 |   assert.equal(readable, 'nine hundred');
5436 | });
5437 | 
5438 | it.optional("Should return 'nine hundred one' when 901 given", () => {
5439 |   const readable = toReadable(901);
5440 | 
5441 |   assert.equal(readable, 'nine hundred one');
5442 | });
5443 | 
5444 | it.optional("Should return 'nine hundred two' when 902 given", () => {
5445 |   const readable = toReadable(902);
5446 | 
5447 |   assert.equal(readable, 'nine hundred two');
5448 | });
5449 | 
5450 | it.optional("Should return 'nine hundred three' when 903 given", () => {
5451 |   const readable = toReadable(903);
5452 | 
5453 |   assert.equal(readable, 'nine hundred three');
5454 | });
5455 | 
5456 | it.optional("Should return 'nine hundred four' when 904 given", () => {
5457 |   const readable = toReadable(904);
5458 | 
5459 |   assert.equal(readable, 'nine hundred four');
5460 | });
5461 | 
5462 | it.optional("Should return 'nine hundred five' when 905 given", () => {
5463 |   const readable = toReadable(905);
5464 | 
5465 |   assert.equal(readable, 'nine hundred five');
5466 | });
5467 | 
5468 | it.optional("Should return 'nine hundred six' when 906 given", () => {
5469 |   const readable = toReadable(906);
5470 | 
5471 |   assert.equal(readable, 'nine hundred six');
5472 | });
5473 | 
5474 | it.optional("Should return 'nine hundred seven' when 907 given", () => {
5475 |   const readable = toReadable(907);
5476 | 
5477 |   assert.equal(readable, 'nine hundred seven');
5478 | });
5479 | 
5480 | it.optional("Should return 'nine hundred eight' when 908 given", () => {
5481 |   const readable = toReadable(908);
5482 | 
5483 |   assert.equal(readable, 'nine hundred eight');
5484 | });
5485 | 
5486 | it.optional("Should return 'nine hundred nine' when 909 given", () => {
5487 |   const readable = toReadable(909);
5488 | 
5489 |   assert.equal(readable, 'nine hundred nine');
5490 | });
5491 | 
5492 | it.optional("Should return 'nine hundred ten' when 910 given", () => {
5493 |   const readable = toReadable(910);
5494 | 
5495 |   assert.equal(readable, 'nine hundred ten');
5496 | });
5497 | 
5498 | it.optional("Should return 'nine hundred eleven' when 911 given", () => {
5499 |   const readable = toReadable(911);
5500 | 
5501 |   assert.equal(readable, 'nine hundred eleven');
5502 | });
5503 | 
5504 | it.optional("Should return 'nine hundred twelve' when 912 given", () => {
5505 |   const readable = toReadable(912);
5506 | 
5507 |   assert.equal(readable, 'nine hundred twelve');
5508 | });
5509 | 
5510 | it.optional("Should return 'nine hundred thirteen' when 913 given", () => {
5511 |   const readable = toReadable(913);
5512 | 
5513 |   assert.equal(readable, 'nine hundred thirteen');
5514 | });
5515 | 
5516 | it.optional("Should return 'nine hundred fourteen' when 914 given", () => {
5517 |   const readable = toReadable(914);
5518 | 
5519 |   assert.equal(readable, 'nine hundred fourteen');
5520 | });
5521 | 
5522 | it.optional("Should return 'nine hundred fifteen' when 915 given", () => {
5523 |   const readable = toReadable(915);
5524 | 
5525 |   assert.equal(readable, 'nine hundred fifteen');
5526 | });
5527 | 
5528 | it.optional("Should return 'nine hundred sixteen' when 916 given", () => {
5529 |   const readable = toReadable(916);
5530 | 
5531 |   assert.equal(readable, 'nine hundred sixteen');
5532 | });
5533 | 
5534 | it.optional("Should return 'nine hundred seventeen' when 917 given", () => {
5535 |   const readable = toReadable(917);
5536 | 
5537 |   assert.equal(readable, 'nine hundred seventeen');
5538 | });
5539 | 
5540 | it.optional("Should return 'nine hundred eighteen' when 918 given", () => {
5541 |   const readable = toReadable(918);
5542 | 
5543 |   assert.equal(readable, 'nine hundred eighteen');
5544 | });
5545 | 
5546 | it.optional("Should return 'nine hundred nineteen' when 919 given", () => {
5547 |   const readable = toReadable(919);
5548 | 
5549 |   assert.equal(readable, 'nine hundred nineteen');
5550 | });
5551 | 
5552 | it.optional("Should return 'nine hundred twenty' when 920 given", () => {
5553 |   const readable = toReadable(920);
5554 | 
5555 |   assert.equal(readable, 'nine hundred twenty');
5556 | });
5557 | 
5558 | it.optional("Should return 'nine hundred twenty one' when 921 given", () => {
5559 |   const readable = toReadable(921);
5560 | 
5561 |   assert.equal(readable, 'nine hundred twenty one');
5562 | });
5563 | 
5564 | it.optional("Should return 'nine hundred twenty two' when 922 given", () => {
5565 |   const readable = toReadable(922);
5566 | 
5567 |   assert.equal(readable, 'nine hundred twenty two');
5568 | });
5569 | 
5570 | it.optional("Should return 'nine hundred twenty three' when 923 given", () => {
5571 |   const readable = toReadable(923);
5572 | 
5573 |   assert.equal(readable, 'nine hundred twenty three');
5574 | });
5575 | 
5576 | it.optional("Should return 'nine hundred twenty four' when 924 given", () => {
5577 |   const readable = toReadable(924);
5578 | 
5579 |   assert.equal(readable, 'nine hundred twenty four');
5580 | });
5581 | 
5582 | it.optional("Should return 'nine hundred twenty five' when 925 given", () => {
5583 |   const readable = toReadable(925);
5584 | 
5585 |   assert.equal(readable, 'nine hundred twenty five');
5586 | });
5587 | 
5588 | it.optional("Should return 'nine hundred twenty six' when 926 given", () => {
5589 |   const readable = toReadable(926);
5590 | 
5591 |   assert.equal(readable, 'nine hundred twenty six');
5592 | });
5593 | 
5594 | it.optional("Should return 'nine hundred twenty seven' when 927 given", () => {
5595 |   const readable = toReadable(927);
5596 | 
5597 |   assert.equal(readable, 'nine hundred twenty seven');
5598 | });
5599 | 
5600 | it.optional("Should return 'nine hundred twenty eight' when 928 given", () => {
5601 |   const readable = toReadable(928);
5602 | 
5603 |   assert.equal(readable, 'nine hundred twenty eight');
5604 | });
5605 | 
5606 | it.optional("Should return 'nine hundred twenty nine' when 929 given", () => {
5607 |   const readable = toReadable(929);
5608 | 
5609 |   assert.equal(readable, 'nine hundred twenty nine');
5610 | });
5611 | 
5612 | it.optional("Should return 'nine hundred thirty' when 930 given", () => {
5613 |   const readable = toReadable(930);
5614 | 
5615 |   assert.equal(readable, 'nine hundred thirty');
5616 | });
5617 | 
5618 | it.optional("Should return 'nine hundred thirty one' when 931 given", () => {
5619 |   const readable = toReadable(931);
5620 | 
5621 |   assert.equal(readable, 'nine hundred thirty one');
5622 | });
5623 | 
5624 | it.optional("Should return 'nine hundred thirty two' when 932 given", () => {
5625 |   const readable = toReadable(932);
5626 | 
5627 |   assert.equal(readable, 'nine hundred thirty two');
5628 | });
5629 | 
5630 | it.optional("Should return 'nine hundred thirty three' when 933 given", () => {
5631 |   const readable = toReadable(933);
5632 | 
5633 |   assert.equal(readable, 'nine hundred thirty three');
5634 | });
5635 | 
5636 | it.optional("Should return 'nine hundred thirty four' when 934 given", () => {
5637 |   const readable = toReadable(934);
5638 | 
5639 |   assert.equal(readable, 'nine hundred thirty four');
5640 | });
5641 | 
5642 | it.optional("Should return 'nine hundred thirty five' when 935 given", () => {
5643 |   const readable = toReadable(935);
5644 | 
5645 |   assert.equal(readable, 'nine hundred thirty five');
5646 | });
5647 | 
5648 | it.optional("Should return 'nine hundred thirty six' when 936 given", () => {
5649 |   const readable = toReadable(936);
5650 | 
5651 |   assert.equal(readable, 'nine hundred thirty six');
5652 | });
5653 | 
5654 | it.optional("Should return 'nine hundred thirty seven' when 937 given", () => {
5655 |   const readable = toReadable(937);
5656 | 
5657 |   assert.equal(readable, 'nine hundred thirty seven');
5658 | });
5659 | 
5660 | it.optional("Should return 'nine hundred thirty eight' when 938 given", () => {
5661 |   const readable = toReadable(938);
5662 | 
5663 |   assert.equal(readable, 'nine hundred thirty eight');
5664 | });
5665 | 
5666 | it.optional("Should return 'nine hundred thirty nine' when 939 given", () => {
5667 |   const readable = toReadable(939);
5668 | 
5669 |   assert.equal(readable, 'nine hundred thirty nine');
5670 | });
5671 | 
5672 | it.optional("Should return 'nine hundred forty' when 940 given", () => {
5673 |   const readable = toReadable(940);
5674 | 
5675 |   assert.equal(readable, 'nine hundred forty');
5676 | });
5677 | 
5678 | it.optional("Should return 'nine hundred forty one' when 941 given", () => {
5679 |   const readable = toReadable(941);
5680 | 
5681 |   assert.equal(readable, 'nine hundred forty one');
5682 | });
5683 | 
5684 | it.optional("Should return 'nine hundred forty two' when 942 given", () => {
5685 |   const readable = toReadable(942);
5686 | 
5687 |   assert.equal(readable, 'nine hundred forty two');
5688 | });
5689 | 
5690 | it.optional("Should return 'nine hundred forty three' when 943 given", () => {
5691 |   const readable = toReadable(943);
5692 | 
5693 |   assert.equal(readable, 'nine hundred forty three');
5694 | });
5695 | 
5696 | it.optional("Should return 'nine hundred forty four' when 944 given", () => {
5697 |   const readable = toReadable(944);
5698 | 
5699 |   assert.equal(readable, 'nine hundred forty four');
5700 | });
5701 | 
5702 | it.optional("Should return 'nine hundred forty five' when 945 given", () => {
5703 |   const readable = toReadable(945);
5704 | 
5705 |   assert.equal(readable, 'nine hundred forty five');
5706 | });
5707 | 
5708 | it.optional("Should return 'nine hundred forty six' when 946 given", () => {
5709 |   const readable = toReadable(946);
5710 | 
5711 |   assert.equal(readable, 'nine hundred forty six');
5712 | });
5713 | 
5714 | it.optional("Should return 'nine hundred forty seven' when 947 given", () => {
5715 |   const readable = toReadable(947);
5716 | 
5717 |   assert.equal(readable, 'nine hundred forty seven');
5718 | });
5719 | 
5720 | it.optional("Should return 'nine hundred forty eight' when 948 given", () => {
5721 |   const readable = toReadable(948);
5722 | 
5723 |   assert.equal(readable, 'nine hundred forty eight');
5724 | });
5725 | 
5726 | it.optional("Should return 'nine hundred forty nine' when 949 given", () => {
5727 |   const readable = toReadable(949);
5728 | 
5729 |   assert.equal(readable, 'nine hundred forty nine');
5730 | });
5731 | 
5732 | it.optional("Should return 'nine hundred fifty' when 950 given", () => {
5733 |   const readable = toReadable(950);
5734 | 
5735 |   assert.equal(readable, 'nine hundred fifty');
5736 | });
5737 | 
5738 | it.optional("Should return 'nine hundred fifty one' when 951 given", () => {
5739 |   const readable = toReadable(951);
5740 | 
5741 |   assert.equal(readable, 'nine hundred fifty one');
5742 | });
5743 | 
5744 | it.optional("Should return 'nine hundred fifty two' when 952 given", () => {
5745 |   const readable = toReadable(952);
5746 | 
5747 |   assert.equal(readable, 'nine hundred fifty two');
5748 | });
5749 | 
5750 | it.optional("Should return 'nine hundred fifty three' when 953 given", () => {
5751 |   const readable = toReadable(953);
5752 | 
5753 |   assert.equal(readable, 'nine hundred fifty three');
5754 | });
5755 | 
5756 | it.optional("Should return 'nine hundred fifty four' when 954 given", () => {
5757 |   const readable = toReadable(954);
5758 | 
5759 |   assert.equal(readable, 'nine hundred fifty four');
5760 | });
5761 | 
5762 | it.optional("Should return 'nine hundred fifty five' when 955 given", () => {
5763 |   const readable = toReadable(955);
5764 | 
5765 |   assert.equal(readable, 'nine hundred fifty five');
5766 | });
5767 | 
5768 | it.optional("Should return 'nine hundred fifty six' when 956 given", () => {
5769 |   const readable = toReadable(956);
5770 | 
5771 |   assert.equal(readable, 'nine hundred fifty six');
5772 | });
5773 | 
5774 | it.optional("Should return 'nine hundred fifty seven' when 957 given", () => {
5775 |   const readable = toReadable(957);
5776 | 
5777 |   assert.equal(readable, 'nine hundred fifty seven');
5778 | });
5779 | 
5780 | it.optional("Should return 'nine hundred fifty eight' when 958 given", () => {
5781 |   const readable = toReadable(958);
5782 | 
5783 |   assert.equal(readable, 'nine hundred fifty eight');
5784 | });
5785 | 
5786 | it.optional("Should return 'nine hundred fifty nine' when 959 given", () => {
5787 |   const readable = toReadable(959);
5788 | 
5789 |   assert.equal(readable, 'nine hundred fifty nine');
5790 | });
5791 | 
5792 | it.optional("Should return 'nine hundred sixty' when 960 given", () => {
5793 |   const readable = toReadable(960);
5794 | 
5795 |   assert.equal(readable, 'nine hundred sixty');
5796 | });
5797 | 
5798 | it.optional("Should return 'nine hundred sixty one' when 961 given", () => {
5799 |   const readable = toReadable(961);
5800 | 
5801 |   assert.equal(readable, 'nine hundred sixty one');
5802 | });
5803 | 
5804 | it.optional("Should return 'nine hundred sixty two' when 962 given", () => {
5805 |   const readable = toReadable(962);
5806 | 
5807 |   assert.equal(readable, 'nine hundred sixty two');
5808 | });
5809 | 
5810 | it.optional("Should return 'nine hundred sixty three' when 963 given", () => {
5811 |   const readable = toReadable(963);
5812 | 
5813 |   assert.equal(readable, 'nine hundred sixty three');
5814 | });
5815 | 
5816 | it.optional("Should return 'nine hundred sixty four' when 964 given", () => {
5817 |   const readable = toReadable(964);
5818 | 
5819 |   assert.equal(readable, 'nine hundred sixty four');
5820 | });
5821 | 
5822 | it.optional("Should return 'nine hundred sixty five' when 965 given", () => {
5823 |   const readable = toReadable(965);
5824 | 
5825 |   assert.equal(readable, 'nine hundred sixty five');
5826 | });
5827 | 
5828 | it.optional("Should return 'nine hundred sixty six' when 966 given", () => {
5829 |   const readable = toReadable(966);
5830 | 
5831 |   assert.equal(readable, 'nine hundred sixty six');
5832 | });
5833 | 
5834 | it.optional("Should return 'nine hundred sixty seven' when 967 given", () => {
5835 |   const readable = toReadable(967);
5836 | 
5837 |   assert.equal(readable, 'nine hundred sixty seven');
5838 | });
5839 | 
5840 | it.optional("Should return 'nine hundred sixty eight' when 968 given", () => {
5841 |   const readable = toReadable(968);
5842 | 
5843 |   assert.equal(readable, 'nine hundred sixty eight');
5844 | });
5845 | 
5846 | it.optional("Should return 'nine hundred sixty nine' when 969 given", () => {
5847 |   const readable = toReadable(969);
5848 | 
5849 |   assert.equal(readable, 'nine hundred sixty nine');
5850 | });
5851 | 
5852 | it.optional("Should return 'nine hundred seventy' when 970 given", () => {
5853 |   const readable = toReadable(970);
5854 | 
5855 |   assert.equal(readable, 'nine hundred seventy');
5856 | });
5857 | 
5858 | it.optional("Should return 'nine hundred seventy one' when 971 given", () => {
5859 |   const readable = toReadable(971);
5860 | 
5861 |   assert.equal(readable, 'nine hundred seventy one');
5862 | });
5863 | 
5864 | it.optional("Should return 'nine hundred seventy two' when 972 given", () => {
5865 |   const readable = toReadable(972);
5866 | 
5867 |   assert.equal(readable, 'nine hundred seventy two');
5868 | });
5869 | 
5870 | it.optional("Should return 'nine hundred seventy three' when 973 given", () => {
5871 |   const readable = toReadable(973);
5872 | 
5873 |   assert.equal(readable, 'nine hundred seventy three');
5874 | });
5875 | 
5876 | it.optional("Should return 'nine hundred seventy four' when 974 given", () => {
5877 |   const readable = toReadable(974);
5878 | 
5879 |   assert.equal(readable, 'nine hundred seventy four');
5880 | });
5881 | 
5882 | it.optional("Should return 'nine hundred seventy five' when 975 given", () => {
5883 |   const readable = toReadable(975);
5884 | 
5885 |   assert.equal(readable, 'nine hundred seventy five');
5886 | });
5887 | 
5888 | it.optional("Should return 'nine hundred seventy six' when 976 given", () => {
5889 |   const readable = toReadable(976);
5890 | 
5891 |   assert.equal(readable, 'nine hundred seventy six');
5892 | });
5893 | 
5894 | it.optional("Should return 'nine hundred seventy seven' when 977 given", () => {
5895 |   const readable = toReadable(977);
5896 | 
5897 |   assert.equal(readable, 'nine hundred seventy seven');
5898 | });
5899 | 
5900 | it.optional("Should return 'nine hundred seventy eight' when 978 given", () => {
5901 |   const readable = toReadable(978);
5902 | 
5903 |   assert.equal(readable, 'nine hundred seventy eight');
5904 | });
5905 | 
5906 | it.optional("Should return 'nine hundred seventy nine' when 979 given", () => {
5907 |   const readable = toReadable(979);
5908 | 
5909 |   assert.equal(readable, 'nine hundred seventy nine');
5910 | });
5911 | 
5912 | it.optional("Should return 'nine hundred eighty' when 980 given", () => {
5913 |   const readable = toReadable(980);
5914 | 
5915 |   assert.equal(readable, 'nine hundred eighty');
5916 | });
5917 | 
5918 | it.optional("Should return 'nine hundred eighty one' when 981 given", () => {
5919 |   const readable = toReadable(981);
5920 | 
5921 |   assert.equal(readable, 'nine hundred eighty one');
5922 | });
5923 | 
5924 | it.optional("Should return 'nine hundred eighty two' when 982 given", () => {
5925 |   const readable = toReadable(982);
5926 | 
5927 |   assert.equal(readable, 'nine hundred eighty two');
5928 | });
5929 | 
5930 | it.optional("Should return 'nine hundred eighty three' when 983 given", () => {
5931 |   const readable = toReadable(983);
5932 | 
5933 |   assert.equal(readable, 'nine hundred eighty three');
5934 | });
5935 | 
5936 | it.optional("Should return 'nine hundred eighty four' when 984 given", () => {
5937 |   const readable = toReadable(984);
5938 | 
5939 |   assert.equal(readable, 'nine hundred eighty four');
5940 | });
5941 | 
5942 | it.optional("Should return 'nine hundred eighty five' when 985 given", () => {
5943 |   const readable = toReadable(985);
5944 | 
5945 |   assert.equal(readable, 'nine hundred eighty five');
5946 | });
5947 | 
5948 | it.optional("Should return 'nine hundred eighty six' when 986 given", () => {
5949 |   const readable = toReadable(986);
5950 | 
5951 |   assert.equal(readable, 'nine hundred eighty six');
5952 | });
5953 | 
5954 | it.optional("Should return 'nine hundred eighty seven' when 987 given", () => {
5955 |   const readable = toReadable(987);
5956 | 
5957 |   assert.equal(readable, 'nine hundred eighty seven');
5958 | });
5959 | 
5960 | it.optional("Should return 'nine hundred eighty eight' when 988 given", () => {
5961 |   const readable = toReadable(988);
5962 | 
5963 |   assert.equal(readable, 'nine hundred eighty eight');
5964 | });
5965 | 
5966 | it.optional("Should return 'nine hundred eighty nine' when 989 given", () => {
5967 |   const readable = toReadable(989);
5968 | 
5969 |   assert.equal(readable, 'nine hundred eighty nine');
5970 | });
5971 | 
5972 | it.optional("Should return 'nine hundred ninety' when 990 given", () => {
5973 |   const readable = toReadable(990);
5974 | 
5975 |   assert.equal(readable, 'nine hundred ninety');
5976 | });
5977 | 
5978 | it.optional("Should return 'nine hundred ninety one' when 991 given", () => {
5979 |   const readable = toReadable(991);
5980 | 
5981 |   assert.equal(readable, 'nine hundred ninety one');
5982 | });
5983 | 
5984 | it.optional("Should return 'nine hundred ninety two' when 992 given", () => {
5985 |   const readable = toReadable(992);
5986 | 
5987 |   assert.equal(readable, 'nine hundred ninety two');
5988 | });
5989 | 
5990 | it.optional("Should return 'nine hundred ninety three' when 993 given", () => {
5991 |   const readable = toReadable(993);
5992 | 
5993 |   assert.equal(readable, 'nine hundred ninety three');
5994 | });
5995 | 
5996 | it.optional("Should return 'nine hundred ninety four' when 994 given", () => {
5997 |   const readable = toReadable(994);
5998 | 
5999 |   assert.equal(readable, 'nine hundred ninety four');
6000 | });
6001 | 
6002 | it.optional("Should return 'nine hundred ninety five' when 995 given", () => {
6003 |   const readable = toReadable(995);
6004 | 
6005 |   assert.equal(readable, 'nine hundred ninety five');
6006 | });
6007 | 
6008 | it.optional("Should return 'nine hundred ninety six' when 996 given", () => {
6009 |   const readable = toReadable(996);
6010 | 
6011 |   assert.equal(readable, 'nine hundred ninety six');
6012 | });
6013 | 
6014 | it.optional("Should return 'nine hundred ninety seven' when 997 given", () => {
6015 |   const readable = toReadable(997);
6016 | 
6017 |   assert.equal(readable, 'nine hundred ninety seven');
6018 | });
6019 | 
6020 | it.optional("Should return 'nine hundred ninety eight' when 998 given", () => {
6021 |   const readable = toReadable(998);
6022 | 
6023 |   assert.equal(readable, 'nine hundred ninety eight');
6024 | });
6025 | 
6026 | it.optional("Should return 'nine hundred ninety nine' when 999 given", () => {
6027 |   const readable = toReadable(999);
6028 | 
6029 |   assert.equal(readable, 'nine hundred ninety nine');
6030 | });
6031 | 


--------------------------------------------------------------------------------