test.js

const assert = require('assert');

const toReadable = require('./src');


it('Should return \'zero\' when 0 given', () => {
  const readable = toReadable(0);

  assert.equal(readable, 'zero');
});

it('Should return \'one\' when 1 given', () => {
  const readable = toReadable(1);

  assert.equal(readable, 'one');
});

it('Should return \'two\' when 2 given', () => {
  const readable = toReadable(2);

  assert.equal(readable, 'two');
});

it('Should return \'three\' when 3 given', () => {
  const readable = toReadable(3);

  assert.equal(readable, 'three');
});

it('Should return \'four\' when 4 given', () => {
  const readable = toReadable(4);

  assert.equal(readable, 'four');
});

it('Should return \'five\' when 5 given', () => {
  const readable = toReadable(5);

  assert.equal(readable, 'five');
});

it('Should return \'six\' when 6 given', () => {
  const readable = toReadable(6);

  assert.equal(readable, 'six');
});

it('Should return \'seven\' when 7 given', () => {
  const readable = toReadable(7);

  assert.equal(readable, 'seven');
});

it('Should return \'eight\' when 8 given', () => {
  const readable = toReadable(8);

  assert.equal(readable, 'eight');
});

it('Should return \'nine\' when 9 given', () => {
  const readable = toReadable(9);

  assert.equal(readable, 'nine');
});

it('Should return \'ten\' when 10 given', () => {
  const readable = toReadable(10);

  assert.equal(readable, 'ten');
});

it('Should return \'eleven\' when 11 given', () => {
  const readable = toReadable(11);

  assert.equal(readable, 'eleven');
});

it('Should return \'twelve\' when 12 given', () => {
  const readable = toReadable(12);

  assert.equal(readable, 'twelve');
});

it('Should return \'thirteen\' when 13 given', () => {
  const readable = toReadable(13);

  assert.equal(readable, 'thirteen');
});

it('Should return \'fourteen\' when 14 given', () => {
  const readable = toReadable(14);

  assert.equal(readable, 'fourteen');
});

it('Should return \'fifteen\' when 15 given', () => {
  const readable = toReadable(15);

  assert.equal(readable, 'fifteen');
});

it('Should return \'sixteen\' when 16 given', () => {
  const readable = toReadable(16);

  assert.equal(readable, 'sixteen');
});

it('Should return \'seventeen\' when 17 given', () => {
  const readable = toReadable(17);

  assert.equal(readable, 'seventeen');
});

it('Should return \'eighteen\' when 18 given', () => {
  const readable = toReadable(18);

  assert.equal(readable, 'eighteen');
});

it('Should return \'nineteen\' when 19 given', () => {
  const readable = toReadable(19);

  assert.equal(readable, 'nineteen');
});

it('Should return \'twenty\' when 20 given', () => {
  const readable = toReadable(20);

  assert.equal(readable, 'twenty');
});

it('Should return \'twenty one\' when 21 given', () => {
  const readable = toReadable(21);

  assert.equal(readable, 'twenty one');
});

it('Should return \'twenty two\' when 22 given', () => {
  const readable = toReadable(22);

  assert.equal(readable, 'twenty two');
});

it('Should return \'twenty three\' when 23 given', () => {
  const readable = toReadable(23);

  assert.equal(readable, 'twenty three');
});

it('Should return \'twenty four\' when 24 given', () => {
  const readable = toReadable(24);

  assert.equal(readable, 'twenty four');
});

it('Should return \'twenty five\' when 25 given', () => {
  const readable = toReadable(25);

  assert.equal(readable, 'twenty five');
});

it('Should return \'twenty six\' when 26 given', () => {
  const readable = toReadable(26);

  assert.equal(readable, 'twenty six');
});

it('Should return \'twenty seven\' when 27 given', () => {
  const readable = toReadable(27);

  assert.equal(readable, 'twenty seven');
});

it('Should return \'twenty eight\' when 28 given', () => {
  const readable = toReadable(28);

  assert.equal(readable, 'twenty eight');
});

it('Should return \'twenty nine\' when 29 given', () => {
  const readable = toReadable(29);

  assert.equal(readable, 'twenty nine');
});

it('Should return \'thirty\' when 30 given', () => {
  const readable = toReadable(30);

  assert.equal(readable, 'thirty');
});

it('Should return \'thirty one\' when 31 given', () => {
  const readable = toReadable(31);

  assert.equal(readable, 'thirty one');
});

it('Should return \'thirty two\' when 32 given', () => {
  const readable = toReadable(32);

  assert.equal(readable, 'thirty two');
});

it('Should return \'thirty three\' when 33 given', () => {
  const readable = toReadable(33);

  assert.equal(readable, 'thirty three');
});

it('Should return \'thirty four\' when 34 given', () => {
  const readable = toReadable(34);

  assert.equal(readable, 'thirty four');
});

it('Should return \'thirty five\' when 35 given', () => {
  const readable = toReadable(35);

  assert.equal(readable, 'thirty five');
});

it('Should return \'thirty six\' when 36 given', () => {
  const readable = toReadable(36);

  assert.equal(readable, 'thirty six');
});

it('Should return \'thirty seven\' when 37 given', () => {
  const readable = toReadable(37);

  assert.equal(readable, 'thirty seven');
});

it('Should return \'thirty eight\' when 38 given', () => {
  const readable = toReadable(38);

  assert.equal(readable, 'thirty eight');
});

it('Should return \'thirty nine\' when 39 given', () => {
  const readable = toReadable(39);

  assert.equal(readable, 'thirty nine');
});

it('Should return \'forty\' when 40 given', () => {
  const readable = toReadable(40);

  assert.equal(readable, 'forty');
});

it('Should return \'forty one\' when 41 given', () => {
  const readable = toReadable(41);

  assert.equal(readable, 'forty one');
});

it('Should return \'forty two\' when 42 given', () => {
  const readable = toReadable(42);

  assert.equal(readable, 'forty two');
});

it('Should return \'forty three\' when 43 given', () => {
  const readable = toReadable(43);

  assert.equal(readable, 'forty three');
});

it('Should return \'forty four\' when 44 given', () => {
  const readable = toReadable(44);

  assert.equal(readable, 'forty four');
});

it('Should return \'forty five\' when 45 given', () => {
  const readable = toReadable(45);

  assert.equal(readable, 'forty five');
});

it('Should return \'forty six\' when 46 given', () => {
  const readable = toReadable(46);

  assert.equal(readable, 'forty six');
});

it('Should return \'forty seven\' when 47 given', () => {
  const readable = toReadable(47);

  assert.equal(readable, 'forty seven');
});

it('Should return \'forty eight\' when 48 given', () => {
  const readable = toReadable(48);

  assert.equal(readable, 'forty eight');
});

it('Should return \'forty nine\' when 49 given', () => {
  const readable = toReadable(49);

  assert.equal(readable, 'forty nine');
});

it('Should return \'fifty\' when 50 given', () => {
  const readable = toReadable(50);

  assert.equal(readable, 'fifty');
});

it('Should return \'fifty one\' when 51 given', () => {
  const readable = toReadable(51);

  assert.equal(readable, 'fifty one');
});

it('Should return \'fifty two\' when 52 given', () => {
  const readable = toReadable(52);

  assert.equal(readable, 'fifty two');
});

it('Should return \'fifty three\' when 53 given', () => {
  const readable = toReadable(53);

  assert.equal(readable, 'fifty three');
});

it('Should return \'fifty four\' when 54 given', () => {
  const readable = toReadable(54);

  assert.equal(readable, 'fifty four');
});

it('Should return \'fifty five\' when 55 given', () => {
  const readable = toReadable(55);

  assert.equal(readable, 'fifty five');
});

it('Should return \'fifty six\' when 56 given', () => {
  const readable = toReadable(56);

  assert.equal(readable, 'fifty six');
});

it('Should return \'fifty seven\' when 57 given', () => {
  const readable = toReadable(57);

  assert.equal(readable, 'fifty seven');
});

it('Should return \'fifty eight\' when 58 given', () => {
  const readable = toReadable(58);

  assert.equal(readable, 'fifty eight');
});

it('Should return \'fifty nine\' when 59 given', () => {
  const readable = toReadable(59);

  assert.equal(readable, 'fifty nine');
});

it('Should return \'sixty\' when 60 given', () => {
  const readable = toReadable(60);

  assert.equal(readable, 'sixty');
});

it('Should return \'sixty one\' when 61 given', () => {
  const readable = toReadable(61);

  assert.equal(readable, 'sixty one');
});

it('Should return \'sixty two\' when 62 given', () => {
  const readable = toReadable(62);

  assert.equal(readable, 'sixty two');
});

it('Should return \'sixty three\' when 63 given', () => {
  const readable = toReadable(63);

  assert.equal(readable, 'sixty three');
});

it('Should return \'sixty four\' when 64 given', () => {
  const readable = toReadable(64);

  assert.equal(readable, 'sixty four');
});

it('Should return \'sixty five\' when 65 given', () => {
  const readable = toReadable(65);

  assert.equal(readable, 'sixty five');
});

it('Should return \'sixty six\' when 66 given', () => {
  const readable = toReadable(66);

  assert.equal(readable, 'sixty six');
});

it('Should return \'sixty seven\' when 67 given', () => {
  const readable = toReadable(67);

  assert.equal(readable, 'sixty seven');
});

it('Should return \'sixty eight\' when 68 given', () => {
  const readable = toReadable(68);

  assert.equal(readable, 'sixty eight');
});

it('Should return \'sixty nine\' when 69 given', () => {
  const readable = toReadable(69);

  assert.equal(readable, 'sixty nine');
});

it('Should return \'seventy\' when 70 given', () => {
  const readable = toReadable(70);

  assert.equal(readable, 'seventy');
});

it('Should return \'seventy one\' when 71 given', () => {
  const readable = toReadable(71);

  assert.equal(readable, 'seventy one');
});

it('Should return \'seventy two\' when 72 given', () => {
  const readable = toReadable(72);

  assert.equal(readable, 'seventy two');
});

it('Should return \'seventy three\' when 73 given', () => {
  const readable = toReadable(73);

  assert.equal(readable, 'seventy three');
});

it('Should return \'seventy four\' when 74 given', () => {
  const readable = toReadable(74);

  assert.equal(readable, 'seventy four');
});

it('Should return \'seventy five\' when 75 given', () => {
  const readable = toReadable(75);

  assert.equal(readable, 'seventy five');
});

it('Should return \'seventy six\' when 76 given', () => {
  const readable = toReadable(76);

  assert.equal(readable, 'seventy six');
});

it('Should return \'seventy seven\' when 77 given', () => {
  const readable = toReadable(77);

  assert.equal(readable, 'seventy seven');
});

it('Should return \'seventy eight\' when 78 given', () => {
  const readable = toReadable(78);

  assert.equal(readable, 'seventy eight');
});

it('Should return \'seventy nine\' when 79 given', () => {
  const readable = toReadable(79);

  assert.equal(readable, 'seventy nine');
});

it('Should return \'eighty\' when 80 given', () => {
  const readable = toReadable(80);

  assert.equal(readable, 'eighty');
});

it('Should return \'eighty one\' when 81 given', () => {
  const readable = toReadable(81);

  assert.equal(readable, 'eighty one');
});

it('Should return \'eighty two\' when 82 given', () => {
  const readable = toReadable(82);

  assert.equal(readable, 'eighty two');
});

it('Should return \'eighty three\' when 83 given', () => {
  const readable = toReadable(83);

  assert.equal(readable, 'eighty three');
});

it('Should return \'eighty four\' when 84 given', () => {
  const readable = toReadable(84);

  assert.equal(readable, 'eighty four');
});

it('Should return \'eighty five\' when 85 given', () => {
  const readable = toReadable(85);

  assert.equal(readable, 'eighty five');
});

it('Should return \'eighty six\' when 86 given', () => {
  const readable = toReadable(86);

  assert.equal(readable, 'eighty six');
});

it('Should return \'eighty seven\' when 87 given', () => {
  const readable = toReadable(87);

  assert.equal(readable, 'eighty seven');
});

it('Should return \'eighty eight\' when 88 given', () => {
  const readable = toReadable(88);

  assert.equal(readable, 'eighty eight');
});

it('Should return \'eighty nine\' when 89 given', () => {
  const readable = toReadable(89);

  assert.equal(readable, 'eighty nine');
});

it('Should return \'ninety\' when 90 given', () => {
  const readable = toReadable(90);

  assert.equal(readable, 'ninety');
});

it('Should return \'ninety one\' when 91 given', () => {
  const readable = toReadable(91);

  assert.equal(readable, 'ninety one');
});

it('Should return \'ninety two\' when 92 given', () => {
  const readable = toReadable(92);

  assert.equal(readable, 'ninety two');
});

it('Should return \'ninety three\' when 93 given', () => {
  const readable = toReadable(93);

  assert.equal(readable, 'ninety three');
});

it('Should return \'ninety four\' when 94 given', () => {
  const readable = toReadable(94);

  assert.equal(readable, 'ninety four');
});

it('Should return \'ninety five\' when 95 given', () => {
  const readable = toReadable(95);

  assert.equal(readable, 'ninety five');
});

it('Should return \'ninety six\' when 96 given', () => {
  const readable = toReadable(96);

  assert.equal(readable, 'ninety six');
});

it('Should return \'ninety seven\' when 97 given', () => {
  const readable = toReadable(97);

  assert.equal(readable, 'ninety seven');
});

it('Should return \'ninety eight\' when 98 given', () => {
  const readable = toReadable(98);

  assert.equal(readable, 'ninety eight');
});

it('Should return \'ninety nine\' when 99 given', () => {
  const readable = toReadable(99);

  assert.equal(readable, 'ninety nine');
});

it('Should return \'one hundred\' when 100 given', () => {
  const readable = toReadable(100);

  assert.equal(readable, 'one hundred');
});

it('Should return \'one hundred one\' when 101 given', () => {
  const readable = toReadable(101);

  assert.equal(readable, 'one hundred one');
});

it('Should return \'one hundred two\' when 102 given', () => {
  const readable = toReadable(102);

  assert.equal(readable, 'one hundred two');
});

it('Should return \'one hundred three\' when 103 given', () => {
  const readable = toReadable(103);

  assert.equal(readable, 'one hundred three');
});

it('Should return \'one hundred four\' when 104 given', () => {
  const readable = toReadable(104);

  assert.equal(readable, 'one hundred four');
});

it('Should return \'one hundred five\' when 105 given', () => {
  const readable = toReadable(105);

  assert.equal(readable, 'one hundred five');
});

it('Should return \'one hundred six\' when 106 given', () => {
  const readable = toReadable(106);

  assert.equal(readable, 'one hundred six');
});

it('Should return \'one hundred seven\' when 107 given', () => {
  const readable = toReadable(107);

  assert.equal(readable, 'one hundred seven');
});

it('Should return \'one hundred eight\' when 108 given', () => {
  const readable = toReadable(108);

  assert.equal(readable, 'one hundred eight');
});

it('Should return \'one hundred nine\' when 109 given', () => {
  const readable = toReadable(109);

  assert.equal(readable, 'one hundred nine');
});

it('Should return \'one hundred ten\' when 110 given', () => {
  const readable = toReadable(110);

  assert.equal(readable, 'one hundred ten');
});

it('Should return \'one hundred eleven\' when 111 given', () => {
  const readable = toReadable(111);

  assert.equal(readable, 'one hundred eleven');
});

it('Should return \'one hundred twelve\' when 112 given', () => {
  const readable = toReadable(112);

  assert.equal(readable, 'one hundred twelve');
});

it('Should return \'one hundred thirteen\' when 113 given', () => {
  const readable = toReadable(113);

  assert.equal(readable, 'one hundred thirteen');
});

it('Should return \'one hundred fourteen\' when 114 given', () => {
  const readable = toReadable(114);

  assert.equal(readable, 'one hundred fourteen');
});

it('Should return \'one hundred fifteen\' when 115 given', () => {
  const readable = toReadable(115);

  assert.equal(readable, 'one hundred fifteen');
});

it('Should return \'one hundred sixteen\' when 116 given', () => {
  const readable = toReadable(116);

  assert.equal(readable, 'one hundred sixteen');
});

it('Should return \'one hundred seventeen\' when 117 given', () => {
  const readable = toReadable(117);

  assert.equal(readable, 'one hundred seventeen');
});

it('Should return \'one hundred eighteen\' when 118 given', () => {
  const readable = toReadable(118);

  assert.equal(readable, 'one hundred eighteen');
});

it('Should return \'one hundred nineteen\' when 119 given', () => {
  const readable = toReadable(119);

  assert.equal(readable, 'one hundred nineteen');
});

it('Should return \'one hundred twenty\' when 120 given', () => {
  const readable = toReadable(120);

  assert.equal(readable, 'one hundred twenty');
});

it('Should return \'one hundred twenty one\' when 121 given', () => {
  const readable = toReadable(121);

  assert.equal(readable, 'one hundred twenty one');
});

it('Should return \'one hundred twenty two\' when 122 given', () => {
  const readable = toReadable(122);

  assert.equal(readable, 'one hundred twenty two');
});

it('Should return \'one hundred twenty three\' when 123 given', () => {
  const readable = toReadable(123);

  assert.equal(readable, 'one hundred twenty three');
});

it('Should return \'one hundred twenty four\' when 124 given', () => {
  const readable = toReadable(124);

  assert.equal(readable, 'one hundred twenty four');
});

it('Should return \'one hundred twenty five\' when 125 given', () => {
  const readable = toReadable(125);

  assert.equal(readable, 'one hundred twenty five');
});

it('Should return \'one hundred twenty six\' when 126 given', () => {
  const readable = toReadable(126);

  assert.equal(readable, 'one hundred twenty six');
});

it('Should return \'one hundred twenty seven\' when 127 given', () => {
  const readable = toReadable(127);

  assert.equal(readable, 'one hundred twenty seven');
});

it('Should return \'one hundred twenty eight\' when 128 given', () => {
  const readable = toReadable(128);

  assert.equal(readable, 'one hundred twenty eight');
});

it('Should return \'one hundred twenty nine\' when 129 given', () => {
  const readable = toReadable(129);

  assert.equal(readable, 'one hundred twenty nine');
});

it('Should return \'one hundred thirty\' when 130 given', () => {
  const readable = toReadable(130);

  assert.equal(readable, 'one hundred thirty');
});

it('Should return \'one hundred thirty one\' when 131 given', () => {
  const readable = toReadable(131);

  assert.equal(readable, 'one hundred thirty one');
});

it('Should return \'one hundred thirty two\' when 132 given', () => {
  const readable = toReadable(132);

  assert.equal(readable, 'one hundred thirty two');
});

it('Should return \'one hundred thirty three\' when 133 given', () => {
  const readable = toReadable(133);

  assert.equal(readable, 'one hundred thirty three');
});

it('Should return \'one hundred thirty four\' when 134 given', () => {
  const readable = toReadable(134);

  assert.equal(readable, 'one hundred thirty four');
});

it('Should return \'one hundred thirty five\' when 135 given', () => {
  const readable = toReadable(135);

  assert.equal(readable, 'one hundred thirty five');
});

it('Should return \'one hundred thirty six\' when 136 given', () => {
  const readable = toReadable(136);

  assert.equal(readable, 'one hundred thirty six');
});

