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