it('Should return \'one hundred thirty seven\' when 137 given', () => {
  const readable = toReadable(137);

  assert.equal(readable, 'one hundred thirty seven');
});

it('Should return \'one hundred thirty eight\' when 138 given', () => {
  const readable = toReadable(138);

  assert.equal(readable, 'one hundred thirty eight');
});

it('Should return \'one hundred thirty nine\' when 139 given', () => {
  const readable = toReadable(139);

  assert.equal(readable, 'one hundred thirty nine');
});

it('Should return \'one hundred forty\' when 140 given', () => {
  const readable = toReadable(140);

  assert.equal(readable, 'one hundred forty');
});

it('Should return \'one hundred forty one\' when 141 given', () => {
  const readable = toReadable(141);

  assert.equal(readable, 'one hundred forty one');
});

it('Should return \'one hundred forty two\' when 142 given', () => {
  const readable = toReadable(142);

  assert.equal(readable, 'one hundred forty two');
});

it('Should return \'one hundred forty three\' when 143 given', () => {
  const readable = toReadable(143);

  assert.equal(readable, 'one hundred forty three');
});

it('Should return \'one hundred forty four\' when 144 given', () => {
  const readable = toReadable(144);

  assert.equal(readable, 'one hundred forty four');
});

it('Should return \'one hundred forty five\' when 145 given', () => {
  const readable = toReadable(145);

  assert.equal(readable, 'one hundred forty five');
});

it('Should return \'one hundred forty six\' when 146 given', () => {
  const readable = toReadable(146);

  assert.equal(readable, 'one hundred forty six');
});

it('Should return \'one hundred forty seven\' when 147 given', () => {
  const readable = toReadable(147);

  assert.equal(readable, 'one hundred forty seven');
});

it('Should return \'one hundred forty eight\' when 148 given', () => {
  const readable = toReadable(148);

  assert.equal(readable, 'one hundred forty eight');
});

it('Should return \'one hundred forty nine\' when 149 given', () => {
  const readable = toReadable(149);

  assert.equal(readable, 'one hundred forty nine');
});

it('Should return \'one hundred fifty\' when 150 given', () => {
  const readable = toReadable(150);

  assert.equal(readable, 'one hundred fifty');
});

it('Should return \'one hundred fifty one\' when 151 given', () => {
  const readable = toReadable(151);

  assert.equal(readable, 'one hundred fifty one');
});

it('Should return \'one hundred fifty two\' when 152 given', () => {
  const readable = toReadable(152);

  assert.equal(readable, 'one hundred fifty two');
});

it('Should return \'one hundred fifty three\' when 153 given', () => {
  const readable = toReadable(153);

  assert.equal(readable, 'one hundred fifty three');
});

it('Should return \'one hundred fifty four\' when 154 given', () => {
  const readable = toReadable(154);

  assert.equal(readable, 'one hundred fifty four');
});

it('Should return \'one hundred fifty five\' when 155 given', () => {
  const readable = toReadable(155);

  assert.equal(readable, 'one hundred fifty five');
});

it('Should return \'one hundred fifty six\' when 156 given', () => {
  const readable = toReadable(156);

  assert.equal(readable, 'one hundred fifty six');
});

it('Should return \'one hundred fifty seven\' when 157 given', () => {
  const readable = toReadable(157);

  assert.equal(readable, 'one hundred fifty seven');
});

it('Should return \'one hundred fifty eight\' when 158 given', () => {
  const readable = toReadable(158);

  assert.equal(readable, 'one hundred fifty eight');
});

it('Should return \'one hundred fifty nine\' when 159 given', () => {
  const readable = toReadable(159);

  assert.equal(readable, 'one hundred fifty nine');
});

it('Should return \'one hundred sixty\' when 160 given', () => {
  const readable = toReadable(160);

  assert.equal(readable, 'one hundred sixty');
});

it('Should return \'one hundred sixty one\' when 161 given', () => {
  const readable = toReadable(161);

  assert.equal(readable, 'one hundred sixty one');
});

it('Should return \'one hundred sixty two\' when 162 given', () => {
  const readable = toReadable(162);

  assert.equal(readable, 'one hundred sixty two');
});

it('Should return \'one hundred sixty three\' when 163 given', () => {
  const readable = toReadable(163);

  assert.equal(readable, 'one hundred sixty three');
});

it('Should return \'one hundred sixty four\' when 164 given', () => {
  const readable = toReadable(164);

  assert.equal(readable, 'one hundred sixty four');
});

it('Should return \'one hundred sixty five\' when 165 given', () => {
  const readable = toReadable(165);

  assert.equal(readable, 'one hundred sixty five');
});

it('Should return \'one hundred sixty six\' when 166 given', () => {
  const readable = toReadable(166);

  assert.equal(readable, 'one hundred sixty six');
});

it('Should return \'one hundred sixty seven\' when 167 given', () => {
  const readable = toReadable(167);

  assert.equal(readable, 'one hundred sixty seven');
});

it('Should return \'one hundred sixty eight\' when 168 given', () => {
  const readable = toReadable(168);

  assert.equal(readable, 'one hundred sixty eight');
});

it('Should return \'one hundred sixty nine\' when 169 given', () => {
  const readable = toReadable(169);

  assert.equal(readable, 'one hundred sixty nine');
});

it('Should return \'one hundred seventy\' when 170 given', () => {
  const readable = toReadable(170);

  assert.equal(readable, 'one hundred seventy');
});

it('Should return \'one hundred seventy one\' when 171 given', () => {
  const readable = toReadable(171);

  assert.equal(readable, 'one hundred seventy one');
});

it('Should return \'one hundred seventy two\' when 172 given', () => {
  const readable = toReadable(172);

  assert.equal(readable, 'one hundred seventy two');
});

it('Should return \'one hundred seventy three\' when 173 given', () => {
  const readable = toReadable(173);

  assert.equal(readable, 'one hundred seventy three');
});

it('Should return \'one hundred seventy four\' when 174 given', () => {
  const readable = toReadable(174);

  assert.equal(readable, 'one hundred seventy four');
});

it('Should return \'one hundred seventy five\' when 175 given', () => {
  const readable = toReadable(175);

  assert.equal(readable, 'one hundred seventy five');
});

it('Should return \'one hundred seventy six\' when 176 given', () => {
  const readable = toReadable(176);

  assert.equal(readable, 'one hundred seventy six');
});

it('Should return \'one hundred seventy seven\' when 177 given', () => {
  const readable = toReadable(177);

  assert.equal(readable, 'one hundred seventy seven');
});

it('Should return \'one hundred seventy eight\' when 178 given', () => {
  const readable = toReadable(178);

  assert.equal(readable, 'one hundred seventy eight');
});

it('Should return \'one hundred seventy nine\' when 179 given', () => {
  const readable = toReadable(179);

  assert.equal(readable, 'one hundred seventy nine');
});

it('Should return \'one hundred eighty\' when 180 given', () => {
  const readable = toReadable(180);

  assert.equal(readable, 'one hundred eighty');
});

it('Should return \'one hundred eighty one\' when 181 given', () => {
  const readable = toReadable(181);

  assert.equal(readable, 'one hundred eighty one');
});

it('Should return \'one hundred eighty two\' when 182 given', () => {
  const readable = toReadable(182);

  assert.equal(readable, 'one hundred eighty two');
});

it('Should return \'one hundred eighty three\' when 183 given', () => {
  const readable = toReadable(183);

  assert.equal(readable, 'one hundred eighty three');
});

it('Should return \'one hundred eighty four\' when 184 given', () => {
  const readable = toReadable(184);

  assert.equal(readable, 'one hundred eighty four');
});

it('Should return \'one hundred eighty five\' when 185 given', () => {
  const readable = toReadable(185);

  assert.equal(readable, 'one hundred eighty five');
});

it('Should return \'one hundred eighty six\' when 186 given', () => {
  const readable = toReadable(186);

  assert.equal(readable, 'one hundred eighty six');
});

it('Should return \'one hundred eighty seven\' when 187 given', () => {
  const readable = toReadable(187);

  assert.equal(readable, 'one hundred eighty seven');
});

it('Should return \'one hundred eighty eight\' when 188 given', () => {
  const readable = toReadable(188);

  assert.equal(readable, 'one hundred eighty eight');
});

it('Should return \'one hundred eighty nine\' when 189 given', () => {
  const readable = toReadable(189);

  assert.equal(readable, 'one hundred eighty nine');
});

it('Should return \'one hundred ninety\' when 190 given', () => {
  const readable = toReadable(190);

  assert.equal(readable, 'one hundred ninety');
});

it('Should return \'one hundred ninety one\' when 191 given', () => {
  const readable = toReadable(191);

  assert.equal(readable, 'one hundred ninety one');
});

it('Should return \'one hundred ninety two\' when 192 given', () => {
  const readable = toReadable(192);

  assert.equal(readable, 'one hundred ninety two');
});

it('Should return \'one hundred ninety three\' when 193 given', () => {
  const readable = toReadable(193);

  assert.equal(readable, 'one hundred ninety three');
});

it('Should return \'one hundred ninety four\' when 194 given', () => {
  const readable = toReadable(194);

  assert.equal(readable, 'one hundred ninety four');
});

it('Should return \'one hundred ninety five\' when 195 given', () => {
  const readable = toReadable(195);

  assert.equal(readable, 'one hundred ninety five');
});

it('Should return \'one hundred ninety six\' when 196 given', () => {
  const readable = toReadable(196);

  assert.equal(readable, 'one hundred ninety six');
});

it('Should return \'one hundred ninety seven\' when 197 given', () => {
  const readable = toReadable(197);

  assert.equal(readable, 'one hundred ninety seven');
});

it('Should return \'one hundred ninety eight\' when 198 given', () => {
  const readable = toReadable(198);

  assert.equal(readable, 'one hundred ninety eight');
});

it('Should return \'one hundred ninety nine\' when 199 given', () => {
  const readable = toReadable(199);

  assert.equal(readable, 'one hundred ninety nine');
});

it('Should return \'two hundred\' when 200 given', () => {
  const readable = toReadable(200);

  assert.equal(readable, 'two hundred');
});

it('Should return \'two hundred one\' when 201 given', () => {
  const readable = toReadable(201);

  assert.equal(readable, 'two hundred one');
});

it('Should return \'two hundred two\' when 202 given', () => {
  const readable = toReadable(202);

  assert.equal(readable, 'two hundred two');
});

it('Should return \'two hundred three\' when 203 given', () => {
  const readable = toReadable(203);

  assert.equal(readable, 'two hundred three');
});

it('Should return \'two hundred four\' when 204 given', () => {
  const readable = toReadable(204);

  assert.equal(readable, 'two hundred four');
});

it('Should return \'two hundred five\' when 205 given', () => {
  const readable = toReadable(205);

  assert.equal(readable, 'two hundred five');
});

it('Should return \'two hundred six\' when 206 given', () => {
  const readable = toReadable(206);

  assert.equal(readable, 'two hundred six');
});

it('Should return \'two hundred seven\' when 207 given', () => {
  const readable = toReadable(207);

  assert.equal(readable, 'two hundred seven');
});

it('Should return \'two hundred eight\' when 208 given', () => {
  const readable = toReadable(208);

  assert.equal(readable, 'two hundred eight');
});

it('Should return \'two hundred nine\' when 209 given', () => {
  const readable = toReadable(209);

  assert.equal(readable, 'two hundred nine');
});

it('Should return \'two hundred ten\' when 210 given', () => {
  const readable = toReadable(210);

  assert.equal(readable, 'two hundred ten');
});

it('Should return \'two hundred eleven\' when 211 given', () => {
  const readable = toReadable(211);

  assert.equal(readable, 'two hundred eleven');
});

it('Should return \'two hundred twelve\' when 212 given', () => {
  const readable = toReadable(212);

  assert.equal(readable, 'two hundred twelve');
});

it('Should return \'two hundred thirteen\' when 213 given', () => {
  const readable = toReadable(213);

  assert.equal(readable, 'two hundred thirteen');
});

it('Should return \'two hundred fourteen\' when 214 given', () => {
  const readable = toReadable(214);

  assert.equal(readable, 'two hundred fourteen');
});

it('Should return \'two hundred fifteen\' when 215 given', () => {
  const readable = toReadable(215);

  assert.equal(readable, 'two hundred fifteen');
});

it('Should return \'two hundred sixteen\' when 216 given', () => {
  const readable = toReadable(216);

  assert.equal(readable, 'two hundred sixteen');
});

it('Should return \'two hundred seventeen\' when 217 given', () => {
  const readable = toReadable(217);

  assert.equal(readable, 'two hundred seventeen');
});

it('Should return \'two hundred eighteen\' when 218 given', () => {
  const readable = toReadable(218);

  assert.equal(readable, 'two hundred eighteen');
});

it('Should return \'two hundred nineteen\' when 219 given', () => {
  const readable = toReadable(219);

  assert.equal(readable, 'two hundred nineteen');
});

it('Should return \'two hundred twenty\' when 220 given', () => {
  const readable = toReadable(220);

  assert.equal(readable, 'two hundred twenty');
});

it('Should return \'two hundred twenty one\' when 221 given', () => {
  const readable = toReadable(221);

  assert.equal(readable, 'two hundred twenty one');
});

it('Should return \'two hundred twenty two\' when 222 given', () => {
  const readable = toReadable(222);

  assert.equal(readable, 'two hundred twenty two');
});

it('Should return \'two hundred twenty three\' when 223 given', () => {
  const readable = toReadable(223);

  assert.equal(readable, 'two hundred twenty three');
});

it('Should return \'two hundred twenty four\' when 224 given', () => {
  const readable = toReadable(224);

  assert.equal(readable, 'two hundred twenty four');
});

it('Should return \'two hundred twenty five\' when 225 given', () => {
  const readable = toReadable(225);

  assert.equal(readable, 'two hundred twenty five');
});

it('Should return \'two hundred twenty six\' when 226 given', () => {
  const readable = toReadable(226);

  assert.equal(readable, 'two hundred twenty six');
});

it('Should return \'two hundred twenty seven\' when 227 given', () => {
  const readable = toReadable(227);

  assert.equal(readable, 'two hundred twenty seven');
});

it('Should return \'two hundred twenty eight\' when 228 given', () => {
  const readable = toReadable(228);

  assert.equal(readable, 'two hundred twenty eight');
});

it('Should return \'two hundred twenty nine\' when 229 given', () => {
  const readable = toReadable(229);

  assert.equal(readable, 'two hundred twenty nine');
});

it('Should return \'two hundred thirty\' when 230 given', () => {
  const readable = toReadable(230);

  assert.equal(readable, 'two hundred thirty');
});

it('Should return \'two hundred thirty one\' when 231 given', () => {
  const readable = toReadable(231);

  assert.equal(readable, 'two hundred thirty one');
});

it('Should return \'two hundred thirty two\' when 232 given', () => {
  const readable = toReadable(232);

  assert.equal(readable, 'two hundred thirty two');
});

it('Should return \'two hundred thirty three\' when 233 given', () => {
  const readable = toReadable(233);

  assert.equal(readable, 'two hundred thirty three');
});

it('Should return \'two hundred thirty four\' when 234 given', () => {
  const readable = toReadable(234);

  assert.equal(readable, 'two hundred thirty four');
});

it('Should return \'two hundred thirty five\' when 235 given', () => {
  const readable = toReadable(235);

  assert.equal(readable, 'two hundred thirty five');
});

it('Should return \'two hundred thirty six\' when 236 given', () => {
  const readable = toReadable(236);

  assert.equal(readable, 'two hundred thirty six');
});

it('Should return \'two hundred thirty seven\' when 237 given', () => {
  const readable = toReadable(237);

  assert.equal(readable, 'two hundred thirty seven');
});

it('Should return \'two hundred thirty eight\' when 238 given', () => {
  const readable = toReadable(238);

  assert.equal(readable, 'two hundred thirty eight');
});

it('Should return \'two hundred thirty nine\' when 239 given', () => {
  const readable = toReadable(239);

  assert.equal(readable, 'two hundred thirty nine');
});

it('Should return \'two hundred forty\' when 240 given', () => {
  const readable = toReadable(240);

  assert.equal(readable, 'two hundred forty');
});

it('Should return \'two hundred forty one\' when 241 given', () => {
  const readable = toReadable(241);

  assert.equal(readable, 'two hundred forty one');
});

it('Should return \'two hundred forty two\' when 242 given', () => {
  const readable = toReadable(242);

  assert.equal(readable, 'two hundred forty two');
});

it('Should return \'two hundred forty three\' when 243 given', () => {
  const readable = toReadable(243);

  assert.equal(readable, 'two hundred forty three');
});

it('Should return \'two hundred forty four\' when 244 given', () => {
  const readable = toReadable(244);

  assert.equal(readable, 'two hundred forty four');
});

it('Should return \'two hundred forty five\' when 245 given', () => {
  const readable = toReadable(245);

  assert.equal(readable, 'two hundred forty five');
});

it('Should return \'two hundred forty six\' when 246 given', () => {
  const readable = toReadable(246);

  assert.equal(readable, 'two hundred forty six');
});

it('Should return \'two hundred forty seven\' when 247 given', () => {
  const readable = toReadable(247);

  assert.equal(readable, 'two hundred forty seven');
});

it('Should return \'two hundred forty eight\' when 248 given', () => {
  const readable = toReadable(248);

  assert.equal(readable, 'two hundred forty eight');
});

it('Should return \'two hundred forty nine\' when 249 given', () => {
  const readable = toReadable(249);

  assert.equal(readable, 'two hundred forty nine');
});

it('Should return \'two hundred fifty\' when 250 given', () => {
  const readable = toReadable(250);

  assert.equal(readable, 'two hundred fifty');
});

it('Should return \'two hundred fifty one\' when 251 given', () => {
  const readable = toReadable(251);

  assert.equal(readable, 'two hundred fifty one');
});

it('Should return \'two hundred fifty two\' when 252 given', () => {
  const readable = toReadable(252);

  assert.equal(readable, 'two hundred fifty two');
});

it('Should return \'two hundred fifty three\' when 253 given', () => {
  const readable = toReadable(253);

  assert.equal(readable, 'two hundred fifty three');
});

it('Should return \'two hundred fifty four\' when 254 given', () => {
  const readable = toReadable(254);

  assert.equal(readable, 'two hundred fifty four');
});

it('Should return \'two hundred fifty five\' when 255 given', () => {
  const readable = toReadable(255);

  assert.equal(readable, 'two hundred fifty five');
});

it('Should return \'two hundred fifty six\' when 256 given', () => {
  const readable = toReadable(256);

  assert.equal(readable, 'two hundred fifty six');
});

it('Should return \'two hundred fifty seven\' when 257 given', () => {
  const readable = toReadable(257);

  assert.equal(readable, 'two hundred fifty seven');
});

it('Should return \'two hundred fifty eight\' when 258 given', () => {
  const readable = toReadable(258);

  assert.equal(readable, 'two hundred fifty eight');
});

it('Should return \'two hundred fifty nine\' when 259 given', () => {
  const readable = toReadable(259);

  assert.equal(readable, 'two hundred fifty nine');
});

it('Should return \'two hundred sixty\' when 260 given', () => {
  const readable = toReadable(260);

  assert.equal(readable, 'two hundred sixty');
});

it('Should return \'two hundred sixty one\' when 261 given', () => {
  const readable = toReadable(261);

  assert.equal(readable, 'two hundred sixty one');
});

it('Should return \'two hundred sixty two\' when 262 given', () => {
  const readable = toReadable(262);

  assert.equal(readable, 'two hundred sixty two');
});

it('Should return \'two hundred sixty three\' when 263 given', () => {
  const readable = toReadable(263);

  assert.equal(readable, 'two hundred sixty three');
});

it('Should return \'two hundred sixty four\' when 264 given', () => {
  const readable = toReadable(264);

  assert.equal(readable, 'two hundred sixty four');
});

it('Should return \'two hundred sixty five\' when 265 given', () => {
  const readable = toReadable(265);

  assert.equal(readable, 'two hundred sixty five');
});

it('Should return \'two hundred sixty six\' when 266 given', () => {
  const readable = toReadable(266);

  assert.equal(readable, 'two hundred sixty six');
});

it('Should return \'two hundred sixty seven\' when 267 given', () => {
  const readable = toReadable(267);

  assert.equal(readable, 'two hundred sixty seven');
});

it('Should return \'two hundred sixty eight\' when 268 given', () => {
  const readable = toReadable(268);

  assert.equal(readable, 'two hundred sixty eight');
});

it('Should return \'two hundred sixty nine\' when 269 given', () => {
  const readable = toReadable(269);

  assert.equal(readable, 'two hundred sixty nine');
});

it('Should return \'two hundred seventy\' when 270 given', () => {
  const readable = toReadable(270);

  assert.equal(readable, 'two hundred seventy');
});

it('Should return \'two hundred seventy one\' when 271 given', () => {
  const readable = toReadable(271);

  assert.equal(readable, 'two hundred seventy one');
});

it('Should return \'two hundred seventy two\' when 272 given', () => {
  const readable = toReadable(272);

  assert.equal(readable, 'two hundred seventy two');
});

it('Should return \'two hundred seventy three\' when 273 given', () => {
  const readable = toReadable(273);

  assert.equal(readable, 'two hundred seventy three');
});

it('Should return \'two hundred seventy four\' when 274 given', () => {
  const readable = toReadable(274);

  assert.equal(readable, 'two hundred seventy four');
});

it('Should return \'two hundred seventy five\' when 275 given', () => {
  const readable = toReadable(275);

  assert.equal(readable, 'two hundred seventy five');
});

it('Should return \'two hundred seventy six\' when 276 given', () => {
  const readable = toReadable(276);

  assert.equal(readable, 'two hundred seventy six');
});

it('Should return \'two hundred seventy seven\' when 277 given', () => {
  const readable = toReadable(277);

  assert.equal(readable, 'two hundred seventy seven');
});

it('Should return \'two hundred seventy eight\' when 278 given', () => {
  const readable = toReadable(278);

  assert.equal(readable, 'two hundred seventy eight');
});

it('Should return \'two hundred seventy nine\' when 279 given', () => {
  const readable = toReadable(279);

  assert.equal(readable, 'two hundred seventy nine');
});

it('Should return \'two hundred eighty\' when 280 given', () => {
  const readable = toReadable(280);

  assert.equal(readable, 'two hundred eighty');
});

it('Should return \'two hundred eighty one\' when 281 given', () => {
  const readable = toReadable(281);

  assert.equal(readable, 'two hundred eighty one');
});

it('Should return \'two hundred eighty two\' when 282 given', () => {
  const readable = toReadable(282);

  assert.equal(readable, 'two hundred eighty two');
});

it('Should return \'two hundred eighty three\' when 283 given', () => {
  const readable = toReadable(283);

  assert.equal(readable, 'two hundred eighty three');
});

it('Should return \'two hundred eighty four\' when 284 given', () => {
  const readable = toReadable(284);

  assert.equal(readable, 'two hundred eighty four');
});

it('Should return \'two hundred eighty five\' when 285 given', () => {
  const readable = toReadable(285);

  assert.equal(readable, 'two hundred eighty five');
});

it('Should return \'two hundred eighty six\' when 286 given', () => {
  const readable = toReadable(286);

  assert.equal(readable, 'two hundred eighty six');
});

it('Should return \'two hundred eighty seven\' when 287 given', () => {
  const readable = toReadable(287);

  assert.equal(readable, 'two hundred eighty seven');
});

it('Should return \'two hundred eighty eight\' when 288 given', () => {
  const readable = toReadable(288);

  assert.equal(readable, 'two hundred eighty eight');
});

it('Should return \'two hundred eighty nine\' when 289 given', () => {
  const readable = toReadable(289);

  assert.equal(readable, 'two hundred eighty nine');
});

it('Should return \'two hundred ninety\' when 290 given', () => {
  const readable = toReadable(290);

  assert.equal(readable, 'two hundred ninety');
});

it('Should return \'two hundred ninety one\' when 291 given', () => {
  const readable = toReadable(291);

  assert.equal(readable, 'two hundred ninety one');
});

it('Should return \'two hundred ninety two\' when 292 given', () => {
  const readable = toReadable(292);

  assert.equal(readable, 'two hundred ninety two');
});

it('Should return \'two hundred ninety three\' when 293 given', () => {
  const readable = toReadable(293);

  assert.equal(readable, 'two hundred ninety three');
});

it('Should return \'two hundred ninety four\' when 294 given', () => {
  const readable = toReadable(294);

  assert.equal(readable, 'two hundred ninety four');
});

it('Should return \'two hundred ninety five\' when 295 given', () => {
  const readable = toReadable(295);

  assert.equal(readable, 'two hundred ninety five');
});

it('Should return \'two hundred ninety six\' when 296 given', () => {
  const readable = toReadable(296);

  assert.equal(readable, 'two hundred ninety six');
});

it('Should return \'two hundred ninety seven\' when 297 given', () => {
  const readable = toReadable(297);

  assert.equal(readable, 'two hundred ninety seven');
});

it('Should return \'two hundred ninety eight\' when 298 given', () => {
  const readable = toReadable(298);

  assert.equal(readable, 'two hundred ninety eight');
});

it('Should return \'two hundred ninety nine\' when 299 given', () => {
  const readable = toReadable(299);

  assert.equal(readable, 'two hundred ninety nine');
});

it('Should return \'three hundred\' when 300 given', () => {
  const readable = toReadable(300);

  assert.equal(readable, 'three hundred');
});

it('Should return \'three hundred one\' when 301 given', () => {
  const readable = toReadable(301);

  assert.equal(readable, 'three hundred one');
});

it('Should return \'three hundred two\' when 302 given', () => {
  const readable = toReadable(302);

  assert.equal(readable, 'three hundred two');
});

it('Should return \'three hundred three\' when 303 given', () => {
  const readable = toReadable(303);

  assert.equal(readable, 'three hundred three');
});

it('Should return \'three hundred four\' when 304 given', () => {
  const readable = toReadable(304);

  assert.equal(readable, 'three hundred four');
});

it('Should return \'three hundred five\' when 305 given', () => {
  const readable = toReadable(305);

  assert.equal(readable, 'three hundred five');
});

it('Should return \'three hundred six\' when 306 given', () => {
  const readable = toReadable(306);

  assert.equal(readable, 'three hundred six');
});

it('Should return \'three hundred seven\' when 307 given', () => {
  const readable = toReadable(307);

  assert.equal(readable, 'three hundred seven');
});

it('Should return \'three hundred eight\' when 308 given', () => {
  const readable = toReadable(308);

  assert.equal(readable, 'three hundred eight');
});

it('Should return \'three hundred nine\' when 309 given', () => {
  const readable = toReadable(309);

  assert.equal(readable, 'three hundred nine');
});

it('Should return \'three hundred ten\' when 310 given', () => {
  const readable = toReadable(310);

  assert.equal(readable, 'three hundred ten');
});

it('Should return \'three hundred eleven\' when 311 given', () => {
  const readable = toReadable(311);

  assert.equal(readable, 'three hundred eleven');
});

it('Should return \'three hundred twelve\' when 312 given', () => {
  const readable = toReadable(312);

  assert.equal(readable, 'three hundred twelve');
});

it('Should return \'three hundred thirteen\' when 313 given', () => {
  const readable = toReadable(313);

  assert.equal(readable, 'three hundred thirteen');
});

it('Should return \'three hundred fourteen\' when 314 given', () => {
  const readable = toReadable(314);

  assert.equal(readable, 'three hundred fourteen');
});

it('Should return \'three hundred fifteen\' when 315 given', () => {
  const readable = toReadable(315);

  assert.equal(readable, 'three hundred fifteen');
});

it('Should return \'three hundred sixteen\' when 316 given', () => {
  const readable = toReadable(316);

  assert.equal(readable, 'three hundred sixteen');
});

it('Should return \'three hundred seventeen\' when 317 given', () => {
  const readable = toReadable(317);

  assert.equal(readable, 'three hundred seventeen');
});

it('Should return \'three hundred eighteen\' when 318 given', () => {
  const readable = toReadable(318);

  assert.equal(readable, 'three hundred eighteen');
});

it('Should return \'three hundred nineteen\' when 319 given', () => {
  const readable = toReadable(319);

  assert.equal(readable, 'three hundred nineteen');
});

it('Should return \'three hundred twenty\' when 320 given', () => {
  const readable = toReadable(320);

  assert.equal(readable, 'three hundred twenty');
});

it('Should return \'three hundred twenty one\' when 321 given', () => {
  const readable = toReadable(321);

  assert.equal(readable, 'three hundred twenty one');
});

it('Should return \'three hundred twenty two\' when 322 given', () => {
  const readable = toReadable(322);

  assert.equal(readable, 'three hundred twenty two');
});

it('Should return \'three hundred twenty three\' when 323 given', () => {
  const readable = toReadable(323);

  assert.equal(readable, 'three hundred twenty three');
});

it('Should return \'three hundred twenty four\' when 324 given', () => {
  const readable = toReadable(324);

  assert.equal(readable, 'three hundred twenty four');
});

it('Should return \'three hundred twenty five\' when 325 given', () => {
  const readable = toReadable(325);

  assert.equal(readable, 'three hundred twenty five');
});

it('Should return \'three hundred twenty six\' when 326 given', () => {
  const readable = toReadable(326);

  assert.equal(readable, 'three hundred twenty six');
});

it('Should return \'three hundred twenty seven\' when 327 given', () => {
  const readable = toReadable(327);

  assert.equal(readable, 'three hundred twenty seven');
});

it('Should return \'three hundred twenty eight\' when 328 given', () => {
  const readable = toReadable(328);

  assert.equal(readable, 'three hundred twenty eight');
});

it('Should return \'three hundred twenty nine\' when 329 given', () => {
  const readable = toReadable(329);

  assert.equal(readable, 'three hundred twenty nine');
});

it('Should return \'three hundred thirty\' when 330 given', () => {
  const readable = toReadable(330);

  assert.equal(readable, 'three hundred thirty');
});

it('Should return \'three hundred thirty one\' when 331 given', () => {
  const readable = toReadable(331);

  assert.equal(readable, 'three hundred thirty one');
});

it('Should return \'three hundred thirty two\' when 332 given', () => {
  const readable = toReadable(332);

  assert.equal(readable, 'three hundred thirty two');
});

it('Should return \'three hundred thirty three\' when 333 given', () => {
  const readable = toReadable(333);

  assert.equal(readable, 'three hundred thirty three');
});

it('Should return \'three hundred thirty four\' when 334 given', () => {
  const readable = toReadable(334);

  assert.equal(readable, 'three hundred thirty four');
});

it('Should return \'three hundred thirty five\' when 335 given', () => {
  const readable = toReadable(335);

  assert.equal(readable, 'three hundred thirty five');
});

it('Should return \'three hundred thirty six\' when 336 given', () => {
  const readable = toReadable(336);

  assert.equal(readable, 'three hundred thirty six');
});

it('Should return \'three hundred thirty seven\' when 337 given', () => {
  const readable = toReadable(337);

  assert.equal(readable, 'three hundred thirty seven');
});

it('Should return \'three hundred thirty eight\' when 338 given', () => {
  const readable = toReadable(338);

  assert.equal(readable, 'three hundred thirty eight');
});

it('Should return \'three hundred thirty nine\' when 339 given', () => {
  const readable = toReadable(339);

  assert.equal(readable, 'three hundred thirty nine');
});

it('Should return \'three hundred forty\' when 340 given', () => {
  const readable = toReadable(340);

  assert.equal(readable, 'three hundred forty');
});

it('Should return \'three hundred forty one\' when 341 given', () => {
  const readable = toReadable(341);

  assert.equal(readable, 'three hundred forty one');
});

it('Should return \'three hundred forty two\' when 342 given', () => {
  const readable = toReadable(342);

  assert.equal(readable, 'three hundred forty two');
});

it('Should return \'three hundred forty three\' when 343 given', () => {
  const readable = toReadable(343);

  assert.equal(readable, 'three hundred forty three');
});

it('Should return \'three hundred forty four\' when 344 given', () => {
  const readable = toReadable(344);

  assert.equal(readable, 'three hundred forty four');
});

it('Should return \'three hundred forty five\' when 345 given', () => {
  const readable = toReadable(345);

  assert.equal(readable, 'three hundred forty five');
});

it('Should return \'three hundred forty six\' when 346 given', () => {
  const readable = toReadable(346);

  assert.equal(readable, 'three hundred forty six');
});

it('Should return \'three hundred forty seven\' when 347 given', () => {
  const readable = toReadable(347);

  assert.equal(readable, 'three hundred forty seven');
});

it('Should return \'three hundred forty eight\' when 348 given', () => {
  const readable = toReadable(348);

  assert.equal(readable, 'three hundred forty eight');
});

it('Should return \'three hundred forty nine\' when 349 given', () => {
  const readable = toReadable(349);

  assert.equal(readable, 'three hundred forty nine');
});

it('Should return \'three hundred fifty\' when 350 given', () => {
  const readable = toReadable(350);

  assert.equal(readable, 'three hundred fifty');
});

it('Should return \'three hundred fifty one\' when 351 given', () => {
  const readable = toReadable(351);

  assert.equal(readable, 'three hundred fifty one');
});

it('Should return \'three hundred fifty two\' when 352 given', () => {
  const readable = toReadable(352);

  assert.equal(readable, 'three hundred fifty two');
});

it('Should return \'three hundred fifty three\' when 353 given', () => {
  const readable = toReadable(353);

  assert.equal(readable, 'three hundred fifty three');
});

it('Should return \'three hundred fifty four\' when 354 given', () => {
  const readable = toReadable(354);

  assert.equal(readable, 'three hundred fifty four');
});

it('Should return \'three hundred fifty five\' when 355 given', () => {
  const readable = toReadable(355);

  assert.equal(readable, 'three hundred fifty five');
});

it('Should return \'three hundred fifty six\' when 356 given', () => {
  const readable = toReadable(356);

  assert.equal(readable, 'three hundred fifty six');
});

it('Should return \'three hundred fifty seven\' when 357 given', () => {
  const readable = toReadable(357);

  assert.equal(readable, 'three hundred fifty seven');
});

it('Should return \'three hundred fifty eight\' when 358 given', () => {
  const readable = toReadable(358);

  assert.equal(readable, 'three hundred fifty eight');
});

it('Should return \'three hundred fifty nine\' when 359 given', () => {
  const readable = toReadable(359);

  assert.equal(readable, 'three hundred fifty nine');
});

it('Should return \'three hundred sixty\' when 360 given', () => {
  const readable = toReadable(360);

  assert.equal(readable, 'three hundred sixty');
});

it('Should return \'three hundred sixty one\' when 361 given', () => {
  const readable = toReadable(361);

  assert.equal(readable, 'three hundred sixty one');
});

it('Should return \'three hundred sixty two\' when 362 given', () => {
  const readable = toReadable(362);

  assert.equal(readable, 'three hundred sixty two');
});

it('Should return \'three hundred sixty three\' when 363 given', () => {
  const readable = toReadable(363);

  assert.equal(readable, 'three hundred sixty three');
});

it('Should return \'three hundred sixty four\' when 364 given', () => {
  const readable = toReadable(364);

  assert.equal(readable, 'three hundred sixty four');
});

it('Should return \'three hundred sixty five\' when 365 given', () => {
  const readable = toReadable(365);

  assert.equal(readable, 'three hundred sixty five');
});

it('Should return \'three hundred sixty six\' when 366 given', () => {
  const readable = toReadable(366);

  assert.equal(readable, 'three hundred sixty six');
});

it('Should return \'three hundred sixty seven\' when 367 given', () => {
  const readable = toReadable(367);

  assert.equal(readable, 'three hundred sixty seven');
});

it('Should return \'three hundred sixty eight\' when 368 given', () => {
  const readable = toReadable(368);

  assert.equal(readable, 'three hundred sixty eight');
});

it('Should return \'three hundred sixty nine\' when 369 given', () => {
  const readable = toReadable(369);

  assert.equal(readable, 'three hundred sixty nine');
});

it('Should return \'three hundred seventy\' when 370 given', () => {
  const readable = toReadable(370);

  assert.equal(readable, 'three hundred seventy');
});

it('Should return \'three hundred seventy one\' when 371 given', () => {
  const readable = toReadable(371);

  assert.equal(readable, 'three hundred seventy one');
});

it('Should return \'three hundred seventy two\' when 372 given', () => {
  const readable = toReadable(372);

  assert.equal(readable, 'three hundred seventy two');
});

it('Should return \'three hundred seventy three\' when 373 given', () => {
  const readable = toReadable(373);

  assert.equal(readable, 'three hundred seventy three');
});

it('Should return \'three hundred seventy four\' when 374 given', () => {
  const readable = toReadable(374);

  assert.equal(readable, 'three hundred seventy four');
});

it('Should return \'three hundred seventy five\' when 375 given', () => {
  const readable = toReadable(375);

  assert.equal(readable, 'three hundred seventy five');
});

it('Should return \'three hundred seventy six\' when 376 given', () => {
  const readable = toReadable(376);

  assert.equal(readable, 'three hundred seventy six');
});

it('Should return \'three hundred seventy seven\' when 377 given', () => {
  const readable = toReadable(377);

  assert.equal(readable, 'three hundred seventy seven');
});

it('Should return \'three hundred seventy eight\' when 378 given', () => {
  const readable = toReadable(378);

  assert.equal(readable, 'three hundred seventy eight');
});

it('Should return \'three hundred seventy nine\' when 379 given', () => {
  const readable = toReadable(379);

  assert.equal(readable, 'three hundred seventy nine');
});

it('Should return \'three hundred eighty\' when 380 given', () => {
  const readable = toReadable(380);

  assert.equal(readable, 'three hundred eighty');
});

it('Should return \'three hundred eighty one\' when 381 given', () => {
  const readable = toReadable(381);

  assert.equal(readable, 'three hundred eighty one');
});

it('Should return \'three hundred eighty two\' when 382 given', () => {
  const readable = toReadable(382);

  assert.equal(readable, 'three hundred eighty two');
});

it('Should return \'three hundred eighty three\' when 383 given', () => {
  const readable = toReadable(383);

  assert.equal(readable, 'three hundred eighty three');
});

it('Should return \'three hundred eighty four\' when 384 given', () => {
  const readable = toReadable(384);

  assert.equal(readable, 'three hundred eighty four');
});

it('Should return \'three hundred eighty five\' when 385 given', () => {
  const readable = toReadable(385);

  assert.equal(readable, 'three hundred eighty five');
});

it('Should return \'three hundred eighty six\' when 386 given', () => {
  const readable = toReadable(386);

  assert.equal(readable, 'three hundred eighty six');
});

it('Should return \'three hundred eighty seven\' when 387 given', () => {
  const readable = toReadable(387);

  assert.equal(readable, 'three hundred eighty seven');
});

it('Should return \'three hundred eighty eight\' when 388 given', () => {
  const readable = toReadable(388);

  assert.equal(readable, 'three hundred eighty eight');
});

it('Should return \'three hundred eighty nine\' when 389 given', () => {
  const readable = toReadable(389);

  assert.equal(readable, 'three hundred eighty nine');
});

it('Should return \'three hundred ninety\' when 390 given', () => {
  const readable = toReadable(390);

  assert.equal(readable, 'three hundred ninety');
});

it('Should return \'three hundred ninety one\' when 391 given', () => {
  const readable = toReadable(391);

  assert.equal(readable, 'three hundred ninety one');
});

it('Should return \'three hundred ninety two\' when 392 given', () => {
  const readable = toReadable(392);

  assert.equal(readable, 'three hundred ninety two');
});

it('Should return \'three hundred ninety three\' when 393 given', () => {
  const readable = toReadable(393);

  assert.equal(readable, 'three hundred ninety three');
});

it('Should return \'three hundred ninety four\' when 394 given', () => {
  const readable = toReadable(394);

  assert.equal(readable, 'three hundred ninety four');
});

it('Should return \'three hundred ninety five\' when 395 given', () => {
  const readable = toReadable(395);

  assert.equal(readable, 'three hundred ninety five');
});

it('Should return \'three hundred ninety six\' when 396 given', () => {
  const readable = toReadable(396);

  assert.equal(readable, 'three hundred ninety six');
});

it('Should return \'three hundred ninety seven\' when 397 given', () => {
  const readable = toReadable(397);

  assert.equal(readable, 'three hundred ninety seven');
});

it('Should return \'three hundred ninety eight\' when 398 given', () => {
  const readable = toReadable(398);

  assert.equal(readable, 'three hundred ninety eight');
});

it('Should return \'three hundred ninety nine\' when 399 given', () => {
  const readable = toReadable(399);

  assert.equal(readable, 'three hundred ninety nine');
});

it('Should return \'four hundred\' when 400 given', () => {
  const readable = toReadable(400);

  assert.equal(readable, 'four hundred');
});

it('Should return \'four hundred one\' when 401 given', () => {
  const readable = toReadable(401);

  assert.equal(readable, 'four hundred one');
});

it('Should return \'four hundred two\' when 402 given', () => {
  const readable = toReadable(402);

  assert.equal(readable, 'four hundred two');
});

it('Should return \'four hundred three\' when 403 given', () => {
  const readable = toReadable(403);

  assert.equal(readable, 'four hundred three');
});

it('Should return \'four hundred four\' when 404 given', () => {
  const readable = toReadable(404);

  assert.equal(readable, 'four hundred four');
});

it('Should return \'four hundred five\' when 405 given', () => {
  const readable = toReadable(405);

  assert.equal(readable, 'four hundred five');
});

it('Should return \'four hundred six\' when 406 given', () => {
  const readable = toReadable(406);

  assert.equal(readable, 'four hundred six');
});

it('Should return \'four hundred seven\' when 407 given', () => {
  const readable = toReadable(407);

  assert.equal(readable, 'four hundred seven');
});

it('Should return \'four hundred eight\' when 408 given', () => {
  const readable = toReadable(408);

  assert.equal(readable, 'four hundred eight');
});

it('Should return \'four hundred nine\' when 409 given', () => {
  const readable = toReadable(409);

  assert.equal(readable, 'four hundred nine');
});

it('Should return \'four hundred ten\' when 410 given', () => {
  const readable = toReadable(410);

  assert.equal(readable, 'four hundred ten');
});

it('Should return \'four hundred eleven\' when 411 given', () => {
  const readable = toReadable(411);

  assert.equal(readable, 'four hundred eleven');
});

it('Should return \'four hundred twelve\' when 412 given', () => {
  const readable = toReadable(412);

  assert.equal(readable, 'four hundred twelve');
});

it('Should return \'four hundred thirteen\' when 413 given', () => {
  const readable = toReadable(413);

  assert.equal(readable, 'four hundred thirteen');
});

it('Should return \'four hundred fourteen\' when 414 given', () => {
  const readable = toReadable(414);

  assert.equal(readable, 'four hundred fourteen');
});

it('Should return \'four hundred fifteen\' when 415 given', () => {
  const readable = toReadable(415);

  assert.equal(readable, 'four hundred fifteen');
});

it('Should return \'four hundred sixteen\' when 416 given', () => {
  const readable = toReadable(416);

  assert.equal(readable, 'four hundred sixteen');
});

it('Should return \'four hundred seventeen\' when 417 given', () => {
  const readable = toReadable(417);

  assert.equal(readable, 'four hundred seventeen');
});

it('Should return \'four hundred eighteen\' when 418 given', () => {
  const readable = toReadable(418);

  assert.equal(readable, 'four hundred eighteen');
});

it('Should return \'four hundred nineteen\' when 419 given', () => {
  const readable = toReadable(419);

  assert.equal(readable, 'four hundred nineteen');
});

it('Should return \'four hundred twenty\' when 420 given', () => {
  const readable = toReadable(420);

  assert.equal(readable, 'four hundred twenty');
});

it('Should return \'four hundred twenty one\' when 421 given', () => {
  const readable = toReadable(421);

  assert.equal(readable, 'four hundred twenty one');
});

it('Should return \'four hundred twenty two\' when 422 given', () => {
  const readable = toReadable(422);

  assert.equal(readable, 'four hundred twenty two');
});

it('Should return \'four hundred twenty three\' when 423 given', () => {
  const readable = toReadable(423);

  assert.equal(readable, 'four hundred twenty three');
});

it('Should return \'four hundred twenty four\' when 424 given', () => {
  const readable = toReadable(424);

  assert.equal(readable, 'four hundred twenty four');
});

it('Should return \'four hundred twenty five\' when 425 given', () => {
  const readable = toReadable(425);

  assert.equal(readable, 'four hundred twenty five');
});

it('Should return \'four hundred twenty six\' when 426 given', () => {
  const readable = toReadable(426);

  assert.equal(readable, 'four hundred twenty six');
});

it('Should return \'four hundred twenty seven\' when 427 given', () => {
  const readable = toReadable(427);

  assert.equal(readable, 'four hundred twenty seven');
});

it('Should return \'four hundred twenty eight\' when 428 given', () => {
  const readable = toReadable(428);

  assert.equal(readable, 'four hundred twenty eight');
});

it('Should return \'four hundred twenty nine\' when 429 given', () => {
  const readable = toReadable(429);

  assert.equal(readable, 'four hundred twenty nine');
});

it('Should return \'four hundred thirty\' when 430 given', () => {
  const readable = toReadable(430);

  assert.equal(readable, 'four hundred thirty');
});

it('Should return \'four hundred thirty one\' when 431 given', () => {
  const readable = toReadable(431);

  assert.equal(readable, 'four hundred thirty one');
});

it('Should return \'four hundred thirty two\' when 432 given', () => {
  const readable = toReadable(432);

  assert.equal(readable, 'four hundred thirty two');
});

it('Should return \'four hundred thirty three\' when 433 given', () => {
  const readable = toReadable(433);

  assert.equal(readable, 'four hundred thirty three');
});

it('Should return \'four hundred thirty four\' when 434 given', () => {
  const readable = toReadable(434);

  assert.equal(readable, 'four hundred thirty four');
});

it('Should return \'four hundred thirty five\' when 435 given', () => {
  const readable = toReadable(435);

  assert.equal(readable, 'four hundred thirty five');
});

it('Should return \'four hundred thirty six\' when 436 given', () => {
  const readable = toReadable(436);

  assert.equal(readable, 'four hundred thirty six');
});

it('Should return \'four hundred thirty seven\' when 437 given', () => {
  const readable = toReadable(437);

  assert.equal(readable, 'four hundred thirty seven');
});

it('Should return \'four hundred thirty eight\' when 438 given', () => {
  const readable = toReadable(438);

  assert.equal(readable, 'four hundred thirty eight');
});

it('Should return \'four hundred thirty nine\' when 439 given', () => {
  const readable = toReadable(439);

  assert.equal(readable, 'four hundred thirty nine');
});

it('Should return \'four hundred forty\' when 440 given', () => {
  const readable = toReadable(440);

  assert.equal(readable, 'four hundred forty');
});

it('Should return \'four hundred forty one\' when 441 given', () => {
  const readable = toReadable(441);

  assert.equal(readable, 'four hundred forty one');
});

it('Should return \'four hundred forty two\' when 442 given', () => {
  const readable = toReadable(442);

  assert.equal(readable, 'four hundred forty two');
});

it('Should return \'four hundred forty three\' when 443 given', () => {
  const readable = toReadable(443);

  assert.equal(readable, 'four hundred forty three');
});

it('Should return \'four hundred forty four\' when 444 given', () => {
  const readable = toReadable(444);

  assert.equal(readable, 'four hundred forty four');
});

it('Should return \'four hundred forty five\' when 445 given', () => {
  const readable = toReadable(445);

  assert.equal(readable, 'four hundred forty five');
});

it('Should return \'four hundred forty six\' when 446 given', () => {
  const readable = toReadable(446);

  assert.equal(readable, 'four hundred forty six');
});

it('Should return \'four hundred forty seven\' when 447 given', () => {
  const readable = toReadable(447);

  assert.equal(readable, 'four hundred forty seven');
});

it('Should return \'four hundred forty eight\' when 448 given', () => {
  const readable = toReadable(448);

  assert.equal(readable, 'four hundred forty eight');
});

it('Should return \'four hundred forty nine\' when 449 given', () => {
  const readable = toReadable(449);

  assert.equal(readable, 'four hundred forty nine');
});

it('Should return \'four hundred fifty\' when 450 given', () => {
  const readable = toReadable(450);

  assert.equal(readable, 'four hundred fifty');
});

it('Should return \'four hundred fifty one\' when 451 given', () => {
  const readable = toReadable(451);

  assert.equal(readable, 'four hundred fifty one');
});

it('Should return \'four hundred fifty two\' when 452 given', () => {
  const readable = toReadable(452);

  assert.equal(readable, 'four hundred fifty two');
});

it('Should return \'four hundred fifty three\' when 453 given', () => {
  const readable = toReadable(453);

  assert.equal(readable, 'four hundred fifty three');
});

it('Should return \'four hundred fifty four\' when 454 given', () => {
  const readable = toReadable(454);

  assert.equal(readable, 'four hundred fifty four');
});

it('Should return \'four hundred fifty five\' when 455 given', () => {
  const readable = toReadable(455);

  assert.equal(readable, 'four hundred fifty five');
});

it('Should return \'four hundred fifty six\' when 456 given', () => {
  const readable = toReadable(456);

  assert.equal(readable, 'four hundred fifty six');
});

it('Should return \'four hundred fifty seven\' when 457 given', () => {
  const readable = toReadable(457);

  assert.equal(readable, 'four hundred fifty seven');
});

it('Should return \'four hundred fifty eight\' when 458 given', () => {
  const readable = toReadable(458);

  assert.equal(readable, 'four hundred fifty eight');
});

it('Should return \'four hundred fifty nine\' when 459 given', () => {
  const readable = toReadable(459);

  assert.equal(readable, 'four hundred fifty nine');
});

it('Should return \'four hundred sixty\' when 460 given', () => {
  const readable = toReadable(460);

  assert.equal(readable, 'four hundred sixty');
});

it('Should return \'four hundred sixty one\' when 461 given', () => {
  const readable = toReadable(461);

  assert.equal(readable, 'four hundred sixty one');
});

it('Should return \'four hundred sixty two\' when 462 given', () => {
  const readable = toReadable(462);

  assert.equal(readable, 'four hundred sixty two');
});

it('Should return \'four hundred sixty three\' when 463 given', () => {
  const readable = toReadable(463);

  assert.equal(readable, 'four hundred sixty three');
});

it('Should return \'four hundred sixty four\' when 464 given', () => {
  const readable = toReadable(464);

  assert.equal(readable, 'four hundred sixty four');
});

it('Should return \'four hundred sixty five\' when 465 given', () => {
  const readable = toReadable(465);

  assert.equal(readable, 'four hundred sixty five');
});

it('Should return \'four hundred sixty six\' when 466 given', () => {
  const readable = toReadable(466);

  assert.equal(readable, 'four hundred sixty six');
});

it('Should return \'four hundred sixty seven\' when 467 given', () => {
  const readable = toReadable(467);

  assert.equal(readable, 'four hundred sixty seven');
});

it('Should return \'four hundred sixty eight\' when 468 given', () => {
  const readable = toReadable(468);

  assert.equal(readable, 'four hundred sixty eight');
});

it('Should return \'four hundred sixty nine\' when 469 given', () => {
  const readable = toReadable(469);

  assert.equal(readable, 'four hundred sixty nine');
});

it('Should return \'four hundred seventy\' when 470 given', () => {
  const readable = toReadable(470);

  assert.equal(readable, 'four hundred seventy');
});

it('Should return \'four hundred seventy one\' when 471 given', () => {
  const readable = toReadable(471);

  assert.equal(readable, 'four hundred seventy one');
});

it('Should return \'four hundred seventy two\' when 472 given', () => {
  const readable = toReadable(472);

  assert.equal(readable, 'four hundred seventy two');
});

it('Should return \'four hundred seventy three\' when 473 given', () => {
  const readable = toReadable(473);

  assert.equal(readable, 'four hundred seventy three');
});

it('Should return \'four hundred seventy four\' when 474 given', () => {
  const readable = toReadable(474);

  assert.equal(readable, 'four hundred seventy four');
});

it('Should return \'four hundred seventy five\' when 475 given', () => {
  const readable = toReadable(475);

  assert.equal(readable, 'four hundred seventy five');
});

it('Should return \'four hundred seventy six\' when 476 given', () => {
  const readable = toReadable(476);

  assert.equal(readable, 'four hundred seventy six');
});

it('Should return \'four hundred seventy seven\' when 477 given', () => {
  const readable = toReadable(477);

  assert.equal(readable, 'four hundred seventy seven');
});

it('Should return \'four hundred seventy eight\' when 478 given', () => {
  const readable = toReadable(478);

  assert.equal(readable, 'four hundred seventy eight');
});

it('Should return \'four hundred seventy nine\' when 479 given', () => {
  const readable = toReadable(479);

  assert.equal(readable, 'four hundred seventy nine');
});

it('Should return \'four hundred eighty\' when 480 given', () => {
  const readable = toReadable(480);

  assert.equal(readable, 'four hundred eighty');
});

it('Should return \'four hundred eighty one\' when 481 given', () => {
  const readable = toReadable(481);

  assert.equal(readable, 'four hundred eighty one');
});

it('Should return \'four hundred eighty two\' when 482 given', () => {
  const readable = toReadable(482);

  assert.equal(readable, 'four hundred eighty two');
});

it('Should return \'four hundred eighty three\' when 483 given', () => {
  const readable = toReadable(483);

  assert.equal(readable, 'four hundred eighty three');
});

it('Should return \'four hundred eighty four\' when 484 given', () => {
  const readable = toReadable(484);

  assert.equal(readable, 'four hundred eighty four');
});

it('Should return \'four hundred eighty five\' when 485 given', () => {
  const readable = toReadable(485);

  assert.equal(readable, 'four hundred eighty five');
});

it('Should return \'four hundred eighty six\' when 486 given', () => {
  const readable = toReadable(486);

  assert.equal(readable, 'four hundred eighty six');
});

it('Should return \'four hundred eighty seven\' when 487 given', () => {
  const readable = toReadable(487);

  assert.equal(readable, 'four hundred eighty seven');
});

it('Should return \'four hundred eighty eight\' when 488 given', () => {
  const readable = toReadable(488);

  assert.equal(readable, 'four hundred eighty eight');
});

it('Should return \'four hundred eighty nine\' when 489 given', () => {
  const readable = toReadable(489);

  assert.equal(readable, 'four hundred eighty nine');
});

it('Should return \'four hundred ninety\' when 490 given', () => {
  const readable = toReadable(490);

  assert.equal(readable, 'four hundred ninety');
});

it('Should return \'four hundred ninety one\' when 491 given', () => {
  const readable = toReadable(491);

  assert.equal(readable, 'four hundred ninety one');
});

it('Should return \'four hundred ninety two\' when 492 given', () => {
  const readable = toReadable(492);

  assert.equal(readable, 'four hundred ninety two');
});

it('Should return \'four hundred ninety three\' when 493 given', () => {
  const readable = toReadable(493);

  assert.equal(readable, 'four hundred ninety three');
});

it('Should return \'four hundred ninety four\' when 494 given', () => {
  const readable = toReadable(494);

  assert.equal(readable, 'four hundred ninety four');
});

it('Should return \'four hundred ninety five\' when 495 given', () => {
  const readable = toReadable(495);

  assert.equal(readable, 'four hundred ninety five');
});

it('Should return \'four hundred ninety six\' when 496 given', () => {
  const readable = toReadable(496);

  assert.equal(readable, 'four hundred ninety six');
});

it('Should return \'four hundred ninety seven\' when 497 given', () => {
  const readable = toReadable(497);

  assert.equal(readable, 'four hundred ninety seven');
});

it('Should return \'four hundred ninety eight\' when 498 given', () => {
  const readable = toReadable(498);

  assert.equal(readable, 'four hundred ninety eight');
});

it('Should return \'four hundred ninety nine\' when 499 given', () => {
  const readable = toReadable(499);

  assert.equal(readable, 'four hundred ninety nine');
});

it('Should return \'five hundred\' when 500 given', () => {
  const readable = toReadable(500);

  assert.equal(readable, 'five hundred');
});

it('Should return \'five hundred one\' when 501 given', () => {
  const readable = toReadable(501);

  assert.equal(readable, 'five hundred one');
});

it('Should return \'five hundred two\' when 502 given', () => {
  const readable = toReadable(502);

  assert.equal(readable, 'five hundred two');
});

it('Should return \'five hundred three\' when 503 given', () => {
  const readable = toReadable(503);

  assert.equal(readable, 'five hundred three');
});

it('Should return \'five hundred four\' when 504 given', () => {
  const readable = toReadable(504);

  assert.equal(readable, 'five hundred four');
});

it('Should return \'five hundred five\' when 505 given', () => {
  const readable = toReadable(505);

  assert.equal(readable, 'five hundred five');
});

it('Should return \'five hundred six\' when 506 given', () => {
  const readable = toReadable(506);

  assert.equal(readable, 'five hundred six');
});

it('Should return \'five hundred seven\' when 507 given', () => {
  const readable = toReadable(507);

  assert.equal(readable, 'five hundred seven');
});

it('Should return \'five hundred eight\' when 508 given', () => {
  const readable = toReadable(508);

  assert.equal(readable, 'five hundred eight');
});

it('Should return \'five hundred nine\' when 509 given', () => {
  const readable = toReadable(509);

  assert.equal(readable, 'five hundred nine');
});

it('Should return \'five hundred ten\' when 510 given', () => {
  const readable = toReadable(510);

  assert.equal(readable, 'five hundred ten');
});

it('Should return \'five hundred eleven\' when 511 given', () => {
  const readable = toReadable(511);

  assert.equal(readable, 'five hundred eleven');
});

it('Should return \'five hundred twelve\' when 512 given', () => {
  const readable = toReadable(512);

  assert.equal(readable, 'five hundred twelve');
});

it('Should return \'five hundred thirteen\' when 513 given', () => {
  const readable = toReadable(513);

  assert.equal(readable, 'five hundred thirteen');
});

it('Should return \'five hundred fourteen\' when 514 given', () => {
  const readable = toReadable(514);

  assert.equal(readable, 'five hundred fourteen');
});

it('Should return \'five hundred fifteen\' when 515 given', () => {
  const readable = toReadable(515);

  assert.equal(readable, 'five hundred fifteen');
});

it('Should return \'five hundred sixteen\' when 516 given', () => {
  const readable = toReadable(516);

  assert.equal(readable, 'five hundred sixteen');
});

it('Should return \'five hundred seventeen\' when 517 given', () => {
  const readable = toReadable(517);

  assert.equal(readable, 'five hundred seventeen');
});

it('Should return \'five hundred eighteen\' when 518 given', () => {
  const readable = toReadable(518);

  assert.equal(readable, 'five hundred eighteen');
});

it('Should return \'five hundred nineteen\' when 519 given', () => {
  const readable = toReadable(519);

  assert.equal(readable, 'five hundred nineteen');
});

it('Should return \'five hundred twenty\' when 520 given', () => {
  const readable = toReadable(520);

  assert.equal(readable, 'five hundred twenty');
});

it('Should return \'five hundred twenty one\' when 521 given', () => {
  const readable = toReadable(521);

  assert.equal(readable, 'five hundred twenty one');
});

it('Should return \'five hundred twenty two\' when 522 given', () => {
  const readable = toReadable(522);

  assert.equal(readable, 'five hundred twenty two');
});

it('Should return \'five hundred twenty three\' when 523 given', () => {
  const readable = toReadable(523);

  assert.equal(readable, 'five hundred twenty three');
});

it('Should return \'five hundred twenty four\' when 524 given', () => {
  const readable = toReadable(524);

  assert.equal(readable, 'five hundred twenty four');
});

it('Should return \'five hundred twenty five\' when 525 given', () => {
  const readable = toReadable(525);

  assert.equal(readable, 'five hundred twenty five');
});

it('Should return \'five hundred twenty six\' when 526 given', () => {
  const readable = toReadable(526);

  assert.equal(readable, 'five hundred twenty six');
});

it('Should return \'five hundred twenty seven\' when 527 given', () => {
  const readable = toReadable(527);

  assert.equal(readable, 'five hundred twenty seven');
});

it('Should return \'five hundred twenty eight\' when 528 given', () => {
  const readable = toReadable(528);

  assert.equal(readable, 'five hundred twenty eight');
});

it('Should return \'five hundred twenty nine\' when 529 given', () => {
  const readable = toReadable(529);

  assert.equal(readable, 'five hundred twenty nine');
});

it('Should return \'five hundred thirty\' when 530 given', () => {
  const readable = toReadable(530);

  assert.equal(readable, 'five hundred thirty');
});

it('Should return \'five hundred thirty one\' when 531 given', () => {
  const readable = toReadable(531);

  assert.equal(readable, 'five hundred thirty one');
});

it('Should return \'five hundred thirty two\' when 532 given', () => {
  const readable = toReadable(532);

  assert.equal(readable, 'five hundred thirty two');
});

it('Should return \'five hundred thirty three\' when 533 given', () => {
  const readable = toReadable(533);

  assert.equal(readable, 'five hundred thirty three');
});

it('Should return \'five hundred thirty four\' when 534 given', () => {
  const readable = toReadable(534);

  assert.equal(readable, 'five hundred thirty four');
});

it('Should return \'five hundred thirty five\' when 535 given', () => {
  const readable = toReadable(535);

  assert.equal(readable, 'five hundred thirty five');
});

it('Should return \'five hundred thirty six\' when 536 given', () => {
  const readable = toReadable(536);

  assert.equal(readable, 'five hundred thirty six');
});

it('Should return \'five hundred thirty seven\' when 537 given', () => {
  const readable = toReadable(537);

  assert.equal(readable, 'five hundred thirty seven');
});

it('Should return \'five hundred thirty eight\' when 538 given', () => {
  const readable = toReadable(538);

  assert.equal(readable, 'five hundred thirty eight');
});

it('Should return \'five hundred thirty nine\' when 539 given', () => {
  const readable = toReadable(539);

  assert.equal(readable, 'five hundred thirty nine');
});

it('Should return \'five hundred forty\' when 540 given', () => {
  const readable = toReadable(540);

  assert.equal(readable, 'five hundred forty');
});

it('Should return \'five hundred forty one\' when 541 given', () => {
  const readable = toReadable(541);

  assert.equal(readable, 'five hundred forty one');
});

it('Should return \'five hundred forty two\' when 542 given', () => {
  const readable = toReadable(542);

  assert.equal(readable, 'five hundred forty two');
});

it('Should return \'five hundred forty three\' when 543 given', () => {
  const readable = toReadable(543);

  assert.equal(readable, 'five hundred forty three');
});

it('Should return \'five hundred forty four\' when 544 given', () => {
  const readable = toReadable(544);

  assert.equal(readable, 'five hundred forty four');
});

it('Should return \'five hundred forty five\' when 545 given', () => {
  const readable = toReadable(545);

  assert.equal(readable, 'five hundred forty five');
});

it('Should return \'five hundred forty six\' when 546 given', () => {
  const readable = toReadable(546);

  assert.equal(readable, 'five hundred forty six');
});

it('Should return \'five hundred forty seven\' when 547 given', () => {
  const readable = toReadable(547);

  assert.equal(readable, 'five hundred forty seven');
});

it('Should return \'five hundred forty eight\' when 548 given', () => {
  const readable = toReadable(548);

  assert.equal(readable, 'five hundred forty eight');
});

it('Should return \'five hundred forty nine\' when 549 given', () => {
  const readable = toReadable(549);

  assert.equal(readable, 'five hundred forty nine');
});

it('Should return \'five hundred fifty\' when 550 given', () => {
  const readable = toReadable(550);

  assert.equal(readable, 'five hundred fifty');
});

it('Should return \'five hundred fifty one\' when 551 given', () => {
  const readable = toReadable(551);

  assert.equal(readable, 'five hundred fifty one');
});

it('Should return \'five hundred fifty two\' when 552 given', () => {
  const readable = toReadable(552);

  assert.equal(readable, 'five hundred fifty two');
});

it('Should return \'five hundred fifty three\' when 553 given', () => {
  const readable = toReadable(553);

  assert.equal(readable, 'five hundred fifty three');
});

it('Should return \'five hundred fifty four\' when 554 given', () => {
  const readable = toReadable(554);

  assert.equal(readable, 'five hundred fifty four');
});

it('Should return \'five hundred fifty five\' when 555 given', () => {
  const readable = toReadable(555);

  assert.equal(readable, 'five hundred fifty five');
});

it('Should return \'five hundred fifty six\' when 556 given', () => {
  const readable = toReadable(556);

  assert.equal(readable, 'five hundred fifty six');
});

it('Should return \'five hundred fifty seven\' when 557 given', () => {
  const readable = toReadable(557);

  assert.equal(readable, 'five hundred fifty seven');
});

it('Should return \'five hundred fifty eight\' when 558 given', () => {
  const readable = toReadable(558);

  assert.equal(readable, 'five hundred fifty eight');
});

it('Should return \'five hundred fifty nine\' when 559 given', () => {
  const readable = toReadable(559);

  assert.equal(readable, 'five hundred fifty nine');
});

it('Should return \'five hundred sixty\' when 560 given', () => {
  const readable = toReadable(560);

  assert.equal(readable, 'five hundred sixty');
});

it('Should return \'five hundred sixty one\' when 561 given', () => {
  const readable = toReadable(561);

  assert.equal(readable, 'five hundred sixty one');
});

it('Should return \'five hundred sixty two\' when 562 given', () => {
  const readable = toReadable(562);

  assert.equal(readable, 'five hundred sixty two');
});

it('Should return \'five hundred sixty three\' when 563 given', () => {
  const readable = toReadable(563);

  assert.equal(readable, 'five hundred sixty three');
});

it('Should return \'five hundred sixty four\' when 564 given', () => {
  const readable = toReadable(564);

  assert.equal(readable, 'five hundred sixty four');
});

it('Should return \'five hundred sixty five\' when 565 given', () => {
  const readable = toReadable(565);

  assert.equal(readable, 'five hundred sixty five');
});

it('Should return \'five hundred sixty six\' when 566 given', () => {
  const readable = toReadable(566);

  assert.equal(readable, 'five hundred sixty six');
});

it('Should return \'five hundred sixty seven\' when 567 given', () => {
  const readable = toReadable(567);

  assert.equal(readable, 'five hundred sixty seven');
});

it('Should return \'five hundred sixty eight\' when 568 given', () => {
  const readable = toReadable(568);

  assert.equal(readable, 'five hundred sixty eight');
});

it('Should return \'five hundred sixty nine\' when 569 given', () => {
  const readable = toReadable(569);

  assert.equal(readable, 'five hundred sixty nine');
});

it('Should return \'five hundred seventy\' when 570 given', () => {
  const readable = toReadable(570);

  assert.equal(readable, 'five hundred seventy');
});

it('Should return \'five hundred seventy one\' when 571 given', () => {
  const readable = toReadable(571);

  assert.equal(readable, 'five hundred seventy one');
});

it('Should return \'five hundred seventy two\' when 572 given', () => {
  const readable = toReadable(572);

  assert.equal(readable, 'five hundred seventy two');
});

it('Should return \'five hundred seventy three\' when 573 given', () => {
  const readable = toReadable(573);

  assert.equal(readable, 'five hundred seventy three');
});

it('Should return \'five hundred seventy four\' when 574 given', () => {
  const readable = toReadable(574);

  assert.equal(readable, 'five hundred seventy four');
});

it('Should return \'five hundred seventy five\' when 575 given', () => {
  const readable = toReadable(575);

  assert.equal(readable, 'five hundred seventy five');
});

it('Should return \'five hundred seventy six\' when 576 given', () => {
  const readable = toReadable(576);

  assert.equal(readable, 'five hundred seventy six');
});

it('Should return \'five hundred seventy seven\' when 577 given', () => {
  const readable = toReadable(577);

  assert.equal(readable, 'five hundred seventy seven');
});

it('Should return \'five hundred seventy eight\' when 578 given', () => {
  const readable = toReadable(578);

  assert.equal(readable, 'five hundred seventy eight');
});

it('Should return \'five hundred seventy nine\' when 579 given', () => {
  const readable = toReadable(579);

  assert.equal(readable, 'five hundred seventy nine');
});

it('Should return \'five hundred eighty\' when 580 given', () => {
  const readable = toReadable(580);

  assert.equal(readable, 'five hundred eighty');
});

it('Should return \'five hundred eighty one\' when 581 given', () => {
  const readable = toReadable(581);

  assert.equal(readable, 'five hundred eighty one');
});

it('Should return \'five hundred eighty two\' when 582 given', () => {
  const readable = toReadable(582);

  assert.equal(readable, 'five hundred eighty two');
});

it('Should return \'five hundred eighty three\' when 583 given', () => {
  const readable = toReadable(583);

  assert.equal(readable, 'five hundred eighty three');
});

it('Should return \'five hundred eighty four\' when 584 given', () => {
  const readable = toReadable(584);

  assert.equal(readable, 'five hundred eighty four');
});

it('Should return \'five hundred eighty five\' when 585 given', () => {
  const readable = toReadable(585);

  assert.equal(readable, 'five hundred eighty five');
});

it('Should return \'five hundred eighty six\' when 586 given', () => {
  const readable = toReadable(586);

  assert.equal(readable, 'five hundred eighty six');
});

it('Should return \'five hundred eighty seven\' when 587 given', () => {
  const readable = toReadable(587);

  assert.equal(readable, 'five hundred eighty seven');
});

it('Should return \'five hundred eighty eight\' when 588 given', () => {
  const readable = toReadable(588);

  assert.equal(readable, 'five hundred eighty eight');
});

it('Should return \'five hundred eighty nine\' when 589 given', () => {
  const readable = toReadable(589);

  assert.equal(readable, 'five hundred eighty nine');
});

it('Should return \'five hundred ninety\' when 590 given', () => {
  const readable = toReadable(590);

  assert.equal(readable, 'five hundred ninety');
});

it('Should return \'five hundred ninety one\' when 591 given', () => {
  const readable = toReadable(591);

  assert.equal(readable, 'five hundred ninety one');
});

it('Should return \'five hundred ninety two\' when 592 given', () => {
  const readable = toReadable(592);

  assert.equal(readable, 'five hundred ninety two');
});

it('Should return \'five hundred ninety three\' when 593 given', () => {
  const readable = toReadable(593);

  assert.equal(readable, 'five hundred ninety three');
});

it('Should return \'five hundred ninety four\' when 594 given', () => {
  const readable = toReadable(594);

  assert.equal(readable, 'five hundred ninety four');
});

it('Should return \'five hundred ninety five\' when 595 given', () => {
  const readable = toReadable(595);

  assert.equal(readable, 'five hundred ninety five');
});

it('Should return \'five hundred ninety six\' when 596 given', () => {
  const readable = toReadable(596);

  assert.equal(readable, 'five hundred ninety six');
});

it('Should return \'five hundred ninety seven\' when 597 given', () => {
  const readable = toReadable(597);

  assert.equal(readable, 'five hundred ninety seven');
});

it('Should return \'five hundred ninety eight\' when 598 given', () => {
  const readable = toReadable(598);

  assert.equal(readable, 'five hundred ninety eight');
});

it('Should return \'five hundred ninety nine\' when 599 given', () => {
  const readable = toReadable(599);

  assert.equal(readable, 'five hundred ninety nine');
});

it('Should return \'six hundred\' when 600 given', () => {
  const readable = toReadable(600);

  assert.equal(readable, 'six hundred');
});

it('Should return \'six hundred one\' when 601 given', () => {
  const readable = toReadable(601);

  assert.equal(readable, 'six hundred one');
});

it('Should return \'six hundred two\' when 602 given', () => {
  const readable = toReadable(602);

  assert.equal(readable, 'six hundred two');
});

it('Should return \'six hundred three\' when 603 given', () => {
  const readable = toReadable(603);

  assert.equal(readable, 'six hundred three');
});

it('Should return \'six hundred four\' when 604 given', () => {
  const readable = toReadable(604);

  assert.equal(readable, 'six hundred four');
});

it('Should return \'six hundred five\' when 605 given', () => {
  const readable = toReadable(605);

  assert.equal(readable, 'six hundred five');
});

it('Should return \'six hundred six\' when 606 given', () => {
  const readable = toReadable(606);

  assert.equal(readable, 'six hundred six');
});

it('Should return \'six hundred seven\' when 607 given', () => {
  const readable = toReadable(607);

  assert.equal(readable, 'six hundred seven');
});

it('Should return \'six hundred eight\' when 608 given', () => {
  const readable = toReadable(608);

  assert.equal(readable, 'six hundred eight');
});

it('Should return \'six hundred nine\' when 609 given', () => {
  const readable = toReadable(609);

  assert.equal(readable, 'six hundred nine');
});

it('Should return \'six hundred ten\' when 610 given', () => {
  const readable = toReadable(610);

  assert.equal(readable, 'six hundred ten');
});

it('Should return \'six hundred eleven\' when 611 given', () => {
  const readable = toReadable(611);

  assert.equal(readable, 'six hundred eleven');
});

it('Should return \'six hundred twelve\' when 612 given', () => {
  const readable = toReadable(612);

  assert.equal(readable, 'six hundred twelve');
});

it('Should return \'six hundred thirteen\' when 613 given', () => {
  const readable = toReadable(613);

  assert.equal(readable, 'six hundred thirteen');
});

it('Should return \'six hundred fourteen\' when 614 given', () => {
  const readable = toReadable(614);

  assert.equal(readable, 'six hundred fourteen');
});

it('Should return \'six hundred fifteen\' when 615 given', () => {
  const readable = toReadable(615);

  assert.equal(readable, 'six hundred fifteen');
});

it('Should return \'six hundred sixteen\' when 616 given', () => {
  const readable = toReadable(616);

  assert.equal(readable, 'six hundred sixteen');
});

it('Should return \'six hundred seventeen\' when 617 given', () => {
  const readable = toReadable(617);

  assert.equal(readable, 'six hundred seventeen');
});

it('Should return \'six hundred eighteen\' when 618 given', () => {
  const readable = toReadable(618);

  assert.equal(readable, 'six hundred eighteen');
});

it('Should return \'six hundred nineteen\' when 619 given', () => {
  const readable = toReadable(619);

  assert.equal(readable, 'six hundred nineteen');
});

it('Should return \'six hundred twenty\' when 620 given', () => {
  const readable = toReadable(620);

  assert.equal(readable, 'six hundred twenty');
});

it('Should return \'six hundred twenty one\' when 621 given', () => {
  const readable = toReadable(621);

  assert.equal(readable, 'six hundred twenty one');
});

it('Should return \'six hundred twenty two\' when 622 given', () => {
  const readable = toReadable(622);

  assert.equal(readable, 'six hundred twenty two');
});

it('Should return \'six hundred twenty three\' when 623 given', () => {
  const readable = toReadable(623);

  assert.equal(readable, 'six hundred twenty three');
});

it('Should return \'six hundred twenty four\' when 624 given', () => {
  const readable = toReadable(624);

  assert.equal(readable, 'six hundred twenty four');
});

it('Should return \'six hundred twenty five\' when 625 given', () => {
  const readable = toReadable(625);

  assert.equal(readable, 'six hundred twenty five');
});

it('Should return \'six hundred twenty six\' when 626 given', () => {
  const readable = toReadable(626);

  assert.equal(readable, 'six hundred twenty six');
});

it('Should return \'six hundred twenty seven\' when 627 given', () => {
  const readable = toReadable(627);

  assert.equal(readable, 'six hundred twenty seven');
});

it('Should return \'six hundred twenty eight\' when 628 given', () => {
  const readable = toReadable(628);

  assert.equal(readable, 'six hundred twenty eight');
});

it('Should return \'six hundred twenty nine\' when 629 given', () => {
  const readable = toReadable(629);

  assert.equal(readable, 'six hundred twenty nine');
});

it('Should return \'six hundred thirty\' when 630 given', () => {
  const readable = toReadable(630);

  assert.equal(readable, 'six hundred thirty');
});

it('Should return \'six hundred thirty one\' when 631 given', () => {
  const readable = toReadable(631);

  assert.equal(readable, 'six hundred thirty one');
});

it('Should return \'six hundred thirty two\' when 632 given', () => {
  const readable = toReadable(632);

  assert.equal(readable, 'six hundred thirty two');
});

it('Should return \'six hundred thirty three\' when 633 given', () => {
  const readable = toReadable(633);

  assert.equal(readable, 'six hundred thirty three');
});

it('Should return \'six hundred thirty four\' when 634 given', () => {
  const readable = toReadable(634);

  assert.equal(readable, 'six hundred thirty four');
});

it('Should return \'six hundred thirty five\' when 635 given', () => {
  const readable = toReadable(635);

  assert.equal(readable, 'six hundred thirty five');
});

it('Should return \'six hundred thirty six\' when 636 given', () => {
  const readable = toReadable(636);

  assert.equal(readable, 'six hundred thirty six');
});

it('Should return \'six hundred thirty seven\' when 637 given', () => {
  const readable = toReadable(637);

  assert.equal(readable, 'six hundred thirty seven');
});

it('Should return \'six hundred thirty eight\' when 638 given', () => {
  const readable = toReadable(638);

  assert.equal(readable, 'six hundred thirty eight');
});

it('Should return \'six hundred thirty nine\' when 639 given', () => {
  const readable = toReadable(639);

  assert.equal(readable, 'six hundred thirty nine');
});

it('Should return \'six hundred forty\' when 640 given', () => {
  const readable = toReadable(640);

  assert.equal(readable, 'six hundred forty');
});

it('Should return \'six hundred forty one\' when 641 given', () => {
  const readable = toReadable(641);

  assert.equal(readable, 'six hundred forty one');
});

it('Should return \'six hundred forty two\' when 642 given', () => {
  const readable = toReadable(642);

  assert.equal(readable, 'six hundred forty two');
});

it('Should return \'six hundred forty three\' when 643 given', () => {
  const readable = toReadable(643);

  assert.equal(readable, 'six hundred forty three');
});

it('Should return \'six hundred forty four\' when 644 given', () => {
  const readable = toReadable(644);

  assert.equal(readable, 'six hundred forty four');
});

it('Should return \'six hundred forty five\' when 645 given', () => {
  const readable = toReadable(645);

  assert.equal(readable, 'six hundred forty five');
});

it('Should return \'six hundred forty six\' when 646 given', () => {
  const readable = toReadable(646);

  assert.equal(readable, 'six hundred forty six');
});

it('Should return \'six hundred forty seven\' when 647 given', () => {
  const readable = toReadable(647);

  assert.equal(readable, 'six hundred forty seven');
});

it('Should return \'six hundred forty eight\' when 648 given', () => {
  const readable = toReadable(648);

  assert.equal(readable, 'six hundred forty eight');
});

it('Should return \'six hundred forty nine\' when 649 given', () => {
  const readable = toReadable(649);

  assert.equal(readable, 'six hundred forty nine');
});

it('Should return \'six hundred fifty\' when 650 given', () => {
  const readable = toReadable(650);

  assert.equal(readable, 'six hundred fifty');
});

it('Should return \'six hundred fifty one\' when 651 given', () => {
  const readable = toReadable(651);

  assert.equal(readable, 'six hundred fifty one');
});

it('Should return \'six hundred fifty two\' when 652 given', () => {
  const readable = toReadable(652);

  assert.equal(readable, 'six hundred fifty two');
});

it('Should return \'six hundred fifty three\' when 653 given', () => {
  const readable = toReadable(653);

  assert.equal(readable, 'six hundred fifty three');
});

it('Should return \'six hundred fifty four\' when 654 given', () => {
  const readable = toReadable(654);

  assert.equal(readable, 'six hundred fifty four');
});

it('Should return \'six hundred fifty five\' when 655 given', () => {
  const readable = toReadable(655);

  assert.equal(readable, 'six hundred fifty five');
});

it('Should return \'six hundred fifty six\' when 656 given', () => {
  const readable = toReadable(656);

  assert.equal(readable, 'six hundred fifty six');
});

it('Should return \'six hundred fifty seven\' when 657 given', () => {
  const readable = toReadable(657);

  assert.equal(readable, 'six hundred fifty seven');
});

it('Should return \'six hundred fifty eight\' when 658 given', () => {
  const readable = toReadable(658);

  assert.equal(readable, 'six hundred fifty eight');
});

it('Should return \'six hundred fifty nine\' when 659 given', () => {
  const readable = toReadable(659);

  assert.equal(readable, 'six hundred fifty nine');
});

it('Should return \'six hundred sixty\' when 660 given', () => {
  const readable = toReadable(660);

  assert.equal(readable, 'six hundred sixty');
});

it('Should return \'six hundred sixty one\' when 661 given', () => {
  const readable = toReadable(661);

  assert.equal(readable, 'six hundred sixty one');
});

it('Should return \'six hundred sixty two\' when 662 given', () => {
  const readable = toReadable(662);

  assert.equal(readable, 'six hundred sixty two');
});

it('Should return \'six hundred sixty three\' when 663 given', () => {
  const readable = toReadable(663);

  assert.equal(readable, 'six hundred sixty three');
});

it('Should return \'six hundred sixty four\' when 664 given', () => {
  const readable = toReadable(664);

  assert.equal(readable, 'six hundred sixty four');
});

it('Should return \'six hundred sixty five\' when 665 given', () => {
  const readable = toReadable(665);

  assert.equal(readable, 'six hundred sixty five');
});

it('Should return \'six hundred sixty six\' when 666 given', () => {
  const readable = toReadable(666);

  assert.equal(readable, 'six hundred sixty six');
});

it('Should return \'six hundred sixty seven\' when 667 given', () => {
  const readable = toReadable(667);

  assert.equal(readable, 'six hundred sixty seven');
});

it('Should return \'six hundred sixty eight\' when 668 given', () => {
  const readable = toReadable(668);

  assert.equal(readable, 'six hundred sixty eight');
});

it('Should return \'six hundred sixty nine\' when 669 given', () => {
  const readable = toReadable(669);

  assert.equal(readable, 'six hundred sixty nine');
});

it('Should return \'six hundred seventy\' when 670 given', () => {
  const readable = toReadable(670);

  assert.equal(readable, 'six hundred seventy');
});

it('Should return \'six hundred seventy one\' when 671 given', () => {
  const readable = toReadable(671);

  assert.equal(readable, 'six hundred seventy one');
});

it('Should return \'six hundred seventy two\' when 672 given', () => {
  const readable = toReadable(672);

  assert.equal(readable, 'six hundred seventy two');
});

it('Should return \'six hundred seventy three\' when 673 given', () => {
  const readable = toReadable(673);

  assert.equal(readable, 'six hundred seventy three');
});

it('Should return \'six hundred seventy four\' when 674 given', () => {
  const readable = toReadable(674);

  assert.equal(readable, 'six hundred seventy four');
});

it('Should return \'six hundred seventy five\' when 675 given', () => {
  const readable = toReadable(675);

  assert.equal(readable, 'six hundred seventy five');
});

it('Should return \'six hundred seventy six\' when 676 given', () => {
  const readable = toReadable(676);

  assert.equal(readable, 'six hundred seventy six');
});

it('Should return \'six hundred seventy seven\' when 677 given', () => {
  const readable = toReadable(677);

  assert.equal(readable, 'six hundred seventy seven');
});

it('Should return \'six hundred seventy eight\' when 678 given', () => {
  const readable = toReadable(678);

  assert.equal(readable, 'six hundred seventy eight');
});

it('Should return \'six hundred seventy nine\' when 679 given', () => {
  const readable = toReadable(679);

  assert.equal(readable, 'six hundred seventy nine');
});

it('Should return \'six hundred eighty\' when 680 given', () => {
  const readable = toReadable(680);

  assert.equal(readable, 'six hundred eighty');
});

it('Should return \'six hundred eighty one\' when 681 given', () => {
  const readable = toReadable(681);

  assert.equal(readable, 'six hundred eighty one');
});

it('Should return \'six hundred eighty two\' when 682 given', () => {
  const readable = toReadable(682);

  assert.equal(readable, 'six hundred eighty two');
});

it('Should return \'six hundred eighty three\' when 683 given', () => {
  const readable = toReadable(683);

  assert.equal(readable, 'six hundred eighty three');
});

it('Should return \'six hundred eighty four\' when 684 given', () => {
  const readable = toReadable(684);

  assert.equal(readable, 'six hundred eighty four');
});

it('Should return \'six hundred eighty five\' when 685 given', () => {
  const readable = toReadable(685);

  assert.equal(readable, 'six hundred eighty five');
});

it('Should return \'six hundred eighty six\' when 686 given', () => {
  const readable = toReadable(686);

  assert.equal(readable, 'six hundred eighty six');
});

it('Should return \'six hundred eighty seven\' when 687 given', () => {
  const readable = toReadable(687);

  assert.equal(readable, 'six hundred eighty seven');
});

it('Should return \'six hundred eighty eight\' when 688 given', () => {
  const readable = toReadable(688);

  assert.equal(readable, 'six hundred eighty eight');
});

it('Should return \'six hundred eighty nine\' when 689 given', () => {
  const readable = toReadable(689);

  assert.equal(readable, 'six hundred eighty nine');
});

it('Should return \'six hundred ninety\' when 690 given', () => {
  const readable = toReadable(690);

  assert.equal(readable, 'six hundred ninety');
});

it('Should return \'six hundred ninety one\' when 691 given', () => {
  const readable = toReadable(691);

  assert.equal(readable, 'six hundred ninety one');
});

it('Should return \'six hundred ninety two\' when 692 given', () => {
  const readable = toReadable(692);

  assert.equal(readable, 'six hundred ninety two');
});

it('Should return \'six hundred ninety three\' when 693 given', () => {
  const readable = toReadable(693);

  assert.equal(readable, 'six hundred ninety three');
});

it('Should return \'six hundred ninety four\' when 694 given', () => {
  const readable = toReadable(694);

  assert.equal(readable, 'six hundred ninety four');
});

it('Should return \'six hundred ninety five\' when 695 given', () => {
  const readable = toReadable(695);

  assert.equal(readable, 'six hundred ninety five');
});

it('Should return \'six hundred ninety six\' when 696 given', () => {
  const readable = toReadable(696);

  assert.equal(readable, 'six hundred ninety six');
});

it('Should return \'six hundred ninety seven\' when 697 given', () => {
  const readable = toReadable(697);

  assert.equal(readable, 'six hundred ninety seven');
});

it('Should return \'six hundred ninety eight\' when 698 given', () => {
  const readable = toReadable(698);

  assert.equal(readable, 'six hundred ninety eight');
});

it('Should return \'six hundred ninety nine\' when 699 given', () => {
  const readable = toReadable(699);

  assert.equal(readable, 'six hundred ninety nine');
});

it('Should return \'seven hundred\' when 700 given', () => {
  const readable = toReadable(700);

  assert.equal(readable, 'seven hundred');
});

it('Should return \'seven hundred one\' when 701 given', () => {
  const readable = toReadable(701);

  assert.equal(readable, 'seven hundred one');
});

it('Should return \'seven hundred two\' when 702 given', () => {
  const readable = toReadable(702);

  assert.equal(readable, 'seven hundred two');
});

it('Should return \'seven hundred three\' when 703 given', () => {
  const readable = toReadable(703);

  assert.equal(readable, 'seven hundred three');
});

it('Should return \'seven hundred four\' when 704 given', () => {
  const readable = toReadable(704);

  assert.equal(readable, 'seven hundred four');
});

it('Should return \'seven hundred five\' when 705 given', () => {
  const readable = toReadable(705);

  assert.equal(readable, 'seven hundred five');
});

it('Should return \'seven hundred six\' when 706 given', () => {
  const readable = toReadable(706);

  assert.equal(readable, 'seven hundred six');
});

it('Should return \'seven hundred seven\' when 707 given', () => {
  const readable = toReadable(707);

  assert.equal(readable, 'seven hundred seven');
});

it('Should return \'seven hundred eight\' when 708 given', () => {
  const readable = toReadable(708);

  assert.equal(readable, 'seven hundred eight');
});

it('Should return \'seven hundred nine\' when 709 given', () => {
  const readable = toReadable(709);

  assert.equal(readable, 'seven hundred nine');
});

it('Should return \'seven hundred ten\' when 710 given', () => {
  const readable = toReadable(710);

  assert.equal(readable, 'seven hundred ten');
});

it('Should return \'seven hundred eleven\' when 711 given', () => {
  const readable = toReadable(711);

  assert.equal(readable, 'seven hundred eleven');
});

it('Should return \'seven hundred twelve\' when 712 given', () => {
  const readable = toReadable(712);

  assert.equal(readable, 'seven hundred twelve');
});

it('Should return \'seven hundred thirteen\' when 713 given', () => {
  const readable = toReadable(713);

  assert.equal(readable, 'seven hundred thirteen');
});

it('Should return \'seven hundred fourteen\' when 714 given', () => {
  const readable = toReadable(714);

  assert.equal(readable, 'seven hundred fourteen');
});

it('Should return \'seven hundred fifteen\' when 715 given', () => {
  const readable = toReadable(715);

  assert.equal(readable, 'seven hundred fifteen');
});

it('Should return \'seven hundred sixteen\' when 716 given', () => {
  const readable = toReadable(716);

  assert.equal(readable, 'seven hundred sixteen');
});

it('Should return \'seven hundred seventeen\' when 717 given', () => {
  const readable = toReadable(717);

  assert.equal(readable, 'seven hundred seventeen');
});

it('Should return \'seven hundred eighteen\' when 718 given', () => {
  const readable = toReadable(718);

  assert.equal(readable, 'seven hundred eighteen');
});

it('Should return \'seven hundred nineteen\' when 719 given', () => {
  const readable = toReadable(719);

  assert.equal(readable, 'seven hundred nineteen');
});

it('Should return \'seven hundred twenty\' when 720 given', () => {
  const readable = toReadable(720);

  assert.equal(readable, 'seven hundred twenty');
});

it('Should return \'seven hundred twenty one\' when 721 given', () => {
  const readable = toReadable(721);

  assert.equal(readable, 'seven hundred twenty one');
});

it('Should return \'seven hundred twenty two\' when 722 given', () => {
  const readable = toReadable(722);

  assert.equal(readable, 'seven hundred twenty two');
});

it('Should return \'seven hundred twenty three\' when 723 given', () => {
  const readable = toReadable(723);

  assert.equal(readable, 'seven hundred twenty three');
});

it('Should return \'seven hundred twenty four\' when 724 given', () => {
  const readable = toReadable(724);

  assert.equal(readable, 'seven hundred twenty four');
});

it('Should return \'seven hundred twenty five\' when 725 given', () => {
  const readable = toReadable(725);

  assert.equal(readable, 'seven hundred twenty five');
});

it('Should return \'seven hundred twenty six\' when 726 given', () => {
  const readable = toReadable(726);

  assert.equal(readable, 'seven hundred twenty six');
});

it('Should return \'seven hundred twenty seven\' when 727 given', () => {
  const readable = toReadable(727);

  assert.equal(readable, 'seven hundred twenty seven');
});

it('Should return \'seven hundred twenty eight\' when 728 given', () => {
  const readable = toReadable(728);

  assert.equal(readable, 'seven hundred twenty eight');
});

it('Should return \'seven hundred twenty nine\' when 729 given', () => {
  const readable = toReadable(729);

  assert.equal(readable, 'seven hundred twenty nine');
});

it('Should return \'seven hundred thirty\' when 730 given', () => {
  const readable = toReadable(730);

  assert.equal(readable, 'seven hundred thirty');
});

it('Should return \'seven hundred thirty one\' when 731 given', () => {
  const readable = toReadable(731);

  assert.equal(readable, 'seven hundred thirty one');
});

it('Should return \'seven hundred thirty two\' when 732 given', () => {
  const readable = toReadable(732);

  assert.equal(readable, 'seven hundred thirty two');
});

it('Should return \'seven hundred thirty three\' when 733 given', () => {
  const readable = toReadable(733);

  assert.equal(readable, 'seven hundred thirty three');
});

it('Should return \'seven hundred thirty four\' when 734 given', () => {
  const readable = toReadable(734);

  assert.equal(readable, 'seven hundred thirty four');
});

it('Should return \'seven hundred thirty five\' when 735 given', () => {
  const readable = toReadable(735);

  assert.equal(readable, 'seven hundred thirty five');
});

it('Should return \'seven hundred thirty six\' when 736 given', () => {
  const readable = toReadable(736);

  assert.equal(readable, 'seven hundred thirty six');
});

it('Should return \'seven hundred thirty seven\' when 737 given', () => {
  const readable = toReadable(737);

  assert.equal(readable, 'seven hundred thirty seven');
});

it('Should return \'seven hundred thirty eight\' when 738 given', () => {
  const readable = toReadable(738);

  assert.equal(readable, 'seven hundred thirty eight');
});

it('Should return \'seven hundred thirty nine\' when 739 given', () => {
  const readable = toReadable(739);

  assert.equal(readable, 'seven hundred thirty nine');
});

it('Should return \'seven hundred forty\' when 740 given', () => {
  const readable = toReadable(740);

  assert.equal(readable, 'seven hundred forty');
});

it('Should return \'seven hundred forty one\' when 741 given', () => {
  const readable = toReadable(741);

  assert.equal(readable, 'seven hundred forty one');
});

it('Should return \'seven hundred forty two\' when 742 given', () => {
  const readable = toReadable(742);

  assert.equal(readable, 'seven hundred forty two');
});

it('Should return \'seven hundred forty three\' when 743 given', () => {
  const readable = toReadable(743);

  assert.equal(readable, 'seven hundred forty three');
});

it('Should return \'seven hundred forty four\' when 744 given', () => {
  const readable = toReadable(744);

  assert.equal(readable, 'seven hundred forty four');
});

it('Should return \'seven hundred forty five\' when 745 given', () => {
  const readable = toReadable(745);

  assert.equal(readable, 'seven hundred forty five');
});

it('Should return \'seven hundred forty six\' when 746 given', () => {
  const readable = toReadable(746);

  assert.equal(readable, 'seven hundred forty six');
});

it('Should return \'seven hundred forty seven\' when 747 given', () => {
  const readable = toReadable(747);

  assert.equal(readable, 'seven hundred forty seven');
});

it('Should return \'seven hundred forty eight\' when 748 given', () => {
  const readable = toReadable(748);

  assert.equal(readable, 'seven hundred forty eight');
});

it('Should return \'seven hundred forty nine\' when 749 given', () => {
  const readable = toReadable(749);

  assert.equal(readable, 'seven hundred forty nine');
});

it('Should return \'seven hundred fifty\' when 750 given', () => {
  const readable = toReadable(750);

  assert.equal(readable, 'seven hundred fifty');
});

it('Should return \'seven hundred fifty one\' when 751 given', () => {
  const readable = toReadable(751);

  assert.equal(readable, 'seven hundred fifty one');
});

it('Should return \'seven hundred fifty two\' when 752 given', () => {
  const readable = toReadable(752);

  assert.equal(readable, 'seven hundred fifty two');
});

it('Should return \'seven hundred fifty three\' when 753 given', () => {
  const readable = toReadable(753);

  assert.equal(readable, 'seven hundred fifty three');
});

it('Should return \'seven hundred fifty four\' when 754 given', () => {
  const readable = toReadable(754);

  assert.equal(readable, 'seven hundred fifty four');
});

it('Should return \'seven hundred fifty five\' when 755 given', () => {
  const readable = toReadable(755);

  assert.equal(readable, 'seven hundred fifty five');
});

it('Should return \'seven hundred fifty six\' when 756 given', () => {
  const readable = toReadable(756);

  assert.equal(readable, 'seven hundred fifty six');
});

it('Should return \'seven hundred fifty seven\' when 757 given', () => {
  const readable = toReadable(757);

  assert.equal(readable, 'seven hundred fifty seven');
});

it('Should return \'seven hundred fifty eight\' when 758 given', () => {
  const readable = toReadable(758);

  assert.equal(readable, 'seven hundred fifty eight');
});

it('Should return \'seven hundred fifty nine\' when 759 given', () => {
  const readable = toReadable(759);

  assert.equal(readable, 'seven hundred fifty nine');
});

it('Should return \'seven hundred sixty\' when 760 given', () => {
  const readable = toReadable(760);

  assert.equal(readable, 'seven hundred sixty');
});

it('Should return \'seven hundred sixty one\' when 761 given', () => {
  const readable = toReadable(761);

  assert.equal(readable, 'seven hundred sixty one');
});

it('Should return \'seven hundred sixty two\' when 762 given', () => {
  const readable = toReadable(762);

  assert.equal(readable, 'seven hundred sixty two');
});

it('Should return \'seven hundred sixty three\' when 763 given', () => {
  const readable = toReadable(763);

  assert.equal(readable, 'seven hundred sixty three');
});

it('Should return \'seven hundred sixty four\' when 764 given', () => {
  const readable = toReadable(764);

  assert.equal(readable, 'seven hundred sixty four');
});

it('Should return \'seven hundred sixty five\' when 765 given', () => {
  const readable = toReadable(765);

  assert.equal(readable, 'seven hundred sixty five');
});

it('Should return \'seven hundred sixty six\' when 766 given', () => {
  const readable = toReadable(766);

  assert.equal(readable, 'seven hundred sixty six');
});

it('Should return \'seven hundred sixty seven\' when 767 given', () => {
  const readable = toReadable(767);

  assert.equal(readable, 'seven hundred sixty seven');
});

it('Should return \'seven hundred sixty eight\' when 768 given', () => {
  const readable = toReadable(768);

  assert.equal(readable, 'seven hundred sixty eight');
});

it('Should return \'seven hundred sixty nine\' when 769 given', () => {
  const readable = toReadable(769);

  assert.equal(readable, 'seven hundred sixty nine');
});

it('Should return \'seven hundred seventy\' when 770 given', () => {
  const readable = toReadable(770);

  assert.equal(readable, 'seven hundred seventy');
});

it('Should return \'seven hundred seventy one\' when 771 given', () => {
  const readable = toReadable(771);

  assert.equal(readable, 'seven hundred seventy one');
});

it('Should return \'seven hundred seventy two\' when 772 given', () => {
  const readable = toReadable(772);

  assert.equal(readable, 'seven hundred seventy two');
});

it('Should return \'seven hundred seventy three\' when 773 given', () => {
  const readable = toReadable(773);

  assert.equal(readable, 'seven hundred seventy three');
});

it('Should return \'seven hundred seventy four\' when 774 given', () => {
  const readable = toReadable(774);

  assert.equal(readable, 'seven hundred seventy four');
});

it('Should return \'seven hundred seventy five\' when 775 given', () => {
  const readable = toReadable(775);

  assert.equal(readable, 'seven hundred seventy five');
});

it('Should return \'seven hundred seventy six\' when 776 given', () => {
  const readable = toReadable(776);

  assert.equal(readable, 'seven hundred seventy six');
});

it('Should return \'seven hundred seventy seven\' when 777 given', () => {
  const readable = toReadable(777);

  assert.equal(readable, 'seven hundred seventy seven');
});

it('Should return \'seven hundred seventy eight\' when 778 given', () => {
  const readable = toReadable(778);

  assert.equal(readable, 'seven hundred seventy eight');
});

it('Should return \'seven hundred seventy nine\' when 779 given', () => {
  const readable = toReadable(779);

  assert.equal(readable, 'seven hundred seventy nine');
});

it('Should return \'seven hundred eighty\' when 780 given', () => {
  const readable = toReadable(780);

  assert.equal(readable, 'seven hundred eighty');
});

it('Should return \'seven hundred eighty one\' when 781 given', () => {
  const readable = toReadable(781);

  assert.equal(readable, 'seven hundred eighty one');
});

it('Should return \'seven hundred eighty two\' when 782 given', () => {
  const readable = toReadable(782);

  assert.equal(readable, 'seven hundred eighty two');
});

it('Should return \'seven hundred eighty three\' when 783 given', () => {
  const readable = toReadable(783);

  assert.equal(readable, 'seven hundred eighty three');
});

it('Should return \'seven hundred eighty four\' when 784 given', () => {
  const readable = toReadable(784);

  assert.equal(readable, 'seven hundred eighty four');
});

it('Should return \'seven hundred eighty five\' when 785 given', () => {
  const readable = toReadable(785);

  assert.equal(readable, 'seven hundred eighty five');
});

it('Should return \'seven hundred eighty six\' when 786 given', () => {
  const readable = toReadable(786);

  assert.equal(readable, 'seven hundred eighty six');
});

it('Should return \'seven hundred eighty seven\' when 787 given', () => {
  const readable = toReadable(787);

  assert.equal(readable, 'seven hundred eighty seven');
});

it('Should return \'seven hundred eighty eight\' when 788 given', () => {
  const readable = toReadable(788);

  assert.equal(readable, 'seven hundred eighty eight');
});

it('Should return \'seven hundred eighty nine\' when 789 given', () => {
  const readable = toReadable(789);

  assert.equal(readable, 'seven hundred eighty nine');
});

it('Should return \'seven hundred ninety\' when 790 given', () => {
  const readable = toReadable(790);

  assert.equal(readable, 'seven hundred ninety');
});

it('Should return \'seven hundred ninety one\' when 791 given', () => {
  const readable = toReadable(791);

  assert.equal(readable, 'seven hundred ninety one');
});

it('Should return \'seven hundred ninety two\' when 792 given', () => {
  const readable = toReadable(792);

  assert.equal(readable, 'seven hundred ninety two');
});

it('Should return \'seven hundred ninety three\' when 793 given', () => {
  const readable = toReadable(793);

  assert.equal(readable, 'seven hundred ninety three');
});

it('Should return \'seven hundred ninety four\' when 794 given', () => {
  const readable = toReadable(794);

  assert.equal(readable, 'seven hundred ninety four');
});

it('Should return \'seven hundred ninety five\' when 795 given', () => {
  const readable = toReadable(795);

  assert.equal(readable, 'seven hundred ninety five');
});

it('Should return \'seven hundred ninety six\' when 796 given', () => {
  const readable = toReadable(796);

  assert.equal(readable, 'seven hundred ninety six');
});

it('Should return \'seven hundred ninety seven\' when 797 given', () => {
  const readable = toReadable(797);

  assert.equal(readable, 'seven hundred ninety seven');
});

it('Should return \'seven hundred ninety eight\' when 798 given', () => {
  const readable = toReadable(798);

  assert.equal(readable, 'seven hundred ninety eight');
});

it('Should return \'seven hundred ninety nine\' when 799 given', () => {
  const readable = toReadable(799);

  assert.equal(readable, 'seven hundred ninety nine');
});

it('Should return \'eight hundred\' when 800 given', () => {
  const readable = toReadable(800);

  assert.equal(readable, 'eight hundred');
});

it('Should return \'eight hundred one\' when 801 given', () => {
  const readable = toReadable(801);

  assert.equal(readable, 'eight hundred one');
});

it('Should return \'eight hundred two\' when 802 given', () => {
  const readable = toReadable(802);

  assert.equal(readable, 'eight hundred two');
});

it('Should return \'eight hundred three\' when 803 given', () => {
  const readable = toReadable(803);

  assert.equal(readable, 'eight hundred three');
});

it('Should return \'eight hundred four\' when 804 given', () => {
  const readable = toReadable(804);

  assert.equal(readable, 'eight hundred four');
});

it('Should return \'eight hundred five\' when 805 given', () => {
  const readable = toReadable(805);

  assert.equal(readable, 'eight hundred five');
});

it('Should return \'eight hundred six\' when 806 given', () => {
  const readable = toReadable(806);

  assert.equal(readable, 'eight hundred six');
});

it('Should return \'eight hundred seven\' when 807 given', () => {
  const readable = toReadable(807);

  assert.equal(readable, 'eight hundred seven');
});

it('Should return \'eight hundred eight\' when 808 given', () => {
  const readable = toReadable(808);

  assert.equal(readable, 'eight hundred eight');
});

it('Should return \'eight hundred nine\' when 809 given', () => {
  const readable = toReadable(809);

  assert.equal(readable, 'eight hundred nine');
});

it('Should return \'eight hundred ten\' when 810 given', () => {
  const readable = toReadable(810);

  assert.equal(readable, 'eight hundred ten');
});

it('Should return \'eight hundred eleven\' when 811 given', () => {
  const readable = toReadable(811);

  assert.equal(readable, 'eight hundred eleven');
});

it('Should return \'eight hundred twelve\' when 812 given', () => {
  const readable = toReadable(812);

  assert.equal(readable, 'eight hundred twelve');
});

it('Should return \'eight hundred thirteen\' when 813 given', () => {
  const readable = toReadable(813);

  assert.equal(readable, 'eight hundred thirteen');
});

it('Should return \'eight hundred fourteen\' when 814 given', () => {
  const readable = toReadable(814);

  assert.equal(readable, 'eight hundred fourteen');
});

it('Should return \'eight hundred fifteen\' when 815 given', () => {
  const readable = toReadable(815);

  assert.equal(readable, 'eight hundred fifteen');
});

it('Should return \'eight hundred sixteen\' when 816 given', () => {
  const readable = toReadable(816);

  assert.equal(readable, 'eight hundred sixteen');
});

it('Should return \'eight hundred seventeen\' when 817 given', () => {
  const readable = toReadable(817);

  assert.equal(readable, 'eight hundred seventeen');
});

it('Should return \'eight hundred eighteen\' when 818 given', () => {
  const readable = toReadable(818);

  assert.equal(readable, 'eight hundred eighteen');
});

it('Should return \'eight hundred nineteen\' when 819 given', () => {
  const readable = toReadable(819);

  assert.equal(readable, 'eight hundred nineteen');
});

it('Should return \'eight hundred twenty\' when 820 given', () => {
  const readable = toReadable(820);

  assert.equal(readable, 'eight hundred twenty');
});

it('Should return \'eight hundred twenty one\' when 821 given', () => {
  const readable = toReadable(821);

  assert.equal(readable, 'eight hundred twenty one');
});

it('Should return \'eight hundred twenty two\' when 822 given', () => {
  const readable = toReadable(822);

  assert.equal(readable, 'eight hundred twenty two');
});

it('Should return \'eight hundred twenty three\' when 823 given', () => {
  const readable = toReadable(823);

  assert.equal(readable, 'eight hundred twenty three');
});

it('Should return \'eight hundred twenty four\' when 824 given', () => {
  const readable = toReadable(824);

  assert.equal(readable, 'eight hundred twenty four');
});

it('Should return \'eight hundred twenty five\' when 825 given', () => {
  const readable = toReadable(825);

  assert.equal(readable, 'eight hundred twenty five');
});

it('Should return \'eight hundred twenty six\' when 826 given', () => {
  const readable = toReadable(826);

  assert.equal(readable, 'eight hundred twenty six');
});

it('Should return \'eight hundred twenty seven\' when 827 given', () => {
  const readable = toReadable(827);

  assert.equal(readable, 'eight hundred twenty seven');
});

it('Should return \'eight hundred twenty eight\' when 828 given', () => {
  const readable = toReadable(828);

  assert.equal(readable, 'eight hundred twenty eight');
});

it('Should return \'eight hundred twenty nine\' when 829 given', () => {
  const readable = toReadable(829);

  assert.equal(readable, 'eight hundred twenty nine');
});

it('Should return \'eight hundred thirty\' when 830 given', () => {
  const readable = toReadable(830);

  assert.equal(readable, 'eight hundred thirty');
});

it('Should return \'eight hundred thirty one\' when 831 given', () => {
  const readable = toReadable(831);

  assert.equal(readable, 'eight hundred thirty one');
});

it('Should return \'eight hundred thirty two\' when 832 given', () => {
  const readable = toReadable(832);

  assert.equal(readable, 'eight hundred thirty two');
});

it('Should return \'eight hundred thirty three\' when 833 given', () => {
  const readable = toReadable(833);

  assert.equal(readable, 'eight hundred thirty three');
});

it('Should return \'eight hundred thirty four\' when 834 given', () => {
  const readable = toReadable(834);

  assert.equal(readable, 'eight hundred thirty four');
});

it('Should return \'eight hundred thirty five\' when 835 given', () => {
  const readable = toReadable(835);

  assert.equal(readable, 'eight hundred thirty five');
});

it('Should return \'eight hundred thirty six\' when 836 given', () => {
  const readable = toReadable(836);

  assert.equal(readable, 'eight hundred thirty six');
});

it('Should return \'eight hundred thirty seven\' when 837 given', () => {
  const readable = toReadable(837);

  assert.equal(readable, 'eight hundred thirty seven');
});

it('Should return \'eight hundred thirty eight\' when 838 given', () => {
  const readable = toReadable(838);

  assert.equal(readable, 'eight hundred thirty eight');
});

it('Should return \'eight hundred thirty nine\' when 839 given', () => {
  const readable = toReadable(839);

  assert.equal(readable, 'eight hundred thirty nine');
});

it('Should return \'eight hundred forty\' when 840 given', () => {
  const readable = toReadable(840);

  assert.equal(readable, 'eight hundred forty');
});

it('Should return \'eight hundred forty one\' when 841 given', () => {
  const readable = toReadable(841);

  assert.equal(readable, 'eight hundred forty one');
});

it('Should return \'eight hundred forty two\' when 842 given', () => {
  const readable = toReadable(842);

  assert.equal(readable, 'eight hundred forty two');
});

it('Should return \'eight hundred forty three\' when 843 given', () => {
  const readable = toReadable(843);

  assert.equal(readable, 'eight hundred forty three');
});

it('Should return \'eight hundred forty four\' when 844 given', () => {
  const readable = toReadable(844);

  assert.equal(readable, 'eight hundred forty four');
});

it('Should return \'eight hundred forty five\' when 845 given', () => {
  const readable = toReadable(845);

  assert.equal(readable, 'eight hundred forty five');
});

it('Should return \'eight hundred forty six\' when 846 given', () => {
  const readable = toReadable(846);

  assert.equal(readable, 'eight hundred forty six');
});

it('Should return \'eight hundred forty seven\' when 847 given', () => {
  const readable = toReadable(847);

  assert.equal(readable, 'eight hundred forty seven');
});

it('Should return \'eight hundred forty eight\' when 848 given', () => {
  const readable = toReadable(848);

  assert.equal(readable, 'eight hundred forty eight');
});

it('Should return \'eight hundred forty nine\' when 849 given', () => {
  const readable = toReadable(849);

  assert.equal(readable, 'eight hundred forty nine');
});

it('Should return \'eight hundred fifty\' when 850 given', () => {
  const readable = toReadable(850);

  assert.equal(readable, 'eight hundred fifty');
});

it('Should return \'eight hundred fifty one\' when 851 given', () => {
  const readable = toReadable(851);

  assert.equal(readable, 'eight hundred fifty one');
});

it('Should return \'eight hundred fifty two\' when 852 given', () => {
  const readable = toReadable(852);

  assert.equal(readable, 'eight hundred fifty two');
});

it('Should return \'eight hundred fifty three\' when 853 given', () => {
  const readable = toReadable(853);

  assert.equal(readable, 'eight hundred fifty three');
});

it('Should return \'eight hundred fifty four\' when 854 given', () => {
  const readable = toReadable(854);

  assert.equal(readable, 'eight hundred fifty four');
});

it('Should return \'eight hundred fifty five\' when 855 given', () => {
  const readable = toReadable(855);

  assert.equal(readable, 'eight hundred fifty five');
});

it('Should return \'eight hundred fifty six\' when 856 given', () => {
  const readable = toReadable(856);

  assert.equal(readable, 'eight hundred fifty six');
});

it('Should return \'eight hundred fifty seven\' when 857 given', () => {
  const readable = toReadable(857);

  assert.equal(readable, 'eight hundred fifty seven');
});

it('Should return \'eight hundred fifty eight\' when 858 given', () => {
  const readable = toReadable(858);

  assert.equal(readable, 'eight hundred fifty eight');
});

it('Should return \'eight hundred fifty nine\' when 859 given', () => {
  const readable = toReadable(859);

  assert.equal(readable, 'eight hundred fifty nine');
});

it('Should return \'eight hundred sixty\' when 860 given', () => {
  const readable = toReadable(860);

  assert.equal(readable, 'eight hundred sixty');
});

it('Should return \'eight hundred sixty one\' when 861 given', () => {
  const readable = toReadable(861);

  assert.equal(readable, 'eight hundred sixty one');
});

it('Should return \'eight hundred sixty two\' when 862 given', () => {
  const readable = toReadable(862);

  assert.equal(readable, 'eight hundred sixty two');
});

it('Should return \'eight hundred sixty three\' when 863 given', () => {
  const readable = toReadable(863);

  assert.equal(readable, 'eight hundred sixty three');
});

it('Should return \'eight hundred sixty four\' when 864 given', () => {
  const readable = toReadable(864);

  assert.equal(readable, 'eight hundred sixty four');
});

it('Should return \'eight hundred sixty five\' when 865 given', () => {
  const readable = toReadable(865);

  assert.equal(readable, 'eight hundred sixty five');
});

it('Should return \'eight hundred sixty six\' when 866 given', () => {
  const readable = toReadable(866);

  assert.equal(readable, 'eight hundred sixty six');
});

it('Should return \'eight hundred sixty seven\' when 867 given', () => {
  const readable = toReadable(867);

  assert.equal(readable, 'eight hundred sixty seven');
});

it('Should return \'eight hundred sixty eight\' when 868 given', () => {
  const readable = toReadable(868);

  assert.equal(readable, 'eight hundred sixty eight');
});

it('Should return \'eight hundred sixty nine\' when 869 given', () => {
  const readable = toReadable(869);

  assert.equal(readable, 'eight hundred sixty nine');
});

it('Should return \'eight hundred seventy\' when 870 given', () => {
  const readable = toReadable(870);

  assert.equal(readable, 'eight hundred seventy');
});

it('Should return \'eight hundred seventy one\' when 871 given', () => {
  const readable = toReadable(871);

  assert.equal(readable, 'eight hundred seventy one');
});

it('Should return \'eight hundred seventy two\' when 872 given', () => {
  const readable = toReadable(872);

  assert.equal(readable, 'eight hundred seventy two');
});

it('Should return \'eight hundred seventy three\' when 873 given', () => {
  const readable = toReadable(873);

  assert.equal(readable, 'eight hundred seventy three');
});

it('Should return \'eight hundred seventy four\' when 874 given', () => {
  const readable = toReadable(874);

  assert.equal(readable, 'eight hundred seventy four');
});

it('Should return \'eight hundred seventy five\' when 875 given', () => {
  const readable = toReadable(875);

  assert.equal(readable, 'eight hundred seventy five');
});

it('Should return \'eight hundred seventy six\' when 876 given', () => {
  const readable = toReadable(876);

  assert.equal(readable, 'eight hundred seventy six');
});

it('Should return \'eight hundred seventy seven\' when 877 given', () => {
  const readable = toReadable(877);

  assert.equal(readable, 'eight hundred seventy seven');
});

it('Should return \'eight hundred seventy eight\' when 878 given', () => {
  const readable = toReadable(878);

  assert.equal(readable, 'eight hundred seventy eight');
});

it('Should return \'eight hundred seventy nine\' when 879 given', () => {
  const readable = toReadable(879);

  assert.equal(readable, 'eight hundred seventy nine');
});

it('Should return \'eight hundred eighty\' when 880 given', () => {
  const readable = toReadable(880);

  assert.equal(readable, 'eight hundred eighty');
});

it('Should return \'eight hundred eighty one\' when 881 given', () => {
  const readable = toReadable(881);

  assert.equal(readable, 'eight hundred eighty one');
});

it('Should return \'eight hundred eighty two\' when 882 given', () => {
  const readable = toReadable(882);

  assert.equal(readable, 'eight hundred eighty two');
});

it('Should return \'eight hundred eighty three\' when 883 given', () => {
  const readable = toReadable(883);

  assert.equal(readable, 'eight hundred eighty three');
});

it('Should return \'eight hundred eighty four\' when 884 given', () => {
  const readable = toReadable(884);

  assert.equal(readable, 'eight hundred eighty four');
});

it('Should return \'eight hundred eighty five\' when 885 given', () => {
  const readable = toReadable(885);

  assert.equal(readable, 'eight hundred eighty five');
});

it('Should return \'eight hundred eighty six\' when 886 given', () => {
  const readable = toReadable(886);

  assert.equal(readable, 'eight hundred eighty six');
});

it('Should return \'eight hundred eighty seven\' when 887 given', () => {
  const readable = toReadable(887);

  assert.equal(readable, 'eight hundred eighty seven');
});

it('Should return \'eight hundred eighty eight\' when 888 given', () => {
  const readable = toReadable(888);

  assert.equal(readable, 'eight hundred eighty eight');
});

it('Should return \'eight hundred eighty nine\' when 889 given', () => {
  const readable = toReadable(889);

  assert.equal(readable, 'eight hundred eighty nine');
});

it('Should return \'eight hundred ninety\' when 890 given', () => {
  const readable = toReadable(890);

  assert.equal(readable, 'eight hundred ninety');
});

it('Should return \'eight hundred ninety one\' when 891 given', () => {
  const readable = toReadable(891);

  assert.equal(readable, 'eight hundred ninety one');
});

it('Should return \'eight hundred ninety two\' when 892 given', () => {
  const readable = toReadable(892);

  assert.equal(readable, 'eight hundred ninety two');
});

it('Should return \'eight hundred ninety three\' when 893 given', () => {
  const readable = toReadable(893);

  assert.equal(readable, 'eight hundred ninety three');
});

it('Should return \'eight hundred ninety four\' when 894 given', () => {
  const readable = toReadable(894);

  assert.equal(readable, 'eight hundred ninety four');
});

it('Should return \'eight hundred ninety five\' when 895 given', () => {
  const readable = toReadable(895);

  assert.equal(readable, 'eight hundred ninety five');
});

it('Should return \'eight hundred ninety six\' when 896 given', () => {
  const readable = toReadable(896);

  assert.equal(readable, 'eight hundred ninety six');
});

it('Should return \'eight hundred ninety seven\' when 897 given', () => {
  const readable = toReadable(897);

  assert.equal(readable, 'eight hundred ninety seven');
});

it('Should return \'eight hundred ninety eight\' when 898 given', () => {
  const readable = toReadable(898);

  assert.equal(readable, 'eight hundred ninety eight');
});

it('Should return \'eight hundred ninety nine\' when 899 given', () => {
  const readable = toReadable(899);

  assert.equal(readable, 'eight hundred ninety nine');
});

it('Should return \'nine hundred\' when 900 given', () => {
  const readable = toReadable(900);

  assert.equal(readable, 'nine hundred');
});

it('Should return \'nine hundred one\' when 901 given', () => {
  const readable = toReadable(901);

  assert.equal(readable, 'nine hundred one');
});

it('Should return \'nine hundred two\' when 902 given', () => {
  const readable = toReadable(902);

  assert.equal(readable, 'nine hundred two');
});

it('Should return \'nine hundred three\' when 903 given', () => {
  const readable = toReadable(903);

  assert.equal(readable, 'nine hundred three');
});

it('Should return \'nine hundred four\' when 904 given', () => {
  const readable = toReadable(904);

  assert.equal(readable, 'nine hundred four');
});

it('Should return \'nine hundred five\' when 905 given', () => {
  const readable = toReadable(905);

  assert.equal(readable, 'nine hundred five');
});

it('Should return \'nine hundred six\' when 906 given', () => {
  const readable = toReadable(906);

  assert.equal(readable, 'nine hundred six');
});

it('Should return \'nine hundred seven\' when 907 given', () => {
  const readable = toReadable(907);

  assert.equal(readable, 'nine hundred seven');
});

it('Should return \'nine hundred eight\' when 908 given', () => {
  const readable = toReadable(908);

  assert.equal(readable, 'nine hundred eight');
});

it('Should return \'nine hundred nine\' when 909 given', () => {
  const readable = toReadable(909);

  assert.equal(readable, 'nine hundred nine');
});

it('Should return \'nine hundred ten\' when 910 given', () => {
  const readable = toReadable(910);

  assert.equal(readable, 'nine hundred ten');
});

it('Should return \'nine hundred eleven\' when 911 given', () => {
  const readable = toReadable(911);

  assert.equal(readable, 'nine hundred eleven');
});

it('Should return \'nine hundred twelve\' when 912 given', () => {
  const readable = toReadable(912);

  assert.equal(readable, 'nine hundred twelve');
});

it('Should return \'nine hundred thirteen\' when 913 given', () => {
  const readable = toReadable(913);

  assert.equal(readable, 'nine hundred thirteen');
});

it('Should return \'nine hundred fourteen\' when 914 given', () => {
  const readable = toReadable(914);

  assert.equal(readable, 'nine hundred fourteen');
});

it('Should return \'nine hundred fifteen\' when 915 given', () => {
  const readable = toReadable(915);

  assert.equal(readable, 'nine hundred fifteen');
});

it('Should return \'nine hundred sixteen\' when 916 given', () => {
  const readable = toReadable(916);

  assert.equal(readable, 'nine hundred sixteen');
});

it('Should return \'nine hundred seventeen\' when 917 given', () => {
  const readable = toReadable(917);

  assert.equal(readable, 'nine hundred seventeen');
});

it('Should return \'nine hundred eighteen\' when 918 given', () => {
  const readable = toReadable(918);

  assert.equal(readable, 'nine hundred eighteen');
});

it('Should return \'nine hundred nineteen\' when 919 given', () => {
  const readable = toReadable(919);

  assert.equal(readable, 'nine hundred nineteen');
});

it('Should return \'nine hundred twenty\' when 920 given', () => {
  const readable = toReadable(920);

  assert.equal(readable, 'nine hundred twenty');
});

it('Should return \'nine hundred twenty one\' when 921 given', () => {
  const readable = toReadable(921);

  assert.equal(readable, 'nine hundred twenty one');
});

it('Should return \'nine hundred twenty two\' when 922 given', () => {
  const readable = toReadable(922);

  assert.equal(readable, 'nine hundred twenty two');
});

it('Should return \'nine hundred twenty three\' when 923 given', () => {
  const readable = toReadable(923);

  assert.equal(readable, 'nine hundred twenty three');
});

it('Should return \'nine hundred twenty four\' when 924 given', () => {
  const readable = toReadable(924);

  assert.equal(readable, 'nine hundred twenty four');
});

it('Should return \'nine hundred twenty five\' when 925 given', () => {
  const readable = toReadable(925);

  assert.equal(readable, 'nine hundred twenty five');
});

it('Should return \'nine hundred twenty six\' when 926 given', () => {
  const readable = toReadable(926);

  assert.equal(readable, 'nine hundred twenty six');
});

it('Should return \'nine hundred twenty seven\' when 927 given', () => {
  const readable = toReadable(927);

  assert.equal(readable, 'nine hundred twenty seven');
});

it('Should return \'nine hundred twenty eight\' when 928 given', () => {
  const readable = toReadable(928);

  assert.equal(readable, 'nine hundred twenty eight');
});

it('Should return \'nine hundred twenty nine\' when 929 given', () => {
  const readable = toReadable(929);

  assert.equal(readable, 'nine hundred twenty nine');
});

it('Should return \'nine hundred thirty\' when 930 given', () => {
  const readable = toReadable(930);

  assert.equal(readable, 'nine hundred thirty');
});

it('Should return \'nine hundred thirty one\' when 931 given', () => {
  const readable = toReadable(931);

  assert.equal(readable, 'nine hundred thirty one');
});

it('Should return \'nine hundred thirty two\' when 932 given', () => {
  const readable = toReadable(932);

  assert.equal(readable, 'nine hundred thirty two');
});

it('Should return \'nine hundred thirty three\' when 933 given', () => {
  const readable = toReadable(933);

  assert.equal(readable, 'nine hundred thirty three');
});

it('Should return \'nine hundred thirty four\' when 934 given', () => {
  const readable = toReadable(934);

  assert.equal(readable, 'nine hundred thirty four');
});

it('Should return \'nine hundred thirty five\' when 935 given', () => {
  const readable = toReadable(935);

  assert.equal(readable, 'nine hundred thirty five');
});

it('Should return \'nine hundred thirty six\' when 936 given', () => {
  const readable = toReadable(936);

  assert.equal(readable, 'nine hundred thirty six');
});

it('Should return \'nine hundred thirty seven\' when 937 given', () => {
  const readable = toReadable(937);

  assert.equal(readable, 'nine hundred thirty seven');
});

it('Should return \'nine hundred thirty eight\' when 938 given', () => {
  const readable = toReadable(938);

  assert.equal(readable, 'nine hundred thirty eight');
});

it('Should return \'nine hundred thirty nine\' when 939 given', () => {
  const readable = toReadable(939);

  assert.equal(readable, 'nine hundred thirty nine');
});

it('Should return \'nine hundred forty\' when 940 given', () => {
  const readable = toReadable(940);

  assert.equal(readable, 'nine hundred forty');
});

it('Should return \'nine hundred forty one\' when 941 given', () => {
  const readable = toReadable(941);

  assert.equal(readable, 'nine hundred forty one');
});

it('Should return \'nine hundred forty two\' when 942 given', () => {
  const readable = toReadable(942);

  assert.equal(readable, 'nine hundred forty two');
});

it('Should return \'nine hundred forty three\' when 943 given', () => {
  const readable = toReadable(943);

  assert.equal(readable, 'nine hundred forty three');
});

it('Should return \'nine hundred forty four\' when 944 given', () => {
  const readable = toReadable(944);

  assert.equal(readable, 'nine hundred forty four');
});

it('Should return \'nine hundred forty five\' when 945 given', () => {
  const readable = toReadable(945);

  assert.equal(readable, 'nine hundred forty five');
});

it('Should return \'nine hundred forty six\' when 946 given', () => {
  const readable = toReadable(946);

  assert.equal(readable, 'nine hundred forty six');
});

it('Should return \'nine hundred forty seven\' when 947 given', () => {
  const readable = toReadable(947);

  assert.equal(readable, 'nine hundred forty seven');
});

it('Should return \'nine hundred forty eight\' when 948 given', () => {
  const readable = toReadable(948);

  assert.equal(readable, 'nine hundred forty eight');
});

it('Should return \'nine hundred forty nine\' when 949 given', () => {
  const readable = toReadable(949);

  assert.equal(readable, 'nine hundred forty nine');
});

it('Should return \'nine hundred fifty\' when 950 given', () => {
  const readable = toReadable(950);

  assert.equal(readable, 'nine hundred fifty');
});

it('Should return \'nine hundred fifty one\' when 951 given', () => {
  const readable = toReadable(951);

  assert.equal(readable, 'nine hundred fifty one');
});

it('Should return \'nine hundred fifty two\' when 952 given', () => {
  const readable = toReadable(952);

  assert.equal(readable, 'nine hundred fifty two');
});

it('Should return \'nine hundred fifty three\' when 953 given', () => {
  const readable = toReadable(953);

  assert.equal(readable, 'nine hundred fifty three');
});

it('Should return \'nine hundred fifty four\' when 954 given', () => {
  const readable = toReadable(954);

  assert.equal(readable, 'nine hundred fifty four');
});

it('Should return \'nine hundred fifty five\' when 955 given', () => {
  const readable = toReadable(955);

  assert.equal(readable, 'nine hundred fifty five');
});

it('Should return \'nine hundred fifty six\' when 956 given', () => {
  const readable = toReadable(956);

  assert.equal(readable, 'nine hundred fifty six');
});

it('Should return \'nine hundred fifty seven\' when 957 given', () => {
  const readable = toReadable(957);

  assert.equal(readable, 'nine hundred fifty seven');
});

it('Should return \'nine hundred fifty eight\' when 958 given', () => {
  const readable = toReadable(958);

  assert.equal(readable, 'nine hundred fifty eight');
});

it('Should return \'nine hundred fifty nine\' when 959 given', () => {
  const readable = toReadable(959);

  assert.equal(readable, 'nine hundred fifty nine');
});

it('Should return \'nine hundred sixty\' when 960 given', () => {
  const readable = toReadable(960);

  assert.equal(readable, 'nine hundred sixty');
});

it('Should return \'nine hundred sixty one\' when 961 given', () => {
  const readable = toReadable(961);

  assert.equal(readable, 'nine hundred sixty one');
});

it('Should return \'nine hundred sixty two\' when 962 given', () => {
  const readable = toReadable(962);

  assert.equal(readable, 'nine hundred sixty two');
});

it('Should return \'nine hundred sixty three\' when 963 given', () => {
  const readable = toReadable(963);

  assert.equal(readable, 'nine hundred sixty three');
});

it('Should return \'nine hundred sixty four\' when 964 given', () => {
  const readable = toReadable(964);

  assert.equal(readable, 'nine hundred sixty four');
});

it('Should return \'nine hundred sixty five\' when 965 given', () => {
  const readable = toReadable(965);

  assert.equal(readable, 'nine hundred sixty five');
});

it('Should return \'nine hundred sixty six\' when 966 given', () => {
  const readable = toReadable(966);

  assert.equal(readable, 'nine hundred sixty six');
});

it('Should return \'nine hundred sixty seven\' when 967 given', () => {
  const readable = toReadable(967);

  assert.equal(readable, 'nine hundred sixty seven');
});

it('Should return \'nine hundred sixty eight\' when 968 given', () => {
  const readable = toReadable(968);

  assert.equal(readable, 'nine hundred sixty eight');
});

it('Should return \'nine hundred sixty nine\' when 969 given', () => {
  const readable = toReadable(969);

  assert.equal(readable, 'nine hundred sixty nine');
});

it('Should return \'nine hundred seventy\' when 970 given', () => {
  const readable = toReadable(970);

  assert.equal(readable, 'nine hundred seventy');
});

it('Should return \'nine hundred seventy one\' when 971 given', () => {
  const readable = toReadable(971);

  assert.equal(readable, 'nine hundred seventy one');
});

it('Should return \'nine hundred seventy two\' when 972 given', () => {
  const readable = toReadable(972);

  assert.equal(readable, 'nine hundred seventy two');
});

it('Should return \'nine hundred seventy three\' when 973 given', () => {
  const readable = toReadable(973);

  assert.equal(readable, 'nine hundred seventy three');
});

it('Should return \'nine hundred seventy four\' when 974 given', () => {
  const readable = toReadable(974);

  assert.equal(readable, 'nine hundred seventy four');
});

it('Should return \'nine hundred seventy five\' when 975 given', () => {
  const readable = toReadable(975);

  assert.equal(readable, 'nine hundred seventy five');
});

it('Should return \'nine hundred seventy six\' when 976 given', () => {
  const readable = toReadable(976);

  assert.equal(readable, 'nine hundred seventy six');
});

it('Should return \'nine hundred seventy seven\' when 977 given', () => {
  const readable = toReadable(977);

  assert.equal(readable, 'nine hundred seventy seven');
});

it('Should return \'nine hundred seventy eight\' when 978 given', () => {
  const readable = toReadable(978);

  assert.equal(readable, 'nine hundred seventy eight');
});

it('Should return \'nine hundred seventy nine\' when 979 given', () => {
  const readable = toReadable(979);

  assert.equal(readable, 'nine hundred seventy nine');
});

it('Should return \'nine hundred eighty\' when 980 given', () => {
  const readable = toReadable(980);

  assert.equal(readable, 'nine hundred eighty');
});

it('Should return \'nine hundred eighty one\' when 981 given', () => {
  const readable = toReadable(981);

  assert.equal(readable, 'nine hundred eighty one');
});

it('Should return \'nine hundred eighty two\' when 982 given', () => {
  const readable = toReadable(982);

  assert.equal(readable, 'nine hundred eighty two');
});

it('Should return \'nine hundred eighty three\' when 983 given', () => {
  const readable = toReadable(983);

  assert.equal(readable, 'nine hundred eighty three');
});

it('Should return \'nine hundred eighty four\' when 984 given', () => {
  const readable = toReadable(984);

  assert.equal(readable, 'nine hundred eighty four');
});

it('Should return \'nine hundred eighty five\' when 985 given', () => {
  const readable = toReadable(985);

  assert.equal(readable, 'nine hundred eighty five');
});

it('Should return \'nine hundred eighty six\' when 986 given', () => {
  const readable = toReadable(986);

  assert.equal(readable, 'nine hundred eighty six');
});

it('Should return \'nine hundred eighty seven\' when 987 given', () => {
  const readable = toReadable(987);

  assert.equal(readable, 'nine hundred eighty seven');
});

it('Should return \'nine hundred eighty eight\' when 988 given', () => {
  const readable = toReadable(988);

  assert.equal(readable, 'nine hundred eighty eight');
});

it('Should return \'nine hundred eighty nine\' when 989 given', () => {
  const readable = toReadable(989);

  assert.equal(readable, 'nine hundred eighty nine');
});

it('Should return \'nine hundred ninety\' when 990 given', () => {
  const readable = toReadable(990);

  assert.equal(readable, 'nine hundred ninety');
});

it('Should return \'nine hundred ninety one\' when 991 given', () => {
  const readable = toReadable(991);

  assert.equal(readable, 'nine hundred ninety one');
});

it('Should return \'nine hundred ninety two\' when 992 given', () => {
  const readable = toReadable(992);

  assert.equal(readable, 'nine hundred ninety two');
});

it('Should return \'nine hundred ninety three\' when 993 given', () => {
  const readable = toReadable(993);

  assert.equal(readable, 'nine hundred ninety three');
});

it('Should return \'nine hundred ninety four\' when 994 given', () => {
  const readable = toReadable(994);

  assert.equal(readable, 'nine hundred ninety four');
});

it('Should return \'nine hundred ninety five\' when 995 given', () => {
  const readable = toReadable(995);

  assert.equal(readable, 'nine hundred ninety five');
});

it('Should return \'nine hundred ninety six\' when 996 given', () => {
  const readable = toReadable(996);

  assert.equal(readable, 'nine hundred ninety six');
});

it('Should return \'nine hundred ninety seven\' when 997 given', () => {
  const readable = toReadable(997);

  assert.equal(readable, 'nine hundred ninety seven');
});

it('Should return \'nine hundred ninety eight\' when 998 given', () => {
  const readable = toReadable(998);

  assert.equal(readable, 'nine hundred ninety eight');
});

it('Should return \'nine hundred ninety nine\' when 999 given', () => {
  const readable = toReadable(999);

  assert.equal(readable, 'nine hundred ninety nine');
});