diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..3c3629e --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +node_modules diff --git a/Gruntfile.js b/Gruntfile.js new file mode 100644 index 0000000..136edb5 --- /dev/null +++ b/Gruntfile.js @@ -0,0 +1,20 @@ +module.exports = function(grunt) { + + //load tasks + grunt.loadNpmTasks('grunt-mocha-test'); + + //configure tasks + grunt.initConfig({ + mochaTest: { + test: { + options: { + reporter: 'spec' + }, + src: ['test/**/*.js'] + } + } + }); + + grunt.registerTask('test', ['mochaTest']); + grunt.registerTask('default', ['test']); +}; \ No newline at end of file diff --git a/package.json b/package.json index 9117cf5..ce5e030 100644 --- a/package.json +++ b/package.json @@ -10,6 +10,11 @@ }, "main": "index.js", "dependencies": {}, - "devDependencies": {}, + "devDependencies": { + "chai": "^1.10.0", + "grunt": "^0.4.5", + "grunt-mocha-test": "^0.12.6", + "mocha": "^2.1.0" + }, "optionalDependencies": {} } diff --git a/test/cmu_lex.test.js b/test/cmu_lex.test.js new file mode 100644 index 0000000..4d5dbbe --- /dev/null +++ b/test/cmu_lex.test.js @@ -0,0 +1,10574 @@ +var chai = require('chai'); +var assert = chai.assert; + +/* + + Words failing according to the CMU pronunciation dictionary. + +*/ + +var TS = require('../index'); +var ts = TS(); + + +describe('Test Syllables', function(){ + + it('testSyllableCountFailingCMUWords', function(){ + + assert.equal(4, ts.syllableCount("abalone")); + assert.equal(3, ts.syllableCount("abare")); + assert.equal(3, ts.syllableCount("abatement")); + assert.equal(3, ts.syllableCount("abatements")); + assert.equal(5, ts.syllableCount("abbatiello")); + assert.equal(4, ts.syllableCount("abbruzzese")); + assert.equal(2, ts.syllableCount("abed")); + assert.equal(3, ts.syllableCount("abeyance")); + assert.equal(5, ts.syllableCount("aborigine")); + assert.equal(5, ts.syllableCount("aborigines")); + assert.equal(3, ts.syllableCount("abounded")); + assert.equal(3, ts.syllableCount("aboveboard")); + assert.equal(3, ts.syllableCount("aboveground")); + assert.equal(2, ts.syllableCount("abridged")); + assert.equal(4, ts.syllableCount("abruzzese")); + assert.equal(3, ts.syllableCount("absences")); + assert.equal(4, ts.syllableCount("absoluteness")); + assert.equal(2, ts.syllableCount("absolve")); + assert.equal(2, ts.syllableCount("absolves")); + assert.equal(3, ts.syllableCount("abuses")); + assert.equal(3, ts.syllableCount("acacia")); + assert.equal(6, ts.syllableCount("academically")); + assert.equal(5, ts.syllableCount("academician")); + assert.equal(5, ts.syllableCount("academicians")); + assert.equal(3, ts.syllableCount("acceding")); + assert.equal(4, ts.syllableCount("acceptances")); + assert.equal(3, ts.syllableCount("accion")); + assert.equal(5, ts.syllableCount("accompaniment")); + assert.equal(5, ts.syllableCount("accompaniments")); + assert.equal(3, ts.syllableCount("accomplice")); + assert.equal(4, ts.syllableCount("accomplices")); + assert.equal(3, ts.syllableCount("accorded")); + assert.equal(4, ts.syllableCount("accordion")); + assert.equal(3, ts.syllableCount("accuses")); + assert.equal(2, ts.syllableCount("aces")); + assert.equal(3, ts.syllableCount("achievement")); + assert.equal(3, ts.syllableCount("achievements")); + assert.equal(3, ts.syllableCount("achoa")); + assert.equal(3, ts.syllableCount("acknowledged")); + assert.equal(4, ts.syllableCount("acknowledgement")); + assert.equal(4, ts.syllableCount("acknowledges")); + assert.equal(5, ts.syllableCount("acoustically")); + assert.equal(2, ts.syllableCount("acquaint")); + assert.equal(3, ts.syllableCount("acquaintance")); + assert.equal(3, ts.syllableCount("acquainted")); + assert.equal(3, ts.syllableCount("acquiesced")); + assert.equal(2, ts.syllableCount("acquire")); + assert.equal(2, ts.syllableCount("acquired")); + assert.equal(3, ts.syllableCount("acquirer")); + assert.equal(3, ts.syllableCount("acquirers")); + assert.equal(2, ts.syllableCount("acquires")); + assert.equal(3, ts.syllableCount("acreage")); + assert.equal(3, ts.syllableCount("acuteness")); + assert.equal(3, ts.syllableCount("adabelle")); + assert.equal(2, ts.syllableCount("adage")); + assert.equal(3, ts.syllableCount("adame")); + assert.equal(2, ts.syllableCount("added")); + assert.equal(3, ts.syllableCount("addeo")); + assert.equal(2, ts.syllableCount("addled")); + assert.equal(2, ts.syllableCount("adelle")); + assert.equal(2, ts.syllableCount("adieu")); + assert.equal(2, ts.syllableCount("adjudged")); + assert.equal(2, ts.syllableCount("admired")); + assert.equal(4, ts.syllableCount("adorabelle")); + assert.equal(2, ts.syllableCount("advanced")); + assert.equal(3, ts.syllableCount("advancement")); + assert.equal(3, ts.syllableCount("advancements")); + assert.equal(3, ts.syllableCount("advances")); + assert.equal(3, ts.syllableCount("advantage")); + assert.equal(3, ts.syllableCount("advantaged")); + assert.equal(4, ts.syllableCount("advantageous")); + assert.equal(4, ts.syllableCount("advantages")); + assert.equal(4, ts.syllableCount("adventuresome")); + assert.equal(4, ts.syllableCount("advertisement")); + assert.equal(4, ts.syllableCount("advertisements")); + assert.equal(4, ts.syllableCount("advertises")); + assert.equal(2, ts.syllableCount("advice")); + assert.equal(4, ts.syllableCount("advisedly")); + assert.equal(3, ts.syllableCount("advisement")); + assert.equal(3, ts.syllableCount("advises")); + assert.equal(3, ts.syllableCount("aegean")); + assert.equal(5, ts.syllableCount("aerobically")); + assert.equal(7, ts.syllableCount("aerodynamically")); + assert.equal(3, ts.syllableCount("aerospace")); + assert.equal(4, ts.syllableCount("aerospatiale")); + assert.equal(5, ts.syllableCount("aesthetically")); + assert.equal(5, ts.syllableCount("afanasyev")); + assert.equal(3, ts.syllableCount("affixes")); + assert.equal(3, ts.syllableCount("affluence")); + assert.equal(3, ts.syllableCount("affluent")); + assert.equal(3, ts.syllableCount("afforded")); + assert.equal(4, ts.syllableCount("aforementioned")); + assert.equal(3, ts.syllableCount("aforesaid")); + assert.equal(4, ts.syllableCount("afterimage")); + assert.equal(3, ts.syllableCount("aftertaste")); + assert.equal(1, ts.syllableCount("aged")); + assert.equal(2, ts.syllableCount("ageless")); + assert.equal(2, ts.syllableCount("ages")); + assert.equal(4, ts.syllableCount("aggrandizement")); + assert.equal(4, ts.syllableCount("aggressiveness")); + assert.equal(3, ts.syllableCount("agius")); + assert.equal(1, ts.syllableCount("agne")); + assert.equal(4, ts.syllableCount("agonizes")); + assert.equal(3, ts.syllableCount("agreement")); + assert.equal(4, ts.syllableCount("agribusiness")); + assert.equal(3, ts.syllableCount("aguayo")); + assert.equal(2, ts.syllableCount("aherne")); + assert.equal(3, ts.syllableCount("aiguebelle")); + assert.equal(2, ts.syllableCount("airborne")); + assert.equal(3, ts.syllableCount("aircoa")); + assert.equal(2, ts.syllableCount("airspace")); + assert.equal(1, ts.syllableCount("aisle")); + assert.equal(1, ts.syllableCount("aisles")); + assert.equal(4, ts.syllableCount("akiyama")); + assert.equal(3, ts.syllableCount("alarice")); + assert.equal(3, ts.syllableCount("albertville")); + assert.equal(3, ts.syllableCount("albion")); + assert.equal(3, ts.syllableCount("alcoa")); + assert.equal(2, ts.syllableCount("aldred")); + assert.equal(3, ts.syllableCount("aleo")); + assert.equal(3, ts.syllableCount("algeo")); + assert.equal(4, ts.syllableCount("algorithm")); + assert.equal(4, ts.syllableCount("aliases")); + assert.equal(2, ts.syllableCount("alice")); + assert.equal(3, ts.syllableCount("alicia")); + assert.equal(3, ts.syllableCount("allderdice")); + assert.equal(2, ts.syllableCount("allege")); + assert.equal(2, ts.syllableCount("alleged")); + assert.equal(3, ts.syllableCount("alleges")); + assert.equal(5, ts.syllableCount("allegiances")); + assert.equal(1, ts.syllableCount("alles")); + assert.equal(4, ts.syllableCount("alliances")); + assert.equal(4, ts.syllableCount("allowances")); + assert.equal(2, ts.syllableCount("allspice")); + assert.equal(2, ts.syllableCount("allwaste")); + assert.equal(2, ts.syllableCount("alsace")); + assert.equal(3, ts.syllableCount("altarpiece")); + assert.equal(2, ts.syllableCount("altice")); + assert.equal(3, ts.syllableCount("alusuisse")); + assert.equal(4, ts.syllableCount("alveolar")); + assert.equal(4, ts.syllableCount("alveoli")); + assert.equal(2, ts.syllableCount("alyce")); + assert.equal(3, ts.syllableCount("alyea")); + assert.equal(4, ts.syllableCount("alyeska")); + assert.equal(3, ts.syllableCount("amabelle")); + assert.equal(4, ts.syllableCount("amadea")); + assert.equal(4, ts.syllableCount("amadeo")); + assert.equal(5, ts.syllableCount("amaryllises")); + assert.equal(3, ts.syllableCount("amaya")); + assert.equal(3, ts.syllableCount("amazement")); + assert.equal(3, ts.syllableCount("amazes")); + assert.equal(2, ts.syllableCount("ambled")); + assert.equal(3, ts.syllableCount("ambrosial")); + assert.equal(3, ts.syllableCount("ambrosian")); + assert.equal(4, ts.syllableCount("ambulances")); + assert.equal(3, ts.syllableCount("amended")); + assert.equal(4, ts.syllableCount("amezcua")); + assert.equal(4, ts.syllableCount("amityville")); + assert.equal(3, ts.syllableCount("amorette")); + assert.equal(3, ts.syllableCount("amperage")); + assert.equal(3, ts.syllableCount("amusement")); + assert.equal(3, ts.syllableCount("amusements")); + assert.equal(3, ts.syllableCount("amuses")); + assert.equal(4, ts.syllableCount("analyses")); + assert.equal(4, ts.syllableCount("analyzes")); + assert.equal(3, ts.syllableCount("anaya")); + assert.equal(3, ts.syllableCount("anchorage")); + assert.equal(4, ts.syllableCount("andalusian")); + assert.equal(4, ts.syllableCount("andreoli")); + assert.equal(4, ts.syllableCount("andreoni")); + assert.equal(4, ts.syllableCount("andreotti")); + assert.equal(4, ts.syllableCount("andreozzi")); + assert.equal(2, ts.syllableCount("anette")); + assert.equal(2, ts.syllableCount("angelle")); + assert.equal(3, ts.syllableCount("angerer")); + assert.equal(3, ts.syllableCount("angering")); + assert.equal(2, ts.syllableCount("angled")); + assert.equal(3, ts.syllableCount("anisette")); + assert.equal(3, ts.syllableCount("annabelle")); + assert.equal(1, ts.syllableCount("anne")); + assert.equal(2, ts.syllableCount("annette")); + assert.equal(3, ts.syllableCount("annexes")); + assert.equal(2, ts.syllableCount("announced")); + assert.equal(3, ts.syllableCount("announcement")); + assert.equal(3, ts.syllableCount("announcements")); + assert.equal(3, ts.syllableCount("announces")); + assert.equal(3, ts.syllableCount("annoyance")); + assert.equal(4, ts.syllableCount("annoyances")); + assert.equal(2, ts.syllableCount("anstice")); + assert.equal(3, ts.syllableCount("antaya")); + assert.equal(5, ts.syllableCount("antiabortion")); + assert.equal(5, ts.syllableCount("antiapartheid")); + assert.equal(3, ts.syllableCount("antoinette")); + assert.equal(3, ts.syllableCount("anyplace")); + assert.equal(4, ts.syllableCount("anzaldua")); + assert.equal(3, ts.syllableCount("aoyama")); + assert.equal(2, ts.syllableCount("apace")); + assert.equal(2, ts.syllableCount("apiece")); + assert.equal(5, ts.syllableCount("apologizes")); + assert.equal(5, ts.syllableCount("apotheosis")); + assert.equal(5, ts.syllableCount("apparatuses")); + assert.equal(4, ts.syllableCount("appearances")); + assert.equal(3, ts.syllableCount("appeasement")); + assert.equal(3, ts.syllableCount("appendage")); + assert.equal(4, ts.syllableCount("appendages")); + assert.equal(3, ts.syllableCount("appended")); + assert.equal(4, ts.syllableCount("appendixes")); + assert.equal(3, ts.syllableCount("applesauce")); + assert.equal(3, ts.syllableCount("appleyard")); + assert.equal(4, ts.syllableCount("appliances")); + assert.equal(3, ts.syllableCount("appraises")); + assert.equal(4, ts.syllableCount("apprehended")); + assert.equal(3, ts.syllableCount("apprentice")); + assert.equal(3, ts.syllableCount("apprenticed")); + assert.equal(4, ts.syllableCount("apprentices")); + assert.equal(4, ts.syllableCount("apprenticeship")); + assert.equal(2, ts.syllableCount("approached")); + assert.equal(5, ts.syllableCount("appropriateness")); + assert.equal(3, ts.syllableCount("araya")); + assert.equal(2, ts.syllableCount("arbed")); + assert.equal(3, ts.syllableCount("arbitrage")); + assert.equal(4, ts.syllableCount("arboreal")); + assert.equal(3, ts.syllableCount("arceneaux")); + assert.equal(3, ts.syllableCount("arceo")); + assert.equal(3, ts.syllableCount("archambeau")); + assert.equal(3, ts.syllableCount("archambeault")); + assert.equal(6, ts.syllableCount("archeological")); + assert.equal(5, ts.syllableCount("archeology")); + assert.equal(2, ts.syllableCount("arches")); + assert.equal(2, ts.syllableCount("ardelle")); + assert.equal(2, ts.syllableCount("argonne")); + assert.equal(4, ts.syllableCount("ariella")); + assert.equal(3, ts.syllableCount("arises")); + assert.equal(2, ts.syllableCount("arlette")); + assert.equal(3, ts.syllableCount("armistice")); + assert.equal(3, ts.syllableCount("armitage")); + assert.equal(1, ts.syllableCount("arne")); + assert.equal(2, ts.syllableCount("arnelle")); + assert.equal(2, ts.syllableCount("arnette")); + assert.equal(3, ts.syllableCount("arouses")); + assert.equal(2, ts.syllableCount("arranged")); + assert.equal(3, ts.syllableCount("arrangement")); + assert.equal(3, ts.syllableCount("arrangements")); + assert.equal(3, ts.syllableCount("arranges")); + assert.equal(3, ts.syllableCount("arrearage")); + assert.equal(4, ts.syllableCount("arrearages")); + assert.equal(4, ts.syllableCount("arreola")); + assert.equal(5, ts.syllableCount("arriortua")); + assert.equal(3, ts.syllableCount("arroyo")); + assert.equal(3, ts.syllableCount("arseneau")); + assert.equal(3, ts.syllableCount("arseneault")); + assert.equal(3, ts.syllableCount("artifice")); + assert.equal(3, ts.syllableCount("aryan")); + assert.equal(3, ts.syllableCount("ascended")); + assert.equal(3, ts.syllableCount("asiain")); + assert.equal(2, ts.syllableCount("asian")); + assert.equal(2, ts.syllableCount("asians")); + assert.equal(3, ts.syllableCount("asiaweek")); + assert.equal(3, ts.syllableCount("assemblage")); + assert.equal(3, ts.syllableCount("assembled")); + assert.equal(4, ts.syllableCount("assertiveness")); + assert.equal(4, ts.syllableCount("assurances")); + assert.equal(3, ts.syllableCount("astounded")); + assert.equal(3, ts.syllableCount("astuteness")); + assert.equal(4, ts.syllableCount("atalaya")); + assert.equal(3, ts.syllableCount("atlases")); + assert.equal(3, ts.syllableCount("atonement")); + assert.equal(2, ts.syllableCount("attached")); + assert.equal(3, ts.syllableCount("attended")); + assert.equal(4, ts.syllableCount("attentiveness")); + assert.equal(4, ts.syllableCount("attractiveness")); + assert.equal(2, ts.syllableCount("audette")); + assert.equal(4, ts.syllableCount("audiences")); + assert.equal(2, ts.syllableCount("auguste")); + assert.equal(3, ts.syllableCount("auspices")); + assert.equal(2, ts.syllableCount("authement")); + assert.equal(4, ts.syllableCount("authorizes")); + assert.equal(2, ts.syllableCount("auyeung")); + assert.equal(2, ts.syllableCount("auzenne")); + assert.equal(3, ts.syllableCount("avarice")); + assert.equal(4, ts.syllableCount("avedisian")); + assert.equal(2, ts.syllableCount("avenged")); + assert.equal(3, ts.syllableCount("average")); + assert.equal(3, ts.syllableCount("averette")); + assert.equal(2, ts.syllableCount("avice")); + assert.equal(4, ts.syllableCount("avowedly")); + assert.equal(3, ts.syllableCount("awarded")); + assert.equal(3, ts.syllableCount("awareness")); + assert.equal(2, ts.syllableCount("AWOL")); + assert.equal(2, ts.syllableCount("axes")); + assert.equal(4, ts.syllableCount("ayacucho")); + assert.equal(3, ts.syllableCount("ayala")); + assert.equal(2, ts.syllableCount("ayars")); + assert.equal(4, ts.syllableCount("ayatollah")); + assert.equal(4, ts.syllableCount("ayatollahs")); + assert.equal(4, ts.syllableCount("Ayatullah")); + assert.equal(2, ts.syllableCount("ayerst")); + assert.equal(2, ts.syllableCount("ayo")); + assert.equal(2, ts.syllableCount("ayon")); + assert.equal(2, ts.syllableCount("ayoub")); + assert.equal(3, ts.syllableCount("ayuso")); + assert.equal(2, ts.syllableCount("ayyad")); + assert.equal(4, ts.syllableCount("azpurua")); + assert.equal(2, ts.syllableCount("babbled")); + assert.equal(2, ts.syllableCount("babette")); + assert.equal(3, ts.syllableCount("babineau")); + assert.equal(3, ts.syllableCount("babineaux")); + assert.equal(3, ts.syllableCount("babyak")); + assert.equal(3, ts.syllableCount("backhanded")); + assert.equal(2, ts.syllableCount("backstage")); + assert.equal(2, ts.syllableCount("badeau")); + assert.equal(2, ts.syllableCount("badeaux")); + assert.equal(3, ts.syllableCount("badgering")); + assert.equal(2, ts.syllableCount("badges")); + assert.equal(2, ts.syllableCount("baffled")); + assert.equal(2, ts.syllableCount("baggage")); + assert.equal(3, ts.syllableCount("baidoa")); + assert.equal(2, ts.syllableCount("balanced")); + assert.equal(3, ts.syllableCount("balances")); + assert.equal(3, ts.syllableCount("balboa")); + assert.equal(2, ts.syllableCount("baldrige")); + assert.equal(1, ts.syllableCount("balle")); + assert.equal(1, ts.syllableCount("balles")); + assert.equal(3, ts.syllableCount("balliet")); + assert.equal(3, ts.syllableCount("balyeat")); + assert.equal(2, ts.syllableCount("bandage")); + assert.equal(2, ts.syllableCount("bandaged")); + assert.equal(3, ts.syllableCount("bandages")); + assert.equal(2, ts.syllableCount("banded")); + assert.equal(2, ts.syllableCount("banville")); + assert.equal(2, ts.syllableCount("baptiste")); + assert.equal(2, ts.syllableCount("barbeau")); + assert.equal(2, ts.syllableCount("barbette")); + assert.equal(2, ts.syllableCount("barcia")); + assert.equal(2, ts.syllableCount("barges")); + assert.equal(3, ts.syllableCount("baribeau")); + assert.equal(2, ts.syllableCount("barlage")); + assert.equal(1, ts.syllableCount("barnes")); + assert.equal(2, ts.syllableCount("barnette")); + assert.equal(2, ts.syllableCount("barrage")); + assert.equal(2, ts.syllableCount("barraged")); + assert.equal(3, ts.syllableCount("barrages")); + assert.equal(2, ts.syllableCount("barrette")); + assert.equal(3, ts.syllableCount("barrilleaux")); + assert.equal(3, ts.syllableCount("barrineau")); + assert.equal(3, ts.syllableCount("bartlesville")); + assert.equal(5, ts.syllableCount("bartolomeo")); + assert.equal(4, ts.syllableCount("basaldua")); + assert.equal(2, ts.syllableCount("basement")); + assert.equal(2, ts.syllableCount("basements")); + assert.equal(2, ts.syllableCount("bases")); + assert.equal(3, ts.syllableCount("baskerville")); + assert.equal(2, ts.syllableCount("baskette")); + assert.equal(1, ts.syllableCount("basque")); + assert.equal(1, ts.syllableCount("basques")); + assert.equal(1, ts.syllableCount("basse")); + assert.equal(2, ts.syllableCount("bassette")); + assert.equal(2, ts.syllableCount("bastille")); + assert.equal(2, ts.syllableCount("bastogne")); + assert.equal(2, ts.syllableCount("batches")); + assert.equal(2, ts.syllableCount("batesville")); + assert.equal(1, ts.syllableCount("bathe")); + assert.equal(1, ts.syllableCount("bathed")); + assert.equal(1, ts.syllableCount("bathes")); + assert.equal(2, ts.syllableCount("battelle")); + assert.equal(5, ts.syllableCount("batticaloa")); + assert.equal(2, ts.syllableCount("bayard")); + assert.equal(2, ts.syllableCount("bayog")); + assert.equal(3, ts.syllableCount("bayonet")); + assert.equal(3, ts.syllableCount("bayonets")); + assert.equal(2, ts.syllableCount("bayou")); + assert.equal(2, ts.syllableCount("bayous")); + assert.equal(2, ts.syllableCount("bayuk")); + assert.equal(2, ts.syllableCount("bayus")); + assert.equal(2, ts.syllableCount("bearded")); + assert.equal(1, ts.syllableCount("beau")); + assert.equal(2, ts.syllableCount("beaubien")); + assert.equal(2, ts.syllableCount("beauchaine")); + assert.equal(2, ts.syllableCount("beauchamp")); + assert.equal(3, ts.syllableCount("beauchemin")); + assert.equal(2, ts.syllableCount("beauchene")); + assert.equal(2, ts.syllableCount("beaudet")); + assert.equal(2, ts.syllableCount("beaudette")); + assert.equal(2, ts.syllableCount("beaudin")); + assert.equal(2, ts.syllableCount("beaudoin")); + assert.equal(2, ts.syllableCount("beaudreau")); + assert.equal(2, ts.syllableCount("beaudry")); + assert.equal(2, ts.syllableCount("beauford")); + assert.equal(2, ts.syllableCount("beaufort")); + assert.equal(2, ts.syllableCount("beaufrere")); + assert.equal(3, ts.syllableCount("beaujolais")); + assert.equal(2, ts.syllableCount("beaulac")); + assert.equal(3, ts.syllableCount("beaumier")); + assert.equal(2, ts.syllableCount("beaumont")); + assert.equal(2, ts.syllableCount("beaupre")); + assert.equal(3, ts.syllableCount("beauregard")); + assert.equal(3, ts.syllableCount("beausoleil")); + assert.equal(3, ts.syllableCount("beautician")); + assert.equal(2, ts.syllableCount("beauties")); + assert.equal(3, ts.syllableCount("beautiful")); + assert.equal(3, ts.syllableCount("beautify")); + assert.equal(2, ts.syllableCount("beauty")); + assert.equal(2, ts.syllableCount("beauvais")); + assert.equal(1, ts.syllableCount("beaux")); + assert.equal(2, ts.syllableCount("bebeau")); + assert.equal(3, ts.syllableCount("becherer")); + assert.equal(3, ts.syllableCount("bedoya")); + assert.equal(3, ts.syllableCount("bedraggled")); + assert.equal(3, ts.syllableCount("bedrosian")); + assert.equal(3, ts.syllableCount("Beetlejuice")); + assert.equal(3, ts.syllableCount("befriended")); + assert.equal(3, ts.syllableCount("befuddled")); + assert.equal(3, ts.syllableCount("beidaihe")); + assert.equal(2, ts.syllableCount("beiges")); + assert.equal(1, ts.syllableCount("beirne")); + assert.equal(2, ts.syllableCount("belge")); + assert.equal(3, ts.syllableCount("beliveau")); + assert.equal(1, ts.syllableCount("belle")); + assert.equal(2, ts.syllableCount("belleau")); + assert.equal(4, ts.syllableCount("bellefeuille")); + assert.equal(1, ts.syllableCount("belles")); + assert.equal(2, ts.syllableCount("belleville")); + assert.equal(3, ts.syllableCount("belliveau")); + assert.equal(2, ts.syllableCount("bellville")); + assert.equal(3, ts.syllableCount("bellyache")); + assert.equal(2, ts.syllableCount("belonged")); + assert.equal(2, ts.syllableCount("beltsville")); + assert.equal(2, ts.syllableCount("belville")); + assert.equal(3, ts.syllableCount("belyea")); + assert.equal(3, ts.syllableCount("belyeu")); + assert.equal(3, ts.syllableCount("bemusement")); + assert.equal(2, ts.syllableCount("bended")); + assert.equal(1, ts.syllableCount("benne")); + assert.equal(2, ts.syllableCount("bennette")); + assert.equal(3, ts.syllableCount("bentonville")); + assert.equal(3, ts.syllableCount("beowulf")); + assert.equal(3, ts.syllableCount("bereavement")); + assert.equal(2, ts.syllableCount("berges")); + assert.equal(3, ts.syllableCount("berjaya")); + assert.equal(3, ts.syllableCount("bernadette")); + assert.equal(1, ts.syllableCount("berne")); + assert.equal(2, ts.syllableCount("berneice")); + assert.equal(2, ts.syllableCount("bernice")); + assert.equal(2, ts.syllableCount("beseiged")); + assert.equal(2, ts.syllableCount("besiege")); + assert.equal(2, ts.syllableCount("besieged")); + assert.equal(1, ts.syllableCount("beske")); + assert.equal(4, ts.syllableCount("bespectacled")); + assert.equal(1, ts.syllableCount("besse")); + assert.equal(2, ts.syllableCount("bessette")); + assert.equal(1, ts.syllableCount("beste")); + assert.equal(2, ts.syllableCount("bethpage")); + assert.equal(3, ts.syllableCount("betrayal")); + assert.equal(3, ts.syllableCount("betrayals")); + assert.equal(3, ts.syllableCount("beverage")); + assert.equal(2, ts.syllableCount("beville")); + assert.equal(2, ts.syllableCount("beyond")); + assert.equal(3, ts.syllableCount("biases")); + assert.equal(2, ts.syllableCount("bibeau")); + assert.equal(2, ts.syllableCount("bibeault")); + assert.equal(3, ts.syllableCount("bicycled")); + assert.equal(2, ts.syllableCount("bierbusse")); + assert.equal(1, ts.syllableCount("bille")); + assert.equal(1, ts.syllableCount("billes")); + assert.equal(3, ts.syllableCount("bilodeau")); + assert.equal(3, ts.syllableCount("bilyeu")); + assert.equal(2, ts.syllableCount("binette")); + assert.equal(2, ts.syllableCount("binges")); + assert.equal(3, ts.syllableCount("biondi")); + assert.equal(3, ts.syllableCount("biondo")); + assert.equal(5, ts.syllableCount("biondolillo")); + assert.equal(4, ts.syllableCount("bionetics")); + assert.equal(2, ts.syllableCount("birthplace")); + assert.equal(1, ts.syllableCount("bisque")); + assert.equal(2, ts.syllableCount("bissette")); + assert.equal(3, ts.syllableCount("bissonette")); + assert.equal(3, ts.syllableCount("bissonnette")); + assert.equal(3, ts.syllableCount("bistodeau")); + assert.equal(2, ts.syllableCount("bivalve")); + assert.equal(2, ts.syllableCount("bivalves")); + assert.equal(2, ts.syllableCount("blanchette")); + assert.equal(1, ts.syllableCount("blaske")); + assert.equal(2, ts.syllableCount("blazes")); + assert.equal(1, ts.syllableCount("bleau")); + assert.equal(2, ts.syllableCount("blended")); + assert.equal(2, ts.syllableCount("blinded")); + assert.equal(3, ts.syllableCount("blindfolded")); + assert.equal(1, ts.syllableCount("blithe")); + assert.equal(2, ts.syllableCount("blithely")); + assert.equal(2, ts.syllableCount("blockage")); + assert.equal(3, ts.syllableCount("blockages")); + assert.equal(2, ts.syllableCount("blouses")); + assert.equal(1, ts.syllableCount("blythe")); + assert.equal(2, ts.syllableCount("boa")); + assert.equal(2, ts.syllableCount("boarded")); + assert.equal(4, ts.syllableCount("boardinghouses")); + assert.equal(2, ts.syllableCount("bobbette")); + assert.equal(2, ts.syllableCount("bobsled")); + assert.equal(2, ts.syllableCount("boccia")); + assert.equal(2, ts.syllableCount("bocian")); + assert.equal(2, ts.syllableCount("boggled")); + assert.equal(3, ts.syllableCount("boghosian")); + assert.equal(3, ts.syllableCount("bogosian")); + assert.equal(5, ts.syllableCount("boguslavskaya")); + assert.equal(2, ts.syllableCount("boileau")); + assert.equal(2, ts.syllableCount("boisseau")); + assert.equal(3, ts.syllableCount("boissonneault")); + assert.equal(2, ts.syllableCount("boldface")); + assert.equal(1, ts.syllableCount("bolle")); + assert.equal(1, ts.syllableCount("bolles")); + assert.equal(3, ts.syllableCount("bombarded")); + assert.equal(2, ts.syllableCount("bondage")); + assert.equal(2, ts.syllableCount("bonded")); + assert.equal(1, ts.syllableCount("bonne")); + assert.equal(2, ts.syllableCount("bonneau")); + assert.equal(1, ts.syllableCount("bonnes")); + assert.equal(2, ts.syllableCount("bonnette")); + assert.equal(3, ts.syllableCount("bonnibelle")); + assert.equal(3, ts.syllableCount("bonuses")); + assert.equal(2, ts.syllableCount("bonville")); + assert.equal(3, ts.syllableCount("bookcases")); + assert.equal(2, ts.syllableCount("bookshelves")); + assert.equal(3, ts.syllableCount("boomeranged")); + assert.equal(2, ts.syllableCount("boonville")); + assert.equal(1, ts.syllableCount("boothe")); + assert.equal(2, ts.syllableCount("bordeau")); + assert.equal(2, ts.syllableCount("bordeaux")); + assert.equal(4, ts.syllableCount("borealis")); + assert.equal(2, ts.syllableCount("borges")); + assert.equal(1, ts.syllableCount("borne")); + assert.equal(3, ts.syllableCount("borneo")); + assert.equal(3, ts.syllableCount("borosage")); + assert.equal(2, ts.syllableCount("boscia")); + assert.equal(1, ts.syllableCount("bosse")); + assert.equal(1, ts.syllableCount("bothe")); + assert.equal(2, ts.syllableCount("boudreau")); + assert.equal(2, ts.syllableCount("boudreaux")); + assert.equal(3, ts.syllableCount("bougainville")); + assert.equal(2, ts.syllableCount("boulette")); + assert.equal(2, ts.syllableCount("bounces")); + assert.equal(2, ts.syllableCount("bounded")); + assert.equal(2, ts.syllableCount("bourbeau")); + assert.equal(2, ts.syllableCount("bourdeau")); + assert.equal(1, ts.syllableCount("bourne")); + assert.equal(3, ts.syllableCount("bournonville")); + assert.equal(2, ts.syllableCount("boutelle")); + assert.equal(2, ts.syllableCount("boxes")); + assert.equal(2, ts.syllableCount("boyack")); + assert.equal(4, ts.syllableCount("boyajian")); + assert.equal(2, ts.syllableCount("boyan")); + assert.equal(2, ts.syllableCount("boyar")); + assert.equal(2, ts.syllableCount("boyett")); + assert.equal(3, ts.syllableCount("boyington")); + assert.equal(2, ts.syllableCount("boyish")); + assert.equal(2, ts.syllableCount("boyum")); + assert.equal(2, ts.syllableCount("braces")); + assert.equal(1, ts.syllableCount("braille")); + assert.equal(1, ts.syllableCount("brailles")); + assert.equal(2, ts.syllableCount("bralorne")); + assert.equal(2, ts.syllableCount("bramlage")); + assert.equal(2, ts.syllableCount("bramlette")); + assert.equal(2, ts.syllableCount("brancheau")); + assert.equal(2, ts.syllableCount("branded")); + assert.equal(2, ts.syllableCount("brasseaux")); + assert.equal(2, ts.syllableCount("brazeau")); + assert.equal(3, ts.syllableCount("brazzaville")); + assert.equal(2, ts.syllableCount("breakage")); + assert.equal(1, ts.syllableCount("breathe")); + assert.equal(1, ts.syllableCount("breathed")); + assert.equal(1, ts.syllableCount("breathes")); + assert.equal(1, ts.syllableCount("breau")); + assert.equal(1, ts.syllableCount("breault")); + assert.equal(1, ts.syllableCount("breaux")); + assert.equal(2, ts.syllableCount("breezes")); + assert.equal(2, ts.syllableCount("breon")); + assert.equal(2, ts.syllableCount("brescia")); + assert.equal(2, ts.syllableCount("bresette")); + assert.equal(1, ts.syllableCount("bresse")); + assert.equal(2, ts.syllableCount("bressette")); + assert.equal(2, ts.syllableCount("brideau")); + assert.equal(2, ts.syllableCount("bridgeport")); + assert.equal(2, ts.syllableCount("bridges")); + assert.equal(2, ts.syllableCount("bridled")); + assert.equal(3, ts.syllableCount("briefcases")); + assert.equal(2, ts.syllableCount("brion")); + assert.equal(2, ts.syllableCount("brissette")); + assert.equal(2, ts.syllableCount("britches")); + assert.equal(3, ts.syllableCount("brokerage")); + assert.equal(4, ts.syllableCount("brokerages")); + assert.equal(3, ts.syllableCount("brokering")); + assert.equal(2, ts.syllableCount("brooksville")); + assert.equal(2, ts.syllableCount("brosseau")); + assert.equal(2, ts.syllableCount("brossette")); + assert.equal(2, ts.syllableCount("brousseau")); + assert.equal(2, ts.syllableCount("brownsville")); + assert.equal(2, ts.syllableCount("bruegge")); + assert.equal(2, ts.syllableCount("bruges")); + assert.equal(2, ts.syllableCount("bruises")); + assert.equal(2, ts.syllableCount("brundage")); + assert.equal(2, ts.syllableCount("brundige")); + assert.equal(2, ts.syllableCount("bruneau")); + assert.equal(2, ts.syllableCount("brunelle")); + assert.equal(2, ts.syllableCount("brunette")); + assert.equal(1, ts.syllableCount("bruske")); + assert.equal(1, ts.syllableCount("brusque")); + assert.equal(2, ts.syllableCount("brusquely")); + assert.equal(2, ts.syllableCount("brusseau")); + assert.equal(4, ts.syllableCount("brutalizes")); + assert.equal(2, ts.syllableCount("brutsche")); + assert.equal(2, ts.syllableCount("bryan")); + assert.equal(2, ts.syllableCount("bryans")); + assert.equal(2, ts.syllableCount("bryant")); + assert.equal(2, ts.syllableCount("bryars")); + assert.equal(2, ts.syllableCount("brydges")); + assert.equal(2, ts.syllableCount("bryen")); + assert.equal(2, ts.syllableCount("bua")); + assert.equal(2, ts.syllableCount("bubbled")); + assert.equal(3, ts.syllableCount("Bubiyan")); + assert.equal(2, ts.syllableCount("buckled")); + assert.equal(2, ts.syllableCount("budreau")); + assert.equal(2, ts.syllableCount("bulges")); + assert.equal(2, ts.syllableCount("bundled")); + assert.equal(2, ts.syllableCount("bungled")); + assert.equal(3, ts.syllableCount("buoyancy")); + assert.equal(2, ts.syllableCount("buoyant")); + assert.equal(2, ts.syllableCount("burbage")); + assert.equal(2, ts.syllableCount("burchette")); + assert.equal(2, ts.syllableCount("burdette")); + assert.equal(2, ts.syllableCount("bureau")); + assert.equal(4, ts.syllableCount("bureaucracies")); + assert.equal(4, ts.syllableCount("bureaucracy")); + assert.equal(3, ts.syllableCount("bureaucrat")); + assert.equal(4, ts.syllableCount("bureaucratic")); + assert.equal(3, ts.syllableCount("bureaucrats")); + assert.equal(2, ts.syllableCount("bureaus")); + assert.equal(2, ts.syllableCount("burlesque")); + assert.equal(1, ts.syllableCount("burne")); + assert.equal(1, ts.syllableCount("burnes")); + assert.equal(2, ts.syllableCount("burnette")); + assert.equal(2, ts.syllableCount("burrage")); + assert.equal(2, ts.syllableCount("buses")); + assert.equal(2, ts.syllableCount("business")); + assert.equal(3, ts.syllableCount("businesses")); + assert.equal(1, ts.syllableCount("buske")); + assert.equal(1, ts.syllableCount("busse")); + assert.equal(3, ts.syllableCount("butchering")); + assert.equal(2, ts.syllableCount("buteau")); + assert.equal(3, ts.syllableCount("buttonville")); + assert.equal(2, ts.syllableCount("buyout")); + assert.equal(2, ts.syllableCount("buyouts")); + assert.equal(1, ts.syllableCount("buysse")); + assert.equal(2, ts.syllableCount("byam")); + assert.equal(2, ts.syllableCount("byars")); + assert.equal(2, ts.syllableCount("byas")); + assert.equal(3, ts.syllableCount("byassee")); + assert.equal(3, ts.syllableCount("byerley")); + assert.equal(1, ts.syllableCount("byrne")); + assert.equal(1, ts.syllableCount("byrnes")); + assert.equal(2, ts.syllableCount("cabbage")); + assert.equal(3, ts.syllableCount("cabbages")); + assert.equal(2, ts.syllableCount("cabled")); + assert.equal(3, ts.syllableCount("cableone")); + assert.equal(3, ts.syllableCount("cabooses")); + assert.equal(3, ts.syllableCount("cabotage")); + assert.equal(2, ts.syllableCount("cacace")); + assert.equal(2, ts.syllableCount("caccia")); + assert.equal(3, ts.syllableCount("cadences")); + assert.equal(3, ts.syllableCount("cadorette")); + assert.equal(2, ts.syllableCount("cafe")); + assert.equal(2, ts.syllableCount("cafes")); + assert.equal(2, ts.syllableCount("cages")); + assert.equal(1, ts.syllableCount("cairnes")); + assert.equal(1, ts.syllableCount("caisse")); + assert.equal(2, ts.syllableCount("calif")); + assert.equal(5, ts.syllableCount("california")); + assert.equal(5, ts.syllableCount("californian")); + assert.equal(5, ts.syllableCount("californians")); + assert.equal(1, ts.syllableCount("calle")); + assert.equal(1, ts.syllableCount("calles")); + assert.equal(1, ts.syllableCount("calves")); + assert.equal(3, ts.syllableCount("cambridgeport")); + assert.equal(3, ts.syllableCount("cambridgeside")); + assert.equal(3, ts.syllableCount("cameo")); + assert.equal(3, ts.syllableCount("cameos")); + assert.equal(3, ts.syllableCount("camerer")); + assert.equal(2, ts.syllableCount("camille")); + assert.equal(3, ts.syllableCount("camouflage")); + assert.equal(3, ts.syllableCount("camouflaged")); + assert.equal(2, ts.syllableCount("campeau")); + assert.equal(3, ts.syllableCount("campion")); + assert.equal(3, ts.syllableCount("campuses")); + assert.equal(4, ts.syllableCount("canadienne")); + assert.equal(2, ts.syllableCount("candace")); + assert.equal(2, ts.syllableCount("candice")); + assert.equal(1, ts.syllableCount("cannes")); + assert.equal(2, ts.syllableCount("cantrelle")); + assert.equal(3, ts.syllableCount("canvases")); + assert.equal(2, ts.syllableCount("capece")); + assert.equal(2, ts.syllableCount("capelle")); + assert.equal(5, ts.syllableCount("capitalizes")); + assert.equal(4, ts.syllableCount("cappiello")); + assert.equal(2, ts.syllableCount("caprice")); + assert.equal(3, ts.syllableCount("capua")); + assert.equal(3, ts.syllableCount("caravelle")); + assert.equal(4, ts.syllableCount("caraveo")); + assert.equal(3, ts.syllableCount("carbonneau")); + assert.equal(3, ts.syllableCount("carcione")); + assert.equal(2, ts.syllableCount("carded")); + assert.equal(3, ts.syllableCount("cardiges")); + assert.equal(2, ts.syllableCount("caresse")); + assert.equal(4, ts.syllableCount("cariello")); + assert.equal(2, ts.syllableCount("carlisle")); + assert.equal(2, ts.syllableCount("carnage")); + assert.equal(1, ts.syllableCount("carne")); + assert.equal(1, ts.syllableCount("carnes")); + assert.equal(3, ts.syllableCount("carreon")); + assert.equal(3, ts.syllableCount("carrion")); + assert.equal(3, ts.syllableCount("carriveau")); + assert.equal(3, ts.syllableCount("cartaya")); + assert.equal(3, ts.syllableCount("cartersville")); + assert.equal(2, ts.syllableCount("carthage")); + assert.equal(3, ts.syllableCount("cartilage")); + assert.equal(2, ts.syllableCount("cartrette")); + assert.equal(3, ts.syllableCount("cartridges")); + assert.equal(5, ts.syllableCount("cartusciello")); + assert.equal(1, ts.syllableCount("carves")); + assert.equal(2, ts.syllableCount("carville")); + assert.equal(2, ts.syllableCount("cases")); + assert.equal(2, ts.syllableCount("cassette")); + assert.equal(2, ts.syllableCount("cassettes")); + assert.equal(1, ts.syllableCount("caste")); + assert.equal(2, ts.syllableCount("castille")); + assert.equal(3, ts.syllableCount("cataloged")); + assert.equal(4, ts.syllableCount("cataloguing")); + assert.equal(2, ts.syllableCount("catches")); + assert.equal(5, ts.syllableCount("categorizes")); + assert.equal(4, ts.syllableCount("cattaneo")); + assert.equal(3, ts.syllableCount("caucasian")); + assert.equal(3, ts.syllableCount("caucuses")); + assert.equal(2, ts.syllableCount("causes")); + assert.equal(2, ts.syllableCount("cawthorne")); + assert.equal(2, ts.syllableCount("caya")); + assert.equal(3, ts.syllableCount("cayuses")); + assert.equal(2, ts.syllableCount("ceases")); + assert.equal(3, ts.syllableCount("ceausescu")); + assert.equal(2, ts.syllableCount("ceder")); + assert.equal(2, ts.syllableCount("ceding")); + assert.equal(3, ts.syllableCount("celaya")); + assert.equal(2, ts.syllableCount("celeste")); + assert.equal(3, ts.syllableCount("censuses")); + assert.equal(3, ts.syllableCount("centerpiece")); + assert.equal(3, ts.syllableCount("centrifuge")); + assert.equal(4, ts.syllableCount("centrifuges")); + assert.equal(3, ts.syllableCount("ceraceous")); + assert.equal(3, ts.syllableCount("cereal")); + assert.equal(3, ts.syllableCount("cereals")); + assert.equal(2, ts.syllableCount("cezanne")); + assert.equal(2, ts.syllableCount("chadbourne")); + assert.equal(2, ts.syllableCount("challenged")); + assert.equal(3, ts.syllableCount("challenges")); + assert.equal(2, ts.syllableCount("chalmette")); + assert.equal(4, ts.syllableCount("chameleon")); + assert.equal(2, ts.syllableCount("champagne")); + assert.equal(2, ts.syllableCount("champagnes")); + assert.equal(2, ts.syllableCount("champeau")); + assert.equal(3, ts.syllableCount("champion")); + assert.equal(3, ts.syllableCount("championed")); + assert.equal(4, ts.syllableCount("championing")); + assert.equal(3, ts.syllableCount("champions")); + assert.equal(4, ts.syllableCount("championship")); + assert.equal(4, ts.syllableCount("championships")); + assert.equal(2, ts.syllableCount("chances")); + assert.equal(2, ts.syllableCount("changes")); + assert.equal(2, ts.syllableCount("chapelle")); + assert.equal(2, ts.syllableCount("chappelle")); + assert.equal(5, ts.syllableCount("characterizes")); + assert.equal(2, ts.syllableCount("charasse")); + assert.equal(3, ts.syllableCount("charboneau")); + assert.equal(3, ts.syllableCount("charbonneau")); + assert.equal(2, ts.syllableCount("charette")); + assert.equal(2, ts.syllableCount("charges")); + assert.equal(3, ts.syllableCount("charlemagne")); + assert.equal(3, ts.syllableCount("charmion")); + assert.equal(2, ts.syllableCount("chases")); + assert.equal(2, ts.syllableCount("chasm")); + assert.equal(1, ts.syllableCount("chasse")); + assert.equal(1, ts.syllableCount("chaste")); + assert.equal(3, ts.syllableCount("chastises")); + assert.equal(2, ts.syllableCount("chateau")); + assert.equal(2, ts.syllableCount("chateaux")); + assert.equal(1, ts.syllableCount("chausse")); + assert.equal(3, ts.syllableCount("chechnya")); + assert.equal(3, ts.syllableCount("chechnyan")); + assert.equal(2, ts.syllableCount("cheeses")); + assert.equal(2, ts.syllableCount("chelette")); + assert.equal(2, ts.syllableCount("chenette")); + assert.equal(2, ts.syllableCount("cheong")); + assert.equal(2, ts.syllableCount("chequing")); + assert.equal(1, ts.syllableCount("cherne")); + assert.equal(2, ts.syllableCount("chevette")); + assert.equal(2, ts.syllableCount("chevrette")); + assert.equal(3, ts.syllableCount("chiyoda")); + assert.equal(2, ts.syllableCount("choices")); + assert.equal(2, ts.syllableCount("chooses")); + assert.equal(4, ts.syllableCount("choreograph")); + assert.equal(4, ts.syllableCount("choreographed")); + assert.equal(5, ts.syllableCount("choreographer")); + assert.equal(5, ts.syllableCount("choreographers")); + assert.equal(5, ts.syllableCount("choreographic")); + assert.equal(5, ts.syllableCount("choreography")); + assert.equal(3, ts.syllableCount("choruses")); + assert.equal(3, ts.syllableCount("christabelle")); + assert.equal(3, ts.syllableCount("chronicled")); + assert.equal(2, ts.syllableCount("chua")); + assert.equal(2, ts.syllableCount("chuckled")); + assert.equal(4, ts.syllableCount("chujitsuya")); + assert.equal(2, ts.syllableCount("churches")); + assert.equal(1, ts.syllableCount("cian")); + assert.equal(3, ts.syllableCount("cigarette")); + assert.equal(3, ts.syllableCount("cigarettes")); + assert.equal(3, ts.syllableCount("cilicia")); + assert.equal(2, ts.syllableCount("circled")); + assert.equal(4, ts.syllableCount("circumstances")); + assert.equal(3, ts.syllableCount("circuses")); + assert.equal(4, ts.syllableCount("ciriello")); + assert.equal(4, ts.syllableCount("cirincione")); + assert.equal(4, ts.syllableCount("cirrincione")); + assert.equal(3, ts.syllableCount("cistercian")); + assert.equal(3, ts.syllableCount("cityplace")); + assert.equal(2, ts.syllableCount("claiborne")); + assert.equal(3, ts.syllableCount("clairvoyance")); + assert.equal(3, ts.syllableCount("clarabelle")); + assert.equal(2, ts.syllableCount("clarette")); + assert.equal(2, ts.syllableCount("clarice")); + assert.equal(2, ts.syllableCount("clarisse")); + assert.equal(2, ts.syllableCount("clarksville")); + assert.equal(2, ts.syllableCount("clarrisse")); + assert.equal(2, ts.syllableCount("claudette")); + assert.equal(2, ts.syllableCount("clauses")); + assert.equal(2, ts.syllableCount("clavette")); + assert.equal(2, ts.syllableCount("clayborne")); + assert.equal(2, ts.syllableCount("claybourne")); + assert.equal(2, ts.syllableCount("clayey")); + assert.equal(3, ts.syllableCount("clearances")); + assert.equal(4, ts.syllableCount("clearinghouses")); + assert.equal(2, ts.syllableCount("cleavage")); + assert.equal(2, ts.syllableCount("cleo")); + assert.equal(4, ts.syllableCount("cleopatra")); + assert.equal(3, ts.syllableCount("climaxes")); + assert.equal(3, ts.syllableCount("clinician")); + assert.equal(3, ts.syllableCount("clinicians")); + assert.equal(4, ts.syllableCount("clodoveo")); + assert.equal(2, ts.syllableCount("closeness")); + assert.equal(2, ts.syllableCount("closes")); + assert.equal(1, ts.syllableCount("clothe")); + assert.equal(1, ts.syllableCount("clothed")); + assert.equal(1, ts.syllableCount("clothes")); + assert.equal(3, ts.syllableCount("clubhouses")); + assert.equal(2, ts.syllableCount("clutches")); + assert.equal(2, ts.syllableCount("clyatt")); + assert.equal(3, ts.syllableCount("coalesced")); + assert.equal(2, ts.syllableCount("coatesville")); + assert.equal(2, ts.syllableCount("cobbled")); + assert.equal(2, ts.syllableCount("coccia")); + assert.equal(2, ts.syllableCount("coddled")); + assert.equal(3, ts.syllableCount("coercion")); + assert.equal(4, ts.syllableCount("cohesiveness")); + assert.equal(2, ts.syllableCount("coinage")); + assert.equal(2, ts.syllableCount("cointreau")); + assert.equal(2, ts.syllableCount("colette")); + assert.equal(2, ts.syllableCount("collage")); + assert.equal(3, ts.syllableCount("collages")); + assert.equal(1, ts.syllableCount("colle")); + assert.equal(2, ts.syllableCount("college")); + assert.equal(3, ts.syllableCount("colleges")); + assert.equal(3, ts.syllableCount("collegeville")); + assert.equal(2, ts.syllableCount("collette")); + assert.equal(2, ts.syllableCount("colleville")); + assert.equal(2, ts.syllableCount("cologne")); + assert.equal(2, ts.syllableCount("colville")); + assert.equal(3, ts.syllableCount("comanche")); + assert.equal(4, ts.syllableCount("combativeness")); + assert.equal(2, ts.syllableCount("comeau")); + assert.equal(2, ts.syllableCount("comeaux")); + assert.equal(4, ts.syllableCount("comedienne")); + assert.equal(3, ts.syllableCount("commanded")); + assert.equal(2, ts.syllableCount("commenced")); + assert.equal(3, ts.syllableCount("commencement")); + assert.equal(3, ts.syllableCount("commences")); + assert.equal(3, ts.syllableCount("commended")); + assert.equal(3, ts.syllableCount("commingled")); + assert.equal(3, ts.syllableCount("commonplace")); + assert.equal(2, ts.syllableCount("compeau")); + assert.equal(5, ts.syllableCount("competitiveness")); + assert.equal(3, ts.syllableCount("completeness")); + assert.equal(3, ts.syllableCount("complexes")); + assert.equal(3, ts.syllableCount("composes")); + assert.equal(3, ts.syllableCount("compounded")); + assert.equal(4, ts.syllableCount("comprehended")); + assert.equal(3, ts.syllableCount("comprises")); + assert.equal(4, ts.syllableCount("compromises")); + assert.equal(3, ts.syllableCount("conceding")); + assert.equal(4, ts.syllableCount("concepcion")); + assert.equal(3, ts.syllableCount("concierge")); + assert.equal(4, ts.syllableCount("concubinage")); + assert.equal(4, ts.syllableCount("condolences")); + assert.equal(4, ts.syllableCount("conferences")); + assert.equal(4, ts.syllableCount("confidences")); + assert.equal(3, ts.syllableCount("confinement")); + assert.equal(3, ts.syllableCount("confluence")); + assert.equal(3, ts.syllableCount("confounded")); + assert.equal(3, ts.syllableCount("confucian")); + assert.equal(3, ts.syllableCount("confuses")); + assert.equal(3, ts.syllableCount("congruence")); + assert.equal(2, ts.syllableCount("connely")); + assert.equal(3, ts.syllableCount("consciences")); + assert.equal(5, ts.syllableCount("constituencies")); + assert.equal(5, ts.syllableCount("constituency")); + assert.equal(4, ts.syllableCount("constituent")); + assert.equal(4, ts.syllableCount("constituents")); + assert.equal(3, ts.syllableCount("contended")); + assert.equal(5, ts.syllableCount("continuances")); + assert.equal(4, ts.syllableCount("contrivances")); + assert.equal(4, ts.syllableCount("controversial")); + assert.equal(4, ts.syllableCount("conveniences")); + assert.equal(3, ts.syllableCount("conveyance")); + assert.equal(3, ts.syllableCount("conveyor")); + assert.equal(2, ts.syllableCount("conville")); + assert.equal(2, ts.syllableCount("convinced")); + assert.equal(3, ts.syllableCount("convinces")); + assert.equal(3, ts.syllableCount("cooperage")); + assert.equal(2, ts.syllableCount("coppage")); + assert.equal(3, ts.syllableCount("corabelle")); + assert.equal(2, ts.syllableCount("corded")); + assert.equal(2, ts.syllableCount("corette")); + assert.equal(2, ts.syllableCount("corinne")); + assert.equal(1, ts.syllableCount("corne")); + assert.equal(2, ts.syllableCount("cornelle")); + assert.equal(2, ts.syllableCount("cornette")); + assert.equal(4, ts.syllableCount("corresponded")); + assert.equal(3, ts.syllableCount("corriveau")); + assert.equal(2, ts.syllableCount("corsage")); + assert.equal(2, ts.syllableCount("corvette")); + assert.equal(2, ts.syllableCount("corvettes")); + assert.equal(2, ts.syllableCount("coscia")); + assert.equal(2, ts.syllableCount("cosette")); + assert.equal(2, ts.syllableCount("cossette")); + assert.equal(1, ts.syllableCount("coste")); + assert.equal(2, ts.syllableCount("cotelle")); + assert.equal(4, ts.syllableCount("cotroneo")); + assert.equal(2, ts.syllableCount("cottage")); + assert.equal(3, ts.syllableCount("cottages")); + assert.equal(3, ts.syllableCount("countenanced")); + assert.equal(4, ts.syllableCount("countenances")); + assert.equal(4, ts.syllableCount("counterbalanced")); + assert.equal(4, ts.syllableCount("countercharges")); + assert.equal(6, ts.syllableCount("counterespionage")); + assert.equal(2, ts.syllableCount("coupled")); + assert.equal(2, ts.syllableCount("courage")); + assert.equal(3, ts.syllableCount("courageous")); + assert.equal(4, ts.syllableCount("courageously")); + assert.equal(2, ts.syllableCount("courteau")); + assert.equal(3, ts.syllableCount("courthouses")); + assert.equal(2, ts.syllableCount("courville")); + assert.equal(3, ts.syllableCount("cousineau")); + assert.equal(3, ts.syllableCount("coverage")); + assert.equal(4, ts.syllableCount("coverages")); + assert.equal(3, ts.syllableCount("covering")); + assert.equal(3, ts.syllableCount("coverings")); + assert.equal(4, ts.syllableCount("coviello")); + assert.equal(2, ts.syllableCount("coville")); + assert.equal(3, ts.syllableCount("cowardice")); + assert.equal(3, ts.syllableCount("cowering")); + assert.equal(2, ts.syllableCount("crackled")); + assert.equal(3, ts.syllableCount("crawfordsville")); + assert.equal(2, ts.syllableCount("crayon")); + assert.equal(2, ts.syllableCount("crayons")); + assert.equal(2, ts.syllableCount("creole")); + assert.equal(2, ts.syllableCount("creoles")); + assert.equal(3, ts.syllableCount("creolized")); + assert.equal(3, ts.syllableCount("creosote")); + assert.equal(2, ts.syllableCount("crepeau")); + assert.equal(2, ts.syllableCount("crevice")); + assert.equal(3, ts.syllableCount("crevices")); + assert.equal(2, ts.syllableCount("cribbage")); + assert.equal(2, ts.syllableCount("cringes")); + assert.equal(2, ts.syllableCount("crippled")); + assert.equal(3, ts.syllableCount("criscione")); + assert.equal(2, ts.syllableCount("crises")); + assert.equal(4, ts.syllableCount("criticizes")); + assert.equal(3, ts.syllableCount("crocuses")); + assert.equal(1, ts.syllableCount("crosse")); + assert.equal(2, ts.syllableCount("crosspiece")); + assert.equal(3, ts.syllableCount("crosspieces")); + assert.equal(2, ts.syllableCount("croteau")); + assert.equal(3, ts.syllableCount("crotonville")); + assert.equal(2, ts.syllableCount("crotteau")); + assert.equal(2, ts.syllableCount("crowded")); + assert.equal(2, ts.syllableCount("cruces")); + assert.equal(4, ts.syllableCount("crucifixes")); + assert.equal(2, ts.syllableCount("cruises")); + assert.equal(2, ts.syllableCount("crumbled")); + assert.equal(2, ts.syllableCount("crumpled")); + assert.equal(2, ts.syllableCount("crutches")); + assert.equal(2, ts.syllableCount("cryan")); + assert.equal(2, ts.syllableCount("cubbage")); + assert.equal(2, ts.syllableCount("cuccia")); + assert.equal(2, ts.syllableCount("cuddled")); + assert.equal(2, ts.syllableCount("cuddling")); + assert.equal(3, ts.syllableCount("cuneo")); + assert.equal(2, ts.syllableCount("curtice")); + assert.equal(1, ts.syllableCount("curves")); + assert.equal(2, ts.syllableCount("cuteness")); + assert.equal(4, ts.syllableCount("cuyahoga")); + assert.equal(2, ts.syllableCount("cyacq")); + assert.equal(4, ts.syllableCount("cyanamid")); + assert.equal(4, ts.syllableCount("cyanazine")); + assert.equal(3, ts.syllableCount("cyanide")); + assert.equal(4, ts.syllableCount("cyanuric")); + assert.equal(3, ts.syllableCount("cyberspace")); + assert.equal(2, ts.syllableCount("cycled")); + assert.equal(4, ts.syllableCount("cytoplasm")); + assert.equal(2, ts.syllableCount("dabbled")); + assert.equal(2, ts.syllableCount("daigneault")); + assert.equal(3, ts.syllableCount("daleo")); + assert.equal(2, ts.syllableCount("damage")); + assert.equal(2, ts.syllableCount("damaged")); + assert.equal(3, ts.syllableCount("damages")); + assert.equal(1, ts.syllableCount("damme")); + assert.equal(2, ts.syllableCount("dances")); + assert.equal(3, ts.syllableCount("dandeneau")); + assert.equal(2, ts.syllableCount("danelle")); + assert.equal(2, ts.syllableCount("dangled")); + assert.equal(4, ts.syllableCount("daniello")); + assert.equal(3, ts.syllableCount("dansereau")); + assert.equal(2, ts.syllableCount("danville")); + assert.equal(2, ts.syllableCount("dapice")); + assert.equal(2, ts.syllableCount("darbonne")); + assert.equal(2, ts.syllableCount("darice")); + assert.equal(2, ts.syllableCount("darrelle")); + assert.equal(2, ts.syllableCount("darville")); + assert.equal(4, ts.syllableCount("databases")); + assert.equal(2, ts.syllableCount("daya")); + assert.equal(2, ts.syllableCount("dayan")); + assert.equal(2, ts.syllableCount("dazzled")); + assert.equal(2, ts.syllableCount("deathbed")); + assert.equal(3, ts.syllableCount("deatherage")); + assert.equal(3, ts.syllableCount("debasement")); + assert.equal(2, ts.syllableCount("debrosse")); + assert.equal(4, ts.syllableCount("decapua")); + assert.equal(2, ts.syllableCount("decelle")); + assert.equal(2, ts.syllableCount("decelles")); + assert.equal(4, ts.syllableCount("decisiveness")); + assert.equal(4, ts.syllableCount("decomposes")); + assert.equal(3, ts.syllableCount("decoteau")); + assert.equal(3, ts.syllableCount("decreases")); + assert.equal(2, ts.syllableCount("dedeaux")); + assert.equal(2, ts.syllableCount("deduce")); + assert.equal(2, ts.syllableCount("deduced")); + assert.equal(2, ts.syllableCount("defaced")); + assert.equal(3, ts.syllableCount("defarges")); + assert.equal(3, ts.syllableCount("defelice")); + assert.equal(3, ts.syllableCount("defended")); + assert.equal(4, ts.syllableCount("defensiveness")); + assert.equal(3, ts.syllableCount("defeo")); + assert.equal(2, ts.syllableCount("degaulle")); + assert.equal(3, ts.syllableCount("dehoyos")); + assert.equal(3, ts.syllableCount("dejarnette")); + assert.equal(2, ts.syllableCount("delage")); + assert.equal(2, ts.syllableCount("delbosque")); + assert.equal(3, ts.syllableCount("deleo")); + assert.equal(3, ts.syllableCount("deleon")); + assert.equal(5, ts.syllableCount("deleonardis")); + assert.equal(2, ts.syllableCount("delfosse")); + assert.equal(3, ts.syllableCount("delgiudice")); + assert.equal(3, ts.syllableCount("delguidice")); + assert.equal(3, ts.syllableCount("delicia")); + assert.equal(2, ts.syllableCount("delisle")); + assert.equal(4, ts.syllableCount("deliverers")); + assert.equal(4, ts.syllableCount("delivering")); + assert.equal(1, ts.syllableCount("delle")); + assert.equal(2, ts.syllableCount("delmed")); + assert.equal(3, ts.syllableCount("deluccia")); + assert.equal(3, ts.syllableCount("delucia")); + assert.equal(2, ts.syllableCount("deluge")); + assert.equal(2, ts.syllableCount("deluged")); + assert.equal(1, ts.syllableCount("delve")); + assert.equal(1, ts.syllableCount("delves")); + assert.equal(3, ts.syllableCount("demanded")); + assert.equal(4, ts.syllableCount("dematteo")); + assert.equal(3, ts.syllableCount("demayo")); + assert.equal(3, ts.syllableCount("demeo")); + assert.equal(6, ts.syllableCount("demilitarizes")); + assert.equal(1, ts.syllableCount("demme")); + assert.equal(2, ts.syllableCount("deneau")); + assert.equal(2, ts.syllableCount("deneault")); + assert.equal(2, ts.syllableCount("denice")); + assert.equal(1, ts.syllableCount("denne")); + assert.equal(2, ts.syllableCount("denomme")); + assert.equal(2, ts.syllableCount("denounced")); + assert.equal(3, ts.syllableCount("denounces")); + assert.equal(2, ts.syllableCount("deo")); + assert.equal(4, ts.syllableCount("deodorant")); + assert.equal(4, ts.syllableCount("deodorants")); + assert.equal(5, ts.syllableCount("deoliveira")); + assert.equal(2, ts.syllableCount("deon")); + assert.equal(3, ts.syllableCount("depended")); + assert.equal(4, ts.syllableCount("deployable")); + assert.equal(2, ts.syllableCount("deranged")); + assert.equal(2, ts.syllableCount("derousse")); + assert.equal(3, ts.syllableCount("descended")); + assert.equal(3, ts.syllableCount("descoteaux")); + assert.equal(2, ts.syllableCount("deserves")); + assert.equal(3, ts.syllableCount("desormeaux")); + assert.equal(3, ts.syllableCount("despises")); + assert.equal(2, ts.syllableCount("desselle")); + assert.equal(2, ts.syllableCount("detached")); + assert.equal(6, ts.syllableCount("deterioration")); + assert.equal(3, ts.syllableCount("detherage")); + assert.equal(2, ts.syllableCount("dettling")); + assert.equal(2, ts.syllableCount("deveau")); + assert.equal(2, ts.syllableCount("deveaux")); + assert.equal(2, ts.syllableCount("develle")); + assert.equal(3, ts.syllableCount("devereaux")); + assert.equal(2, ts.syllableCount("device")); + assert.equal(3, ts.syllableCount("devices")); + assert.equal(2, ts.syllableCount("deville")); + assert.equal(3, ts.syllableCount("devises")); + assert.equal(2, ts.syllableCount("deyo")); + assert.equal(2, ts.syllableCount("deyoe")); + assert.equal(2, ts.syllableCount("deyoung")); + assert.equal(4, ts.syllableCount("diagnoses")); + assert.equal(4, ts.syllableCount("dianthia")); + assert.equal(5, ts.syllableCount("diaphonia")); + assert.equal(6, ts.syllableCount("dibartolomeo")); + assert.equal(2, ts.syllableCount("dibbled")); + assert.equal(3, ts.syllableCount("diceon")); + assert.equal(7, ts.syllableCount("dideoxycytidine")); + assert.equal(3, ts.syllableCount("dieringer")); + assert.equal(2, ts.syllableCount("dieses")); + assert.equal(2, ts.syllableCount("diet")); + assert.equal(3, ts.syllableCount("dieters")); + assert.equal(3, ts.syllableCount("difelice")); + assert.equal(4, ts.syllableCount("differences")); + assert.equal(3, ts.syllableCount("diffuses")); + assert.equal(3, ts.syllableCount("dileo")); + assert.equal(5, ts.syllableCount("dileonardo")); + assert.equal(1, ts.syllableCount("dille")); + assert.equal(4, ts.syllableCount("dimatteo")); + assert.equal(3, ts.syllableCount("dimeo")); + assert.equal(2, ts.syllableCount("dimpled")); + assert.equal(2, ts.syllableCount("dinges")); + assert.equal(2, ts.syllableCount("dion")); + assert.equal(3, ts.syllableCount("diona")); + assert.equal(2, ts.syllableCount("dione")); + assert.equal(5, ts.syllableCount("dionysius")); + assert.equal(3, ts.syllableCount("disabled")); + assert.equal(4, ts.syllableCount("disadvantage")); + assert.equal(4, ts.syllableCount("disadvantaged")); + assert.equal(5, ts.syllableCount("disadvantageous")); + assert.equal(5, ts.syllableCount("disadvantages")); + assert.equal(5, ts.syllableCount("disallowances")); + assert.equal(5, ts.syllableCount("disappearances")); + assert.equal(4, ts.syllableCount("disassembled")); + assert.equal(3, ts.syllableCount("disbanded")); + assert.equal(3, ts.syllableCount("disbursement")); + assert.equal(3, ts.syllableCount("disbursements")); + assert.equal(3, ts.syllableCount("discarded")); + assert.equal(3, ts.syllableCount("discharges")); + assert.equal(3, ts.syllableCount("discloses")); + assert.equal(3, ts.syllableCount("discourage")); + assert.equal(3, ts.syllableCount("discouraged")); + assert.equal(4, ts.syllableCount("discouragement")); + assert.equal(4, ts.syllableCount("discourages")); + assert.equal(4, ts.syllableCount("discovering")); + assert.equal(3, ts.syllableCount("diseases")); + assert.equal(5, ts.syllableCount("disenfranchisement")); + assert.equal(3, ts.syllableCount("disengage")); + assert.equal(3, ts.syllableCount("disengaged")); + assert.equal(4, ts.syllableCount("disengagement")); + assert.equal(2, ts.syllableCount("disgrace")); + assert.equal(2, ts.syllableCount("disgraced")); + assert.equal(3, ts.syllableCount("disgraceful")); + assert.equal(3, ts.syllableCount("disguises")); + assert.equal(2, ts.syllableCount("diskette")); + assert.equal(2, ts.syllableCount("diskettes")); + assert.equal(2, ts.syllableCount("dislodged")); + assert.equal(3, ts.syllableCount("disloyal")); + assert.equal(4, ts.syllableCount("disloyalty")); + assert.equal(3, ts.syllableCount("disparage")); + assert.equal(3, ts.syllableCount("disparaged")); + assert.equal(4, ts.syllableCount("disparages")); + assert.equal(3, ts.syllableCount("dispatches")); + assert.equal(2, ts.syllableCount("displace")); + assert.equal(2, ts.syllableCount("displaced")); + assert.equal(3, ts.syllableCount("displacement")); + assert.equal(3, ts.syllableCount("displacements")); + assert.equal(3, ts.syllableCount("displaces")); + assert.equal(3, ts.syllableCount("disposes")); + assert.equal(4, ts.syllableCount("disregarded")); + assert.equal(3, ts.syllableCount("disservice")); + assert.equal(2, ts.syllableCount("dissolve")); + assert.equal(2, ts.syllableCount("dissolves")); + assert.equal(2, ts.syllableCount("distanced")); + assert.equal(3, ts.syllableCount("distances")); + assert.equal(2, ts.syllableCount("distaste")); + assert.equal(3, ts.syllableCount("distasteful")); + assert.equal(3, ts.syllableCount("distended")); + assert.equal(4, ts.syllableCount("distinctiveness")); + assert.equal(4, ts.syllableCount("disturbances")); + assert.equal(2, ts.syllableCount("ditches")); + assert.equal(4, ts.syllableCount("divergences")); + assert.equal(3, ts.syllableCount("diverges")); + assert.equal(4, ts.syllableCount("divisiveness")); + assert.equal(2, ts.syllableCount("divorced")); + assert.equal(3, ts.syllableCount("divorces")); + assert.equal(2, ts.syllableCount("dodges")); + assert.equal(2, ts.syllableCount("doenges")); + assert.equal(3, ts.syllableCount("doggedly")); + assert.equal(2, ts.syllableCount("dolce")); + assert.equal(1, ts.syllableCount("dolle")); + assert.equal(1, ts.syllableCount("donne")); + assert.equal(3, ts.syllableCount("doralynne")); + assert.equal(3, ts.syllableCount("doraville")); + assert.equal(2, ts.syllableCount("dorette")); + assert.equal(2, ts.syllableCount("dorice")); + assert.equal(2, ts.syllableCount("dOrsay")); + assert.equal(2, ts.syllableCount("dosage")); + assert.equal(3, ts.syllableCount("dosages")); + assert.equal(2, ts.syllableCount("doses")); + assert.equal(2, ts.syllableCount("doubled")); + assert.equal(2, ts.syllableCount("doucette")); + assert.equal(2, ts.syllableCount("douville")); + assert.equal(2, ts.syllableCount("downstage")); + assert.equal(2, ts.syllableCount("doyal")); + assert.equal(2, ts.syllableCount("doyel")); + assert.equal(2, ts.syllableCount("doyen")); + assert.equal(2, ts.syllableCount("doyon")); + assert.equal(2, ts.syllableCount("drainage")); + assert.equal(1, ts.syllableCount("dralle")); + assert.equal(4, ts.syllableCount("dramatizes")); + assert.equal(2, ts.syllableCount("drapeau")); + assert.equal(2, ts.syllableCount("dredges")); + assert.equal(2, ts.syllableCount("dressage")); + assert.equal(2, ts.syllableCount("dribbled")); + assert.equal(1, ts.syllableCount("droste")); + assert.equal(2, ts.syllableCount("dubeau")); + assert.equal(2, ts.syllableCount("duchenne")); + assert.equal(3, ts.syllableCount("duchesneau")); + assert.equal(3, ts.syllableCount("dudayev")); + assert.equal(3, ts.syllableCount("duena")); + assert.equal(3, ts.syllableCount("duenas")); + assert.equal(4, ts.syllableCount("dukakises")); + assert.equal(3, ts.syllableCount("dulcibelle")); + assert.equal(1, ts.syllableCount("dulle")); + assert.equal(3, ts.syllableCount("dumbfounded")); + assert.equal(1, ts.syllableCount("dunne")); + assert.equal(2, ts.syllableCount("durette")); + assert.equal(3, ts.syllableCount("duryea")); + assert.equal(2, ts.syllableCount("dusseau")); + assert.equal(2, ts.syllableCount("dusseault")); + assert.equal(1, ts.syllableCount("dwelle")); + assert.equal(2, ts.syllableCount("dwindled")); + assert.equal(2, ts.syllableCount("dyad")); + assert.equal(2, ts.syllableCount("dyal")); + assert.equal(3, ts.syllableCount("dyana")); + assert.equal(2, ts.syllableCount("dyane")); + assert.equal(3, ts.syllableCount("dyansen")); + assert.equal(2, ts.syllableCount("dyar")); + assert.equal(2, ts.syllableCount("dyas")); + assert.equal(3, ts.syllableCount("dyatron")); + assert.equal(3, ts.syllableCount("dyazide")); + assert.equal(2, ts.syllableCount("dyess")); + assert.equal(2, ts.syllableCount("easement")); + assert.equal(2, ts.syllableCount("eases")); + assert.equal(1, ts.syllableCount("eastes")); + assert.equal(1, ts.syllableCount("eau")); + assert.equal(1, ts.syllableCount("eaux")); + assert.equal(2, ts.syllableCount("edges")); + assert.equal(3, ts.syllableCount("edifice")); + assert.equal(2, ts.syllableCount("edithe")); + assert.equal(2, ts.syllableCount("edythe")); + assert.equal(4, ts.syllableCount("effectiveness")); + assert.equal(4, ts.syllableCount("efficiences")); + assert.equal(3, ts.syllableCount("effluent")); + assert.equal(3, ts.syllableCount("egerer")); + assert.equal(2, ts.syllableCount("Ehud")); + assert.equal(2, ts.syllableCount("eldred")); + assert.equal(4, ts.syllableCount("electrician")); + assert.equal(4, ts.syllableCount("electricians")); + assert.equal(4, ts.syllableCount("electrospace")); + assert.equal(1, ts.syllableCount("elle")); + assert.equal(2, ts.syllableCount("ellesse")); + assert.equal(2, ts.syllableCount("ellette")); + assert.equal(2, ts.syllableCount("ellice")); + assert.equal(4, ts.syllableCount("elusiveness")); + assert.equal(1, ts.syllableCount("elves")); + assert.equal(2, ts.syllableCount("embed")); + assert.equal(3, ts.syllableCount("embedded")); + assert.equal(3, ts.syllableCount("embezzled")); + assert.equal(2, ts.syllableCount("embrace")); + assert.equal(2, ts.syllableCount("embraced")); + assert.equal(3, ts.syllableCount("embraces")); + assert.equal(5, ts.syllableCount("embryology")); + assert.equal(3, ts.syllableCount("emerges")); + assert.equal(4, ts.syllableCount("emeryville")); + assert.equal(4, ts.syllableCount("eminences")); + assert.equal(2, ts.syllableCount("emlynne")); + assert.equal(1, ts.syllableCount("emme")); + assert.equal(3, ts.syllableCount("emphases")); + assert.equal(4, ts.syllableCount("emphasizes")); + assert.equal(3, ts.syllableCount("emplacement")); + assert.equal(4, ts.syllableCount("employable")); + assert.equal(3, ts.syllableCount("employee")); + assert.equal(3, ts.syllableCount("employees")); + assert.equal(4, ts.syllableCount("empowering")); + assert.equal(3, ts.syllableCount("enabled")); + assert.equal(3, ts.syllableCount("encircled")); + assert.equal(3, ts.syllableCount("encourage")); + assert.equal(3, ts.syllableCount("encouraged")); + assert.equal(4, ts.syllableCount("encouragement")); + assert.equal(4, ts.syllableCount("encourages")); + assert.equal(2, ts.syllableCount("encroached")); + assert.equal(4, ts.syllableCount("endangering")); + assert.equal(2, ts.syllableCount("ended")); + assert.equal(3, ts.syllableCount("endorsement")); + assert.equal(3, ts.syllableCount("endorsements")); + assert.equal(3, ts.syllableCount("enfeebled")); + assert.equal(2, ts.syllableCount("enforced")); + assert.equal(3, ts.syllableCount("enforcement")); + assert.equal(3, ts.syllableCount("enforces")); + assert.equal(4, ts.syllableCount("enfranchises")); + assert.equal(2, ts.syllableCount("engage")); + assert.equal(2, ts.syllableCount("engaged")); + assert.equal(3, ts.syllableCount("engagement")); + assert.equal(3, ts.syllableCount("engagements")); + assert.equal(3, ts.syllableCount("engages")); + assert.equal(2, ts.syllableCount("enhanced")); + assert.equal(3, ts.syllableCount("enhancement")); + assert.equal(3, ts.syllableCount("enhancements")); + assert.equal(3, ts.syllableCount("enhances")); + assert.equal(4, ts.syllableCount("enjoyable")); + assert.equal(3, ts.syllableCount("enlarges")); + assert.equal(1, ts.syllableCount("ennes")); + assert.equal(2, ts.syllableCount("enrage")); + assert.equal(2, ts.syllableCount("enraged")); + assert.equal(2, ts.syllableCount("enriched")); + assert.equal(2, ts.syllableCount("ensconced")); + assert.equal(3, ts.syllableCount("enslavement")); + assert.equal(3, ts.syllableCount("entangled")); + assert.equal(4, ts.syllableCount("enterprises")); + assert.equal(3, ts.syllableCount("enthuses")); + assert.equal(6, ts.syllableCount("enthusiastically")); + assert.equal(2, ts.syllableCount("entice")); + assert.equal(2, ts.syllableCount("enticed")); + assert.equal(3, ts.syllableCount("enticement")); + assert.equal(3, ts.syllableCount("enticements")); + assert.equal(3, ts.syllableCount("entourage")); + assert.equal(2, ts.syllableCount("entranced")); + assert.equal(3, ts.syllableCount("entrances")); + assert.equal(2, ts.syllableCount("entrenched")); + assert.equal(3, ts.syllableCount("envisage")); + assert.equal(3, ts.syllableCount("envisaged")); + assert.equal(4, ts.syllableCount("envisages")); + assert.equal(3, ts.syllableCount("eocene")); + assert.equal(2, ts.syllableCount("eoff")); + assert.equal(4, ts.syllableCount("eohippus")); + assert.equal(4, ts.syllableCount("eolande")); + assert.equal(2, ts.syllableCount("eon")); + assert.equal(2, ts.syllableCount("eons")); + assert.equal(5, ts.syllableCount("epitomizes")); + assert.equal(3, ts.syllableCount("erases")); + assert.equal(1, ts.syllableCount("erne")); + assert.equal(3, ts.syllableCount("escapement")); + assert.equal(4, ts.syllableCount("espionage")); + assert.equal(3, ts.syllableCount("espouses")); + assert.equal(3, ts.syllableCount("essayist")); + assert.equal(1, ts.syllableCount("esse")); + assert.equal(1, ts.syllableCount("este")); + assert.equal(2, ts.syllableCount("estelle")); + assert.equal(2, ts.syllableCount("estranged")); + assert.equal(3, ts.syllableCount("estrangement")); + assert.equal(2, ts.syllableCount("etches")); + assert.equal(4, ts.syllableCount("ethereal")); + assert.equal(3, ts.syllableCount("ettlinger")); + assert.equal(4, ts.syllableCount("etzioni")); + assert.equal(3, ts.syllableCount("eudocia")); + assert.equal(2, ts.syllableCount("eunice")); + assert.equal(3, ts.syllableCount("eurasian")); + assert.equal(3, ts.syllableCount("europeenne")); + assert.equal(3, ts.syllableCount("euroyen")); + assert.equal(2, ts.syllableCount("eustace")); + assert.equal(3, ts.syllableCount("eustacia")); + assert.equal(2, ts.syllableCount("eustice")); + assert.equal(3, ts.syllableCount("evansville")); + assert.equal(4, ts.syllableCount("evenhanded")); + assert.equal(5, ts.syllableCount("evenhandedly")); + assert.equal(3, ts.syllableCount("everage")); + assert.equal(3, ts.syllableCount("everette")); + assert.equal(3, ts.syllableCount("evidenced")); + assert.equal(4, ts.syllableCount("evidences")); + assert.equal(2, ts.syllableCount("evinced")); + assert.equal(2, ts.syllableCount("evolve")); + assert.equal(2, ts.syllableCount("evolves")); + assert.equal(2, ts.syllableCount("evonne")); + assert.equal(2, ts.syllableCount("exchanged")); + assert.equal(3, ts.syllableCount("exchanges")); + assert.equal(3, ts.syllableCount("excises")); + assert.equal(3, ts.syllableCount("excitement")); + assert.equal(3, ts.syllableCount("excoa")); + assert.equal(3, ts.syllableCount("excuses")); + assert.equal(4, ts.syllableCount("exercises")); + assert.equal(2, ts.syllableCount("exes")); + assert.equal(3, ts.syllableCount("expanded")); + assert.equal(3, ts.syllableCount("expended")); + assert.equal(3, ts.syllableCount("exposes")); + assert.equal(3, ts.syllableCount("expounded")); + assert.equal(2, ts.syllableCount("expunged")); + assert.equal(3, ts.syllableCount("extended")); + assert.equal(5, ts.syllableCount("extraordinaire")); + assert.equal(3, ts.syllableCount("eyerman")); + assert.equal(2, ts.syllableCount("ezelle")); + assert.equal(2, ts.syllableCount("fabled")); + assert.equal(2, ts.syllableCount("faceless")); + assert.equal(2, ts.syllableCount("faces")); + assert.equal(2, ts.syllableCount("facteau")); + assert.equal(3, ts.syllableCount("falardeau")); + assert.equal(2, ts.syllableCount("fangled")); + assert.equal(4, ts.syllableCount("fantasizes")); + assert.equal(4, ts.syllableCount("fariello")); + assert.equal(3, ts.syllableCount("farmhouses")); + assert.equal(1, ts.syllableCount("farnes")); + assert.equal(2, ts.syllableCount("faucette")); + assert.equal(2, ts.syllableCount("favreau")); + assert.equal(2, ts.syllableCount("faxes")); + assert.equal(2, ts.syllableCount("fayard")); + assert.equal(2, ts.syllableCount("fayez")); + assert.equal(3, ts.syllableCount("faymonville")); + assert.equal(2, ts.syllableCount("feces")); + assert.equal(2, ts.syllableCount("fecteau")); + assert.equal(2, ts.syllableCount("fejes")); + assert.equal(2, ts.syllableCount("felice")); + assert.equal(3, ts.syllableCount("felicia")); + assert.equal(2, ts.syllableCount("felrice")); + assert.equal(1, ts.syllableCount("femme")); + assert.equal(2, ts.syllableCount("fences")); + assert.equal(2, ts.syllableCount("fended")); + assert.equal(3, ts.syllableCount("feodor")); + assert.equal(4, ts.syllableCount("feodora")); + assert.equal(3, ts.syllableCount("feola")); + assert.equal(4, ts.syllableCount("fertilizes")); + assert.equal(2, ts.syllableCount("fetches")); + assert.equal(1, ts.syllableCount("fette")); + assert.equal(1, ts.syllableCount("fettes")); + assert.equal(3, ts.syllableCount("fetuses")); + assert.equal(2, ts.syllableCount("fiddled")); + assert.equal(2, ts.syllableCount("fiddling")); + assert.equal(2, ts.syllableCount("fielded")); + assert.equal(4, ts.syllableCount("figaroa")); + assert.equal(4, ts.syllableCount("figueroa")); + assert.equal(2, ts.syllableCount("filice")); + assert.equal(3, ts.syllableCount("filyaw")); + assert.equal(2, ts.syllableCount("financed")); + assert.equal(3, ts.syllableCount("financement")); + assert.equal(3, ts.syllableCount("finances")); + assert.equal(2, ts.syllableCount("finesse")); + assert.equal(3, ts.syllableCount("fingering")); + assert.equal(1, ts.syllableCount("finne")); + assert.equal(3, ts.syllableCount("fiona")); + assert.equal(4, ts.syllableCount("firehouses")); + assert.equal(3, ts.syllableCount("fireplace")); + assert.equal(4, ts.syllableCount("fireplaces")); + assert.equal(2, ts.syllableCount("fisette")); + assert.equal(2, ts.syllableCount("fishburne")); + assert.equal(1, ts.syllableCount("fiske")); + assert.equal(3, ts.syllableCount("fitzmaurice")); + assert.equal(2, ts.syllableCount("fixes")); + assert.equal(2, ts.syllableCount("fizzled")); + assert.equal(3, ts.syllableCount("flamboyance")); + assert.equal(3, ts.syllableCount("flamboyant")); + assert.equal(4, ts.syllableCount("flamboyantly")); + assert.equal(2, ts.syllableCount("flanges")); + assert.equal(2, ts.syllableCount("fleurette")); + assert.equal(2, ts.syllableCount("flexes")); + assert.equal(2, ts.syllableCount("flounces")); + assert.equal(3, ts.syllableCount("flowering")); + assert.equal(3, ts.syllableCount("fluency")); + assert.equal(2, ts.syllableCount("fluent")); + assert.equal(1, ts.syllableCount("flythe")); + assert.equal(3, ts.syllableCount("focuses")); + assert.equal(2, ts.syllableCount("folded")); + assert.equal(2, ts.syllableCount("follette")); + assert.equal(3, ts.syllableCount("fontenette")); + assert.equal(2, ts.syllableCount("fonville")); + assert.equal(3, ts.syllableCount("foodservice")); + assert.equal(2, ts.syllableCount("footage")); + assert.equal(2, ts.syllableCount("footrace")); + assert.equal(2, ts.syllableCount("forage")); + assert.equal(3, ts.syllableCount("forages")); + assert.equal(2, ts.syllableCount("forces")); + assert.equal(2, ts.syllableCount("fordyce")); + assert.equal(3, ts.syllableCount("forecloses")); + assert.equal(2, ts.syllableCount("foretaste")); + assert.equal(2, ts.syllableCount("forges")); + assert.equal(2, ts.syllableCount("forgette")); + assert.equal(3, ts.syllableCount("forgione")); + assert.equal(3, ts.syllableCount("forgiveness")); + assert.equal(4, ts.syllableCount("formalizes")); + assert.equal(1, ts.syllableCount("fornes")); + assert.equal(2, ts.syllableCount("forsythe")); + assert.equal(3, ts.syllableCount("forwarded")); + assert.equal(1, ts.syllableCount("fosse")); + assert.equal(2, ts.syllableCount("founded")); + assert.equal(2, ts.syllableCount("foxes")); + assert.equal(2, ts.syllableCount("fradette")); + assert.equal(3, ts.syllableCount("fragrances")); + assert.equal(2, ts.syllableCount("frances")); + assert.equal(3, ts.syllableCount("franchises")); + assert.equal(2, ts.syllableCount("francia")); + assert.equal(3, ts.syllableCount("francisville")); + assert.equal(2, ts.syllableCount("frazzled")); + assert.equal(2, ts.syllableCount("frechette")); + assert.equal(2, ts.syllableCount("freckled")); + assert.equal(2, ts.syllableCount("freezes")); + assert.equal(2, ts.syllableCount("fregeau")); + assert.equal(2, ts.syllableCount("frenette")); + assert.equal(2, ts.syllableCount("freon")); + assert.equal(2, ts.syllableCount("freons")); + assert.equal(2, ts.syllableCount("freya")); + assert.equal(3, ts.syllableCount("freyermuth")); + assert.equal(2, ts.syllableCount("fringes")); + assert.equal(3, ts.syllableCount("friona")); + assert.equal(2, ts.syllableCount("friscia")); + assert.equal(1, ts.syllableCount("friske")); + assert.equal(1, ts.syllableCount("fromme")); + assert.equal(2, ts.syllableCount("frontage")); + assert.equal(2, ts.syllableCount("fryar")); + assert.equal(2, ts.syllableCount("fuchsias")); + assert.equal(3, ts.syllableCount("fujiya")); + assert.equal(4, ts.syllableCount("fujiyama")); + assert.equal(4, ts.syllableCount("fukuyama")); + assert.equal(2, ts.syllableCount("fumbled")); + assert.equal(2, ts.syllableCount("funded")); + assert.equal(2, ts.syllableCount("furches")); + assert.equal(2, ts.syllableCount("furloughed")); + assert.equal(2, ts.syllableCount("furnace")); + assert.equal(3, ts.syllableCount("furnaces")); + assert.equal(3, ts.syllableCount("furuya")); + assert.equal(3, ts.syllableCount("fuselage")); + assert.equal(4, ts.syllableCount("fuselages")); + assert.equal(2, ts.syllableCount("fuses")); + assert.equal(2, ts.syllableCount("fuzes")); + assert.equal(4, ts.syllableCount("gabriella")); + assert.equal(4, ts.syllableCount("gabrielli")); + assert.equal(3, ts.syllableCount("gaccione")); + assert.equal(2, ts.syllableCount("gainesville")); + assert.equal(3, ts.syllableCount("galarneau")); + assert.equal(4, ts.syllableCount("galileo")); + assert.equal(3, ts.syllableCount("galipeau")); + assert.equal(1, ts.syllableCount("galle")); + assert.equal(3, ts.syllableCount("galleon")); + assert.equal(3, ts.syllableCount("galleons")); + assert.equal(1, ts.syllableCount("galles")); + assert.equal(3, ts.syllableCount("galyean")); + assert.equal(3, ts.syllableCount("galyen")); + assert.equal(2, ts.syllableCount("gamage")); + assert.equal(2, ts.syllableCount("gambled")); + assert.equal(3, ts.syllableCount("gamboa")); + assert.equal(2, ts.syllableCount("gammage")); + assert.equal(4, ts.syllableCount("ganglionic")); + assert.equal(2, ts.syllableCount("garage")); + assert.equal(3, ts.syllableCount("garages")); + assert.equal(2, ts.syllableCount("garbage")); + assert.equal(2, ts.syllableCount("garbled")); + assert.equal(2, ts.syllableCount("garceau")); + assert.equal(2, ts.syllableCount("garces")); + assert.equal(3, ts.syllableCount("gardea")); + assert.equal(2, ts.syllableCount("gareau")); + assert.equal(2, ts.syllableCount("garges")); + assert.equal(2, ts.syllableCount("garneau")); + assert.equal(1, ts.syllableCount("garnes")); + assert.equal(2, ts.syllableCount("garnette")); + assert.equal(2, ts.syllableCount("garrette")); + assert.equal(2, ts.syllableCount("gases")); + assert.equal(1, ts.syllableCount("gasque")); + assert.equal(3, ts.syllableCount("gastineau")); + assert.equal(2, ts.syllableCount("gaudette")); + assert.equal(2, ts.syllableCount("gaudreau")); + assert.equal(2, ts.syllableCount("gauges")); + assert.equal(1, ts.syllableCount("gaulle")); + assert.equal(2, ts.syllableCount("gauthreaux")); + assert.equal(2, ts.syllableCount("gautreau")); + assert.equal(2, ts.syllableCount("gautreaux")); + assert.equal(2, ts.syllableCount("gauvreau")); + assert.equal(2, ts.syllableCount("gazelle")); + assert.equal(2, ts.syllableCount("gazelles")); + assert.equal(2, ts.syllableCount("gazes")); + assert.equal(2, ts.syllableCount("gazette")); + assert.equal(3, ts.syllableCount("gearboxes")); + assert.equal(3, ts.syllableCount("gedeon")); + assert.equal(2, ts.syllableCount("geers")); + assert.equal(2, ts.syllableCount("gelette")); + assert.equal(3, ts.syllableCount("gelineau")); + assert.equal(1, ts.syllableCount("gelles")); + assert.equal(3, ts.syllableCount("gemayel")); + assert.equal(1, ts.syllableCount("gemme")); + assert.equal(2, ts.syllableCount("gendreau")); + assert.equal(3, ts.syllableCount("genoa")); + assert.equal(2, ts.syllableCount("geo")); + assert.equal(4, ts.syllableCount("geocentric")); + assert.equal(5, ts.syllableCount("geochemistry")); + assert.equal(4, ts.syllableCount("geodesic")); + assert.equal(4, ts.syllableCount("geodesy")); + assert.equal(3, ts.syllableCount("geodyne")); + assert.equal(4, ts.syllableCount("geoffrion")); + assert.equal(3, ts.syllableCount("geoffroy")); + assert.equal(4, ts.syllableCount("geographer")); + assert.equal(4, ts.syllableCount("geographic")); + assert.equal(5, ts.syllableCount("geographical")); + assert.equal(6, ts.syllableCount("geographically")); + assert.equal(4, ts.syllableCount("geography")); + assert.equal(4, ts.syllableCount("geologic")); + assert.equal(5, ts.syllableCount("geological")); + assert.equal(4, ts.syllableCount("geologist")); + assert.equal(4, ts.syllableCount("geologists")); + assert.equal(4, ts.syllableCount("geology")); + assert.equal(5, ts.syllableCount("geomagnetic")); + assert.equal(4, ts.syllableCount("geometric")); + assert.equal(5, ts.syllableCount("geometrical")); + assert.equal(4, ts.syllableCount("geometries")); + assert.equal(4, ts.syllableCount("geometry")); + assert.equal(6, ts.syllableCount("geomorphology")); + assert.equal(2, ts.syllableCount("geon")); + assert.equal(5, ts.syllableCount("geophysical")); + assert.equal(6, ts.syllableCount("geopolitical")); + assert.equal(5, ts.syllableCount("geopolitics")); + assert.equal(3, ts.syllableCount("geordie")); + assert.equal(2, ts.syllableCount("georg")); + assert.equal(4, ts.syllableCount("georgeson")); + assert.equal(3, ts.syllableCount("georgi")); + assert.equal(4, ts.syllableCount("georgiades")); + assert.equal(4, ts.syllableCount("geostrophic")); + assert.equal(4, ts.syllableCount("geosyncline")); + assert.equal(4, ts.syllableCount("geotaxis")); + assert.equal(3, ts.syllableCount("geotek")); + assert.equal(4, ts.syllableCount("geothermal")); + assert.equal(4, ts.syllableCount("geotropic")); + assert.equal(5, ts.syllableCount("geotropism")); + assert.equal(2, ts.syllableCount("gering")); + assert.equal(3, ts.syllableCount("geringer")); + assert.equal(1, ts.syllableCount("geske")); + assert.equal(3, ts.syllableCount("geyelin")); + assert.equal(2, ts.syllableCount("gibeau")); + assert.equal(2, ts.syllableCount("gibeault")); + assert.equal(3, ts.syllableCount("gideon")); + assert.equal(1, ts.syllableCount("gieske")); + assert.equal(2, ts.syllableCount("giggled")); + assert.equal(3, ts.syllableCount("gildea")); + assert.equal(2, ts.syllableCount("gilded")); + assert.equal(1, ts.syllableCount("gille")); + assert.equal(1, ts.syllableCount("gilles")); + assert.equal(2, ts.syllableCount("gillette")); + assert.equal(3, ts.syllableCount("gionet")); + assert.equal(2, ts.syllableCount("giselle")); + assert.equal(3, ts.syllableCount("giudice")); + assert.equal(2, ts.syllableCount("glances")); + assert.equal(2, ts.syllableCount("glanville")); + assert.equal(2, ts.syllableCount("glazes")); + assert.equal(2, ts.syllableCount("glenville")); + assert.equal(2, ts.syllableCount("glitches")); + assert.equal(3, ts.syllableCount("glowering")); + assert.equal(2, ts.syllableCount("goa")); + assert.equal(2, ts.syllableCount("gobbled")); + assert.equal(2, ts.syllableCount("goddeau")); + assert.equal(2, ts.syllableCount("godette")); + assert.equal(1, ts.syllableCount("goethe")); + assert.equal(3, ts.syllableCount("goldfeder")); + assert.equal(1, ts.syllableCount("golle")); + assert.equal(2, ts.syllableCount("goodreau")); + assert.equal(3, ts.syllableCount("gooseberry")); + assert.equal(3, ts.syllableCount("gordeyev")); + assert.equal(2, ts.syllableCount("gorgeous")); + assert.equal(2, ts.syllableCount("gorges")); + assert.equal(2, ts.syllableCount("gossage")); + assert.equal(1, ts.syllableCount("gosse")); + assert.equal(2, ts.syllableCount("goudeau")); + assert.equal(2, ts.syllableCount("goudreau")); + assert.equal(2, ts.syllableCount("goulette")); + assert.equal(2, ts.syllableCount("goya")); + assert.equal(2, ts.syllableCount("goyim")); + assert.equal(2, ts.syllableCount("graceful")); + assert.equal(3, ts.syllableCount("gracefully")); + assert.equal(2, ts.syllableCount("graceless")); + assert.equal(2, ts.syllableCount("graces")); + assert.equal(2, ts.syllableCount("gracia")); + assert.equal(3, ts.syllableCount("graffeo")); + assert.equal(2, ts.syllableCount("grambling")); + assert.equal(2, ts.syllableCount("granges")); + assert.equal(2, ts.syllableCount("granville")); + assert.equal(2, ts.syllableCount("grappled")); + assert.equal(2, ts.syllableCount("grappling")); + assert.equal(1, ts.syllableCount("grasse")); + assert.equal(2, ts.syllableCount("gravelle")); + assert.equal(2, ts.syllableCount("gravette")); + assert.equal(2, ts.syllableCount("grayish")); + assert.equal(2, ts.syllableCount("grecian")); + assert.equal(3, ts.syllableCount("greenhouses")); + assert.equal(2, ts.syllableCount("greenpeace")); + assert.equal(2, ts.syllableCount("greenville")); + assert.equal(1, ts.syllableCount("grelle")); + assert.equal(3, ts.syllableCount("grenouille")); + assert.equal(3, ts.syllableCount("grievances")); + assert.equal(1, ts.syllableCount("grille")); + assert.equal(2, ts.syllableCount("grimaced")); + assert.equal(3, ts.syllableCount("grimaces")); + assert.equal(1, ts.syllableCount("grimme")); + assert.equal(2, ts.syllableCount("grinage")); + assert.equal(2, ts.syllableCount("grizzled")); + assert.equal(2, ts.syllableCount("groleau")); + assert.equal(1, ts.syllableCount("grosse")); + assert.equal(2, ts.syllableCount("grotesque")); + assert.equal(3, ts.syllableCount("grotesquely")); + assert.equal(1, ts.syllableCount("grothe")); + assert.equal(2, ts.syllableCount("grotheer")); + assert.equal(2, ts.syllableCount("grounded")); + assert.equal(2, ts.syllableCount("groupement")); + assert.equal(2, ts.syllableCount("grouses")); + assert.equal(2, ts.syllableCount("grua")); + assert.equal(2, ts.syllableCount("grudges")); + assert.equal(2, ts.syllableCount("grumbled")); + assert.equal(2, ts.syllableCount("guarded")); + assert.equal(3, ts.syllableCount("guardedly")); + assert.equal(4, ts.syllableCount("guayabera")); + assert.equal(3, ts.syllableCount("guccione")); + assert.equal(2, ts.syllableCount("guerette")); + assert.equal(2, ts.syllableCount("guerrette")); + assert.equal(2, ts.syllableCount("guidice")); + assert.equal(2, ts.syllableCount("guilbeau")); + assert.equal(2, ts.syllableCount("guilbeault")); + assert.equal(2, ts.syllableCount("guilbeaux")); + assert.equal(3, ts.syllableCount("guillemette")); + assert.equal(2, ts.syllableCount("guillette")); + assert.equal(2, ts.syllableCount("guilmette")); + assert.equal(2, ts.syllableCount("guises")); + assert.equal(2, ts.syllableCount("gullette")); + assert.equal(1, ts.syllableCount("guste")); + assert.equal(3, ts.syllableCount("guyana")); + assert.equal(2, ts.syllableCount("guyett")); + assert.equal(2, ts.syllableCount("guyon")); + assert.equal(2, ts.syllableCount("guyot")); + assert.equal(4, ts.syllableCount("gvaryahu")); + assert.equal(1, ts.syllableCount("gwynne")); + assert.equal(3, ts.syllableCount("haberer")); + assert.equal(2, ts.syllableCount("hachette")); + assert.equal(2, ts.syllableCount("haggled")); + assert.equal(3, ts.syllableCount("halcion")); + assert.equal(1, ts.syllableCount("halle")); + assert.equal(1, ts.syllableCount("halve")); + assert.equal(1, ts.syllableCount("halves")); + assert.equal(1, ts.syllableCount("hamme")); + assert.equal(1, ts.syllableCount("hammes")); + assert.equal(2, ts.syllableCount("handed")); + assert.equal(3, ts.syllableCount("handedly")); + assert.equal(2, ts.syllableCount("handled")); + assert.equal(1, ts.syllableCount("hannes")); + assert.equal(2, ts.syllableCount("hansche")); + assert.equal(3, ts.syllableCount("haranguing")); + assert.equal(2, ts.syllableCount("hardage")); + assert.equal(3, ts.syllableCount("harleysville")); + assert.equal(2, ts.syllableCount("harnage")); + assert.equal(1, ts.syllableCount("harne")); + assert.equal(3, ts.syllableCount("harriette")); + assert.equal(2, ts.syllableCount("hartlage")); + assert.equal(2, ts.syllableCount("hartshorne")); + assert.equal(2, ts.syllableCount("harville")); + assert.equal(1, ts.syllableCount("haske")); + assert.equal(1, ts.syllableCount("hasse")); + assert.equal(2, ts.syllableCount("hassled")); + assert.equal(1, ts.syllableCount("haste")); + assert.equal(2, ts.syllableCount("hatches")); + assert.equal(2, ts.syllableCount("hathorne")); + assert.equal(2, ts.syllableCount("hauppauge")); + assert.equal(2, ts.syllableCount("hawthorne")); + assert.equal(3, ts.syllableCount("hayashi")); + assert.equal(4, ts.syllableCount("hayashida")); + assert.equal(2, ts.syllableCount("hayek")); + assert.equal(2, ts.syllableCount("hayen")); + assert.equal(3, ts.syllableCount("hayenga")); + assert.equal(1, ts.syllableCount("hearne")); + assert.equal(4, ts.syllableCount("heavyhanded")); + assert.equal(3, ts.syllableCount("heberer")); + assert.equal(2, ts.syllableCount("heckled")); + assert.equal(2, ts.syllableCount("hedges")); + assert.equal(3, ts.syllableCount("heidbreder")); + assert.equal(2, ts.syllableCount("heiges")); + assert.equal(2, ts.syllableCount("helice")); + assert.equal(1, ts.syllableCount("helle")); + assert.equal(1, ts.syllableCount("hemme")); + assert.equal(5, ts.syllableCount("hemocyanin")); + assert.equal(3, ts.syllableCount("hemorrhage")); + assert.equal(3, ts.syllableCount("hemorrhaged")); + assert.equal(1, ts.syllableCount("henne")); + assert.equal(3, ts.syllableCount("henneberry")); + assert.equal(1, ts.syllableCount("hennes")); + assert.equal(3, ts.syllableCount("henriette")); + assert.equal(2, ts.syllableCount("hentges")); + assert.equal(2, ts.syllableCount("henthorne")); + assert.equal(2, ts.syllableCount("heon")); + assert.equal(3, ts.syllableCount("heralded")); + assert.equal(3, ts.syllableCount("herbaceous")); + assert.equal(2, ts.syllableCount("herded")); + assert.equal(3, ts.syllableCount("heritage")); + assert.equal(3, ts.syllableCount("hermitage")); + assert.equal(1, ts.syllableCount("herne")); + assert.equal(3, ts.syllableCount("herriage")); + assert.equal(3, ts.syllableCount("herrlinger")); + assert.equal(1, ts.syllableCount("hesse")); + assert.equal(2, ts.syllableCount("hessian")); + assert.equal(5, ts.syllableCount("heterogeneous")); + assert.equal(2, ts.syllableCount("hicksville")); + assert.equal(3, ts.syllableCount("hideo")); + assert.equal(1, ts.syllableCount("hille")); + assert.equal(4, ts.syllableCount("himalayan")); + assert.equal(4, ts.syllableCount("himalayas")); + assert.equal(3, ts.syllableCount("hindrances")); + assert.equal(2, ts.syllableCount("hinges")); + assert.equal(4, ts.syllableCount("hirayama")); + assert.equal(4, ts.syllableCount("hiroyuki")); + assert.equal(4, ts.syllableCount("histrionic")); + assert.equal(4, ts.syllableCount("histrionics")); + assert.equal(2, ts.syllableCount("hitches")); + assert.equal(2, ts.syllableCount("hoarded")); + assert.equal(2, ts.syllableCount("hoarseness")); + assert.equal(2, ts.syllableCount("hoaxes")); + assert.equal(2, ts.syllableCount("hobbled")); + assert.equal(2, ts.syllableCount("hodges")); + assert.equal(1, ts.syllableCount("hoelle")); + assert.equal(1, ts.syllableCount("holle")); + assert.equal(2, ts.syllableCount("homage")); + assert.equal(5, ts.syllableCount("homeostasis")); + assert.equal(5, ts.syllableCount("homeostatic")); + assert.equal(1, ts.syllableCount("homme")); + assert.equal(1, ts.syllableCount("hommes")); + assert.equal(2, ts.syllableCount("horace")); + assert.equal(1, ts.syllableCount("horne")); + assert.equal(2, ts.syllableCount("hoses")); + assert.equal(2, ts.syllableCount("hospice")); + assert.equal(3, ts.syllableCount("hospices")); + assert.equal(2, ts.syllableCount("hostage")); + assert.equal(3, ts.syllableCount("hostages")); + assert.equal(2, ts.syllableCount("houdaille")); + assert.equal(2, ts.syllableCount("hounded")); + assert.equal(2, ts.syllableCount("houses")); + assert.equal(3, ts.syllableCount("hovering")); + assert.equal(2, ts.syllableCount("hoyos")); + assert.equal(2, ts.syllableCount("hua")); + assert.equal(2, ts.syllableCount("huddled")); + assert.equal(2, ts.syllableCount("hugely")); + assert.equal(2, ts.syllableCount("hugette")); + assert.equal(2, ts.syllableCount("hughette")); + assert.equal(2, ts.syllableCount("hulette")); + assert.equal(2, ts.syllableCount("humbled")); + assert.equal(2, ts.syllableCount("hundred")); + assert.equal(3, ts.syllableCount("hungering")); + assert.equal(2, ts.syllableCount("huntsville")); + assert.equal(2, ts.syllableCount("hurteau")); + assert.equal(3, ts.syllableCount("hutcheon")); + assert.equal(2, ts.syllableCount("huyett")); + assert.equal(3, ts.syllableCount("hyacinth")); + assert.equal(4, ts.syllableCount("hyacintha")); + assert.equal(5, ts.syllableCount("hyacinthia")); + assert.equal(4, ts.syllableCount("hyacinthie")); + assert.equal(3, ts.syllableCount("hyacinths")); + assert.equal(5, ts.syllableCount("hyaluronic")); + assert.equal(2, ts.syllableCount("hyams")); + assert.equal(3, ts.syllableCount("hyannis")); + assert.equal(2, ts.syllableCount("hyatt")); + assert.equal(3, ts.syllableCount("hyena")); + assert.equal(3, ts.syllableCount("hyenas")); + assert.equal(4, ts.syllableCount("hyperion")); + assert.equal(4, ts.syllableCount("hypotheses")); + assert.equal(3, ts.syllableCount("hyraxes")); + assert.equal(5, ts.syllableCount("ianniello")); + assert.equal(2, ts.syllableCount("ices")); + assert.equal(5, ts.syllableCount("iconoclasm")); + assert.equal(3, ts.syllableCount("idea")); + assert.equal(6, ts.syllableCount("ideological")); + assert.equal(5, ts.syllableCount("ideologies")); + assert.equal(5, ts.syllableCount("ideologists")); + assert.equal(2, ts.syllableCount("idette")); + assert.equal(2, ts.syllableCount("idled")); + assert.equal(4, ts.syllableCount("idolizes")); + assert.equal(1, ts.syllableCount("ierne")); + assert.equal(2, ts.syllableCount("ignace")); + assert.equal(1, ts.syllableCount("illes")); + assert.equal(2, ts.syllableCount("Ilyich")); + assert.equal(2, ts.syllableCount("image")); + assert.equal(3, ts.syllableCount("images")); + assert.equal(4, ts.syllableCount("imbalances")); + assert.equal(3, ts.syllableCount("imbedded")); + assert.equal(5, ts.syllableCount("immortalizes")); + assert.equal(4, ts.syllableCount("immunizes")); + assert.equal(2, ts.syllableCount("impasse")); + assert.equal(2, ts.syllableCount("impeached")); + assert.equal(3, ts.syllableCount("impeding")); + assert.equal(3, ts.syllableCount("imposes")); + assert.equal(3, ts.syllableCount("impounded")); + assert.equal(3, ts.syllableCount("improvement")); + assert.equal(3, ts.syllableCount("improvements")); + assert.equal(2, ts.syllableCount("inbred")); + assert.equal(4, ts.syllableCount("incidences")); + assert.equal(4, ts.syllableCount("inconvenienced")); + assert.equal(5, ts.syllableCount("inconveniences")); + assert.equal(3, ts.syllableCount("increases")); + assert.equal(5, ts.syllableCount("indecisiveness")); + assert.equal(3, ts.syllableCount("indexes")); + assert.equal(3, ts.syllableCount("indices")); + assert.equal(4, ts.syllableCount("indonesian")); + assert.equal(2, ts.syllableCount("induce")); + assert.equal(2, ts.syllableCount("induced")); + assert.equal(3, ts.syllableCount("inducement")); + assert.equal(3, ts.syllableCount("inducements")); + assert.equal(3, ts.syllableCount("induces")); + assert.equal(4, ts.syllableCount("indulgences")); + assert.equal(3, ts.syllableCount("indulges")); + assert.equal(5, ts.syllableCount("ineffectiveness")); + assert.equal(4, ts.syllableCount("inferences")); + assert.equal(3, ts.syllableCount("influence")); + assert.equal(3, ts.syllableCount("influenced")); + assert.equal(4, ts.syllableCount("influences")); + assert.equal(4, ts.syllableCount("influencing")); + assert.equal(4, ts.syllableCount("influential")); + assert.equal(4, ts.syllableCount("influenza")); + assert.equal(3, ts.syllableCount("infrared")); + assert.equal(2, ts.syllableCount("infringed")); + assert.equal(3, ts.syllableCount("infringement")); + assert.equal(3, ts.syllableCount("infringements")); + assert.equal(3, ts.syllableCount("infringes")); + assert.equal(3, ts.syllableCount("infuses")); + assert.equal(3, ts.syllableCount("injustice")); + assert.equal(4, ts.syllableCount("injustices")); + assert.equal(3, ts.syllableCount("innerspace")); + assert.equal(4, ts.syllableCount("innuendo")); + assert.equal(4, ts.syllableCount("innuendoes")); + assert.equal(4, ts.syllableCount("innuendos")); + assert.equal(3, ts.syllableCount("instances")); + assert.equal(7, ts.syllableCount("institutionalizes")); + assert.equal(4, ts.syllableCount("insurances")); + assert.equal(3, ts.syllableCount("intended")); + assert.equal(5, ts.syllableCount("interacciones")); + assert.equal(3, ts.syllableCount("interbred")); + assert.equal(4, ts.syllableCount("interceding")); + assert.equal(4, ts.syllableCount("interchanges")); + assert.equal(3, ts.syllableCount("interface")); + assert.equal(4, ts.syllableCount("interfaces")); + assert.equal(3, ts.syllableCount("interlaced")); + assert.equal(4, ts.syllableCount("intermingled")); + assert.equal(4, ts.syllableCount("interoffice")); + assert.equal(3, ts.syllableCount("intervoice")); + assert.equal(5, ts.syllableCount("intraocular")); + assert.equal(5, ts.syllableCount("intrauterine")); + assert.equal(3, ts.syllableCount("intriguing")); + assert.equal(4, ts.syllableCount("intriguingly")); + assert.equal(3, ts.syllableCount("introduce")); + assert.equal(3, ts.syllableCount("introduced")); + assert.equal(4, ts.syllableCount("introduces")); + assert.equal(2, ts.syllableCount("inveighed")); + assert.equal(4, ts.syllableCount("inventiveness")); + assert.equal(2, ts.syllableCount("invoice")); + assert.equal(3, ts.syllableCount("invoices")); + assert.equal(2, ts.syllableCount("involve")); + assert.equal(3, ts.syllableCount("involvement")); + assert.equal(2, ts.syllableCount("involves")); + assert.equal(3, ts.syllableCount("iodice")); + assert.equal(2, ts.syllableCount("ion")); + assert.equal(3, ts.syllableCount("iona")); + assert.equal(3, ts.syllableCount("ionic")); + assert.equal(3, ts.syllableCount("ionics")); + assert.equal(5, ts.syllableCount("ionization")); + assert.equal(4, ts.syllableCount("ionizers")); + assert.equal(4, ts.syllableCount("ionizing")); + assert.equal(5, ts.syllableCount("ionospheric")); + assert.equal(2, ts.syllableCount("ions")); + assert.equal(2, ts.syllableCount("irette")); + assert.equal(3, ts.syllableCount("irises")); + assert.equal(4, ts.syllableCount("ironizes")); + assert.equal(2, ts.syllableCount("irvette")); + assert.equal(3, ts.syllableCount("isabelle")); + assert.equal(1, ts.syllableCount("isle")); + assert.equal(1, ts.syllableCount("isles")); + assert.equal(5, ts.syllableCount("isocyanate")); + assert.equal(4, ts.syllableCount("Isozaki")); + assert.equal(4, ts.syllableCount("issuances")); + assert.equal(2, ts.syllableCount("itches")); + assert.equal(3, ts.syllableCount("jacksonville")); + assert.equal(2, ts.syllableCount("jandreau")); + assert.equal(2, ts.syllableCount("janelle")); + assert.equal(2, ts.syllableCount("janesville")); + assert.equal(2, ts.syllableCount("janette")); + assert.equal(2, ts.syllableCount("jangled")); + assert.equal(2, ts.syllableCount("janice")); + assert.equal(2, ts.syllableCount("jarreau")); + assert.equal(3, ts.syllableCount("jasmer")); + assert.equal(2, ts.syllableCount("jaundice")); + assert.equal(2, ts.syllableCount("jaundiced")); + assert.equal(2, ts.syllableCount("jaya")); + assert.equal(4, ts.syllableCount("jayashankar")); + assert.equal(3, ts.syllableCount("jeanbaptiste")); + assert.equal(2, ts.syllableCount("jeanette")); + assert.equal(1, ts.syllableCount("jeanne")); + assert.equal(2, ts.syllableCount("jeannette")); + assert.equal(2, ts.syllableCount("jeansonne")); + assert.equal(1, ts.syllableCount("jenne")); + assert.equal(2, ts.syllableCount("jennette")); + assert.equal(2, ts.syllableCount("jenrette")); + assert.equal(1, ts.syllableCount("jeske")); + assert.equal(2, ts.syllableCount("jetborne")); + assert.equal(1, ts.syllableCount("jette")); + assert.equal(4, ts.syllableCount("jeyaretnam")); + assert.equal(3, ts.syllableCount("joffrion")); + assert.equal(2, ts.syllableCount("jolette")); + assert.equal(3, ts.syllableCount("joliet")); + assert.equal(3, ts.syllableCount("jolivette")); + assert.equal(2, ts.syllableCount("jopling")); + assert.equal(2, ts.syllableCount("jorge")); + assert.equal(2, ts.syllableCount("josette")); + assert.equal(3, ts.syllableCount("joshua")); + assert.equal(1, ts.syllableCount("jostes")); + assert.equal(2, ts.syllableCount("jostling")); + assert.equal(2, ts.syllableCount("joyal")); + assert.equal(3, ts.syllableCount("joyoni")); + assert.equal(2, ts.syllableCount("joyous")); + assert.equal(1, ts.syllableCount("juan")); + assert.equal(2, ts.syllableCount("juana")); + assert.equal(3, ts.syllableCount("juanita")); + assert.equal(2, ts.syllableCount("juarez")); + assert.equal(3, ts.syllableCount("judaism")); + assert.equal(3, ts.syllableCount("judea")); + assert.equal(3, ts.syllableCount("judeo")); + assert.equal(2, ts.syllableCount("judgement")); + assert.equal(2, ts.syllableCount("judgements")); + assert.equal(2, ts.syllableCount("judges")); + assert.equal(2, ts.syllableCount("judgeship")); + assert.equal(2, ts.syllableCount("judgeships")); + assert.equal(2, ts.syllableCount("judice")); + assert.equal(2, ts.syllableCount("juggled")); + assert.equal(2, ts.syllableCount("juices")); + assert.equal(2, ts.syllableCount("jukebox")); + assert.equal(3, ts.syllableCount("julia")); + assert.equal(3, ts.syllableCount("julianne")); + assert.equal(3, ts.syllableCount("juliet")); + assert.equal(3, ts.syllableCount("julius")); + assert.equal(2, ts.syllableCount("jumbled")); + assert.equal(3, ts.syllableCount("jumonville")); + assert.equal(2, ts.syllableCount("juneau")); + assert.equal(2, ts.syllableCount("junette")); + assert.equal(3, ts.syllableCount("junior")); + assert.equal(3, ts.syllableCount("juniors")); + assert.equal(2, ts.syllableCount("justice")); + assert.equal(3, ts.syllableCount("justices")); + assert.equal(4, ts.syllableCount("kageyama")); + assert.equal(3, ts.syllableCount("kamerer")); + assert.equal(3, ts.syllableCount("kanghua")); + assert.equal(1, ts.syllableCount("kanne")); + assert.equal(2, ts.syllableCount("karges")); + assert.equal(1, ts.syllableCount("karnes")); + assert.equal(3, ts.syllableCount("kasmer")); + assert.equal(4, ts.syllableCount("katayama")); + assert.equal(2, ts.syllableCount("kaya")); + assert.equal(2, ts.syllableCount("kayak")); + assert.equal(3, ts.syllableCount("kayaking")); + assert.equal(2, ts.syllableCount("kayaks")); + assert.equal(2, ts.syllableCount("kayo")); + assert.equal(3, ts.syllableCount("kemerer")); + assert.equal(2, ts.syllableCount("keo")); + assert.equal(2, ts.syllableCount("keogh")); + assert.equal(3, ts.syllableCount("keohane")); + assert.equal(2, ts.syllableCount("keown")); + assert.equal(2, ts.syllableCount("kerestes")); + assert.equal(1, ts.syllableCount("kernes")); + assert.equal(2, ts.syllableCount("kerrville")); + assert.equal(1, ts.syllableCount("keske")); + assert.equal(2, ts.syllableCount("keville")); + assert.equal(3, ts.syllableCount("keynesian")); + assert.equal(3, ts.syllableCount("kibodeaux")); + assert.equal(2, ts.syllableCount("kidded")); + assert.equal(2, ts.syllableCount("kiessling")); + assert.equal(2, ts.syllableCount("kilborne")); + assert.equal(2, ts.syllableCount("kilbourne")); + assert.equal(1, ts.syllableCount("kille")); + assert.equal(2, ts.syllableCount("kimche")); + assert.equal(2, ts.syllableCount("kindled")); + assert.equal(2, ts.syllableCount("kindred")); + assert.equal(2, ts.syllableCount("kingsville")); + assert.equal(1, ts.syllableCount("kinne")); + assert.equal(2, ts.syllableCount("kissling")); + assert.equal(3, ts.syllableCount("kitchenette")); + assert.equal(3, ts.syllableCount("kiyoshi")); + assert.equal(4, ts.syllableCount("kiyotaka")); + assert.equal(2, ts.syllableCount("klages")); + assert.equal(2, ts.syllableCount("kleinpaste")); + assert.equal(1, ts.syllableCount("klemme")); + assert.equal(2, ts.syllableCount("knicely")); + assert.equal(2, ts.syllableCount("knoxville")); + assert.equal(4, ts.syllableCount("kobayashi")); + assert.equal(2, ts.syllableCount("kocian")); + assert.equal(1, ts.syllableCount("koelle")); + assert.equal(1, ts.syllableCount("kolle")); + assert.equal(5, ts.syllableCount("Komsomolskaya")); + assert.equal(2, ts.syllableCount("korfhage")); + assert.equal(1, ts.syllableCount("kothe")); + assert.equal(3, ts.syllableCount("koyama")); + assert.equal(2, ts.syllableCount("koyo")); + assert.equal(1, ts.syllableCount("kramme")); + assert.equal(1, ts.syllableCount("krammes")); + assert.equal(3, ts.syllableCount("krasnoyarsk")); + assert.equal(1, ts.syllableCount("krausse")); + assert.equal(2, ts.syllableCount("kresge")); + assert.equal(1, ts.syllableCount("kresse")); + assert.equal(1, ts.syllableCount("krumme")); + assert.equal(3, ts.syllableCount("kuenheim")); + assert.equal(3, ts.syllableCount("kuenstler")); + assert.equal(3, ts.syllableCount("kuenzi")); + assert.equal(3, ts.syllableCount("kunayev")); + assert.equal(1, ts.syllableCount("kuske")); + assert.equal(2, ts.syllableCount("labeau")); + assert.equal(2, ts.syllableCount("labelle")); + assert.equal(3, ts.syllableCount("labranche")); + assert.equal(3, ts.syllableCount("lacayo")); + assert.equal(2, ts.syllableCount("laces")); + assert.equal(3, ts.syllableCount("lachapelle")); + assert.equal(2, ts.syllableCount("lacoste")); + assert.equal(2, ts.syllableCount("lacrosse")); + assert.equal(2, ts.syllableCount("ladled")); + assert.equal(3, ts.syllableCount("lafalce")); + assert.equal(2, ts.syllableCount("laflamme")); + assert.equal(3, ts.syllableCount("lafollette")); + assert.equal(2, ts.syllableCount("lafosse")); + assert.equal(2, ts.syllableCount("lagesse")); + assert.equal(3, ts.syllableCount("lajeunesse")); + assert.equal(2, ts.syllableCount("lakeside")); + assert.equal(3, ts.syllableCount("lamarche")); + assert.equal(2, ts.syllableCount("lambaste")); + assert.equal(2, ts.syllableCount("lambastes")); + assert.equal(1, ts.syllableCount("lamme")); + assert.equal(3, ts.syllableCount("lamontagne")); + assert.equal(3, ts.syllableCount("lamoreaux")); + assert.equal(2, ts.syllableCount("lamothe")); + assert.equal(3, ts.syllableCount("lamoureaux")); + assert.equal(4, ts.syllableCount("lanceolate")); + assert.equal(2, ts.syllableCount("lancia")); + assert.equal(2, ts.syllableCount("landed")); + assert.equal(3, ts.syllableCount("landreneau")); + assert.equal(2, ts.syllableCount("langhorne")); + assert.equal(2, ts.syllableCount("language")); + assert.equal(3, ts.syllableCount("languages")); + assert.equal(3, ts.syllableCount("lanouette")); + assert.equal(2, ts.syllableCount("lapage")); + assert.equal(2, ts.syllableCount("larche")); + assert.equal(2, ts.syllableCount("larded")); + assert.equal(2, ts.syllableCount("lareau")); + assert.equal(2, ts.syllableCount("largesse")); + assert.equal(3, ts.syllableCount("lariccia")); + assert.equal(3, ts.syllableCount("larochelle")); + assert.equal(2, ts.syllableCount("lasalle")); + assert.equal(3, ts.syllableCount("lashua")); + assert.equal(1, ts.syllableCount("laske")); + assert.equal(2, ts.syllableCount("lasseigne")); + assert.equal(2, ts.syllableCount("latches")); + assert.equal(3, ts.syllableCount("latendresse")); + assert.equal(2, ts.syllableCount("lateness")); + assert.equal(3, ts.syllableCount("latexes")); + assert.equal(1, ts.syllableCount("lathe")); + assert.equal(1, ts.syllableCount("lathes")); + assert.equal(3, ts.syllableCount("latourette")); + assert.equal(2, ts.syllableCount("lattice")); + assert.equal(2, ts.syllableCount("laurette")); + assert.equal(2, ts.syllableCount("laurice")); + assert.equal(2, ts.syllableCount("lausanne")); + assert.equal(2, ts.syllableCount("lavelle")); + assert.equal(2, ts.syllableCount("laverne")); + assert.equal(2, ts.syllableCount("lavette")); + assert.equal(2, ts.syllableCount("lavigne")); + assert.equal(4, ts.syllableCount("laviolette")); + assert.equal(2, ts.syllableCount("lawhorne")); + assert.equal(3, ts.syllableCount("lawrenceville")); + assert.equal(2, ts.syllableCount("layborne")); + assert.equal(2, ts.syllableCount("layered")); + assert.equal(3, ts.syllableCount("layering")); + assert.equal(2, ts.syllableCount("layoff")); + assert.equal(2, ts.syllableCount("layoffs")); + assert.equal(2, ts.syllableCount("layout")); + assert.equal(2, ts.syllableCount("layouts")); + assert.equal(3, ts.syllableCount("layover")); + assert.equal(3, ts.syllableCount("layovers")); + assert.equal(2, ts.syllableCount("leadville")); + assert.equal(2, ts.syllableCount("leakage")); + assert.equal(2, ts.syllableCount("leases")); + assert.equal(2, ts.syllableCount("leatrice")); + assert.equal(2, ts.syllableCount("leavelle")); + assert.equal(2, ts.syllableCount("lebeau")); + assert.equal(2, ts.syllableCount("ledges")); + assert.equal(2, ts.syllableCount("ledonne")); + assert.equal(2, ts.syllableCount("legette")); + assert.equal(2, ts.syllableCount("legged")); + assert.equal(2, ts.syllableCount("leggette")); + assert.equal(5, ts.syllableCount("legitimizes")); + assert.equal(2, ts.syllableCount("leifeste")); + assert.equal(2, ts.syllableCount("lemelle")); + assert.equal(2, ts.syllableCount("leo")); + assert.equal(3, ts.syllableCount("leoma")); + assert.equal(4, ts.syllableCount("leominster")); + assert.equal(2, ts.syllableCount("leon")); + assert.equal(3, ts.syllableCount("leona")); + assert.equal(4, ts.syllableCount("leonardo")); + assert.equal(2, ts.syllableCount("leone")); + assert.equal(3, ts.syllableCount("leonel")); + assert.equal(3, ts.syllableCount("leonerd")); + assert.equal(2, ts.syllableCount("leones")); + assert.equal(3, ts.syllableCount("leonhard")); + assert.equal(3, ts.syllableCount("leoni")); + assert.equal(3, ts.syllableCount("leonid")); + assert.equal(4, ts.syllableCount("leonora")); + assert.equal(3, ts.syllableCount("leonore")); + assert.equal(3, ts.syllableCount("leontine")); + assert.equal(3, ts.syllableCount("leopold")); + assert.equal(4, ts.syllableCount("leopoldine")); + assert.equal(4, ts.syllableCount("leopoldo")); + assert.equal(2, ts.syllableCount("leos")); + assert.equal(3, ts.syllableCount("leotard")); + assert.equal(2, ts.syllableCount("lepage")); + assert.equal(2, ts.syllableCount("lerette")); + assert.equal(2, ts.syllableCount("lesage")); + assert.equal(1, ts.syllableCount("leske")); + assert.equal(3, ts.syllableCount("lespinasse")); + assert.equal(3, ts.syllableCount("leticia")); + assert.equal(3, ts.syllableCount("letourneau")); + assert.equal(2, ts.syllableCount("lettice")); + assert.equal(2, ts.syllableCount("lettuce")); + assert.equal(2, ts.syllableCount("leveille")); + assert.equal(3, ts.syllableCount("leverage")); + assert.equal(3, ts.syllableCount("leveraged")); + assert.equal(3, ts.syllableCount("leverette")); + assert.equal(3, ts.syllableCount("levering")); + assert.equal(2, ts.syllableCount("levesque")); + assert.equal(2, ts.syllableCount("leya")); + assert.equal(2, ts.syllableCount("lianne")); + assert.equal(3, ts.syllableCount("liberace")); + assert.equal(3, ts.syllableCount("libya")); + assert.equal(3, ts.syllableCount("libyan")); + assert.equal(3, ts.syllableCount("libyans")); + assert.equal(3, ts.syllableCount("licences")); + assert.equal(3, ts.syllableCount("licorice")); + assert.equal(3, ts.syllableCount("lighthouses")); + assert.equal(2, ts.syllableCount("likeness")); + assert.equal(3, ts.syllableCount("likenesses")); + assert.equal(1, ts.syllableCount("lille")); + assert.equal(3, ts.syllableCount("lilyan")); + assert.equal(3, ts.syllableCount("limoges")); + assert.equal(2, ts.syllableCount("linage")); + assert.equal(3, ts.syllableCount("lineberry")); + assert.equal(2, ts.syllableCount("linette")); + assert.equal(3, ts.syllableCount("lingering")); + assert.equal(2, ts.syllableCount("linkage")); + assert.equal(3, ts.syllableCount("linkages")); + assert.equal(1, ts.syllableCount("linne")); + assert.equal(2, ts.syllableCount("linville")); + assert.equal(2, ts.syllableCount("lion")); + assert.equal(4, ts.syllableCount("lionberger")); + assert.equal(3, ts.syllableCount("lionel")); + assert.equal(4, ts.syllableCount("lionetti")); + assert.equal(3, ts.syllableCount("lionheart")); + assert.equal(3, ts.syllableCount("lionized")); + assert.equal(2, ts.syllableCount("lions")); + assert.equal(2, ts.syllableCount("lirette")); + assert.equal(2, ts.syllableCount("lisette")); + assert.equal(1, ts.syllableCount("liske")); + assert.equal(6, ts.syllableCount("literaturnaya")); + assert.equal(1, ts.syllableCount("lithe")); + assert.equal(3, ts.syllableCount("littlepage")); + assert.equal(1, ts.syllableCount("loathe")); + assert.equal(1, ts.syllableCount("loathed")); + assert.equal(2, ts.syllableCount("lodges")); + assert.equal(2, ts.syllableCount("loewe")); + assert.equal(4, ts.syllableCount("logarithm")); + assert.equal(2, ts.syllableCount("loges")); + assert.equal(3, ts.syllableCount("logician")); + assert.equal(3, ts.syllableCount("loguidice")); + assert.equal(2, ts.syllableCount("loiselle")); + assert.equal(2, ts.syllableCount("lonesome")); + assert.equal(2, ts.syllableCount("looses")); + assert.equal(2, ts.syllableCount("lorette")); + assert.equal(1, ts.syllableCount("lorne")); + assert.equal(2, ts.syllableCount("loses")); + assert.equal(3, ts.syllableCount("losoya")); + assert.equal(3, ts.syllableCount("louisville")); + assert.equal(2, ts.syllableCount("lounges")); + assert.equal(2, ts.syllableCount("lovage")); + assert.equal(3, ts.syllableCount("lovering")); + assert.equal(2, ts.syllableCount("lovette")); + assert.equal(3, ts.syllableCount("lowering")); + assert.equal(2, ts.syllableCount("loya")); + assert.equal(2, ts.syllableCount("loyal")); + assert.equal(3, ts.syllableCount("loyalist")); + assert.equal(3, ts.syllableCount("loyalists")); + assert.equal(2, ts.syllableCount("loyall")); + assert.equal(3, ts.syllableCount("loyally")); + assert.equal(3, ts.syllableCount("loyalties")); + assert.equal(3, ts.syllableCount("loyalty")); + assert.equal(3, ts.syllableCount("loyola")); + assert.equal(2, ts.syllableCount("lozeau")); + assert.equal(3, ts.syllableCount("lozenges")); + assert.equal(3, ts.syllableCount("lozoya")); + assert.equal(2, ts.syllableCount("lua")); + assert.equal(2, ts.syllableCount("lucerne")); + assert.equal(2, ts.syllableCount("lucette")); + assert.equal(2, ts.syllableCount("lucia")); + assert.equal(2, ts.syllableCount("lucian")); + assert.equal(2, ts.syllableCount("lucille")); + assert.equal(3, ts.syllableCount("lucrecia")); + assert.equal(1, ts.syllableCount("luelle")); + assert.equal(2, ts.syllableCount("luggage")); + assert.equal(2, ts.syllableCount("lunges")); + assert.equal(2, ts.syllableCount("lurches")); + assert.equal(2, ts.syllableCount("lurette")); + assert.equal(2, ts.syllableCount("lyall")); + assert.equal(2, ts.syllableCount("lyell")); + assert.equal(3, ts.syllableCount("lyerla")); + assert.equal(2, ts.syllableCount("lynette")); + assert.equal(1, ts.syllableCount("lynne")); + assert.equal(2, ts.syllableCount("mabelle")); + assert.equal(4, ts.syllableCount("macfadyen")); + assert.equal(3, ts.syllableCount("macioce")); + assert.equal(6, ts.syllableCount("macroeconomic")); + assert.equal(6, ts.syllableCount("macroeconomics")); + assert.equal(3, ts.syllableCount("macrophage")); + assert.equal(4, ts.syllableCount("macrophages")); + assert.equal(2, ts.syllableCount("madelle")); + assert.equal(4, ts.syllableCount("mademoiselle")); + assert.equal(3, ts.syllableCount("maffeo")); + assert.equal(2, ts.syllableCount("mages")); + assert.equal(3, ts.syllableCount("magician")); + assert.equal(3, ts.syllableCount("magicians")); + assert.equal(4, ts.syllableCount("mahayana")); + assert.equal(2, ts.syllableCount("mahe")); + assert.equal(3, ts.syllableCount("mailboxes")); + assert.equal(1, ts.syllableCount("maille")); + assert.equal(2, ts.syllableCount("mainville")); + assert.equal(3, ts.syllableCount("maione")); + assert.equal(2, ts.syllableCount("majette")); + assert.equal(4, ts.syllableCount("makeover")); + assert.equal(3, ts.syllableCount("makepeace")); + assert.equal(3, ts.syllableCount("malayan")); + assert.equal(3, ts.syllableCount("malaysian")); + assert.equal(3, ts.syllableCount("malaysians")); + assert.equal(2, ts.syllableCount("maleness")); + assert.equal(2, ts.syllableCount("malice")); + assert.equal(1, ts.syllableCount("malle")); + assert.equal(2, ts.syllableCount("mallette")); + assert.equal(3, ts.syllableCount("malpractice")); + assert.equal(2, ts.syllableCount("malveaux")); + assert.equal(2, ts.syllableCount("manage")); + assert.equal(2, ts.syllableCount("managed")); + assert.equal(3, ts.syllableCount("management")); + assert.equal(3, ts.syllableCount("managements")); + assert.equal(3, ts.syllableCount("manages")); + assert.equal(3, ts.syllableCount("mandeville")); + assert.equal(2, ts.syllableCount("manette")); + assert.equal(4, ts.syllableCount("maneuvering")); + assert.equal(4, ts.syllableCount("maneuverings")); + assert.equal(5, ts.syllableCount("manganiello")); + assert.equal(2, ts.syllableCount("mangement")); + assert.equal(2, ts.syllableCount("manges")); + assert.equal(3, ts.syllableCount("mangione")); + assert.equal(2, ts.syllableCount("mangled")); + assert.equal(3, ts.syllableCount("manhandled")); + assert.equal(1, ts.syllableCount("manne")); + assert.equal(1, ts.syllableCount("mannes")); + assert.equal(2, ts.syllableCount("manseau")); + assert.equal(3, ts.syllableCount("mantua")); + assert.equal(4, ts.syllableCount("manuevering")); + assert.equal(2, ts.syllableCount("manville")); + assert.equal(3, ts.syllableCount("marantette")); + assert.equal(3, ts.syllableCount("maranville")); + assert.equal(2, ts.syllableCount("marbled")); + assert.equal(2, ts.syllableCount("marceau")); + assert.equal(2, ts.syllableCount("marceaux")); + assert.equal(2, ts.syllableCount("marcelle")); + assert.equal(2, ts.syllableCount("marches")); + assert.equal(2, ts.syllableCount("marcia")); + assert.equal(2, ts.syllableCount("marcille")); + assert.equal(3, ts.syllableCount("marcoses")); + assert.equal(2, ts.syllableCount("marette")); + assert.equal(2, ts.syllableCount("margette")); + assert.equal(5, ts.syllableCount("marginalizes")); + assert.equal(3, ts.syllableCount("marianne")); + assert.equal(2, ts.syllableCount("marice")); + assert.equal(3, ts.syllableCount("mariette")); + assert.equal(3, ts.syllableCount("marineau")); + assert.equal(3, ts.syllableCount("marketplace")); + assert.equal(4, ts.syllableCount("marketplaces")); + assert.equal(2, ts.syllableCount("marlette")); + assert.equal(3, ts.syllableCount("marmion")); + assert.equal(2, ts.syllableCount("marseille")); + assert.equal(2, ts.syllableCount("martelle")); + assert.equal(3, ts.syllableCount("martineau")); + assert.equal(4, ts.syllableCount("maruyama")); + assert.equal(3, ts.syllableCount("maruyu")); + assert.equal(2, ts.syllableCount("marvelle")); + assert.equal(3, ts.syllableCount("maryann")); + assert.equal(3, ts.syllableCount("marysville")); + assert.equal(3, ts.syllableCount("maryville")); + assert.equal(2, ts.syllableCount("marzette")); + assert.equal(3, ts.syllableCount("masaya")); + assert.equal(4, ts.syllableCount("masayoshi")); + assert.equal(4, ts.syllableCount("masayuki")); + assert.equal(2, ts.syllableCount("mascia")); + assert.equal(4, ts.syllableCount("masiello")); + assert.equal(1, ts.syllableCount("maske")); + assert.equal(3, ts.syllableCount("massacred")); + assert.equal(2, ts.syllableCount("massage")); + assert.equal(2, ts.syllableCount("massaged")); + assert.equal(3, ts.syllableCount("massages")); + assert.equal(1, ts.syllableCount("masse")); + assert.equal(4, ts.syllableCount("masterminded")); + assert.equal(3, ts.syllableCount("masterpiece")); + assert.equal(4, ts.syllableCount("masterpieces")); + assert.equal(3, ts.syllableCount("mataya")); + assert.equal(2, ts.syllableCount("matches")); + assert.equal(3, ts.syllableCount("mateo")); + assert.equal(6, ts.syllableCount("materializes")); + assert.equal(1, ts.syllableCount("mathe")); + assert.equal(5, ts.syllableCount("mathematician")); + assert.equal(5, ts.syllableCount("mathematicians")); + assert.equal(2, ts.syllableCount("matherne")); + assert.equal(2, ts.syllableCount("matisse")); + assert.equal(3, ts.syllableCount("matteo")); + assert.equal(2, ts.syllableCount("mattice")); + assert.equal(2, ts.syllableCount("maurice")); + assert.equal(4, ts.syllableCount("mauriello")); + assert.equal(1, ts.syllableCount("mauthe")); + assert.equal(4, ts.syllableCount("maximizes")); + assert.equal(2, ts.syllableCount("maya")); + assert.equal(2, ts.syllableCount("mayall")); + assert.equal(2, ts.syllableCount("mayan")); + assert.equal(2, ts.syllableCount("maybelle")); + assert.equal(3, ts.syllableCount("mayeda")); + assert.equal(3, ts.syllableCount("mayernik")); + assert.equal(3, ts.syllableCount("mayerson")); + assert.equal(2, ts.syllableCount("mayeux")); + assert.equal(2, ts.syllableCount("mayo")); + assert.equal(2, ts.syllableCount("mayon")); + assert.equal(3, ts.syllableCount("mayonnaise")); + assert.equal(2, ts.syllableCount("mayor")); + assert.equal(3, ts.syllableCount("mayoral")); + assert.equal(4, ts.syllableCount("mayoralty")); + assert.equal(3, ts.syllableCount("mayorga")); + assert.equal(2, ts.syllableCount("mayors")); + assert.equal(2, ts.syllableCount("mayville")); + assert.equal(2, ts.syllableCount("mazes")); + assert.equal(3, ts.syllableCount("mazzeo")); + assert.equal(3, ts.syllableCount("mcbryar")); + assert.equal(3, ts.syllableCount("mccarville")); + assert.equal(3, ts.syllableCount("mcconville")); + assert.equal(4, ts.syllableCount("mcfadyen")); + assert.equal(2, ts.syllableCount("mcginnes")); + assert.equal(3, ts.syllableCount("mckeon")); + assert.equal(3, ts.syllableCount("mckeone")); + assert.equal(3, ts.syllableCount("mckeown")); + assert.equal(2, ts.syllableCount("mcneece")); + assert.equal(2, ts.syllableCount("mcneice")); + assert.equal(2, ts.syllableCount("mcquaid")); + assert.equal(2, ts.syllableCount("mcquaide")); + assert.equal(2, ts.syllableCount("mcquaig")); + assert.equal(2, ts.syllableCount("mcquain")); + assert.equal(3, ts.syllableCount("measurement")); + assert.equal(3, ts.syllableCount("measurements")); + assert.equal(1, ts.syllableCount("meaux")); + assert.equal(3, ts.syllableCount("medea")); + assert.equal(4, ts.syllableCount("megahouses")); + assert.equal(4, ts.syllableCount("mehitabelle")); + assert.equal(2, ts.syllableCount("meiyuh")); + assert.equal(4, ts.syllableCount("melanesian")); + assert.equal(2, ts.syllableCount("melbourne")); + assert.equal(2, ts.syllableCount("melded")); + assert.equal(2, ts.syllableCount("melisse")); + assert.equal(1, ts.syllableCount("melle")); + assert.equal(2, ts.syllableCount("melville")); + assert.equal(2, ts.syllableCount("menace")); + assert.equal(2, ts.syllableCount("menaced")); + assert.equal(3, ts.syllableCount("menaces")); + assert.equal(2, ts.syllableCount("mended")); + assert.equal(3, ts.syllableCount("meneses")); + assert.equal(3, ts.syllableCount("menezes")); + assert.equal(2, ts.syllableCount("menges")); + assert.equal(1, ts.syllableCount("menne")); + assert.equal(2, ts.syllableCount("meo")); + assert.equal(3, ts.syllableCount("meola")); + assert.equal(2, ts.syllableCount("meow")); + assert.equal(4, ts.syllableCount("mercedeses")); + assert.equal(2, ts.syllableCount("merdyce")); + assert.equal(2, ts.syllableCount("merges")); + assert.equal(2, ts.syllableCount("merhige")); + assert.equal(3, ts.syllableCount("mersereau")); + assert.equal(2, ts.syllableCount("mertice")); + assert.equal(1, ts.syllableCount("meske")); + assert.equal(2, ts.syllableCount("message")); + assert.equal(3, ts.syllableCount("messages")); + assert.equal(3, ts.syllableCount("messiaen")); + assert.equal(4, ts.syllableCount("messineo")); + assert.equal(3, ts.syllableCount("meteor")); + assert.equal(4, ts.syllableCount("meteoric")); + assert.equal(7, ts.syllableCount("meteorological")); + assert.equal(6, ts.syllableCount("meteorologist")); + assert.equal(6, ts.syllableCount("meteorologists")); + assert.equal(6, ts.syllableCount("meteorology")); + assert.equal(1, ts.syllableCount("mette")); + assert.equal(3, ts.syllableCount("meyerhoff")); + assert.equal(3, ts.syllableCount("meyering")); + assert.equal(3, ts.syllableCount("meyerman")); + assert.equal(4, ts.syllableCount("meyerowitz")); + assert.equal(3, ts.syllableCount("meyerson")); + assert.equal(2, ts.syllableCount("meyo")); + assert.equal(3, ts.syllableCount("meyohas")); + assert.equal(2, ts.syllableCount("micheaux")); + assert.equal(2, ts.syllableCount("michelle")); + assert.equal(3, ts.syllableCount("microage")); + assert.equal(6, ts.syllableCount("microamerica")); + assert.equal(6, ts.syllableCount("microeconomic")); + assert.equal(6, ts.syllableCount("microeconomics")); + assert.equal(6, ts.syllableCount("microelectronic")); + assert.equal(6, ts.syllableCount("microelectronics")); + assert.equal(7, ts.syllableCount("microelettronica")); + assert.equal(4, ts.syllableCount("micromanage")); + assert.equal(5, ts.syllableCount("micromanagement")); + assert.equal(6, ts.syllableCount("microorganism")); + assert.equal(8, ts.syllableCount("micropaleontology")); + assert.equal(2, ts.syllableCount("midges")); + assert.equal(2, ts.syllableCount("midgette")); + assert.equal(2, ts.syllableCount("midpriced")); + assert.equal(1, ts.syllableCount("miesse")); + assert.equal(2, ts.syllableCount("migneault")); + assert.equal(2, ts.syllableCount("milbourne")); + assert.equal(2, ts.syllableCount("mildred")); + assert.equal(2, ts.syllableCount("mileage")); + assert.equal(2, ts.syllableCount("millage")); + assert.equal(1, ts.syllableCount("mille")); + assert.equal(2, ts.syllableCount("millette")); + assert.equal(3, ts.syllableCount("milliet")); + assert.equal(4, ts.syllableCount("mimeograph")); + assert.equal(3, ts.syllableCount("minasian")); + assert.equal(3, ts.syllableCount("minassian")); + assert.equal(2, ts.syllableCount("minded")); + assert.equal(3, ts.syllableCount("mindedly")); + assert.equal(2, ts.syllableCount("mineau")); + assert.equal(3, ts.syllableCount("mineo")); + assert.equal(4, ts.syllableCount("mineola")); + assert.equal(2, ts.syllableCount("minette")); + assert.equal(2, ts.syllableCount("minges")); + assert.equal(2, ts.syllableCount("mingled")); + assert.equal(4, ts.syllableCount("minibuses")); + assert.equal(5, ts.syllableCount("minichiello")); + assert.equal(4, ts.syllableCount("minimizes")); + assert.equal(2, ts.syllableCount("mintage")); + assert.equal(3, ts.syllableCount("minuses")); + assert.equal(2, ts.syllableCount("mion")); + assert.equal(2, ts.syllableCount("mione")); + assert.equal(3, ts.syllableCount("mirabelle")); + assert.equal(2, ts.syllableCount("mirage")); + assert.equal(2, ts.syllableCount("mirelle")); + assert.equal(4, ts.syllableCount("miscayuna")); + assert.equal(3, ts.syllableCount("mischarges")); + assert.equal(2, ts.syllableCount("mises")); + assert.equal(3, ts.syllableCount("mishandled")); + assert.equal(2, ts.syllableCount("misjudged")); + assert.equal(1, ts.syllableCount("miske")); + assert.equal(3, ts.syllableCount("mismanaged")); + assert.equal(4, ts.syllableCount("mismanagement")); + assert.equal(3, ts.syllableCount("mismatches")); + assert.equal(2, ts.syllableCount("misplace")); + assert.equal(2, ts.syllableCount("misplaced")); + assert.equal(2, ts.syllableCount("mispriced")); + assert.equal(3, ts.syllableCount("misstatement")); + assert.equal(3, ts.syllableCount("misstatements")); + assert.equal(3, ts.syllableCount("misuses")); + assert.equal(2, ts.syllableCount("mixes")); + assert.equal(4, ts.syllableCount("miyagawa")); + assert.equal(4, ts.syllableCount("miyahara")); + assert.equal(3, ts.syllableCount("miyako")); + assert.equal(4, ts.syllableCount("miyamori")); + assert.equal(4, ts.syllableCount("miyamoto")); + assert.equal(4, ts.syllableCount("miyasaki")); + assert.equal(4, ts.syllableCount("miyasato")); + assert.equal(4, ts.syllableCount("miyashiro")); + assert.equal(4, ts.syllableCount("miyazaki")); + assert.equal(4, ts.syllableCount("miyazawa")); + assert.equal(2, ts.syllableCount("mizelle")); + assert.equal(2, ts.syllableCount("moccia")); + assert.equal(3, ts.syllableCount("modisette")); + assert.equal(2, ts.syllableCount("moises")); + assert.equal(2, ts.syllableCount("molded")); + assert.equal(3, ts.syllableCount("molineaux")); + assert.equal(1, ts.syllableCount("molle")); + assert.equal(3, ts.syllableCount("molyneaux")); + assert.equal(3, ts.syllableCount("momayez")); + assert.equal(3, ts.syllableCount("moncayo")); + assert.equal(2, ts.syllableCount("monceaux")); + assert.equal(3, ts.syllableCount("mondeo")); + assert.equal(2, ts.syllableCount("monette")); + assert.equal(2, ts.syllableCount("mongeau")); + assert.equal(3, ts.syllableCount("mongering")); + assert.equal(3, ts.syllableCount("mongooses")); + assert.equal(5, ts.syllableCount("monopolizes")); + assert.equal(3, ts.syllableCount("monroeville")); + assert.equal(2, ts.syllableCount("montage")); + assert.equal(2, ts.syllableCount("montagne")); + assert.equal(4, ts.syllableCount("montemayor")); + assert.equal(5, ts.syllableCount("montesdeoca")); + assert.equal(5, ts.syllableCount("montevideo")); + assert.equal(3, ts.syllableCount("montoya")); + assert.equal(3, ts.syllableCount("montreal")); + assert.equal(2, ts.syllableCount("montville")); + assert.equal(2, ts.syllableCount("moragne")); + assert.equal(2, ts.syllableCount("moreau")); + assert.equal(2, ts.syllableCount("morice")); + assert.equal(3, ts.syllableCount("morisette")); + assert.equal(3, ts.syllableCount("morissette")); + assert.equal(3, ts.syllableCount("moriya")); + assert.equal(2, ts.syllableCount("morneau")); + assert.equal(2, ts.syllableCount("morneault")); + assert.equal(3, ts.syllableCount("morreale")); + assert.equal(3, ts.syllableCount("morrisette")); + assert.equal(3, ts.syllableCount("morrissette")); + assert.equal(3, ts.syllableCount("morrisville")); + assert.equal(2, ts.syllableCount("mortage")); + assert.equal(3, ts.syllableCount("mortages")); + assert.equal(2, ts.syllableCount("mortgage")); + assert.equal(2, ts.syllableCount("mortgaged")); + assert.equal(3, ts.syllableCount("mortgages")); + assert.equal(3, ts.syllableCount("mortician")); + assert.equal(2, ts.syllableCount("moselle")); + assert.equal(2, ts.syllableCount("moses")); + assert.equal(1, ts.syllableCount("mosque")); + assert.equal(1, ts.syllableCount("mosques")); + assert.equal(1, ts.syllableCount("mousse")); + assert.equal(2, ts.syllableCount("mousseau")); + assert.equal(1, ts.syllableCount("mouthed")); + assert.equal(2, ts.syllableCount("mouthpiece")); + assert.equal(3, ts.syllableCount("mouthpieces")); + assert.equal(2, ts.syllableCount("movement")); + assert.equal(2, ts.syllableCount("movements")); + assert.equal(2, ts.syllableCount("moya")); + assert.equal(2, ts.syllableCount("mozelle")); + assert.equal(3, ts.syllableCount("Muammar")); + assert.equal(2, ts.syllableCount("muddled")); + assert.equal(2, ts.syllableCount("muffled")); + assert.equal(3, ts.syllableCount("mughniyeh")); + assert.equal(3, ts.syllableCount("mugniyah")); + assert.equal(3, ts.syllableCount("mullineaux")); + assert.equal(4, ts.syllableCount("multilayered")); + assert.equal(3, ts.syllableCount("multivalve")); + assert.equal(3, ts.syllableCount("multiyear")); + assert.equal(2, ts.syllableCount("mumbled")); + assert.equal(1, ts.syllableCount("mumme")); + assert.equal(4, ts.syllableCount("murayama")); + assert.equal(2, ts.syllableCount("muscled")); + assert.equal(2, ts.syllableCount("muses")); + assert.equal(3, ts.syllableCount("musician")); + assert.equal(3, ts.syllableCount("musicians")); + assert.equal(1, ts.syllableCount("muske")); + assert.equal(2, ts.syllableCount("mustached")); + assert.equal(2, ts.syllableCount("muzzled")); + assert.equal(2, ts.syllableCount("myatt")); + assert.equal(3, ts.syllableCount("myelin")); + assert.equal(3, ts.syllableCount("myreon")); + assert.equal(2, ts.syllableCount("myrtice")); + assert.equal(2, ts.syllableCount("nadeau")); + assert.equal(3, ts.syllableCount("nagoya")); + assert.equal(1, ts.syllableCount("nairne")); + assert.equal(4, ts.syllableCount("nakayama")); + assert.equal(2, ts.syllableCount("nanette")); + assert.equal(3, ts.syllableCount("naperville")); + assert.equal(4, ts.syllableCount("napoleon")); + assert.equal(5, ts.syllableCount("napoleonic")); + assert.equal(3, ts.syllableCount("narayan")); + assert.equal(4, ts.syllableCount("narayanan")); + assert.equal(2, ts.syllableCount("narcisse")); + assert.equal(4, ts.syllableCount("nardiello")); + assert.equal(3, ts.syllableCount("nashua")); + assert.equal(2, ts.syllableCount("nashville")); + assert.equal(1, ts.syllableCount("nathe")); + assert.equal(3, ts.syllableCount("navarette")); + assert.equal(3, ts.syllableCount("navarrette")); + assert.equal(4, ts.syllableCount("Nazarbayev")); + assert.equal(1, ts.syllableCount("neault")); + assert.equal(3, ts.syllableCount("nechayev")); + assert.equal(2, ts.syllableCount("necklace")); + assert.equal(3, ts.syllableCount("necklaces")); + assert.equal(2, ts.syllableCount("nedeau")); + assert.equal(4, ts.syllableCount("nederlandsche")); + assert.equal(2, ts.syllableCount("needled")); + assert.equal(2, ts.syllableCount("neises")); + assert.equal(1, ts.syllableCount("nelle")); + assert.equal(1, ts.syllableCount("nelles")); + assert.equal(2, ts.syllableCount("nellette")); + assert.equal(2, ts.syllableCount("neo")); + assert.equal(4, ts.syllableCount("neoclassic")); + assert.equal(5, ts.syllableCount("neoclassical")); + assert.equal(6, ts.syllableCount("neoconservative")); + assert.equal(6, ts.syllableCount("neoconservatives")); + assert.equal(3, ts.syllableCount("neola")); + assert.equal(5, ts.syllableCount("neoliberal")); + assert.equal(5, ts.syllableCount("neoliberals")); + assert.equal(3, ts.syllableCount("neoma")); + assert.equal(2, ts.syllableCount("neon")); + assert.equal(4, ts.syllableCount("neonatal")); + assert.equal(2, ts.syllableCount("neons")); + assert.equal(3, ts.syllableCount("neophyte")); + assert.equal(3, ts.syllableCount("neophytes")); + assert.equal(4, ts.syllableCount("neoplasm")); + assert.equal(5, ts.syllableCount("neoplatonic")); + assert.equal(5, ts.syllableCount("neoplatonist")); + assert.equal(3, ts.syllableCount("neoprene")); + assert.equal(3, ts.syllableCount("neoprobe")); + assert.equal(4, ts.syllableCount("neotenic")); + assert.equal(4, ts.syllableCount("neoteny")); + assert.equal(2, ts.syllableCount("nerice")); + assert.equal(1, ts.syllableCount("nerves")); + assert.equal(1, ts.syllableCount("neste")); + assert.equal(3, ts.syllableCount("netterville")); + assert.equal(3, ts.syllableCount("neuroses")); + assert.equal(4, ts.syllableCount("neutralizes")); + assert.equal(2, ts.syllableCount("neuville")); + assert.equal(2, ts.syllableCount("neveau")); + assert.equal(2, ts.syllableCount("neville")); + assert.equal(3, ts.syllableCount("newfangled")); + assert.equal(3, ts.syllableCount("newlywed")); + assert.equal(2, ts.syllableCount("newville")); + assert.equal(2, ts.syllableCount("nguyen")); + assert.equal(2, ts.syllableCount("nibbled")); + assert.equal(2, ts.syllableCount("nicely")); + assert.equal(2, ts.syllableCount("niceness")); + assert.equal(5, ts.syllableCount("nickelodeon")); + assert.equal(3, ts.syllableCount("nicolette")); + assert.equal(2, ts.syllableCount("nicolle")); + assert.equal(3, ts.syllableCount("nicorette")); + assert.equal(2, ts.syllableCount("nieces")); + assert.equal(2, ts.syllableCount("nietzsche")); + assert.equal(2, ts.syllableCount("nightstage")); + assert.equal(2, ts.syllableCount("nilges")); + assert.equal(1, ts.syllableCount("nilles")); + assert.equal(2, ts.syllableCount("ninette")); + assert.equal(4, ts.syllableCount("nishiyama")); + assert.equal(2, ts.syllableCount("nixes")); + assert.equal(2, ts.syllableCount("noa")); + assert.equal(2, ts.syllableCount("noblesse")); + assert.equal(4, ts.syllableCount("nobuyuki")); + assert.equal(2, ts.syllableCount("nodded")); + assert.equal(2, ts.syllableCount("noises")); + assert.equal(2, ts.syllableCount("nolette")); + assert.equal(3, ts.syllableCount("nonbusiness")); + assert.equal(5, ts.syllableCount("noncontroversial")); + assert.equal(2, ts.syllableCount("nonesuch")); + assert.equal(3, ts.syllableCount("nonetheless")); + assert.equal(4, ts.syllableCount("nonmanagement")); + assert.equal(2, ts.syllableCount("norcia")); + assert.equal(2, ts.syllableCount("norville")); + assert.equal(2, ts.syllableCount("noses")); + assert.equal(2, ts.syllableCount("notches")); + assert.equal(2, ts.syllableCount("notice")); + assert.equal(2, ts.syllableCount("noticed")); + assert.equal(3, ts.syllableCount("notices")); + assert.equal(2, ts.syllableCount("nottage")); + assert.equal(2, ts.syllableCount("nouveau")); + assert.equal(2, ts.syllableCount("nouvelle")); + assert.equal(2, ts.syllableCount("novice")); + assert.equal(3, ts.syllableCount("novices")); + assert.equal(3, ts.syllableCount("novoa")); + assert.equal(3, ts.syllableCount("noyola")); + assert.equal(2, ts.syllableCount("nuanced")); + assert.equal(3, ts.syllableCount("nuances")); + assert.equal(4, ts.syllableCount("nucleonics")); + assert.equal(4, ts.syllableCount("nucleotide")); + assert.equal(2, ts.syllableCount("nudges")); + assert.equal(3, ts.syllableCount("nuisances")); + assert.equal(3, ts.syllableCount("nureyev")); + assert.equal(2, ts.syllableCount("nyack")); + assert.equal(3, ts.syllableCount("nyenhuis")); + assert.equal(3, ts.syllableCount("nyerere")); + assert.equal(2, ts.syllableCount("oakville")); + assert.equal(2, ts.syllableCount("obeirne")); + assert.equal(2, ts.syllableCount("oblige")); + assert.equal(2, ts.syllableCount("obliged")); + assert.equal(3, ts.syllableCount("obliges")); + assert.equal(3, ts.syllableCount("obryan")); + assert.equal(3, ts.syllableCount("obryant")); + assert.equal(4, ts.syllableCount("observances")); + assert.equal(2, ts.syllableCount("observes")); + assert.equal(4, ts.syllableCount("obstetrician")); + assert.equal(4, ts.syllableCount("obstetricians")); + assert.equal(2, ts.syllableCount("obyrne")); + assert.equal(3, ts.syllableCount("occhoa")); + assert.equal(4, ts.syllableCount("occurrences")); + assert.equal(3, ts.syllableCount("ochoa")); + assert.equal(3, ts.syllableCount("odea")); + assert.equal(3, ts.syllableCount("odelette")); + assert.equal(3, ts.syllableCount("odeon")); + assert.equal(2, ts.syllableCount("odette")); + assert.equal(5, ts.syllableCount("oesterreichische")); + assert.equal(3, ts.syllableCount("offended")); + assert.equal(2, ts.syllableCount("office")); + assert.equal(3, ts.syllableCount("offices")); + assert.equal(2, ts.syllableCount("offstage")); + assert.equal(2, ts.syllableCount("ogled")); + assert.equal(4, ts.syllableCount("ohanesian")); + assert.equal(3, ts.syllableCount("OHara")); + assert.equal(4, ts.syllableCount("ohbayashi")); + assert.equal(3, ts.syllableCount("olayan")); + assert.equal(3, ts.syllableCount("oleo")); + assert.equal(3, ts.syllableCount("olivette")); + assert.equal(4, ts.syllableCount("omnibuses")); + assert.equal(2, ts.syllableCount("oneness")); + assert.equal(3, ts.syllableCount("oneok")); + assert.equal(2, ts.syllableCount("onstage")); + assert.equal(2, ts.syllableCount("oozes")); + assert.equal(3, ts.syllableCount("opposes")); + assert.equal(3, ts.syllableCount("opticians")); + assert.equal(3, ts.syllableCount("orabelle")); + assert.equal(3, ts.syllableCount("oranges")); + assert.equal(4, ts.syllableCount("ordinances")); + assert.equal(3, ts.syllableCount("oreffice")); + assert.equal(3, ts.syllableCount("orefice")); + assert.equal(3, ts.syllableCount("oreo")); + assert.equal(3, ts.syllableCount("organelles")); + assert.equal(4, ts.syllableCount("organizes")); + assert.equal(3, ts.syllableCount("orgasm")); + assert.equal(4, ts.syllableCount("orifices")); + assert.equal(1, ts.syllableCount("orne")); + assert.equal(3, ts.syllableCount("orphanage")); + assert.equal(4, ts.syllableCount("orphanages")); + assert.equal(2, ts.syllableCount("orville")); + assert.equal(2, ts.syllableCount("osage")); + assert.equal(3, ts.syllableCount("osages")); + assert.equal(2, ts.syllableCount("osborne")); + assert.equal(2, ts.syllableCount("osbourne")); + assert.equal(4, ts.syllableCount("osceola")); + assert.equal(5, ts.syllableCount("osteopathic")); + assert.equal(6, ts.syllableCount("osteoporosis")); + assert.equal(5, ts.syllableCount("osterreichische")); + assert.equal(3, ts.syllableCount("ouelette")); + assert.equal(3, ts.syllableCount("ouellette")); + assert.equal(2, ts.syllableCount("ounces")); + assert.equal(2, ts.syllableCount("outage")); + assert.equal(3, ts.syllableCount("outages")); + assert.equal(3, ts.syllableCount("outhouses")); + assert.equal(2, ts.syllableCount("outpace")); + assert.equal(2, ts.syllableCount("outpaced")); + assert.equal(3, ts.syllableCount("outpaces")); + assert.equal(3, ts.syllableCount("outplacement")); + assert.equal(2, ts.syllableCount("outrage")); + assert.equal(2, ts.syllableCount("outraged")); + assert.equal(3, ts.syllableCount("outrageous")); + assert.equal(4, ts.syllableCount("outrageously")); + assert.equal(3, ts.syllableCount("outrages")); + assert.equal(2, ts.syllableCount("outweighed")); + assert.equal(2, ts.syllableCount("ovalle")); + assert.equal(4, ts.syllableCount("overcharges")); + assert.equal(4, ts.syllableCount("overcrowded")); + assert.equal(4, ts.syllableCount("overdoses")); + assert.equal(5, ts.syllableCount("overextended")); + assert.equal(4, ts.syllableCount("overfunded")); + assert.equal(3, ts.syllableCount("overpriced")); + assert.equal(4, ts.syllableCount("overproduce")); + assert.equal(4, ts.syllableCount("overproduced")); + assert.equal(3, ts.syllableCount("overreached")); + assert.equal(4, ts.syllableCount("overseer")); + assert.equal(4, ts.syllableCount("overseers")); + assert.equal(4, ts.syllableCount("oversizes")); + assert.equal(4, ts.syllableCount("overstatement")); + assert.equal(4, ts.syllableCount("overstatements")); + assert.equal(3, ts.syllableCount("oyama")); + assert.equal(2, ts.syllableCount("oyen")); + assert.equal(3, ts.syllableCount("oyola")); + assert.equal(2, ts.syllableCount("ozanne")); + assert.equal(2, ts.syllableCount("ozelle")); + assert.equal(3, ts.syllableCount("paccione")); + assert.equal(2, ts.syllableCount("paces")); + assert.equal(2, ts.syllableCount("package")); + assert.equal(2, ts.syllableCount("packaged")); + assert.equal(3, ts.syllableCount("packages")); + assert.equal(2, ts.syllableCount("padded")); + assert.equal(2, ts.syllableCount("paddled")); + assert.equal(3, ts.syllableCount("padua")); + assert.equal(2, ts.syllableCount("pages")); + assert.equal(2, ts.syllableCount("pagette")); + assert.equal(1, ts.syllableCount("paille")); + assert.equal(2, ts.syllableCount("palace")); + assert.equal(3, ts.syllableCount("palaces")); + assert.equal(6, ts.syllableCount("paleobotany")); + assert.equal(4, ts.syllableCount("paleocene")); + assert.equal(6, ts.syllableCount("paleontology")); + assert.equal(2, ts.syllableCount("palette")); + assert.equal(3, ts.syllableCount("paniccia")); + assert.equal(4, ts.syllableCount("pantaleo")); + assert.equal(3, ts.syllableCount("pantheon")); + assert.equal(4, ts.syllableCount("panzhihua")); + assert.equal(4, ts.syllableCount("papaleo")); + assert.equal(3, ts.syllableCount("papaya")); + assert.equal(3, ts.syllableCount("papayas")); + assert.equal(3, ts.syllableCount("papering")); + assert.equal(3, ts.syllableCount("papineau")); + assert.equal(3, ts.syllableCount("papua")); + assert.equal(4, ts.syllableCount("paradoxes")); + assert.equal(4, ts.syllableCount("paraguayan")); + assert.equal(4, ts.syllableCount("paralyzes")); + assert.equal(4, ts.syllableCount("parazoa")); + assert.equal(2, ts.syllableCount("parcplace")); + assert.equal(3, ts.syllableCount("parentage")); + assert.equal(3, ts.syllableCount("parenteau")); + assert.equal(4, ts.syllableCount("parentheses")); + assert.equal(3, ts.syllableCount("pariseau")); + assert.equal(3, ts.syllableCount("parisian")); + assert.equal(3, ts.syllableCount("parizeau")); + assert.equal(2, ts.syllableCount("parlette")); + assert.equal(1, ts.syllableCount("parnes")); + assert.equal(3, ts.syllableCount("parsonage")); + assert.equal(3, ts.syllableCount("partridges")); + assert.equal(3, ts.syllableCount("pascua")); + assert.equal(3, ts.syllableCount("paseo")); + assert.equal(1, ts.syllableCount("paske")); + assert.equal(5, ts.syllableCount("pasquariello")); + assert.equal(1, ts.syllableCount("pasque")); + assert.equal(2, ts.syllableCount("passage")); + assert.equal(3, ts.syllableCount("passages")); + assert.equal(1, ts.syllableCount("paste")); + assert.equal(1, ts.syllableCount("pastes")); + assert.equal(2, ts.syllableCount("patches")); + assert.equal(1, ts.syllableCount("pathe")); + assert.equal(2, ts.syllableCount("patrice")); + assert.equal(3, ts.syllableCount("patricia")); + assert.equal(3, ts.syllableCount("patrician")); + assert.equal(3, ts.syllableCount("patricians")); + assert.equal(3, ts.syllableCount("patronage")); + assert.equal(2, ts.syllableCount("paulette")); + assert.equal(2, ts.syllableCount("pauses")); + assert.equal(2, ts.syllableCount("pavement")); + assert.equal(2, ts.syllableCount("pavements")); + assert.equal(3, ts.syllableCount("payable")); + assert.equal(3, ts.syllableCount("payables")); + assert.equal(2, ts.syllableCount("payan")); + assert.equal(2, ts.syllableCount("payeur")); + assert.equal(2, ts.syllableCount("payoff")); + assert.equal(2, ts.syllableCount("payoffs")); + assert.equal(3, ts.syllableCount("payola")); + assert.equal(2, ts.syllableCount("payout")); + assert.equal(2, ts.syllableCount("payouts")); + assert.equal(2, ts.syllableCount("peaceful")); + assert.equal(3, ts.syllableCount("peacefully")); + assert.equal(3, ts.syllableCount("pebereau")); + assert.equal(2, ts.syllableCount("peddled")); + assert.equal(2, ts.syllableCount("peerage")); + assert.equal(3, ts.syllableCount("peladeau")); + assert.equal(3, ts.syllableCount("pelayo")); + assert.equal(1, ts.syllableCount("pelle")); + assert.equal(5, ts.syllableCount("peloponnesian")); + assert.equal(4, ts.syllableCount("penalizes")); + assert.equal(2, ts.syllableCount("peon")); + assert.equal(3, ts.syllableCount("peonies")); + assert.equal(2, ts.syllableCount("peons")); + assert.equal(3, ts.syllableCount("peony")); + assert.equal(4, ts.syllableCount("peoria")); + assert.equal(3, ts.syllableCount("percentage")); + assert.equal(4, ts.syllableCount("percentages")); + assert.equal(2, ts.syllableCount("perches")); + assert.equal(4, ts.syllableCount("performances")); + assert.equal(4, ts.syllableCount("permissiveness")); + assert.equal(2, ts.syllableCount("pernice")); + assert.equal(3, ts.syllableCount("perplexes")); + assert.equal(2, ts.syllableCount("perreault")); + assert.equal(4, ts.syllableCount("perriello")); + assert.equal(2, ts.syllableCount("persian")); + assert.equal(2, ts.syllableCount("persians")); + assert.equal(4, ts.syllableCount("pervasiveness")); + assert.equal(4, ts.syllableCount("petroleos")); + assert.equal(3, ts.syllableCount("petrossian")); + assert.equal(3, ts.syllableCount("phalanges")); + assert.equal(3, ts.syllableCount("phantasm")); + assert.equal(2, ts.syllableCount("phases")); + assert.equal(3, ts.syllableCount("phileo")); + assert.equal(3, ts.syllableCount("phoenicia")); + assert.equal(3, ts.syllableCount("phoenician")); + assert.equal(3, ts.syllableCount("phoenicians")); + assert.equal(2, ts.syllableCount("phrases")); + assert.equal(2, ts.syllableCount("phua")); + assert.equal(3, ts.syllableCount("physician")); + assert.equal(3, ts.syllableCount("physicians")); + assert.equal(6, ts.syllableCount("phytogeography")); + assert.equal(5, ts.syllableCount("picariello")); + assert.equal(3, ts.syllableCount("picayune")); + assert.equal(3, ts.syllableCount("piccione")); + assert.equal(2, ts.syllableCount("pichette")); + assert.equal(2, ts.syllableCount("pickled")); + assert.equal(3, ts.syllableCount("picturesque")); + assert.equal(2, ts.syllableCount("pieces")); + assert.equal(2, ts.syllableCount("piet")); + assert.equal(3, ts.syllableCount("pilferage")); + assert.equal(3, ts.syllableCount("pilgrimage")); + assert.equal(4, ts.syllableCount("pilgrimages")); + assert.equal(2, ts.syllableCount("pillage")); + assert.equal(2, ts.syllableCount("pillaged")); + assert.equal(3, ts.syllableCount("pillages")); + assert.equal(1, ts.syllableCount("pille")); + assert.equal(3, ts.syllableCount("pincavage")); + assert.equal(2, ts.syllableCount("pineau")); + assert.equal(3, ts.syllableCount("pineo")); + assert.equal(2, ts.syllableCount("pinette")); + assert.equal(3, ts.syllableCount("pinneo")); + assert.equal(3, ts.syllableCount("pinsoneault")); + assert.equal(2, ts.syllableCount("pion")); + assert.equal(3, ts.syllableCount("pioneer")); + assert.equal(3, ts.syllableCount("pioneered")); + assert.equal(4, ts.syllableCount("pioneering")); + assert.equal(3, ts.syllableCount("pioneers")); + assert.equal(3, ts.syllableCount("piontek")); + assert.equal(4, ts.syllableCount("piontkowski")); + assert.equal(3, ts.syllableCount("pirouettes")); + assert.equal(2, ts.syllableCount("pitches")); + assert.equal(2, ts.syllableCount("placement")); + assert.equal(2, ts.syllableCount("placements")); + assert.equal(3, ts.syllableCount("placencia")); + assert.equal(2, ts.syllableCount("places")); + assert.equal(2, ts.syllableCount("plaguing")); + assert.equal(2, ts.syllableCount("plainclothes")); + assert.equal(3, ts.syllableCount("plascencia")); + assert.equal(3, ts.syllableCount("plasencia")); + assert.equal(1, ts.syllableCount("plasse")); + assert.equal(2, ts.syllableCount("plateau")); + assert.equal(2, ts.syllableCount("plateaued")); + assert.equal(2, ts.syllableCount("playa")); + assert.equal(2, ts.syllableCount("playoff")); + assert.equal(2, ts.syllableCount("playoffs")); + assert.equal(3, ts.syllableCount("pleasantville")); + assert.equal(2, ts.syllableCount("pleases")); + assert.equal(2, ts.syllableCount("pledges")); + assert.equal(4, ts.syllableCount("plisetskaya")); + assert.equal(2, ts.syllableCount("plodded")); + assert.equal(2, ts.syllableCount("plumage")); + assert.equal(3, ts.syllableCount("plumages")); + assert.equal(2, ts.syllableCount("plunges")); + assert.equal(2, ts.syllableCount("pluses")); + assert.equal(2, ts.syllableCount("police")); + assert.equal(2, ts.syllableCount("policed")); + assert.equal(3, ts.syllableCount("polices")); + assert.equal(4, ts.syllableCount("policewoman")); + assert.equal(3, ts.syllableCount("politeness")); + assert.equal(4, ts.syllableCount("politician")); + assert.equal(4, ts.syllableCount("politicians")); + assert.equal(4, ts.syllableCount("pollyanna")); + assert.equal(6, ts.syllableCount("polyacetylene")); + assert.equal(3, ts.syllableCount("polyak")); + assert.equal(4, ts.syllableCount("polyamide")); + assert.equal(4, ts.syllableCount("polyandrous")); + assert.equal(4, ts.syllableCount("polyandry")); + assert.equal(4, ts.syllableCount("polyester")); + assert.equal(4, ts.syllableCount("polyesters")); + assert.equal(5, ts.syllableCount("polyethylene")); + assert.equal(5, ts.syllableCount("polymerizes")); + assert.equal(4, ts.syllableCount("polynesian")); + assert.equal(3, ts.syllableCount("pomerleau")); + assert.equal(3, ts.syllableCount("pompeo")); + assert.equal(2, ts.syllableCount("ponsolle")); + assert.equal(3, ts.syllableCount("populace")); + assert.equal(2, ts.syllableCount("porches")); + assert.equal(2, ts.syllableCount("porges")); + assert.equal(3, ts.syllableCount("porpoises")); + assert.equal(2, ts.syllableCount("porsche")); + assert.equal(2, ts.syllableCount("porsches")); + assert.equal(2, ts.syllableCount("portage")); + assert.equal(4, ts.syllableCount("porterages")); + assert.equal(3, ts.syllableCount("portrayal")); + assert.equal(3, ts.syllableCount("portrayals")); + assert.equal(2, ts.syllableCount("poses")); + assert.equal(2, ts.syllableCount("postage")); + assert.equal(3, ts.syllableCount("postponement")); + assert.equal(3, ts.syllableCount("postponements")); + assert.equal(2, ts.syllableCount("postrelle")); + assert.equal(3, ts.syllableCount("poultices")); + assert.equal(2, ts.syllableCount("poundage")); + assert.equal(2, ts.syllableCount("pounded")); + assert.equal(4, ts.syllableCount("powerhouses")); + assert.equal(3, ts.syllableCount("powering")); + assert.equal(2, ts.syllableCount("practice")); + assert.equal(2, ts.syllableCount("practiced")); + assert.equal(3, ts.syllableCount("practices")); + assert.equal(2, ts.syllableCount("praises")); + assert.equal(1, ts.syllableCount("pralle")); + assert.equal(2, ts.syllableCount("prances")); + assert.equal(2, ts.syllableCount("prattville")); + assert.equal(2, ts.syllableCount("preaches")); + assert.equal(5, ts.syllableCount("preadolescent")); + assert.equal(3, ts.syllableCount("preamble")); + assert.equal(3, ts.syllableCount("prearranged")); + assert.equal(3, ts.syllableCount("preceding")); + assert.equal(3, ts.syllableCount("precipice")); + assert.equal(3, ts.syllableCount("predaceous")); + assert.equal(4, ts.syllableCount("preeminence")); + assert.equal(4, ts.syllableCount("preeminent")); + assert.equal(2, ts.syllableCount("preempt")); + assert.equal(3, ts.syllableCount("preempted")); + assert.equal(3, ts.syllableCount("preemption")); + assert.equal(3, ts.syllableCount("preemptive")); + assert.equal(3, ts.syllableCount("preexist")); + assert.equal(4, ts.syllableCount("preexisted")); + assert.equal(4, ts.syllableCount("preexisting")); + assert.equal(3, ts.syllableCount("preexists")); + assert.equal(2, ts.syllableCount("preface")); + assert.equal(2, ts.syllableCount("prefaced")); + assert.equal(3, ts.syllableCount("preferenced")); + assert.equal(4, ts.syllableCount("preferences")); + assert.equal(4, ts.syllableCount("preignition")); + assert.equal(4, ts.syllableCount("preinvasion")); + assert.equal(3, ts.syllableCount("preisler")); + assert.equal(2, ts.syllableCount("prejudged")); + assert.equal(3, ts.syllableCount("prejudice")); + assert.equal(3, ts.syllableCount("prejudiced")); + assert.equal(4, ts.syllableCount("prejudices")); + assert.equal(2, ts.syllableCount("premed")); + assert.equal(3, ts.syllableCount("premiering")); + assert.equal(3, ts.syllableCount("premises")); + assert.equal(2, ts.syllableCount("prentice")); + assert.equal(5, ts.syllableCount("preoccupation")); + assert.equal(5, ts.syllableCount("preoccupations")); + assert.equal(4, ts.syllableCount("preoccupied")); + assert.equal(4, ts.syllableCount("preoccupies")); + assert.equal(4, ts.syllableCount("preoccupy")); + assert.equal(3, ts.syllableCount("preordained")); + assert.equal(3, ts.syllableCount("prepackaged")); + assert.equal(4, ts.syllableCount("prerecorded")); + assert.equal(2, ts.syllableCount("presage")); + assert.equal(2, ts.syllableCount("presaged")); + assert.equal(3, ts.syllableCount("presages")); + assert.equal(3, ts.syllableCount("presences")); + assert.equal(2, ts.syllableCount("preserves")); + assert.equal(2, ts.syllableCount("prestage")); + assert.equal(2, ts.syllableCount("prestige")); + assert.equal(4, ts.syllableCount("presupposes")); + assert.equal(3, ts.syllableCount("pretended")); + assert.equal(2, ts.syllableCount("prevette")); + assert.equal(2, ts.syllableCount("priceless")); + assert.equal(2, ts.syllableCount("prices")); + assert.equal(2, ts.syllableCount("prideaux")); + assert.equal(2, ts.syllableCount("primeau")); + assert.equal(2, ts.syllableCount("primeaux")); + assert.equal(3, ts.syllableCount("primroses")); + assert.equal(2, ts.syllableCount("princes")); + assert.equal(2, ts.syllableCount("princeville")); + assert.equal(3, ts.syllableCount("principled")); + assert.equal(3, ts.syllableCount("prindiville")); + assert.equal(3, ts.syllableCount("prioleau")); + assert.equal(5, ts.syllableCount("prioritizes")); + assert.equal(2, ts.syllableCount("privette")); + assert.equal(2, ts.syllableCount("prizes")); + assert.equal(3, ts.syllableCount("proactive")); + assert.equal(3, ts.syllableCount("probusiness")); + assert.equal(3, ts.syllableCount("procurement")); + assert.equal(3, ts.syllableCount("procurements")); + assert.equal(2, ts.syllableCount("prodded")); + assert.equal(2, ts.syllableCount("produce")); + assert.equal(2, ts.syllableCount("produced")); + assert.equal(3, ts.syllableCount("produces")); + assert.equal(3, ts.syllableCount("prognoses")); + assert.equal(2, ts.syllableCount("programme")); + assert.equal(2, ts.syllableCount("prolonged")); + assert.equal(4, ts.syllableCount("prominences")); + assert.equal(3, ts.syllableCount("promises")); + assert.equal(2, ts.syllableCount("pronounced")); + assert.equal(3, ts.syllableCount("pronouncement")); + assert.equal(3, ts.syllableCount("pronouncements")); + assert.equal(3, ts.syllableCount("pronounces")); + assert.equal(4, ts.syllableCount("propionic")); + assert.equal(3, ts.syllableCount("proposes")); + assert.equal(3, ts.syllableCount("propounded")); + assert.equal(2, ts.syllableCount("proscia")); + assert.equal(4, ts.syllableCount("prospectuses")); + assert.equal(3, ts.syllableCount("prostheses")); + assert.equal(3, ts.syllableCount("proteges")); + assert.equal(4, ts.syllableCount("protozoa")); + assert.equal(5, ts.syllableCount("protuberances")); + assert.equal(5, ts.syllableCount("provideniya")); + assert.equal(3, ts.syllableCount("provinces")); + assert.equal(2, ts.syllableCount("prudhomme")); + assert.equal(2, ts.syllableCount("pruneau")); + assert.equal(2, ts.syllableCount("prussian")); + assert.equal(3, ts.syllableCount("puleo")); + assert.equal(2, ts.syllableCount("pulice")); + assert.equal(2, ts.syllableCount("pumice")); + assert.equal(3, ts.syllableCount("purchases")); + assert.equal(2, ts.syllableCount("purges")); + assert.equal(3, ts.syllableCount("purposes")); + assert.equal(1, ts.syllableCount("purves")); + assert.equal(3, ts.syllableCount("purveyor")); + assert.equal(3, ts.syllableCount("purveyors")); + assert.equal(2, ts.syllableCount("puzzled")); + assert.equal(2, ts.syllableCount("pyatt")); + assert.equal(2, ts.syllableCount("pyeatt")); + assert.equal(3, ts.syllableCount("quadrupled")); + assert.equal(1, ts.syllableCount("quai")); + assert.equal(1, ts.syllableCount("quaid")); + assert.equal(1, ts.syllableCount("quail")); + assert.equal(1, ts.syllableCount("quails")); + assert.equal(1, ts.syllableCount("quain")); + assert.equal(1, ts.syllableCount("quaint")); + assert.equal(2, ts.syllableCount("quaintance")); + assert.equal(2, ts.syllableCount("quaintly")); + assert.equal(1, ts.syllableCount("quamme")); + assert.equal(1, ts.syllableCount("queau")); + assert.equal(3, ts.syllableCount("quebedeaux")); + assert.equal(2, ts.syllableCount("quellette")); + assert.equal(3, ts.syllableCount("quenneville")); + assert.equal(2, ts.syllableCount("queuing")); + assert.equal(3, ts.syllableCount("quintupled")); + assert.equal(3, ts.syllableCount("quivering")); + assert.equal(3, ts.syllableCount("rabideau")); + assert.equal(3, ts.syllableCount("racehorses")); + assert.equal(2, ts.syllableCount("races")); + assert.equal(2, ts.syllableCount("racette")); + assert.equal(2, ts.syllableCount("rachelle")); + assert.equal(2, ts.syllableCount("radborne")); + assert.equal(2, ts.syllableCount("radbourne")); + assert.equal(2, ts.syllableCount("radice")); + assert.equal(2, ts.syllableCount("rages")); + assert.equal(2, ts.syllableCount("ragged")); + assert.equal(2, ts.syllableCount("rahe")); + assert.equal(2, ts.syllableCount("rainville")); + assert.equal(2, ts.syllableCount("raises")); + assert.equal(3, ts.syllableCount("raleses")); + assert.equal(2, ts.syllableCount("ramage")); + assert.equal(2, ts.syllableCount("rambeau")); + assert.equal(2, ts.syllableCount("rambled")); + assert.equal(2, ts.syllableCount("rambling")); + assert.equal(3, ts.syllableCount("rameses")); + assert.equal(2, ts.syllableCount("rampage")); + assert.equal(2, ts.syllableCount("rampaged")); + assert.equal(3, ts.syllableCount("rampages")); + assert.equal(2, ts.syllableCount("ranges")); + assert.equal(2, ts.syllableCount("rankled")); + assert.equal(3, ts.syllableCount("rapprochement")); + assert.equal(1, ts.syllableCount("raske")); + assert.equal(2, ts.syllableCount("rathburne")); + assert.equal(1, ts.syllableCount("rathe")); + assert.equal(2, ts.syllableCount("rattling")); + assert.equal(2, ts.syllableCount("ravaged")); + assert.equal(3, ts.syllableCount("ravages")); + assert.equal(2, ts.syllableCount("raya")); + assert.equal(2, ts.syllableCount("rayon")); + assert.equal(2, ts.syllableCount("rayos")); + assert.equal(3, ts.syllableCount("rayovac")); + assert.equal(3, ts.syllableCount("raytheon")); + assert.equal(3, ts.syllableCount("reabsorbed")); + assert.equal(5, ts.syllableCount("reactionaries")); + assert.equal(5, ts.syllableCount("reactionary")); + assert.equal(3, ts.syllableCount("reactions")); + assert.equal(3, ts.syllableCount("reaganesque")); + assert.equal(3, ts.syllableCount("realign")); + assert.equal(3, ts.syllableCount("realigned")); + assert.equal(4, ts.syllableCount("realigning")); + assert.equal(4, ts.syllableCount("realignment")); + assert.equal(4, ts.syllableCount("realignments")); + assert.equal(4, ts.syllableCount("realistic")); + assert.equal(4, ts.syllableCount("realities")); + assert.equal(4, ts.syllableCount("reality")); + assert.equal(5, ts.syllableCount("realizable")); + assert.equal(4, ts.syllableCount("realizes")); + assert.equal(4, ts.syllableCount("reallocate")); + assert.equal(5, ts.syllableCount("reallocated")); + assert.equal(5, ts.syllableCount("reallocating")); + assert.equal(5, ts.syllableCount("reallocation")); + assert.equal(4, ts.syllableCount("reallowance")); + assert.equal(3, ts.syllableCount("realtor")); + assert.equal(3, ts.syllableCount("realtors")); + assert.equal(3, ts.syllableCount("realty")); + assert.equal(3, ts.syllableCount("reappraised")); + assert.equal(1, ts.syllableCount("reaume")); + assert.equal(1, ts.syllableCount("reaux")); + assert.equal(3, ts.syllableCount("rebounded")); + assert.equal(3, ts.syllableCount("receding")); + assert.equal(4, ts.syllableCount("recognizes")); + assert.equal(4, ts.syllableCount("recommended")); + assert.equal(3, ts.syllableCount("recorded")); + assert.equal(4, ts.syllableCount("recovering")); + assert.equal(3, ts.syllableCount("recycled")); + assert.equal(3, ts.syllableCount("redhanded")); + assert.equal(5, ts.syllableCount("rediscovering")); + assert.equal(3, ts.syllableCount("redoubled")); + assert.equal(2, ts.syllableCount("reduce")); + assert.equal(2, ts.syllableCount("reduced")); + assert.equal(3, ts.syllableCount("reduces")); + assert.equal(3, ts.syllableCount("reemerge")); + assert.equal(3, ts.syllableCount("reemerged")); + assert.equal(4, ts.syllableCount("reestablished")); + assert.equal(3, ts.syllableCount("referenced")); + assert.equal(4, ts.syllableCount("references")); + assert.equal(3, ts.syllableCount("refering")); + assert.equal(3, ts.syllableCount("refinanced")); + assert.equal(4, ts.syllableCount("refinances")); + assert.equal(3, ts.syllableCount("refinement")); + assert.equal(3, ts.syllableCount("refinements")); + assert.equal(3, ts.syllableCount("reflexes")); + assert.equal(4, ts.syllableCount("refocuses")); + assert.equal(2, ts.syllableCount("refuge")); + assert.equal(3, ts.syllableCount("refuges")); + assert.equal(3, ts.syllableCount("refunded")); + assert.equal(3, ts.syllableCount("refuses")); + assert.equal(3, ts.syllableCount("regarded")); + assert.equal(3, ts.syllableCount("reimposed")); + assert.equal(4, ts.syllableCount("rejiggering")); + assert.equal(2, ts.syllableCount("rejoice")); + assert.equal(2, ts.syllableCount("rejoiced")); + assert.equal(3, ts.syllableCount("rekindled")); + assert.equal(2, ts.syllableCount("relaunched")); + assert.equal(3, ts.syllableCount("relaxes")); + assert.equal(3, ts.syllableCount("releases")); + assert.equal(3, ts.syllableCount("remanded")); + assert.equal(4, ts.syllableCount("remembrances")); + assert.equal(3, ts.syllableCount("reminded")); + assert.equal(3, ts.syllableCount("reminisced")); + assert.equal(5, ts.syllableCount("reminiscences")); + assert.equal(4, ts.syllableCount("remittances")); + assert.equal(1, ts.syllableCount("remme")); + assert.equal(3, ts.syllableCount("remolded")); + assert.equal(3, ts.syllableCount("remoteness")); + assert.equal(3, ts.syllableCount("remoulded")); + assert.equal(2, ts.syllableCount("reneau")); + assert.equal(2, ts.syllableCount("renege")); + assert.equal(2, ts.syllableCount("reneged")); + assert.equal(1, ts.syllableCount("renne")); + assert.equal(2, ts.syllableCount("renounced")); + assert.equal(2, ts.syllableCount("reo")); + assert.equal(3, ts.syllableCount("reoffer")); + assert.equal(3, ts.syllableCount("reoffered")); + assert.equal(4, ts.syllableCount("reoffering")); + assert.equal(3, ts.syllableCount("reopen")); + assert.equal(3, ts.syllableCount("reopened")); + assert.equal(4, ts.syllableCount("reopening")); + assert.equal(3, ts.syllableCount("reopens")); + assert.equal(3, ts.syllableCount("reorder")); + assert.equal(4, ts.syllableCount("reordering")); + assert.equal(6, ts.syllableCount("reorganization")); + assert.equal(6, ts.syllableCount("reorganizations")); + assert.equal(4, ts.syllableCount("reorganize")); + assert.equal(4, ts.syllableCount("reorganized")); + assert.equal(5, ts.syllableCount("reorganizes")); + assert.equal(5, ts.syllableCount("reorganizing")); + assert.equal(3, ts.syllableCount("repackage")); + assert.equal(3, ts.syllableCount("repackaged")); + assert.equal(4, ts.syllableCount("repackages")); + assert.equal(4, ts.syllableCount("repayable")); + assert.equal(2, ts.syllableCount("replace")); + assert.equal(2, ts.syllableCount("replaced")); + assert.equal(3, ts.syllableCount("replacement")); + assert.equal(3, ts.syllableCount("replacements")); + assert.equal(3, ts.syllableCount("replaces")); + assert.equal(3, ts.syllableCount("reportage")); + assert.equal(2, ts.syllableCount("reprice")); + assert.equal(2, ts.syllableCount("repriced")); + assert.equal(4, ts.syllableCount("reprimanded")); + assert.equal(3, ts.syllableCount("reproduce")); + assert.equal(3, ts.syllableCount("reproduced")); + assert.equal(4, ts.syllableCount("reproduces")); + assert.equal(4, ts.syllableCount("repurchases")); + assert.equal(3, ts.syllableCount("requirement")); + assert.equal(3, ts.syllableCount("requirements")); + assert.equal(3, ts.syllableCount("rescinded")); + assert.equal(3, ts.syllableCount("researches")); + assert.equal(4, ts.syllableCount("resemblances")); + assert.equal(3, ts.syllableCount("resembled")); + assert.equal(2, ts.syllableCount("reserves")); + assert.equal(3, ts.syllableCount("reshuffled")); + assert.equal(4, ts.syllableCount("residences")); + assert.equal(4, ts.syllableCount("resistiveness")); + assert.equal(1, ts.syllableCount("reske")); + assert.equal(2, ts.syllableCount("resolve")); + assert.equal(2, ts.syllableCount("resolves")); + assert.equal(3, ts.syllableCount("resources")); + assert.equal(3, ts.syllableCount("responded")); + assert.equal(4, ts.syllableCount("responsiveness")); + assert.equal(2, ts.syllableCount("restaged")); + assert.equal(3, ts.syllableCount("restatement")); + assert.equal(3, ts.syllableCount("restatements")); + assert.equal(3, ts.syllableCount("restiveness")); + assert.equal(4, ts.syllableCount("restrictiveness")); + assert.equal(3, ts.syllableCount("resurface")); + assert.equal(3, ts.syllableCount("resurfaced")); + assert.equal(3, ts.syllableCount("retarded")); + assert.equal(3, ts.syllableCount("retirements")); + assert.equal(2, ts.syllableCount("retrace")); + assert.equal(2, ts.syllableCount("retraced")); + assert.equal(3, ts.syllableCount("retracement")); + assert.equal(2, ts.syllableCount("retrenched")); + assert.equal(5, ts.syllableCount("retroviruses")); + assert.equal(2, ts.syllableCount("reused")); + assert.equal(2, ts.syllableCount("revelle")); + assert.equal(2, ts.syllableCount("revette")); + assert.equal(2, ts.syllableCount("reville")); + assert.equal(3, ts.syllableCount("revises")); + assert.equal(2, ts.syllableCount("revolve")); + assert.equal(2, ts.syllableCount("revolves")); + assert.equal(3, ts.syllableCount("rewarded")); + assert.equal(4, ts.syllableCount("rhapsodizes")); + assert.equal(1, ts.syllableCount("rheault")); + assert.equal(1, ts.syllableCount("rheaume")); + assert.equal(4, ts.syllableCount("rhetoricians")); + assert.equal(3, ts.syllableCount("rhodesian")); + assert.equal(2, ts.syllableCount("rhythm")); + assert.equal(2, ts.syllableCount("riddled")); + assert.equal(2, ts.syllableCount("rideau")); + assert.equal(2, ts.syllableCount("rideaux")); + assert.equal(2, ts.syllableCount("ridges")); + assert.equal(2, ts.syllableCount("riendeau")); + assert.equal(2, ts.syllableCount("rifled")); + assert.equal(2, ts.syllableCount("righteous")); + assert.equal(3, ts.syllableCount("righteously")); + assert.equal(3, ts.syllableCount("righteousness")); + assert.equal(2, ts.syllableCount("rillette")); + assert.equal(1, ts.syllableCount("rinne")); + assert.equal(2, ts.syllableCount("rion")); + assert.equal(2, ts.syllableCount("riposte")); + assert.equal(2, ts.syllableCount("ripostes")); + assert.equal(3, ts.syllableCount("rippeon")); + assert.equal(2, ts.syllableCount("rippled")); + assert.equal(2, ts.syllableCount("rises")); + assert.equal(1, ts.syllableCount("riske")); + assert.equal(1, ts.syllableCount("risse")); + assert.equal(3, ts.syllableCount("riverbed")); + assert.equal(2, ts.syllableCount("rivette")); + assert.equal(4, ts.syllableCount("riviello")); + assert.equal(2, ts.syllableCount("riyad")); + assert.equal(2, ts.syllableCount("riyadh")); + assert.equal(2, ts.syllableCount("riyals")); + assert.equal(2, ts.syllableCount("roa")); + assert.equal(3, ts.syllableCount("robicheaux")); + assert.equal(3, ts.syllableCount("robideau")); + assert.equal(3, ts.syllableCount("robinette")); + assert.equal(3, ts.syllableCount("robitaille")); + assert.equal(3, ts.syllableCount("rocheleau")); + assert.equal(2, ts.syllableCount("rochelle")); + assert.equal(2, ts.syllableCount("rochette")); + assert.equal(2, ts.syllableCount("rockville")); + assert.equal(3, ts.syllableCount("rodeo")); + assert.equal(3, ts.syllableCount("rodeos")); + assert.equal(2, ts.syllableCount("roebling")); + assert.equal(1, ts.syllableCount("roelle")); + assert.equal(1, ts.syllableCount("roeske")); + assert.equal(3, ts.syllableCount("rohleder")); + assert.equal(1, ts.syllableCount("rolle")); + assert.equal(3, ts.syllableCount("romances")); + assert.equal(3, ts.syllableCount("romanesque")); + assert.equal(5, ts.syllableCount("romaniello")); + assert.equal(2, ts.syllableCount("romelle")); + assert.equal(3, ts.syllableCount("romeo")); + assert.equal(2, ts.syllableCount("rondeau")); + assert.equal(1, ts.syllableCount("ronne")); + assert.equal(3, ts.syllableCount("rosabelle")); + assert.equal(2, ts.syllableCount("rosanne")); + assert.equal(2, ts.syllableCount("roseanne")); + assert.equal(3, ts.syllableCount("roseberry")); + assert.equal(2, ts.syllableCount("roses")); + assert.equal(2, ts.syllableCount("rosette")); + assert.equal(2, ts.syllableCount("rosettes")); + assert.equal(2, ts.syllableCount("roseville")); + assert.equal(1, ts.syllableCount("roske")); + assert.equal(1, ts.syllableCount("rosse")); + assert.equal(3, ts.syllableCount("rossiya")); + assert.equal(1, ts.syllableCount("rothe")); + assert.equal(3, ts.syllableCount("rototilles")); + assert.equal(2, ts.syllableCount("rougeau")); + assert.equal(2, ts.syllableCount("rouleau")); + assert.equal(2, ts.syllableCount("roulette")); + assert.equal(2, ts.syllableCount("roulettes")); + assert.equal(2, ts.syllableCount("rounded")); + assert.equal(3, ts.syllableCount("rounsaville")); + assert.equal(1, ts.syllableCount("rousse")); + assert.equal(2, ts.syllableCount("rousseau")); + assert.equal(2, ts.syllableCount("rousselle")); + assert.equal(2, ts.syllableCount("rowlette")); + assert.equal(2, ts.syllableCount("roxanne")); + assert.equal(2, ts.syllableCount("royal")); + assert.equal(2, ts.syllableCount("royale")); + assert.equal(3, ts.syllableCount("royalist")); + assert.equal(2, ts.syllableCount("royall")); + assert.equal(2, ts.syllableCount("royals")); + assert.equal(3, ts.syllableCount("royalties")); + assert.equal(3, ts.syllableCount("royalty")); + assert.equal(2, ts.syllableCount("royces")); + assert.equal(2, ts.syllableCount("royex")); + assert.equal(2, ts.syllableCount("rozelle")); + assert.equal(2, ts.syllableCount("rua")); + assert.equal(2, ts.syllableCount("rudelle")); + assert.equal(2, ts.syllableCount("rudeness")); + assert.equal(2, ts.syllableCount("ruffled")); + assert.equal(2, ts.syllableCount("rugged")); + assert.equal(3, ts.syllableCount("ruggedly")); + assert.equal(2, ts.syllableCount("rumage")); + assert.equal(2, ts.syllableCount("rumbled")); + assert.equal(2, ts.syllableCount("rummage")); + assert.equal(2, ts.syllableCount("rumpled")); + assert.equal(2, ts.syllableCount("ruses")); + assert.equal(1, ts.syllableCount("russe")); + assert.equal(3, ts.syllableCount("russellville")); + assert.equal(2, ts.syllableCount("russian")); + assert.equal(2, ts.syllableCount("russians")); + assert.equal(2, ts.syllableCount("ryal")); + assert.equal(2, ts.syllableCount("ryall")); + assert.equal(2, ts.syllableCount("ryals")); + assert.equal(2, ts.syllableCount("ryan")); + assert.equal(3, ts.syllableCount("ryanair")); + assert.equal(2, ts.syllableCount("ryans")); + assert.equal(2, ts.syllableCount("ryen")); + assert.equal(3, ts.syllableCount("sabotage")); + assert.equal(3, ts.syllableCount("sabotaged")); + assert.equal(2, ts.syllableCount("sackville")); + assert.equal(2, ts.syllableCount("sacred")); + assert.equal(3, ts.syllableCount("sacrifice")); + assert.equal(3, ts.syllableCount("sacrificed")); + assert.equal(4, ts.syllableCount("sacrifices")); + assert.equal(3, ts.syllableCount("sacrilege")); + assert.equal(2, ts.syllableCount("saddled")); + assert.equal(2, ts.syllableCount("sages")); + assert.equal(2, ts.syllableCount("salemme")); + assert.equal(3, ts.syllableCount("saleswoman")); + assert.equal(3, ts.syllableCount("saleswomen")); + assert.equal(1, ts.syllableCount("salle")); + assert.equal(2, ts.syllableCount("salvage")); + assert.equal(2, ts.syllableCount("salvaged")); + assert.equal(1, ts.syllableCount("salve")); + assert.equal(1, ts.syllableCount("salves")); + assert.equal(2, ts.syllableCount("samelle")); + assert.equal(2, ts.syllableCount("sameness")); + assert.equal(3, ts.syllableCount("samoa")); + assert.equal(2, ts.syllableCount("sampled")); + assert.equal(2, ts.syllableCount("sancia")); + assert.equal(2, ts.syllableCount("sandage")); + assert.equal(2, ts.syllableCount("sanded")); + assert.equal(2, ts.syllableCount("sandwiched")); + assert.equal(1, ts.syllableCount("sannes")); + assert.equal(5, ts.syllableCount("santaniello")); + assert.equal(4, ts.syllableCount("santayana")); + assert.equal(3, ts.syllableCount("santoyo")); + assert.equal(2, ts.syllableCount("sanville")); + assert.equal(3, ts.syllableCount("sapoa")); + assert.equal(3, ts.syllableCount("sarcasm")); + assert.equal(2, ts.syllableCount("sarette")); + assert.equal(3, ts.syllableCount("sarkisian")); + assert.equal(3, ts.syllableCount("sarkissian")); + assert.equal(1, ts.syllableCount("sasse")); + assert.equal(4, ts.syllableCount("satirizes")); + assert.equal(2, ts.syllableCount("sauces")); + assert.equal(2, ts.syllableCount("sausage")); + assert.equal(3, ts.syllableCount("sausages")); + assert.equal(2, ts.syllableCount("sauternes")); + assert.equal(2, ts.syllableCount("sauvage")); + assert.equal(3, ts.syllableCount("sauvageau")); + assert.equal(2, ts.syllableCount("savage")); + assert.equal(2, ts.syllableCount("savaged")); + assert.equal(3, ts.syllableCount("savagely")); + assert.equal(3, ts.syllableCount("savages")); + assert.equal(2, ts.syllableCount("saville")); + assert.equal(3, ts.syllableCount("sawaya")); + assert.equal(2, ts.syllableCount("sawtelle")); + assert.equal(2, ts.syllableCount("sayad")); + assert.equal(2, ts.syllableCount("sayegh")); + assert.equal(2, ts.syllableCount("scaccia")); + assert.equal(2, ts.syllableCount("scarface")); + assert.equal(1, ts.syllableCount("scarves")); + assert.equal(2, ts.syllableCount("scherer")); + assert.equal(2, ts.syllableCount("schering")); + assert.equal(2, ts.syllableCount("schiewe")); + assert.equal(1, ts.syllableCount("schnelle")); + assert.equal(1, ts.syllableCount("scholle")); + assert.equal(2, ts.syllableCount("sciascia")); + assert.equal(2, ts.syllableCount("scion")); + assert.equal(2, ts.syllableCount("scolded")); + assert.equal(2, ts.syllableCount("sconces")); + assert.equal(3, ts.syllableCount("scorpion")); + assert.equal(3, ts.syllableCount("scorpions")); + assert.equal(2, ts.syllableCount("scotches")); + assert.equal(2, ts.syllableCount("scourges")); + assert.equal(2, ts.syllableCount("scoville")); + assert.equal(2, ts.syllableCount("scrambled")); + assert.equal(2, ts.syllableCount("scratches")); + assert.equal(2, ts.syllableCount("scribbled")); + assert.equal(2, ts.syllableCount("scrimmage")); + assert.equal(4, ts.syllableCount("scrutinizes")); + assert.equal(2, ts.syllableCount("scuffled")); + assert.equal(2, ts.syllableCount("seaborne")); + assert.equal(2, ts.syllableCount("searches")); + assert.equal(3, ts.syllableCount("sebaceous")); + assert.equal(3, ts.syllableCount("seceding")); + assert.equal(3, ts.syllableCount("seconded")); + assert.equal(4, ts.syllableCount("secretiveness")); + assert.equal(2, ts.syllableCount("seduce")); + assert.equal(2, ts.syllableCount("seduced")); + assert.equal(2, ts.syllableCount("seepage")); + assert.equal(1, ts.syllableCount("seethe")); + assert.equal(4, ts.syllableCount("seigniorage")); + assert.equal(3, ts.syllableCount("seiyaku")); + assert.equal(2, ts.syllableCount("seiyu")); + assert.equal(2, ts.syllableCount("seizes")); + assert.equal(1, ts.syllableCount("selle")); + assert.equal(2, ts.syllableCount("selvage")); + assert.equal(1, ts.syllableCount("selves")); + assert.equal(6, ts.syllableCount("semiautomatic")); + assert.equal(5, ts.syllableCount("semionenkov")); + assert.equal(1, ts.syllableCount("semmes")); + assert.equal(1, ts.syllableCount("senne")); + assert.equal(4, ts.syllableCount("sensitiveness")); + assert.equal(2, ts.syllableCount("sentelle")); + assert.equal(2, ts.syllableCount("sentenced")); + assert.equal(3, ts.syllableCount("sentences")); + assert.equal(2, ts.syllableCount("seo")); + assert.equal(2, ts.syllableCount("seow")); + assert.equal(4, ts.syllableCount("separateness")); + assert.equal(3, ts.syllableCount("sequoyah")); + assert.equal(1, ts.syllableCount("serves")); + assert.equal(2, ts.syllableCount("service")); + assert.equal(2, ts.syllableCount("serviced")); + assert.equal(3, ts.syllableCount("services")); + assert.equal(1, ts.syllableCount("sette")); + assert.equal(3, ts.syllableCount("severing")); + assert.equal(2, ts.syllableCount("seville")); + assert.equal(2, ts.syllableCount("sewage")); + assert.equal(3, ts.syllableCount("sewerage")); + assert.equal(2, ts.syllableCount("sexes")); + assert.equal(2, ts.syllableCount("sfernice")); + assert.equal(2, ts.syllableCount("shackled")); + assert.equal(2, ts.syllableCount("shaquille")); + assert.equal(3, ts.syllableCount("sharpeville")); + assert.equal(1, ts.syllableCount("sheathe")); + assert.equal(1, ts.syllableCount("sheathed")); + assert.equal(2, ts.syllableCount("shelburne")); + assert.equal(3, ts.syllableCount("shelbyville")); + assert.equal(1, ts.syllableCount("shelve")); + assert.equal(1, ts.syllableCount("shelves")); + assert.equal(3, ts.syllableCount("shepherded")); + assert.equal(2, ts.syllableCount("sherborne")); + assert.equal(2, ts.syllableCount("sherbourne")); + assert.equal(2, ts.syllableCount("sherburne")); + assert.equal(2, ts.syllableCount("shielded")); + assert.equal(3, ts.syllableCount("shigeo")); + assert.equal(4, ts.syllableCount("shionogi")); + assert.equal(3, ts.syllableCount("shivering")); + assert.equal(3, ts.syllableCount("shiyuan")); + assert.equal(2, ts.syllableCount("shoelace")); + assert.equal(3, ts.syllableCount("shoelaces")); + assert.equal(2, ts.syllableCount("shortage")); + assert.equal(3, ts.syllableCount("shortages")); + assert.equal(2, ts.syllableCount("shortchanged")); + assert.equal(3, ts.syllableCount("showcases")); + assert.equal(3, ts.syllableCount("showering")); + assert.equal(2, ts.syllableCount("showpiece")); + assert.equal(2, ts.syllableCount("showplace")); + assert.equal(2, ts.syllableCount("shredded")); + assert.equal(2, ts.syllableCount("shreveport")); + assert.equal(2, ts.syllableCount("shrinkage")); + assert.equal(2, ts.syllableCount("shuffled")); + assert.equal(2, ts.syllableCount("shuffling")); + assert.equal(1, ts.syllableCount("siang")); + assert.equal(1, ts.syllableCount("sias")); + assert.equal(2, ts.syllableCount("sibelle")); + assert.equal(2, ts.syllableCount("sibille")); + assert.equal(2, ts.syllableCount("sibling")); + assert.equal(2, ts.syllableCount("siblings")); + assert.equal(2, ts.syllableCount("sidekick")); + assert.equal(2, ts.syllableCount("sideline")); + assert.equal(2, ts.syllableCount("sidelined")); + assert.equal(2, ts.syllableCount("sidelines")); + assert.equal(2, ts.syllableCount("sideman")); + assert.equal(2, ts.syllableCount("sideshow")); + assert.equal(2, ts.syllableCount("sidestep")); + assert.equal(2, ts.syllableCount("sidestepped")); + assert.equal(3, ts.syllableCount("sidestepping")); + assert.equal(2, ts.syllableCount("sidesteps")); + assert.equal(2, ts.syllableCount("sidestream")); + assert.equal(2, ts.syllableCount("sidetrack")); + assert.equal(2, ts.syllableCount("sidewalk")); + assert.equal(2, ts.syllableCount("sidewalks")); + assert.equal(3, ts.syllableCount("sidewater")); + assert.equal(2, ts.syllableCount("sideways")); + assert.equal(3, ts.syllableCount("sidewinder")); + assert.equal(2, ts.syllableCount("sidewise")); + assert.equal(2, ts.syllableCount("signage")); + assert.equal(2, ts.syllableCount("silenced")); + assert.equal(3, ts.syllableCount("silences")); + assert.equal(3, ts.syllableCount("sileo")); + assert.equal(3, ts.syllableCount("silhouette")); + assert.equal(3, ts.syllableCount("silhouettes")); + assert.equal(3, ts.syllableCount("silverthorne")); + assert.equal(3, ts.syllableCount("simeon")); + assert.equal(3, ts.syllableCount("simeone")); + assert.equal(3, ts.syllableCount("simoneau")); + assert.equal(3, ts.syllableCount("simoneaux")); + assert.equal(3, ts.syllableCount("simonette")); + assert.equal(4, ts.syllableCount("simpleminded")); + assert.equal(2, ts.syllableCount("simplesse")); + assert.equal(3, ts.syllableCount("sincavage")); + assert.equal(3, ts.syllableCount("Sindayen")); + assert.equal(2, ts.syllableCount("singled")); + assert.equal(5, ts.syllableCount("singlehandedly")); + assert.equal(3, ts.syllableCount("sinuses")); + assert.equal(1, ts.syllableCount("sithe")); + assert.equal(2, ts.syllableCount("sixes")); + assert.equal(2, ts.syllableCount("sizes")); + assert.equal(2, ts.syllableCount("sizzled")); + assert.equal(2, ts.syllableCount("skeoch")); + assert.equal(2, ts.syllableCount("sketches")); + assert.equal(3, ts.syllableCount("skewering")); + assert.equal(2, ts.syllableCount("skidded")); + assert.equal(3, ts.syllableCount("skyboxes")); + assert.equal(4, ts.syllableCount("slaughterhouses")); + assert.equal(2, ts.syllableCount("slices")); + assert.equal(2, ts.syllableCount("slippage")); + assert.equal(1, ts.syllableCount("smoothed")); + assert.equal(2, ts.syllableCount("smuggled")); + assert.equal(1, ts.syllableCount("smythe")); + assert.equal(2, ts.syllableCount("snarled")); + assert.equal(2, ts.syllableCount("snatches")); + assert.equal(3, ts.syllableCount("sobering")); + assert.equal(2, ts.syllableCount("socia")); + assert.equal(3, ts.syllableCount("softimage")); + assert.equal(2, ts.syllableCount("soileau")); + assert.equal(3, ts.syllableCount("sokaiya")); + assert.equal(2, ts.syllableCount("solace")); + assert.equal(3, ts.syllableCount("soldiering")); + assert.equal(1, ts.syllableCount("solve")); + assert.equal(1, ts.syllableCount("solves")); + assert.equal(3, ts.syllableCount("somerville")); + assert.equal(3, ts.syllableCount("sommerville")); + assert.equal(1, ts.syllableCount("sonne")); + assert.equal(1, ts.syllableCount("soothe")); + assert.equal(1, ts.syllableCount("soothed")); + assert.equal(1, ts.syllableCount("soothes")); + assert.equal(2, ts.syllableCount("sorbonne")); + assert.equal(3, ts.syllableCount("sorcerer")); + assert.equal(3, ts.syllableCount("sorcerers")); + assert.equal(2, ts.syllableCount("sorice")); + assert.equal(4, ts.syllableCount("sotomayor")); + assert.equal(2, ts.syllableCount("sounded")); + assert.equal(2, ts.syllableCount("sources")); + assert.equal(3, ts.syllableCount("sourrouille")); + assert.equal(4, ts.syllableCount("sovetskaya")); + assert.equal(3, ts.syllableCount("soviet")); + assert.equal(6, ts.syllableCount("sovietologist")); + assert.equal(2, ts.syllableCount("soya")); + assert.equal(2, ts.syllableCount("soyars")); + assert.equal(2, ts.syllableCount("soysauce")); + assert.equal(2, ts.syllableCount("soyuz")); + assert.equal(2, ts.syllableCount("spaceport")); + assert.equal(2, ts.syllableCount("spaces")); + assert.equal(2, ts.syllableCount("spaceship")); + assert.equal(2, ts.syllableCount("spaceships")); + assert.equal(2, ts.syllableCount("spangled")); + assert.equal(2, ts.syllableCount("sparkled")); + assert.equal(2, ts.syllableCount("spasm")); + assert.equal(4, ts.syllableCount("specializes")); + assert.equal(2, ts.syllableCount("speckled")); + assert.equal(2, ts.syllableCount("spices")); + assert.equal(2, ts.syllableCount("splices")); + assert.equal(2, ts.syllableCount("spoilage")); + assert.equal(3, ts.syllableCount("spokeswoman")); + assert.equal(3, ts.syllableCount("spokewoman")); + assert.equal(2, ts.syllableCount("sponges")); + assert.equal(3, ts.syllableCount("sporleder")); + assert.equal(2, ts.syllableCount("spouses")); + assert.equal(3, ts.syllableCount("springerville")); + assert.equal(2, ts.syllableCount("sprinkled")); + assert.equal(2, ts.syllableCount("squabbled")); + assert.equal(2, ts.syllableCount("squillace")); + assert.equal(4, ts.syllableCount("stabilizes")); + assert.equal(2, ts.syllableCount("stacia")); + assert.equal(2, ts.syllableCount("stages")); + assert.equal(3, ts.syllableCount("staggering")); + assert.equal(3, ts.syllableCount("staircases")); + assert.equal(3, ts.syllableCount("stampeding")); + assert.equal(2, ts.syllableCount("stances")); + assert.equal(2, ts.syllableCount("stapled")); + assert.equal(2, ts.syllableCount("starches")); + assert.equal(1, ts.syllableCount("starnes")); + assert.equal(2, ts.syllableCount("statement")); + assert.equal(2, ts.syllableCount("statements")); + assert.equal(2, ts.syllableCount("stateside")); + assert.equal(4, ts.syllableCount("statistician")); + assert.equal(4, ts.syllableCount("statisticians")); + assert.equal(3, ts.syllableCount("stayover")); + assert.equal(3, ts.syllableCount("stayovers")); + assert.equal(3, ts.syllableCount("steakhouses")); + assert.equal(1, ts.syllableCount("stearne")); + assert.equal(2, ts.syllableCount("steenkiste")); + assert.equal(1, ts.syllableCount("stelle")); + assert.equal(3, ts.syllableCount("stephenville")); + assert.equal(3, ts.syllableCount("stereo")); + assert.equal(5, ts.syllableCount("stereographic")); + assert.equal(3, ts.syllableCount("stereos")); + assert.equal(4, ts.syllableCount("stereotype")); + assert.equal(4, ts.syllableCount("stereotyped")); + assert.equal(4, ts.syllableCount("stereotypes")); + assert.equal(6, ts.syllableCount("stereotypical")); + assert.equal(5, ts.syllableCount("stereotyping")); + assert.equal(4, ts.syllableCount("sterilizes")); + assert.equal(1, ts.syllableCount("sterne")); + assert.equal(3, ts.syllableCount("steubenville")); + assert.equal(2, ts.syllableCount("stifled")); + assert.equal(1, ts.syllableCount("stille")); + assert.equal(2, ts.syllableCount("stinnette")); + assert.equal(2, ts.syllableCount("stitches")); + assert.equal(4, ts.syllableCount("stockbrokerage")); + assert.equal(5, ts.syllableCount("stockbrokerages")); + assert.equal(4, ts.syllableCount("stolichnaya")); + assert.equal(1, ts.syllableCount("stolle")); + assert.equal(2, ts.syllableCount("stooges")); + assert.equal(2, ts.syllableCount("stoppage")); + assert.equal(3, ts.syllableCount("stoppages")); + assert.equal(3, ts.syllableCount("stopwatches")); + assert.equal(2, ts.syllableCount("storage")); + assert.equal(2, ts.syllableCount("straddled")); + assert.equal(2, ts.syllableCount("straddling")); + assert.equal(2, ts.syllableCount("straggled")); + assert.equal(2, ts.syllableCount("straitlaced")); + assert.equal(2, ts.syllableCount("stranded")); + assert.equal(2, ts.syllableCount("strangeness")); + assert.equal(2, ts.syllableCount("strangled")); + assert.equal(2, ts.syllableCount("stretches")); + assert.equal(1, ts.syllableCount("stromme")); + assert.equal(2, ts.syllableCount("struggled")); + assert.equal(2, ts.syllableCount("studded")); + assert.equal(2, ts.syllableCount("stumbled")); + assert.equal(2, ts.syllableCount("stumpage")); + assert.equal(2, ts.syllableCount("sturges")); + assert.equal(2, ts.syllableCount("stuteville")); + assert.equal(4, ts.syllableCount("subsidizes")); + assert.equal(3, ts.syllableCount("substances")); + assert.equal(3, ts.syllableCount("subsurface")); + assert.equal(3, ts.syllableCount("subterfuge")); + assert.equal(2, ts.syllableCount("suffice")); + assert.equal(2, ts.syllableCount("sufficed")); + assert.equal(3, ts.syllableCount("suffices")); + assert.equal(2, ts.syllableCount("suffrage")); + assert.equal(3, ts.syllableCount("suffragettes")); + assert.equal(4, ts.syllableCount("suggestiveness")); + assert.equal(4, ts.syllableCount("sugiyama")); + assert.equal(1, ts.syllableCount("suisse")); + assert.equal(3, ts.syllableCount("suitcases")); + assert.equal(4, ts.syllableCount("sukiyaki")); + assert.equal(4, ts.syllableCount("summarizes")); + assert.equal(3, ts.syllableCount("summerville")); + assert.equal(4, ts.syllableCount("superseding")); + assert.equal(4, ts.syllableCount("supervises")); + assert.equal(4, ts.syllableCount("supposedly")); + assert.equal(3, ts.syllableCount("supposes")); + assert.equal(3, ts.syllableCount("surcharges")); + assert.equal(2, ts.syllableCount("surette")); + assert.equal(2, ts.syllableCount("surface")); + assert.equal(2, ts.syllableCount("surfaced")); + assert.equal(3, ts.syllableCount("surfaceness")); + assert.equal(3, ts.syllableCount("surfaces")); + assert.equal(2, ts.syllableCount("surges")); + assert.equal(3, ts.syllableCount("surmises")); + assert.equal(3, ts.syllableCount("surpluses")); + assert.equal(3, ts.syllableCount("surprises")); + assert.equal(4, ts.syllableCount("surrealisms")); + assert.equal(2, ts.syllableCount("surrette")); + assert.equal(3, ts.syllableCount("surrounded")); + assert.equal(3, ts.syllableCount("surtaxes")); + assert.equal(3, ts.syllableCount("surveyor")); + assert.equal(3, ts.syllableCount("surveyors")); + assert.equal(2, ts.syllableCount("susanne")); + assert.equal(2, ts.syllableCount("susette")); + assert.equal(3, ts.syllableCount("suspended")); + assert.equal(2, ts.syllableCount("suzanne")); + assert.equal(2, ts.syllableCount("suzette")); + assert.equal(2, ts.syllableCount("sverige")); + assert.equal(3, ts.syllableCount("swaggering")); + assert.equal(2, ts.syllableCount("swatches")); + assert.equal(1, ts.syllableCount("swathed")); + assert.equal(2, ts.syllableCount("swinburnes")); + assert.equal(2, ts.syllableCount("swindled")); + assert.equal(2, ts.syllableCount("switches")); + assert.equal(2, ts.syllableCount("sybille")); + assert.equal(3, ts.syllableCount("symbion")); + assert.equal(4, ts.syllableCount("symbolizes")); + assert.equal(1, ts.syllableCount("symmes")); + assert.equal(4, ts.syllableCount("sympathizes")); + assert.equal(3, ts.syllableCount("syringes")); + assert.equal(2, ts.syllableCount("tableau")); + assert.equal(2, ts.syllableCount("tableaux")); + assert.equal(2, ts.syllableCount("tabled")); + assert.equal(2, ts.syllableCount("tackled")); + assert.equal(3, ts.syllableCount("tactician")); + assert.equal(3, ts.syllableCount("tacticians")); + assert.equal(3, ts.syllableCount("taddeo")); + assert.equal(3, ts.syllableCount("tafoya")); + assert.equal(2, ts.syllableCount("taiyo")); + assert.equal(5, ts.syllableCount("takashimaya")); + assert.equal(4, ts.syllableCount("takayama")); + assert.equal(3, ts.syllableCount("takeo")); + assert.equal(2, ts.syllableCount("talmage")); + assert.equal(3, ts.syllableCount("tamayo")); + assert.equal(2, ts.syllableCount("tangled")); + assert.equal(3, ts.syllableCount("tapering")); + assert.equal(2, ts.syllableCount("tasm")); + assert.equal(1, ts.syllableCount("taste")); + assert.equal(2, ts.syllableCount("tasteful")); + assert.equal(3, ts.syllableCount("tastefully")); + assert.equal(2, ts.syllableCount("tasteless")); + assert.equal(1, ts.syllableCount("tastes")); + assert.equal(3, ts.syllableCount("tauruses")); + assert.equal(2, ts.syllableCount("taxes")); + assert.equal(2, ts.syllableCount("teases")); + assert.equal(2, ts.syllableCount("tebeau")); + assert.equal(3, ts.syllableCount("technician")); + assert.equal(3, ts.syllableCount("technicians")); + assert.equal(2, ts.syllableCount("teenage")); + assert.equal(2, ts.syllableCount("teenaged")); + assert.equal(5, ts.syllableCount("telemanagement")); + assert.equal(5, ts.syllableCount("televideo")); + assert.equal(3, ts.syllableCount("telexes")); + assert.equal(1, ts.syllableCount("telles")); + assert.equal(1, ts.syllableCount("temme")); + assert.equal(2, ts.syllableCount("tended")); + assert.equal(2, ts.syllableCount("teo")); + assert.equal(4, ts.syllableCount("teodoro")); + assert.equal(4, ts.syllableCount("teriyaki")); + assert.equal(1, ts.syllableCount("ternes")); + assert.equal(2, ts.syllableCount("terrace")); + assert.equal(2, ts.syllableCount("terraced")); + assert.equal(3, ts.syllableCount("terraces")); + assert.equal(4, ts.syllableCount("terrorizes")); + assert.equal(3, ts.syllableCount("teruya")); + assert.equal(1, ts.syllableCount("teske")); + assert.equal(2, ts.syllableCount("tetreault")); + assert.equal(3, ts.syllableCount("thaddea")); + assert.equal(2, ts.syllableCount("thatches")); + assert.equal(2, ts.syllableCount("thebeau")); + assert.equal(2, ts.syllableCount("themselves")); + assert.equal(2, ts.syllableCount("theo")); + assert.equal(3, ts.syllableCount("theobald")); + assert.equal(4, ts.syllableCount("theocracy")); + assert.equal(4, ts.syllableCount("theocratic")); + assert.equal(3, ts.syllableCount("theodor")); + assert.equal(4, ts.syllableCount("theodora")); + assert.equal(3, ts.syllableCount("theodore")); + assert.equal(4, ts.syllableCount("theodorou")); + assert.equal(3, ts.syllableCount("theodric")); + assert.equal(3, ts.syllableCount("theola")); + assert.equal(5, ts.syllableCount("theologian")); + assert.equal(5, ts.syllableCount("theological")); + assert.equal(4, ts.syllableCount("theology")); + assert.equal(2, ts.syllableCount("theon")); + assert.equal(2, ts.syllableCount("theone")); + assert.equal(5, ts.syllableCount("theophania")); + assert.equal(4, ts.syllableCount("theophila")); + assert.equal(3, ts.syllableCount("theora")); + assert.equal(5, ts.syllableCount("theoretical")); + assert.equal(6, ts.syllableCount("theoretically")); + assert.equal(3, ts.syllableCount("theorist")); + assert.equal(3, ts.syllableCount("theorists")); + assert.equal(3, ts.syllableCount("theorize")); + assert.equal(3, ts.syllableCount("theorized")); + assert.equal(4, ts.syllableCount("theorizes")); + assert.equal(4, ts.syllableCount("theorizing")); + assert.equal(2, ts.syllableCount("theses")); + assert.equal(3, ts.syllableCount("thibadeau")); + assert.equal(2, ts.syllableCount("thibeau")); + assert.equal(2, ts.syllableCount("thibeault")); + assert.equal(2, ts.syllableCount("thibeaux")); + assert.equal(3, ts.syllableCount("thibedeau")); + assert.equal(3, ts.syllableCount("thibodeau")); + assert.equal(3, ts.syllableCount("thibodeaux")); + assert.equal(1, ts.syllableCount("thinnes")); + assert.equal(1, ts.syllableCount("thoennes")); + assert.equal(3, ts.syllableCount("thomases")); + assert.equal(3, ts.syllableCount("thomasville")); + assert.equal(2, ts.syllableCount("thoreau")); + assert.equal(1, ts.syllableCount("thorne")); + assert.equal(3, ts.syllableCount("thoroughbred")); + assert.equal(3, ts.syllableCount("throneberry")); + assert.equal(2, ts.syllableCount("tickled")); + assert.equal(1, ts.syllableCount("tilles")); + assert.equal(1, ts.syllableCount("timme")); + assert.equal(2, ts.syllableCount("tinkled")); + assert.equal(1, ts.syllableCount("tithe")); + assert.equal(3, ts.syllableCount("titusville")); + assert.equal(2, ts.syllableCount("toa")); + assert.equal(2, ts.syllableCount("toddling")); + assert.equal(1, ts.syllableCount("toelle")); + assert.equal(2, ts.syllableCount("toggled")); + assert.equal(2, ts.syllableCount("toggling")); + assert.equal(4, ts.syllableCount("tokuyama")); + assert.equal(4, ts.syllableCount("tolerances")); + assert.equal(1, ts.syllableCount("tolle")); + assert.equal(1, ts.syllableCount("tolles")); + assert.equal(3, ts.syllableCount("tomeo")); + assert.equal(2, ts.syllableCount("tondreau")); + assert.equal(2, ts.syllableCount("tonnage")); + assert.equal(3, ts.syllableCount("tonnages")); + assert.equal(1, ts.syllableCount("tonne")); + assert.equal(1, ts.syllableCount("tonnes")); + assert.equal(1, ts.syllableCount("toothed")); + assert.equal(2, ts.syllableCount("toothpaste")); + assert.equal(2, ts.syllableCount("toothpastes")); + assert.equal(2, ts.syllableCount("toppled")); + assert.equal(2, ts.syllableCount("torches")); + assert.equal(3, ts.syllableCount("torosian")); + assert.equal(3, ts.syllableCount("torreon")); + assert.equal(4, ts.syllableCount("torsiello")); + assert.equal(3, ts.syllableCount("tortoises")); + assert.equal(3, ts.syllableCount("tortorice")); + assert.equal(5, ts.syllableCount("tortoriello")); + assert.equal(4, ts.syllableCount("toshiyuki")); + assert.equal(1, ts.syllableCount("toste")); + assert.equal(2, ts.syllableCount("touchette")); + assert.equal(3, ts.syllableCount("tourangeau")); + assert.equal(2, ts.syllableCount("tourville")); + assert.equal(3, ts.syllableCount("towering")); + assert.equal(3, ts.syllableCount("townhouses")); + assert.equal(3, ts.syllableCount("toyama")); + assert.equal(2, ts.syllableCount("toyo")); + assert.equal(3, ts.syllableCount("toyobo")); + assert.equal(3, ts.syllableCount("toyoda")); + assert.equal(2, ts.syllableCount("toyoo")); + assert.equal(3, ts.syllableCount("toyota")); + assert.equal(3, ts.syllableCount("toyotas")); + assert.equal(2, ts.syllableCount("traces")); + assert.equal(4, ts.syllableCount("tracheophytes")); + assert.equal(2, ts.syllableCount("trackage")); + assert.equal(3, ts.syllableCount("trageser")); + assert.equal(2, ts.syllableCount("trampled")); + assert.equal(3, ts.syllableCount("transcended")); + assert.equal(3, ts.syllableCount("transimage")); + assert.equal(3, ts.syllableCount("treatises")); + assert.equal(2, ts.syllableCount("trebled")); + assert.equal(2, ts.syllableCount("trefgarne")); + assert.equal(2, ts.syllableCount("treharne")); + assert.equal(2, ts.syllableCount("trembled")); + assert.equal(2, ts.syllableCount("trended")); + assert.equal(2, ts.syllableCount("treon")); + assert.equal(2, ts.syllableCount("triage")); + assert.equal(2, ts.syllableCount("tricia")); + assert.equal(2, ts.syllableCount("trickled")); + assert.equal(1, ts.syllableCount("trieste")); + assert.equal(3, ts.syllableCount("triggering")); + assert.equal(2, ts.syllableCount("tripled")); + assert.equal(2, ts.syllableCount("trivette")); + assert.equal(5, ts.syllableCount("trivializes")); + assert.equal(2, ts.syllableCount("troubled")); + assert.equal(2, ts.syllableCount("troyan")); + assert.equal(3, ts.syllableCount("troyanos")); + assert.equal(2, ts.syllableCount("troyat")); + assert.equal(2, ts.syllableCount("troyu")); + assert.equal(2, ts.syllableCount("trudeau")); + assert.equal(2, ts.syllableCount("trudges")); + assert.equal(2, ts.syllableCount("trundled")); + assert.equal(2, ts.syllableCount("tryart")); + assert.equal(1, ts.syllableCount("tsiang")); + assert.equal(3, ts.syllableCount("tsuneo")); + assert.equal(3, ts.syllableCount("tuberville")); + assert.equal(2, ts.syllableCount("tumbled")); + assert.equal(3, ts.syllableCount("tunisian")); + assert.equal(3, ts.syllableCount("turberville")); + assert.equal(4, ts.syllableCount("turbocharges")); + assert.equal(2, ts.syllableCount("turenne")); + assert.equal(2, ts.syllableCount("turnage")); + assert.equal(2, ts.syllableCount("turville")); + assert.equal(2, ts.syllableCount("tussled")); + assert.equal(3, ts.syllableCount("tutelage")); + assert.equal(1, ts.syllableCount("twelve")); + assert.equal(2, ts.syllableCount("twitches")); + assert.equal(2, ts.syllableCount("udelle")); + assert.equal(3, ts.syllableCount("ulloa")); + assert.equal(2, ts.syllableCount("umbrage")); + assert.equal(5, ts.syllableCount("unabashedly")); + assert.equal(3, ts.syllableCount("unabridged")); + assert.equal(4, ts.syllableCount("unacknowledged")); + assert.equal(4, ts.syllableCount("unamended")); + assert.equal(3, ts.syllableCount("unannounced")); + assert.equal(3, ts.syllableCount("unattached")); + assert.equal(4, ts.syllableCount("unattended")); + assert.equal(3, ts.syllableCount("unbalanced")); + assert.equal(3, ts.syllableCount("unbounded")); + assert.equal(3, ts.syllableCount("unbranded")); + assert.equal(3, ts.syllableCount("unbridled")); + assert.equal(3, ts.syllableCount("unchallenged")); + assert.equal(2, ts.syllableCount("unchanged")); + assert.equal(5, ts.syllableCount("uncontroversial")); + assert.equal(3, ts.syllableCount("unconvinced")); + assert.equal(4, ts.syllableCount("uncovering")); + assert.equal(3, ts.syllableCount("undamaged")); + assert.equal(3, ts.syllableCount("underage")); + assert.equal(4, ts.syllableCount("underfinanced")); + assert.equal(4, ts.syllableCount("underfunded")); + assert.equal(4, ts.syllableCount("underhanded")); + assert.equal(3, ts.syllableCount("underprice")); + assert.equal(3, ts.syllableCount("underpriced")); + assert.equal(4, ts.syllableCount("understatement")); + assert.equal(5, ts.syllableCount("unemployable")); + assert.equal(2, ts.syllableCount("unfenced")); + assert.equal(3, ts.syllableCount("unfolded")); + assert.equal(3, ts.syllableCount("unfounded")); + assert.equal(3, ts.syllableCount("unfunded")); + assert.equal(4, ts.syllableCount("Ungeheuer")); + assert.equal(3, ts.syllableCount("ungerer")); + assert.equal(3, ts.syllableCount("unguarded")); + assert.equal(2, ts.syllableCount("unhedged")); + assert.equal(4, ts.syllableCount("unheralded")); + assert.equal(2, ts.syllableCount("unhinged")); + assert.equal(4, ts.syllableCount("unintended")); + assert.equal(3, ts.syllableCount("unionfed")); + assert.equal(4, ts.syllableCount("uniroyal")); + assert.equal(3, ts.syllableCount("unmanage")); + assert.equal(3, ts.syllableCount("unmanaged")); + assert.equal(3, ts.syllableCount("unnoticed")); + assert.equal(4, ts.syllableCount("unpayable")); + assert.equal(2, ts.syllableCount("unplaced")); + assert.equal(4, ts.syllableCount("unprincipled")); + assert.equal(5, ts.syllableCount("unreality")); + assert.equal(4, ts.syllableCount("unrealized")); + assert.equal(4, ts.syllableCount("unrecorded")); + assert.equal(3, ts.syllableCount("unruffled")); + assert.equal(2, ts.syllableCount("unscathed")); + assert.equal(3, ts.syllableCount("unshackled")); + assert.equal(2, ts.syllableCount("untouched")); + assert.equal(3, ts.syllableCount("untroubled")); + assert.equal(4, ts.syllableCount("unwavering")); + assert.equal(3, ts.syllableCount("upended")); + assert.equal(2, ts.syllableCount("upstage")); + assert.equal(2, ts.syllableCount("upstaged")); + assert.equal(2, ts.syllableCount("Ural")); + assert.equal(2, ts.syllableCount("urges")); + assert.equal(2, ts.syllableCount("Urquart")); + assert.equal(4, ts.syllableCount("uruguayan")); + assert.equal(2, ts.syllableCount("usage")); + assert.equal(3, ts.syllableCount("usages")); + assert.equal(2, ts.syllableCount("uses")); + assert.equal(1, ts.syllableCount("uthe")); + assert.equal(4, ts.syllableCount("utilizes")); + assert.equal(2, ts.syllableCount("Uttar")); + assert.equal(4, ts.syllableCount("utterances")); + assert.equal(3, ts.syllableCount("uyeda")); + assert.equal(4, ts.syllableCount("uyehara")); + assert.equal(3, ts.syllableCount("uyeno")); + assert.equal(2, ts.syllableCount("Uzis")); + assert.equal(3, ts.syllableCount("vacaville")); + assert.equal(3, ts.syllableCount("valeo")); + assert.equal(1, ts.syllableCount("valle")); + assert.equal(2, ts.syllableCount("valleau")); + assert.equal(2, ts.syllableCount("vallely")); + assert.equal(1, ts.syllableCount("valles")); + assert.equal(2, ts.syllableCount("vallette")); + assert.equal(1, ts.syllableCount("valve")); + assert.equal(1, ts.syllableCount("valves")); + assert.equal(2, ts.syllableCount("vanasse")); + assert.equal(2, ts.syllableCount("vandamme")); + assert.equal(3, ts.syllableCount("vanderslice")); + assert.equal(3, ts.syllableCount("vandewalle")); + assert.equal(2, ts.syllableCount("vanhorne")); + assert.equal(3, ts.syllableCount("vannguyen")); + assert.equal(2, ts.syllableCount("vannice")); + assert.equal(3, ts.syllableCount("vanscoyoc")); + assert.equal(2, ts.syllableCount("vantage")); + assert.equal(3, ts.syllableCount("vantages")); + assert.equal(4, ts.syllableCount("variances")); + assert.equal(1, ts.syllableCount("varnes")); + assert.equal(1, ts.syllableCount("varves")); + assert.equal(2, ts.syllableCount("vases")); + assert.equal(1, ts.syllableCount("vaske")); + assert.equal(2, ts.syllableCount("vaudeville")); + assert.equal(2, ts.syllableCount("vaxes")); + assert.equal(2, ts.syllableCount("vedette")); + assert.equal(2, ts.syllableCount("veillette")); + assert.equal(4, ts.syllableCount("velayati")); + assert.equal(4, ts.syllableCount("venereal")); + assert.equal(2, ts.syllableCount("venice")); + assert.equal(1, ts.syllableCount("venne")); + assert.equal(3, ts.syllableCount("venturesome")); + assert.equal(3, ts.syllableCount("verbiage")); + assert.equal(2, ts.syllableCount("verges")); + assert.equal(2, ts.syllableCount("verhage")); + assert.equal(2, ts.syllableCount("vermette")); + assert.equal(1, ts.syllableCount("verne")); + assert.equal(1, ts.syllableCount("vernes")); + assert.equal(2, ts.syllableCount("verrette")); + assert.equal(2, ts.syllableCount("versace")); + assert.equal(2, ts.syllableCount("versailles")); + assert.equal(2, ts.syllableCount("verville")); + assert.equal(2, ts.syllableCount("vestige")); + assert.equal(3, ts.syllableCount("vestiges")); + assert.equal(1, ts.syllableCount("vette")); + assert.equal(2, ts.syllableCount("vices")); + assert.equal(3, ts.syllableCount("video")); + assert.equal(4, ts.syllableCount("videodisk")); + assert.equal(4, ts.syllableCount("videodisks")); + assert.equal(4, ts.syllableCount("videogame")); + assert.equal(4, ts.syllableCount("videophone")); + assert.equal(3, ts.syllableCount("videos")); + assert.equal(4, ts.syllableCount("videotape")); + assert.equal(4, ts.syllableCount("videotaped")); + assert.equal(4, ts.syllableCount("videotapes")); + assert.equal(5, ts.syllableCount("videotaping")); + assert.equal(4, ts.syllableCount("videotex")); + assert.equal(4, ts.syllableCount("videotext")); + assert.equal(4, ts.syllableCount("videotron")); + assert.equal(2, ts.syllableCount("vienneau")); + assert.equal(2, ts.syllableCount("viet")); + assert.equal(2, ts.syllableCount("vigneau")); + assert.equal(2, ts.syllableCount("vigneault")); + assert.equal(2, ts.syllableCount("vignette")); + assert.equal(2, ts.syllableCount("vignettes")); + assert.equal(2, ts.syllableCount("village")); + assert.equal(3, ts.syllableCount("villages")); + assert.equal(4, ts.syllableCount("villareal")); + assert.equal(1, ts.syllableCount("ville")); + assert.equal(2, ts.syllableCount("villette")); + assert.equal(3, ts.syllableCount("vincelette")); + assert.equal(4, ts.syllableCount("vindictiveness")); + assert.equal(2, ts.syllableCount("vingmed")); + assert.equal(2, ts.syllableCount("vintage")); + assert.equal(3, ts.syllableCount("vintages")); + assert.equal(4, ts.syllableCount("violation")); + assert.equal(3, ts.syllableCount("violette")); + assert.equal(3, ts.syllableCount("viruses")); + assert.equal(2, ts.syllableCount("visage")); + assert.equal(4, ts.syllableCount("vitiello")); + assert.equal(3, ts.syllableCount("viverette")); + assert.equal(3, ts.syllableCount("viyella")); + assert.equal(3, ts.syllableCount("vizcaya")); + assert.equal(2, ts.syllableCount("voges")); + assert.equal(2, ts.syllableCount("voiceless")); + assert.equal(2, ts.syllableCount("voices")); + assert.equal(1, ts.syllableCount("volle")); + assert.equal(2, ts.syllableCount("voltage")); + assert.equal(3, ts.syllableCount("voltages")); + assert.equal(2, ts.syllableCount("voyage")); + assert.equal(2, ts.syllableCount("voyaged")); + assert.equal(3, ts.syllableCount("voyager")); + assert.equal(3, ts.syllableCount("voyagers")); + assert.equal(3, ts.syllableCount("voyages")); + assert.equal(2, ts.syllableCount("voyeur")); + assert.equal(4, ts.syllableCount("voyeurism")); + assert.equal(3, ts.syllableCount("vremya")); + assert.equal(2, ts.syllableCount("wadded")); + assert.equal(2, ts.syllableCount("waffled")); + assert.equal(2, ts.syllableCount("waffling")); + assert.equal(3, ts.syllableCount("wagering")); + assert.equal(2, ts.syllableCount("wages")); + assert.equal(5, ts.syllableCount("wakabayashi")); + assert.equal(2, ts.syllableCount("wallace")); + assert.equal(1, ts.syllableCount("walle")); + assert.equal(1, ts.syllableCount("walles")); + assert.equal(4, ts.syllableCount("wallpapering")); + assert.equal(3, ts.syllableCount("walruses")); + assert.equal(2, ts.syllableCount("wangled")); + assert.equal(2, ts.syllableCount("wantage")); + assert.equal(3, ts.syllableCount("wantages")); + assert.equal(2, ts.syllableCount("warded")); + assert.equal(2, ts.syllableCount("warehime")); + assert.equal(2, ts.syllableCount("warehouse")); + assert.equal(3, ts.syllableCount("warehousing")); + assert.equal(4, ts.syllableCount("warmongering")); + assert.equal(1, ts.syllableCount("warne")); + assert.equal(1, ts.syllableCount("warnes")); + assert.equal(2, ts.syllableCount("washburne")); + assert.equal(3, ts.syllableCount("wasmer")); + assert.equal(1, ts.syllableCount("waste")); + assert.equal(2, ts.syllableCount("wasteful")); + assert.equal(1, ts.syllableCount("wastes")); + assert.equal(2, ts.syllableCount("watches")); + assert.equal(3, ts.syllableCount("waterbed")); + assert.equal(3, ts.syllableCount("waterborne")); + assert.equal(3, ts.syllableCount("watsonville")); + assert.equal(3, ts.syllableCount("wavering")); + assert.equal(2, ts.syllableCount("waxes")); + assert.equal(2, ts.syllableCount("Wayans")); + assert.equal(2, ts.syllableCount("waynesville")); + assert.equal(2, ts.syllableCount("wedded")); + assert.equal(2, ts.syllableCount("wedges")); + assert.equal(1, ts.syllableCount("weisse")); + assert.equal(2, ts.syllableCount("welborne")); + assert.equal(2, ts.syllableCount("welded")); + assert.equal(1, ts.syllableCount("welle")); + assert.equal(1, ts.syllableCount("welles")); + assert.equal(2, ts.syllableCount("wentzville")); + assert.equal(2, ts.syllableCount("wernette")); + assert.equal(3, ts.syllableCount("wesleyan")); + assert.equal(2, ts.syllableCount("westburne")); + assert.equal(4, ts.syllableCount("westfaelisches")); + assert.equal(2, ts.syllableCount("weyand")); + assert.equal(2, ts.syllableCount("weyandt")); + assert.equal(2, ts.syllableCount("weyant")); + assert.equal(3, ts.syllableCount("whampoa")); + assert.equal(2, ts.syllableCount("wheezes")); + assert.equal(2, ts.syllableCount("whiteness")); + assert.equal(2, ts.syllableCount("whiteside")); + assert.equal(2, ts.syllableCount("whitesides")); + assert.equal(2, ts.syllableCount("whittling")); + assert.equal(2, ts.syllableCount("wholesome")); + assert.equal(2, ts.syllableCount("wicked")); + assert.equal(3, ts.syllableCount("wickedly")); + assert.equal(2, ts.syllableCount("wielded")); + assert.equal(2, ts.syllableCount("wilbourne")); + assert.equal(3, ts.syllableCount("willabelle")); + assert.equal(3, ts.syllableCount("willamette")); + assert.equal(1, ts.syllableCount("wille")); + assert.equal(1, ts.syllableCount("willes")); + assert.equal(2, ts.syllableCount("willette")); + assert.equal(2, ts.syllableCount("wilmette")); + assert.equal(2, ts.syllableCount("winborne")); + assert.equal(2, ts.syllableCount("winded")); + assert.equal(1, ts.syllableCount("winne")); + assert.equal(3, ts.syllableCount("winterbourne")); + assert.equal(2, ts.syllableCount("wion")); + assert.equal(2, ts.syllableCount("witches")); + assert.equal(2, ts.syllableCount("wobbled")); + assert.equal(1, ts.syllableCount("woeste")); + assert.equal(1, ts.syllableCount("wolle")); + assert.equal(1, ts.syllableCount("wolves")); + assert.equal(2, ts.syllableCount("worded")); + assert.equal(2, ts.syllableCount("workplace")); + assert.equal(3, ts.syllableCount("workplaces")); + assert.equal(2, ts.syllableCount("wounded")); + assert.equal(2, ts.syllableCount("wrangled")); + assert.equal(2, ts.syllableCount("wreckage")); + assert.equal(2, ts.syllableCount("wretched")); + assert.equal(3, ts.syllableCount("wretchedly")); + assert.equal(2, ts.syllableCount("wrinkled")); + assert.equal(3, ts.syllableCount("wristwatches")); + assert.equal(2, ts.syllableCount("wyand")); + assert.equal(2, ts.syllableCount("wyant")); + assert.equal(2, ts.syllableCount("wyatt")); + assert.equal(2, ts.syllableCount("wyeth")); + assert.equal(1, ts.syllableCount("wynne")); + assert.equal(1, ts.syllableCount("wythe")); + assert.equal(3, ts.syllableCount("xinhua")); + assert.equal(3, ts.syllableCount("Yanayev")); + assert.equal(2, ts.syllableCount("yardage")); + assert.equal(4, ts.syllableCount("yasuyoshi")); + assert.equal(1, ts.syllableCount("yelle")); + assert.equal(2, ts.syllableCount("yeo")); + assert.equal(2, ts.syllableCount("yeses")); + assert.equal(1, ts.syllableCount("yeske")); + assert.equal(2, ts.syllableCount("yevette")); + assert.equal(2, ts.syllableCount("yielded")); + assert.equal(1, ts.syllableCount("ying")); + assert.equal(2, ts.syllableCount("yinger")); + assert.equal(2, ts.syllableCount("yodice")); + assert.equal(2, ts.syllableCount("yohe")); + assert.equal(4, ts.syllableCount("yokoyama")); + assert.equal(4, ts.syllableCount("yoneyama")); + assert.equal(2, ts.syllableCount("yourselves")); + assert.equal(2, ts.syllableCount("youville")); + assert.equal(1, ts.syllableCount("yuille")); + assert.equal(2, ts.syllableCount("yvette")); + assert.equal(2, ts.syllableCount("yvonne")); + assert.equal(3, ts.syllableCount("zanoyan")); + assert.equal(1, ts.syllableCount("zaske")); + assert.equal(4, ts.syllableCount("zaslavskaya")); + assert.equal(2, ts.syllableCount("zayac")); + assert.equal(2, ts.syllableCount("zayas")); + assert.equal(3, ts.syllableCount("zeebrugge")); + assert.equal(2, ts.syllableCount("zegeer")); + assert.equal(3, ts.syllableCount("zelaya")); + assert.equal(1, ts.syllableCount("zelle")); + assert.equal(3, ts.syllableCount("zeoli")); + assert.equal(2, ts.syllableCount("zeos")); + assert.equal(1, ts.syllableCount("zieske")); + assert.equal(2, ts.syllableCount("zion")); + assert.equal(4, ts.syllableCount("zionism")); + assert.equal(3, ts.syllableCount("zionist")); + assert.equal(3, ts.syllableCount("zionists")); + assert.equal(2, ts.syllableCount("zions")); + assert.equal(2, ts.syllableCount("zises")); + assert.equal(2, ts.syllableCount("ziyad")); + assert.equal(2, ts.syllableCount("ziyang")); + assert.equal(4, ts.syllableCount("zoologist")); + assert.equal(4, ts.syllableCount("zoology")); + assert.equal(1, ts.syllableCount("zornes")); + }); +}); +// Stop here and mark this test as incomplete. +describe.skip('incomplete', function(){ + it('Tests above this line are expected to pass. Tests after this line'+ + 'may fail due to code issues, or due to the test being incorrect..',function(){ + + assert.equal(2, ts.syllableCount("aguiar")); + assert.equal(5, ts.syllableCount("aguinaga")); + assert.equal(2, ts.syllableCount("ahmed")); + assert.equal(3, ts.syllableCount("aichi")); + assert.equal(3, ts.syllableCount("aida")); + assert.equal(3, ts.syllableCount("aidan")); + assert.equal(3, ts.syllableCount("aikin")); + assert.equal(2, ts.syllableCount("airedale")); + assert.equal(2, ts.syllableCount("aires")); + assert.equal(1, ts.syllableCount("aithne")); + assert.equal(3, ts.syllableCount("aiton")); + assert.equal(4, ts.syllableCount("albanese")); + assert.equal(3, ts.syllableCount("albea")); + assert.equal(3, ts.syllableCount("albeit")); + assert.equal(3, ts.syllableCount("albemarle")); + assert.equal(4, ts.syllableCount("alchemically")); + assert.equal(3, ts.syllableCount("aldape")); + assert.equal(1, ts.syllableCount("aldys")); + assert.equal(5, ts.syllableCount("aleatory")); + assert.equal(2, ts.syllableCount("alehouse")); + assert.equal(4, ts.syllableCount("aleksandr")); + assert.equal(2, ts.syllableCount("aleman")); + assert.equal(4, ts.syllableCount("aleshire")); + assert.equal(4, ts.syllableCount("alethea")); + assert.equal(2, ts.syllableCount("alewife")); + assert.equal(2, ts.syllableCount("alewine")); + assert.equal(2, ts.syllableCount("alewives")); + assert.equal(4, ts.syllableCount("alfiero")); + assert.equal(2, ts.syllableCount("alfonse")); + assert.equal(4, ts.syllableCount("alfonsine")); + assert.equal(2, ts.syllableCount("alfred")); + assert.equal(4, ts.syllableCount("algebraic")); + assert.equal(2, ts.syllableCount("algiers")); + assert.equal(4, ts.syllableCount("algonquian")); + assert.equal(4, ts.syllableCount("algorithms")); + assert.equal(3, ts.syllableCount("alguire")); + assert.equal(4, ts.syllableCount("alicea")); + assert.equal(3, ts.syllableCount("alienate")); + assert.equal(3, ts.syllableCount("alire")); + assert.equal(4, ts.syllableCount("allegedly")); + assert.equal(3, ts.syllableCount("allegiance")); + assert.equal(2, ts.syllableCount("alleman")); + assert.equal(4, ts.syllableCount("allender")); + assert.equal(3, ts.syllableCount("almaguer")); + assert.equal(3, ts.syllableCount("aloia")); + assert.equal(4, ts.syllableCount("aloisia")); + assert.equal(4, ts.syllableCount("aloysia")); + assert.equal(5, ts.syllableCount("alphabetically")); + assert.equal(2, ts.syllableCount("alphonse")); + assert.equal(3, ts.syllableCount("altaic")); + assert.equal(3, ts.syllableCount("althea")); + assert.equal(4, ts.syllableCount("altomare")); + assert.equal(4, ts.syllableCount("altruism")); + assert.equal(4, ts.syllableCount("altruistic")); + assert.equal(3, ts.syllableCount("alvares")); + assert.equal(4, ts.syllableCount("alysia")); + assert.equal(4, ts.syllableCount("amadeus")); + assert.equal(4, ts.syllableCount("amalea")); + assert.equal(3, ts.syllableCount("amalia")); + assert.equal(3, ts.syllableCount("ambience")); + assert.equal(3, ts.syllableCount("ambient")); + assert.equal(5, ts.syllableCount("ambiguities")); + assert.equal(3, ts.syllableCount("ambitious")); + assert.equal(4, ts.syllableCount("ambitiously")); + assert.equal(2, ts.syllableCount("ambler")); + assert.equal(4, ts.syllableCount("ambrosine")); + assert.equal(3, ts.syllableCount("amelia")); + assert.equal(4, ts.syllableCount("ameline")); + assert.equal(4, ts.syllableCount("ameliorate")); + assert.equal(4, ts.syllableCount("amerine")); + assert.equal(3, ts.syllableCount("ammonia")); + assert.equal(5, ts.syllableCount("amphitheater")); + assert.equal(5, ts.syllableCount("amphitheaters")); + assert.equal(5, ts.syllableCount("amphitheatre")); + assert.equal(3, ts.syllableCount("amrhein")); + assert.equal(5, ts.syllableCount("amyotrophic")); + assert.equal(5, ts.syllableCount("anachronisms")); + assert.equal(5, ts.syllableCount("anacostia")); + assert.equal(3, ts.syllableCount("analogue")); + assert.equal(5, ts.syllableCount("analytically")); + assert.equal(5, ts.syllableCount("anatomically")); + assert.equal(3, ts.syllableCount("andean")); + assert.equal(3, ts.syllableCount("andrea")); + assert.equal(3, ts.syllableCount("andreas")); + assert.equal(4, ts.syllableCount("andreini")); + assert.equal(3, ts.syllableCount("andren")); + assert.equal(3, ts.syllableCount("angeles")); + assert.equal(4, ts.syllableCount("angelically")); + assert.equal(4, ts.syllableCount("angelone")); + assert.equal(3, ts.syllableCount("anglen")); + assert.equal(3, ts.syllableCount("angove")); + assert.equal(4, ts.syllableCount("anguiano")); + assert.equal(3, ts.syllableCount("annese")); + assert.equal(4, ts.syllableCount("annuities")); + assert.equal(4, ts.syllableCount("annunciata")); + assert.equal(3, ts.syllableCount("anreder")); + assert.equal(1, ts.syllableCount("anse")); + assert.equal(3, ts.syllableCount("anstine")); + assert.equal(5, ts.syllableCount("antagonisms")); + assert.equal(3, ts.syllableCount("antares")); + assert.equal(2, ts.syllableCount("antenne")); + assert.equal(3, ts.syllableCount("anthea")); + assert.equal(1, ts.syllableCount("anthes")); + assert.equal(3, ts.syllableCount("anthiel")); + assert.equal(4, ts.syllableCount("antigone")); + assert.equal(4, ts.syllableCount("antigones")); + assert.equal(5, ts.syllableCount("antinuclear")); + assert.equal(2, ts.syllableCount("antique")); + assert.equal(2, ts.syllableCount("antiques")); + assert.equal(4, ts.syllableCount("antiquity")); + assert.equal(3, ts.syllableCount("antisense")); + assert.equal(3, ts.syllableCount("antone")); + assert.equal(3, ts.syllableCount("antunes")); + assert.equal(4, ts.syllableCount("anxieties")); + assert.equal(4, ts.syllableCount("anxiety")); + assert.equal(2, ts.syllableCount("anxious")); + assert.equal(3, ts.syllableCount("anxiously")); + assert.equal(3, ts.syllableCount("anyon")); + assert.equal(3, ts.syllableCount("anyone")); + assert.equal(3, ts.syllableCount("aoki")); + assert.equal(2, ts.syllableCount("aon")); + assert.equal(3, ts.syllableCount("aorta")); + assert.equal(3, ts.syllableCount("apache")); + assert.equal(3, ts.syllableCount("apaches")); + assert.equal(2, ts.syllableCount("apelike")); + assert.equal(4, ts.syllableCount("aphorisms")); + assert.equal(4, ts.syllableCount("aphrodites")); + assert.equal(3, ts.syllableCount("apnea")); + assert.equal(4, ts.syllableCount("apocalypse")); + assert.equal(6, ts.syllableCount("apologetically")); + assert.equal(4, ts.syllableCount("appalachian")); + assert.equal(4, ts.syllableCount("appalachians")); + assert.equal(4, ts.syllableCount("appreciable")); + assert.equal(4, ts.syllableCount("appreciably")); + assert.equal(3, ts.syllableCount("aprea")); + assert.equal(2, ts.syllableCount("aquirre")); + assert.equal(3, ts.syllableCount("arabe")); + assert.equal(3, ts.syllableCount("arai")); + assert.equal(4, ts.syllableCount("arakelian")); + assert.equal(2, ts.syllableCount("aravind")); + assert.equal(3, ts.syllableCount("archaic")); + assert.equal(3, ts.syllableCount("archetypal")); + assert.equal(3, ts.syllableCount("archibeque")); + assert.equal(4, ts.syllableCount("archimedes")); + assert.equal(3, ts.syllableCount("ardine")); + assert.equal(4, ts.syllableCount("arduini")); + assert.equal(3, ts.syllableCount("area")); + assert.equal(3, ts.syllableCount("areas")); + assert.equal(4, ts.syllableCount("arguable")); + assert.equal(4, ts.syllableCount("arguably")); + assert.equal(3, ts.syllableCount("ariel")); + assert.equal(4, ts.syllableCount("armbrister")); + assert.equal(1, ts.syllableCount("armes")); + assert.equal(3, ts.syllableCount("armine")); + assert.equal(3, ts.syllableCount("arnone")); + assert.equal(2, ts.syllableCount("arquette")); + assert.equal(3, ts.syllableCount("arrieta")); + assert.equal(3, ts.syllableCount("artale")); + assert.equal(2, ts.syllableCount("artcarved")); + assert.equal(4, ts.syllableCount("artistically")); + assert.equal(2, ts.syllableCount("ascii")); + assert.equal(3, ts.syllableCount("asea")); + assert.equal(3, ts.syllableCount("asean")); + assert.equal(4, ts.syllableCount("aseltine")); + assert.equal(1, ts.syllableCount("ashe")); + assert.equal(2, ts.syllableCount("asheville")); + assert.equal(3, ts.syllableCount("asiel")); + assert.equal(3, ts.syllableCount("askren")); + assert.equal(3, ts.syllableCount("aspires")); + assert.equal(2, ts.syllableCount("aspirin")); + assert.equal(3, ts.syllableCount("assembler")); + assert.equal(3, ts.syllableCount("assemblers")); + assert.equal(7, ts.syllableCount("assicurazioni")); + assert.equal(3, ts.syllableCount("assiduous")); + assert.equal(4, ts.syllableCount("assiduously")); + assert.equal(4, ts.syllableCount("assuredly")); + assert.equal(6, ts.syllableCount("astrogeology")); + assert.equal(5, ts.syllableCount("astronomically")); + assert.equal(3, ts.syllableCount("atheist")); + assert.equal(4, ts.syllableCount("atheistic")); + assert.equal(3, ts.syllableCount("atheists")); + assert.equal(4, ts.syllableCount("athenaios")); + assert.equal(4, ts.syllableCount("athletically")); + assert.equal(3, ts.syllableCount("attache")); + assert.equal(3, ts.syllableCount("attaches")); + assert.equal(3, ts.syllableCount("atteberry")); + assert.equal(3, ts.syllableCount("attebury")); + assert.equal(3, ts.syllableCount("attire")); + assert.equal(3, ts.syllableCount("audrie")); + assert.equal(1, ts.syllableCount("aue")); + assert.equal(2, ts.syllableCount("auerback")); + assert.equal(2, ts.syllableCount("aug")); + assert.equal(3, ts.syllableCount("aurea")); + assert.equal(3, ts.syllableCount("australia")); + assert.equal(3, ts.syllableCount("australian")); + assert.equal(3, ts.syllableCount("australians")); + assert.equal(6, ts.syllableCount("austroasiatic")); + assert.equal(4, ts.syllableCount("authentically")); + assert.equal(5, ts.syllableCount("automatically")); + assert.equal(5, ts.syllableCount("automoviles")); + assert.equal(4, ts.syllableCount("auxiliary")); + assert.equal(3, ts.syllableCount("ave")); + assert.equal(4, ts.syllableCount("aveline")); + assert.equal(3, ts.syllableCount("aven")); + assert.equal(3, ts.syllableCount("averages")); + assert.equal(3, ts.syllableCount("averaging")); + assert.equal(6, ts.syllableCount("aviazione")); + assert.equal(3, ts.syllableCount("aviles")); + assert.equal(4, ts.syllableCount("avionic")); + assert.equal(4, ts.syllableCount("avionics")); + assert.equal(3, ts.syllableCount("avions")); + assert.equal(2, ts.syllableCount("awesome")); + assert.equal(2, ts.syllableCount("awestruck")); + assert.equal(2, ts.syllableCount("awfully")); + assert.equal(3, ts.syllableCount("aydelotte")); + assert.equal(3, ts.syllableCount("ayodhya")); + assert.equal(2, ts.syllableCount("babblers")); + assert.equal(3, ts.syllableCount("babyish")); + assert.equal(5, ts.syllableCount("baccalaureate")); + assert.equal(4, ts.syllableCount("bacchanalia")); + assert.equal(2, ts.syllableCount("bachelors")); + assert.equal(1, ts.syllableCount("backe")); + assert.equal(1, ts.syllableCount("backes")); + assert.equal(3, ts.syllableCount("backfired")); + assert.equal(3, ts.syllableCount("backfires")); + assert.equal(4, ts.syllableCount("backfiring")); + assert.equal(2, ts.syllableCount("backlogged")); + assert.equal(1, ts.syllableCount("baer")); + assert.equal(2, ts.syllableCount("baez")); + assert.equal(1, ts.syllableCount("bahre")); + assert.equal(3, ts.syllableCount("baidoan")); + assert.equal(3, ts.syllableCount("baidoans")); + assert.equal(3, ts.syllableCount("baidoas")); + assert.equal(2, ts.syllableCount("baiul")); + assert.equal(2, ts.syllableCount("bakeman")); + assert.equal(2, ts.syllableCount("bakeware")); + assert.equal(2, ts.syllableCount("bakewell")); + assert.equal(1, ts.syllableCount("bakke")); + assert.equal(3, ts.syllableCount("balaguer")); + assert.equal(4, ts.syllableCount("baldassare")); + assert.equal(4, ts.syllableCount("balentine")); + assert.equal(1, ts.syllableCount("balfe")); + assert.equal(3, ts.syllableCount("baliles")); + assert.equal(1, ts.syllableCount("balke")); + assert.equal(4, ts.syllableCount("ballentine")); + assert.equal(3, ts.syllableCount("ballyhooed")); + assert.equal(1, ts.syllableCount("baltes")); + assert.equal(3, ts.syllableCount("bandolier")); + assert.equal(3, ts.syllableCount("bandoliers")); + assert.equal(3, ts.syllableCount("banjoist")); + assert.equal(1, ts.syllableCount("banke")); + assert.equal(1, ts.syllableCount("bankes")); + assert.equal(1, ts.syllableCount("banque")); + assert.equal(3, ts.syllableCount("baoguang")); + assert.equal(3, ts.syllableCount("baptisms")); + assert.equal(3, ts.syllableCount("baptistery")); + assert.equal(1, ts.syllableCount("barbe")); + assert.equal(2, ts.syllableCount("barefoot")); + assert.equal(3, ts.syllableCount("bareknuckle")); + assert.equal(4, ts.syllableCount("barentine")); + assert.equal(3, ts.syllableCount("barfknecht")); + assert.equal(1, ts.syllableCount("barke")); + assert.equal(2, ts.syllableCount("barkeley")); + assert.equal(1, ts.syllableCount("barkes")); + assert.equal(3, ts.syllableCount("barlettesville")); + assert.equal(2, ts.syllableCount("baroque")); + assert.equal(1, ts.syllableCount("barres")); + assert.equal(2, ts.syllableCount("barrientes")); + assert.equal(3, ts.syllableCount("barriere")); + assert.equal(2, ts.syllableCount("barthelme")); + assert.equal(1, ts.syllableCount("barthes")); + assert.equal(2, ts.syllableCount("bartl")); + assert.equal(5, ts.syllableCount("bartolomei")); + assert.equal(3, ts.syllableCount("bartone")); + assert.equal(2, ts.syllableCount("baseball")); + assert.equal(2, ts.syllableCount("baseballs")); + assert.equal(2, ts.syllableCount("baseboard")); + assert.equal(2, ts.syllableCount("baseboards")); + assert.equal(2, ts.syllableCount("baseline")); + assert.equal(2, ts.syllableCount("baseman")); + assert.equal(3, ts.syllableCount("basically")); + assert.equal(3, ts.syllableCount("basler")); + assert.equal(3, ts.syllableCount("basore")); + assert.equal(2, ts.syllableCount("bassler")); + assert.equal(2, ts.syllableCount("bateman")); + assert.equal(1, ts.syllableCount("bathke")); + assert.equal(1, ts.syllableCount("batte")); + assert.equal(4, ts.syllableCount("battiato")); + assert.equal(4, ts.syllableCount("batuigas")); + assert.equal(3, ts.syllableCount("baudoin")); + assert.equal(3, ts.syllableCount("baumler")); + assert.equal(3, ts.syllableCount("bayerische")); + assert.equal(2, ts.syllableCount("bazemore")); + assert.equal(3, ts.syllableCount("bbc")); + assert.equal(3, ts.syllableCount("bbq")); + assert.equal(2, ts.syllableCount("beaches")); + assert.equal(3, ts.syllableCount("beachler")); + assert.equal(1, ts.syllableCount("beaird")); + assert.equal(3, ts.syllableCount("beata")); + assert.equal(3, ts.syllableCount("beato")); + assert.equal(3, ts.syllableCount("beatrice")); + assert.equal(2, ts.syllableCount("beauce")); + assert.equal(2, ts.syllableCount("beauchesne")); + assert.equal(3, ts.syllableCount("beautifully")); + assert.equal(2, ts.syllableCount("bebe")); + assert.equal(2, ts.syllableCount("bedient")); + assert.equal(2, ts.syllableCount("beebe")); + assert.equal(2, ts.syllableCount("beebes")); + assert.equal(1, ts.syllableCount("beer")); + assert.equal(1, ts.syllableCount("beers")); + assert.equal(3, ts.syllableCount("beforehand")); + assert.equal(2, ts.syllableCount("begeman")); + assert.equal(3, ts.syllableCount("begnoche")); + assert.equal(3, ts.syllableCount("begonia")); + assert.equal(3, ts.syllableCount("begonias")); + assert.equal(1, ts.syllableCount("begue")); + assert.equal(3, ts.syllableCount("behavior")); + assert.equal(4, ts.syllableCount("behavioral")); + assert.equal(4, ts.syllableCount("behaviorists")); + assert.equal(3, ts.syllableCount("behaviors")); + assert.equal(1, ts.syllableCount("behlke")); + assert.equal(1, ts.syllableCount("behne")); + assert.equal(1, ts.syllableCount("behnke")); + assert.equal(3, ts.syllableCount("behringwerke")); + assert.equal(3, ts.syllableCount("beidler")); + assert.equal(2, ts.syllableCount("beiersdorf")); + assert.equal(1, ts.syllableCount("beijer")); + assert.equal(1, ts.syllableCount("beilke")); + assert.equal(3, ts.syllableCount("beitler")); + assert.equal(4, ts.syllableCount("belfiore")); + assert.equal(2, ts.syllableCount("belgian")); + assert.equal(2, ts.syllableCount("belgians")); + assert.equal(2, ts.syllableCount("belgique")); + assert.equal(2, ts.syllableCount("belier")); + assert.equal(1, ts.syllableCount("belke")); + assert.equal(2, ts.syllableCount("bellevue")); + assert.equal(3, ts.syllableCount("bellone")); + assert.equal(3, ts.syllableCount("belongia")); + assert.equal(3, ts.syllableCount("belote")); + assert.equal(1, ts.syllableCount("belshe")); + assert.equal(3, ts.syllableCount("belying")); + assert.equal(4, ts.syllableCount("benavides")); + assert.equal(2, ts.syllableCount("benches")); + assert.equal(3, ts.syllableCount("bendure")); + assert.equal(2, ts.syllableCount("bene")); + assert.equal(2, ts.syllableCount("benecke")); + assert.equal(4, ts.syllableCount("benequity")); + assert.equal(2, ts.syllableCount("benes")); + assert.equal(4, ts.syllableCount("benevides")); + assert.equal(5, ts.syllableCount("bengoechea")); + assert.equal(1, ts.syllableCount("benke")); + assert.equal(3, ts.syllableCount("benoist")); + assert.equal(1, ts.syllableCount("bente")); + assert.equal(2, ts.syllableCount("beougher")); + assert.equal(2, ts.syllableCount("bequeath")); + assert.equal(2, ts.syllableCount("bequeathed")); + assert.equal(2, ts.syllableCount("bequette")); + assert.equal(3, ts.syllableCount("berdine")); + assert.equal(3, ts.syllableCount("berea")); + assert.equal(2, ts.syllableCount("beresford")); + assert.equal(2, ts.syllableCount("bergeman")); + assert.equal(2, ts.syllableCount("bergemann")); + assert.equal(3, ts.syllableCount("berghuis")); + assert.equal(1, ts.syllableCount("berke")); + assert.equal(2, ts.syllableCount("berkeley")); + assert.equal(1, ts.syllableCount("berkes")); + assert.equal(4, ts.syllableCount("berlascone")); + assert.equal(1, ts.syllableCount("berle")); + assert.equal(2, ts.syllableCount("berlottes")); + assert.equal(3, ts.syllableCount("bermea")); + assert.equal(1, ts.syllableCount("berres")); + assert.equal(3, ts.syllableCount("berrien")); + assert.equal(1, ts.syllableCount("berte")); + assert.equal(2, ts.syllableCount("bertilde")); + assert.equal(3, ts.syllableCount("bertling")); + assert.equal(3, ts.syllableCount("bertone")); + assert.equal(3, ts.syllableCount("besler")); + assert.equal(3, ts.syllableCount("bessire")); + assert.equal(2, ts.syllableCount("bessler")); + assert.equal(5, ts.syllableCount("bestiality")); + assert.equal(3, ts.syllableCount("bethea")); + assert.equal(1, ts.syllableCount("bethke")); + assert.equal(3, ts.syllableCount("beucler")); + assert.equal(3, ts.syllableCount("beumer")); + assert.equal(3, ts.syllableCount("beutler")); + assert.equal(2, ts.syllableCount("beuys")); + assert.equal(3, ts.syllableCount("beverages")); + assert.equal(2, ts.syllableCount("bewitched")); + assert.equal(5, ts.syllableCount("biagioni")); + assert.equal(4, ts.syllableCount("biaxial")); + assert.equal(3, ts.syllableCount("bichler")); + assert.equal(4, ts.syllableCount("bicycling")); + assert.equal(3, ts.syllableCount("biedermeier")); + assert.equal(3, ts.syllableCount("biegler")); + assert.equal(1, ts.syllableCount("bielke")); + assert.equal(3, ts.syllableCount("bieniek")); + assert.equal(3, ts.syllableCount("biennale")); + assert.equal(4, ts.syllableCount("biennial")); + assert.equal(1, ts.syllableCount("bier")); + assert.equal(2, ts.syllableCount("bierer")); + assert.equal(2, ts.syllableCount("bierly")); + assert.equal(1, ts.syllableCount("biers")); + assert.equal(3, ts.syllableCount("bigler")); + assert.equal(2, ts.syllableCount("billiard")); + assert.equal(2, ts.syllableCount("billiards")); + assert.equal(5, ts.syllableCount("biologically")); + assert.equal(3, ts.syllableCount("biomed")); + assert.equal(4, ts.syllableCount("biosafety")); + assert.equal(4, ts.syllableCount("bioscience")); + assert.equal(5, ts.syllableCount("biosciences")); + assert.equal(3, ts.syllableCount("birchler")); + assert.equal(2, ts.syllableCount("birkeland")); + assert.equal(1, ts.syllableCount("birkes")); + assert.equal(1, ts.syllableCount("birle")); + assert.equal(2, ts.syllableCount("bitesize")); + assert.equal(3, ts.syllableCount("bitler")); + assert.equal(2, ts.syllableCount("bivouac")); + assert.equal(2, ts.syllableCount("bizarre")); + assert.equal(3, ts.syllableCount("bizarrely")); + assert.equal(1, ts.syllableCount("bjerke")); + assert.equal(2, ts.syllableCount("blakeley")); + assert.equal(2, ts.syllableCount("blakeman")); + assert.equal(2, ts.syllableCount("blakemore")); + assert.equal(2, ts.syllableCount("blakeney")); + assert.equal(2, ts.syllableCount("blakeslee")); + assert.equal(2, ts.syllableCount("blakesley")); + assert.equal(1, ts.syllableCount("blanke")); + assert.equal(5, ts.syllableCount("blankenbeckler")); + assert.equal(1, ts.syllableCount("blaschke")); + assert.equal(3, ts.syllableCount("blasia")); + assert.equal(4, ts.syllableCount("blasingame")); + assert.equal(4, ts.syllableCount("blassingame")); + assert.equal(1, ts.syllableCount("blauer")); + assert.equal(2, ts.syllableCount("blessed")); + assert.equal(1, ts.syllableCount("blitzed")); + assert.equal(1, ts.syllableCount("blonde")); + assert.equal(1, ts.syllableCount("blondes")); + assert.equal(2, ts.syllableCount("bloodshed")); + assert.equal(1, ts.syllableCount("blouin")); + assert.equal(2, ts.syllableCount("bluest")); + assert.equal(2, ts.syllableCount("bluey")); + assert.equal(2, ts.syllableCount("bluish")); + assert.equal(2, ts.syllableCount("Bnai")); + assert.equal(2, ts.syllableCount("boas")); + assert.equal(2, ts.syllableCount("boaz")); + assert.equal(2, ts.syllableCount("boches")); + assert.equal(3, ts.syllableCount("bodine")); + assert.equal(1, ts.syllableCount("boehlke")); + assert.equal(1, ts.syllableCount("boehme")); + assert.equal(1, ts.syllableCount("boehne")); + assert.equal(1, ts.syllableCount("boehnke")); + assert.equal(3, ts.syllableCount("boening")); + assert.equal(1, ts.syllableCount("boer")); + assert.equal(1, ts.syllableCount("boers")); + assert.equal(1, ts.syllableCount("bogue")); + assert.equal(3, ts.syllableCount("boheme")); + assert.equal(1, ts.syllableCount("bohlke")); + assert.equal(1, ts.syllableCount("bohne")); + assert.equal(1, ts.syllableCount("boies")); + assert.equal(2, ts.syllableCount("boise")); + assert.equal(2, ts.syllableCount("boleware")); + assert.equal(5, ts.syllableCount("bollettieri")); + assert.equal(4, ts.syllableCount("bolognese")); + assert.equal(1, ts.syllableCount("bolte")); + assert.equal(3, ts.syllableCount("bombardier")); + assert.equal(3, ts.syllableCount("bonaparte")); + assert.equal(1, ts.syllableCount("bonde")); + assert.equal(2, ts.syllableCount("bonebrake")); + assert.equal(3, ts.syllableCount("bonecrusher")); + assert.equal(3, ts.syllableCount("bonecutter")); + assert.equal(2, ts.syllableCount("bonenfant")); + assert.equal(2, ts.syllableCount("bonesteel")); + assert.equal(1, ts.syllableCount("bonet")); + assert.equal(3, ts.syllableCount("bonfire")); + assert.equal(3, ts.syllableCount("bonfires")); + assert.equal(3, ts.syllableCount("bongiorno")); + assert.equal(4, ts.syllableCount("bongiovanni")); + assert.equal(3, ts.syllableCount("bonine")); + assert.equal(3, ts.syllableCount("bonneville")); + assert.equal(3, ts.syllableCount("bonnevilles")); + assert.equal(4, ts.syllableCount("bonsignore")); + assert.equal(1, ts.syllableCount("bonte")); + assert.equal(1, ts.syllableCount("booed")); + assert.equal(4, ts.syllableCount("bordenave")); + assert.equal(1, ts.syllableCount("bordes")); + assert.equal(2, ts.syllableCount("boredom")); + assert.equal(2, ts.syllableCount("borgia")); + assert.equal(2, ts.syllableCount("borneman")); + assert.equal(2, ts.syllableCount("bornemann")); + assert.equal(3, ts.syllableCount("boroian")); + assert.equal(1, ts.syllableCount("borre")); + assert.equal(2, ts.syllableCount("boseman")); + assert.equal(3, ts.syllableCount("bosler")); + assert.equal(2, ts.syllableCount("bottler")); + assert.equal(2, ts.syllableCount("bottlers")); + assert.equal(3, ts.syllableCount("bottone")); + assert.equal(5, ts.syllableCount("bougainvillea")); + assert.equal(2, ts.syllableCount("bourgeois")); + assert.equal(3, ts.syllableCount("bourgeoisie")); + assert.equal(1, ts.syllableCount("bourke")); + assert.equal(2, ts.syllableCount("bournewood")); + assert.equal(1, ts.syllableCount("bourque")); + assert.equal(2, ts.syllableCount("boutique")); + assert.equal(2, ts.syllableCount("boutiques")); + assert.equal(1, ts.syllableCount("boutte")); + assert.equal(2, ts.syllableCount("bovespa")); + assert.equal(1, ts.syllableCount("bowles")); + assert.equal(1, ts.syllableCount("bowne")); + assert.equal(1, ts.syllableCount("bowse")); + assert.equal(2, ts.syllableCount("bowyer")); + assert.equal(3, ts.syllableCount("boyea")); + assert.equal(2, ts.syllableCount("bozeman")); + assert.equal(3, ts.syllableCount("braaten")); + assert.equal(2, ts.syllableCount("bracelet")); + assert.equal(2, ts.syllableCount("bracelets")); + assert.equal(2, ts.syllableCount("bracewell")); + assert.equal(2, ts.syllableCount("brakebill")); + assert.equal(2, ts.syllableCount("brakefield")); + assert.equal(2, ts.syllableCount("brakeman")); + assert.equal(2, ts.syllableCount("brakemen")); + assert.equal(1, ts.syllableCount("brakke")); + assert.equal(4, ts.syllableCount("bramalea")); + assert.equal(2, ts.syllableCount("branches")); + assert.equal(1, ts.syllableCount("brande")); + assert.equal(3, ts.syllableCount("brandeberry")); + assert.equal(1, ts.syllableCount("brandes")); + assert.equal(2, ts.syllableCount("brandl")); + assert.equal(1, ts.syllableCount("braque")); + assert.equal(3, ts.syllableCount("brasilia")); + assert.equal(2, ts.syllableCount("braziers")); + assert.equal(3, ts.syllableCount("brazilian")); + assert.equal(3, ts.syllableCount("brazilians")); + assert.equal(2, ts.syllableCount("brcko")); + assert.equal(2, ts.syllableCount("breaches")); + assert.equal(2, ts.syllableCount("breezeway")); + assert.equal(3, ts.syllableCount("breitling")); + assert.equal(1, ts.syllableCount("brekke")); + assert.equal(4, ts.syllableCount("brendlinger")); + assert.equal(2, ts.syllableCount("breneman")); + assert.equal(2, ts.syllableCount("brennecke")); + assert.equal(3, ts.syllableCount("brenneke")); + assert.equal(2, ts.syllableCount("brenneman")); + assert.equal(4, ts.syllableCount("brentlinger")); + assert.equal(2, ts.syllableCount("bressler")); + assert.equal(2, ts.syllableCount("briarcliff")); + assert.equal(2, ts.syllableCount("bridegroom")); + assert.equal(2, ts.syllableCount("bridesmaid")); + assert.equal(2, ts.syllableCount("bridesmaids")); + assert.equal(2, ts.syllableCount("bridgeforth")); + assert.equal(2, ts.syllableCount("bridgehead")); + assert.equal(2, ts.syllableCount("bridgeman")); + assert.equal(2, ts.syllableCount("bridgestone")); + assert.equal(2, ts.syllableCount("bridgeton")); + assert.equal(3, ts.syllableCount("bridgewater")); + assert.equal(2, ts.syllableCount("brien")); + assert.equal(3, ts.syllableCount("brierley")); + assert.equal(1, ts.syllableCount("brietzke")); + assert.equal(3, ts.syllableCount("brigadier")); + assert.equal(2, ts.syllableCount("brigitte")); + assert.equal(3, ts.syllableCount("brigode")); + assert.equal(2, ts.syllableCount("brilliance")); + assert.equal(2, ts.syllableCount("brilliant")); + assert.equal(3, ts.syllableCount("brilliantly")); + assert.equal(3, ts.syllableCount("briones")); + assert.equal(3, ts.syllableCount("bristling")); + assert.equal(3, ts.syllableCount("brittian")); + assert.equal(4, ts.syllableCount("brizendine")); + assert.equal(3, ts.syllableCount("broerman")); + assert.equal(1, ts.syllableCount("bronze")); + assert.equal(2, ts.syllableCount("brookehill")); + assert.equal(3, ts.syllableCount("brouhard")); + assert.equal(2, ts.syllableCount("brouillard")); + assert.equal(2, ts.syllableCount("brouillet")); + assert.equal(2, ts.syllableCount("brouillette")); + assert.equal(1, ts.syllableCount("browne")); + assert.equal(1, ts.syllableCount("browse")); + assert.equal(2, ts.syllableCount("brueggeman")); + assert.equal(2, ts.syllableCount("brueggemann")); + assert.equal(3, ts.syllableCount("bruella")); + assert.equal(2, ts.syllableCount("bruggeman")); + assert.equal(2, ts.syllableCount("bruin")); + assert.equal(3, ts.syllableCount("bruington")); + assert.equal(2, ts.syllableCount("bruins")); + assert.equal(3, ts.syllableCount("bruinsma")); + assert.equal(2, ts.syllableCount("brunches")); + assert.equal(1, ts.syllableCount("brunke")); + assert.equal(2, ts.syllableCount("brunnhilde")); + assert.equal(2, ts.syllableCount("bruynes")); + assert.equal(3, ts.syllableCount("bruzzese")); + assert.equal(2, ts.syllableCount("bryon")); + assert.equal(2, ts.syllableCount("bt")); + assert.equal(3, ts.syllableCount("bta")); + assert.equal(4, ts.syllableCount("bucciarelli")); + assert.equal(3, ts.syllableCount("buchler")); + assert.equal(3, ts.syllableCount("buckler")); + assert.equal(3, ts.syllableCount("budai")); + assert.equal(1, ts.syllableCount("budde")); + assert.equal(3, ts.syllableCount("buechler")); + assert.equal(2, ts.syllableCount("buell")); + assert.equal(2, ts.syllableCount("buffeted")); + assert.equal(3, ts.syllableCount("buffone")); + assert.equal(3, ts.syllableCount("bugling")); + assert.equal(2, ts.syllableCount("buick")); + assert.equal(2, ts.syllableCount("buicks")); + assert.equal(2, ts.syllableCount("buist")); + assert.equal(3, ts.syllableCount("bulthuis")); + assert.equal(2, ts.syllableCount("bunches")); + assert.equal(1, ts.syllableCount("bunde")); + assert.equal(3, ts.syllableCount("bundling")); + assert.equal(3, ts.syllableCount("bundren")); + assert.equal(3, ts.syllableCount("bungling")); + assert.equal(1, ts.syllableCount("bunke")); + assert.equal(1, ts.syllableCount("bunte")); + assert.equal(2, ts.syllableCount("bunzl")); + assert.equal(4, ts.syllableCount("buonocore")); + assert.equal(2, ts.syllableCount("buoy")); + assert.equal(2, ts.syllableCount("buoyed")); + assert.equal(2, ts.syllableCount("buoys")); + assert.equal(3, ts.syllableCount("burdine")); + assert.equal(3, ts.syllableCount("burdines")); + assert.equal(1, ts.syllableCount("burke")); + assert.equal(1, ts.syllableCount("burkes")); + assert.equal(1, ts.syllableCount("burres")); + assert.equal(3, ts.syllableCount("burriss")); + assert.equal(2, ts.syllableCount("buseman")); + assert.equal(3, ts.syllableCount("businessland")); + assert.equal(3, ts.syllableCount("businesslike")); + assert.equal(3, ts.syllableCount("businessman")); + assert.equal(3, ts.syllableCount("businessmen")); + assert.equal(4, ts.syllableCount("businesswoman")); + assert.equal(3, ts.syllableCount("busler")); + assert.equal(3, ts.syllableCount("bussiere")); + assert.equal(3, ts.syllableCount("bustling")); + assert.equal(3, ts.syllableCount("butare")); + assert.equal(1, ts.syllableCount("butte")); + assert.equal(2, ts.syllableCount("buttler")); + assert.equal(5, ts.syllableCount("byelorussia")); + assert.equal(3, ts.syllableCount("byington")); + assert.equal(2, ts.syllableCount("byus")); + assert.equal(3, ts.syllableCount("cabinetry")); + assert.equal(3, ts.syllableCount("cabrales")); + assert.equal(3, ts.syllableCount("cacao")); + assert.equal(4, ts.syllableCount("caccavale")); + assert.equal(3, ts.syllableCount("cacciola")); + assert.equal(3, ts.syllableCount("caceres")); + assert.equal(2, ts.syllableCount("caches")); + assert.equal(3, ts.syllableCount("cacioppo")); + assert.equal(2, ts.syllableCount("cacique")); + assert.equal(3, ts.syllableCount("cackling")); + assert.equal(2, ts.syllableCount("cadotte")); + assert.equal(4, ts.syllableCount("caesarea")); + assert.equal(4, ts.syllableCount("cafiero")); + assert.equal(2, ts.syllableCount("cahouet")); + assert.equal(3, ts.syllableCount("caiazzo")); + assert.equal(2, ts.syllableCount("caillouet")); + assert.equal(3, ts.syllableCount("caiola")); + assert.equal(4, ts.syllableCount("calabrese")); + assert.equal(3, ts.syllableCount("calame")); + assert.equal(3, ts.syllableCount("calcote")); + assert.equal(4, ts.syllableCount("calderone")); + assert.equal(4, ts.syllableCount("calliope")); + assert.equal(4, ts.syllableCount("calliopes")); + assert.equal(5, ts.syllableCount("caltagirone")); + assert.equal(3, ts.syllableCount("camire")); + assert.equal(4, ts.syllableCount("campanale")); + assert.equal(3, ts.syllableCount("campfire")); + assert.equal(3, ts.syllableCount("campfires")); + assert.equal(4, ts.syllableCount("campione")); + assert.equal(3, ts.syllableCount("canace")); + assert.equal(3, ts.syllableCount("canale")); + assert.equal(4, ts.syllableCount("cananea")); + assert.equal(3, ts.syllableCount("candler")); + assert.equal(4, ts.syllableCount("cangialosi")); + assert.equal(3, ts.syllableCount("canipe")); + assert.equal(3, ts.syllableCount("cannone")); + assert.equal(3, ts.syllableCount("cansler")); + assert.equal(3, ts.syllableCount("cantone")); + assert.equal(3, ts.syllableCount("cantv")); + assert.equal(2, ts.syllableCount("caouette")); + assert.equal(2, ts.syllableCount("capehart")); + assert.equal(2, ts.syllableCount("capetown")); + assert.equal(4, ts.syllableCount("caplinger")); + assert.equal(4, ts.syllableCount("caporale")); + assert.equal(4, ts.syllableCount("caracciolo")); + assert.equal(4, ts.syllableCount("caradine")); + assert.equal(4, ts.syllableCount("cardinale")); + assert.equal(3, ts.syllableCount("cardoen")); + assert.equal(3, ts.syllableCount("cardone")); + assert.equal(2, ts.syllableCount("carefree")); + assert.equal(3, ts.syllableCount("caregivers")); + assert.equal(3, ts.syllableCount("carelessness")); + assert.equal(2, ts.syllableCount("caremark")); + assert.equal(2, ts.syllableCount("careplus")); + assert.equal(3, ts.syllableCount("caretaker")); + assert.equal(3, ts.syllableCount("caretakers")); + assert.equal(4, ts.syllableCount("caribbean")); + assert.equal(3, ts.syllableCount("carine")); + assert.equal(3, ts.syllableCount("carinii")); + assert.equal(1, ts.syllableCount("carles")); + assert.equal(2, ts.syllableCount("carleton")); + assert.equal(3, ts.syllableCount("carlone")); + assert.equal(3, ts.syllableCount("carlyon")); + assert.equal(4, ts.syllableCount("carnevale")); + assert.equal(3, ts.syllableCount("carnine")); + assert.equal(1, ts.syllableCount("carre")); + assert.equal(3, ts.syllableCount("carrere")); + assert.equal(3, ts.syllableCount("carriages")); + assert.equal(3, ts.syllableCount("carriere")); + assert.equal(4, ts.syllableCount("carrizales")); + assert.equal(1, ts.syllableCount("carte")); + assert.equal(4, ts.syllableCount("carusone")); + assert.equal(3, ts.syllableCount("casal")); + assert.equal(3, ts.syllableCount("casale")); + assert.equal(3, ts.syllableCount("casares")); + assert.equal(3, ts.syllableCount("casciato")); + assert.equal(3, ts.syllableCount("cascone")); + assert.equal(2, ts.syllableCount("casebolt")); + assert.equal(2, ts.syllableCount("caseload")); + assert.equal(3, ts.syllableCount("caseworker")); + assert.equal(3, ts.syllableCount("caseworkers")); + assert.equal(2, ts.syllableCount("cashier")); + assert.equal(2, ts.syllableCount("cashiers")); + assert.equal(3, ts.syllableCount("casler")); + assert.equal(3, ts.syllableCount("cassese")); + assert.equal(3, ts.syllableCount("cassia")); + assert.equal(3, ts.syllableCount("cassone")); + assert.equal(4, ts.syllableCount("casstevens")); + assert.equal(5, ts.syllableCount("castiglione")); + assert.equal(3, ts.syllableCount("castine")); + assert.equal(3, ts.syllableCount("castorena")); + assert.equal(4, ts.syllableCount("cataclysm")); + assert.equal(3, ts.syllableCount("catalogue")); + assert.equal(3, ts.syllableCount("catalogued")); + assert.equal(3, ts.syllableCount("catalogues")); + assert.equal(4, ts.syllableCount("catalonia")); + assert.equal(4, ts.syllableCount("catanese")); + assert.equal(3, ts.syllableCount("catania")); + assert.equal(5, ts.syllableCount("categorically")); + assert.equal(2, ts.syllableCount("catharine")); + assert.equal(2, ts.syllableCount("catharines")); + assert.equal(3, ts.syllableCount("cathmor")); + assert.equal(2, ts.syllableCount("catholic")); + assert.equal(2, ts.syllableCount("catholics")); + assert.equal(2, ts.syllableCount("causeway")); + assert.equal(2, ts.syllableCount("causeways")); + assert.equal(2, ts.syllableCount("cautious")); + assert.equal(3, ts.syllableCount("cautiously")); + assert.equal(3, ts.syllableCount("cautiousness")); + assert.equal(3, ts.syllableCount("cavalier")); + assert.equal(4, ts.syllableCount("cavaliere")); + assert.equal(4, ts.syllableCount("cavalierly")); + assert.equal(3, ts.syllableCount("cavaliers")); + assert.equal(3, ts.syllableCount("caveat")); + assert.equal(3, ts.syllableCount("caveats")); + assert.equal(2, ts.syllableCount("caveman")); + assert.equal(2, ts.syllableCount("cawsl")); + assert.equal(3, ts.syllableCount("cazares")); + assert.equal(2, ts.syllableCount("cd")); + assert.equal(4, ts.syllableCount("cdebaca")); + assert.equal(3, ts.syllableCount("cecelia")); + assert.equal(3, ts.syllableCount("cecere")); + assert.equal(3, ts.syllableCount("cecilia")); + assert.equal(3, ts.syllableCount("cedrone")); + assert.equal(4, ts.syllableCount("celestine")); + assert.equal(2, ts.syllableCount("celia")); + assert.equal(4, ts.syllableCount("celosia")); + assert.equal(4, ts.syllableCount("cenozoic")); + assert.equal(2, ts.syllableCount("centerre")); + assert.equal(4, ts.syllableCount("centurion")); + assert.equal(3, ts.syllableCount("cercone")); + assert.equal(2, ts.syllableCount("ceres")); + assert.equal(3, ts.syllableCount("cerone")); + assert.equal(3, ts.syllableCount("cerrone")); + assert.equal(3, ts.syllableCount("cervone")); + assert.equal(3, ts.syllableCount("cesare")); + assert.equal(3, ts.syllableCount("cespedes")); + assert.equal(3, ts.syllableCount("cevaxs")); + assert.equal(3, ts.syllableCount("chaidez")); + assert.equal(3, ts.syllableCount("chairez")); + assert.equal(3, ts.syllableCount("chandelier")); + assert.equal(3, ts.syllableCount("chandeliers")); + assert.equal(2, ts.syllableCount("chaos")); + assert.equal(3, ts.syllableCount("chaotic")); + assert.equal(3, ts.syllableCount("chappuis")); + assert.equal(6, ts.syllableCount("characteristically")); + assert.equal(3, ts.syllableCount("charest")); + assert.equal(1, ts.syllableCount("charles")); + assert.equal(2, ts.syllableCount("charleston")); + assert.equal(2, ts.syllableCount("charlestown")); + assert.equal(2, ts.syllableCount("charlotte")); + assert.equal(3, ts.syllableCount("charlottesville")); + assert.equal(3, ts.syllableCount("charlottetown")); + assert.equal(3, ts.syllableCount("charpentier")); + assert.equal(3, ts.syllableCount("cheeseburger")); + assert.equal(3, ts.syllableCount("cheeseburgers")); + assert.equal(2, ts.syllableCount("cheesecake")); + assert.equal(2, ts.syllableCount("cheeseman")); + assert.equal(2, ts.syllableCount("chemed")); + assert.equal(3, ts.syllableCount("chemically")); + assert.equal(2, ts.syllableCount("chengxiang")); + assert.equal(1, ts.syllableCount("cheque")); + assert.equal(1, ts.syllableCount("cheques")); + assert.equal(3, ts.syllableCount("chesler")); + assert.equal(3, ts.syllableCount("chevalier")); + assert.equal(4, ts.syllableCount("chevrier")); + assert.equal(4, ts.syllableCount("chianese")); + assert.equal(1, ts.syllableCount("chiang")); + assert.equal(4, ts.syllableCount("chiappone")); + assert.equal(2, ts.syllableCount("chiara")); + assert.equal(4, ts.syllableCount("chicagoans")); + assert.equal(3, ts.syllableCount("chihuahua")); + assert.equal(3, ts.syllableCount("chikane")); + assert.equal(1, ts.syllableCount("childe")); + assert.equal(2, ts.syllableCount("chile")); + assert.equal(3, ts.syllableCount("chilean")); + assert.equal(3, ts.syllableCount("chileans")); + assert.equal(3, ts.syllableCount("chisler")); + assert.equal(1, ts.syllableCount("chiu")); + assert.equal(2, ts.syllableCount("chloe")); + assert.equal(2, ts.syllableCount("chmiel")); + assert.equal(4, ts.syllableCount("chmielewski")); + assert.equal(3, ts.syllableCount("chmura")); + assert.equal(2, ts.syllableCount("chocolat")); + assert.equal(2, ts.syllableCount("chocolate")); + assert.equal(2, ts.syllableCount("chocolates")); + assert.equal(3, ts.syllableCount("choiniere")); + assert.equal(2, ts.syllableCount("choir")); + assert.equal(3, ts.syllableCount("chopsuey")); + assert.equal(2, ts.syllableCount("choquette")); + assert.equal(3, ts.syllableCount("chortling")); + assert.equal(2, ts.syllableCount("chouinard")); + assert.equal(4, ts.syllableCount("chrismer")); + assert.equal(4, ts.syllableCount("christiana")); + assert.equal(3, ts.syllableCount("christiane")); + assert.equal(5, ts.syllableCount("christianity")); + assert.equal(4, ts.syllableCount("christiano")); + assert.equal(2, ts.syllableCount("christophe")); + assert.equal(5, ts.syllableCount("chronologically")); + assert.equal(2, ts.syllableCount("chrzan")); + assert.equal(4, ts.syllableCount("chrzanowski")); + assert.equal(1, ts.syllableCount("chseing")); + assert.equal(1, ts.syllableCount("chuang")); + assert.equal(2, ts.syllableCount("chui")); + assert.equal(4, ts.syllableCount("ciaccia")); + assert.equal(3, ts.syllableCount("ciaccio")); + assert.equal(2, ts.syllableCount("ciampa")); + assert.equal(2, ts.syllableCount("ciampi")); + assert.equal(2, ts.syllableCount("cianci")); + assert.equal(3, ts.syllableCount("ciancio")); + assert.equal(3, ts.syllableCount("cianciola")); + assert.equal(3, ts.syllableCount("cianciolo")); + assert.equal(3, ts.syllableCount("cianciulli")); + assert.equal(2, ts.syllableCount("ciani")); + assert.equal(3, ts.syllableCount("ciaobella")); + assert.equal(4, ts.syllableCount("ciaramella")); + assert.equal(5, ts.syllableCount("ciaramitaro")); + assert.equal(4, ts.syllableCount("ciaravino")); + assert.equal(2, ts.syllableCount("ciardi")); + assert.equal(2, ts.syllableCount("ciarlo")); + assert.equal(4, ts.syllableCount("ciavarella")); + assert.equal(4, ts.syllableCount("cicalese")); + assert.equal(3, ts.syllableCount("ciccone")); + assert.equal(3, ts.syllableCount("cicely")); + assert.equal(1, ts.syllableCount("cinque")); + assert.equal(2, ts.syllableCount("ciocca")); + assert.equal(3, ts.syllableCount("ciolino")); + assert.equal(2, ts.syllableCount("ciotti")); + assert.equal(3, ts.syllableCount("circling")); + assert.equal(4, ts.syllableCount("circuitous")); + assert.equal(3, ts.syllableCount("circumference")); + assert.equal(1, ts.syllableCount("cirque")); + assert.equal(3, ts.syllableCount("cisler")); + assert.equal(3, ts.syllableCount("cityfed")); + assert.equal(2, ts.syllableCount("ciucci")); + assert.equal(2, ts.syllableCount("ciulla")); + assert.equal(2, ts.syllableCount("ciullo")); + assert.equal(3, ts.syllableCount("civilian")); + assert.equal(3, ts.syllableCount("civilians")); + assert.equal(1, ts.syllableCount("clague")); + assert.equal(2, ts.syllableCount("claremont")); + assert.equal(3, ts.syllableCount("clarion")); + assert.equal(1, ts.syllableCount("clarke")); + assert.equal(3, ts.syllableCount("classically")); + assert.equal(2, ts.syllableCount("cleah")); + assert.equal(1, ts.syllableCount("cleanse")); + assert.equal(2, ts.syllableCount("cleaveland")); + assert.equal(2, ts.syllableCount("cleveland")); + assert.equal(3, ts.syllableCount("clevelanders")); + assert.equal(2, ts.syllableCount("clevetrust")); + assert.equal(2, ts.syllableCount("cliche")); + assert.equal(2, ts.syllableCount("cliched")); + assert.equal(2, ts.syllableCount("cliches")); + assert.equal(1, ts.syllableCount("cliffe")); + assert.equal(2, ts.syllableCount("clinches")); + assert.equal(1, ts.syllableCount("clique")); + assert.equal(1, ts.syllableCount("cliques")); + assert.equal(2, ts.syllableCount("cloey")); + assert.equal(2, ts.syllableCount("closedown")); + assert.equal(2, ts.syllableCount("closedowns")); + assert.equal(2, ts.syllableCount("clotheshorse")); + assert.equal(2, ts.syllableCount("clothestime")); + assert.equal(2, ts.syllableCount("clothier")); + assert.equal(2, ts.syllableCount("clothiers")); + assert.equal(2, ts.syllableCount("clothilde")); + assert.equal(2, ts.syllableCount("clouatre")); + assert.equal(2, ts.syllableCount("cluett")); + assert.equal(2, ts.syllableCount("clydesdale")); + assert.equal(2, ts.syllableCount("cmon")); + assert.equal(2, ts.syllableCount("cmos")); + assert.equal(2, ts.syllableCount("cmx")); + assert.equal(2, ts.syllableCount("coaches")); + assert.equal(2, ts.syllableCount("coady")); + assert.equal(1, ts.syllableCount("coale")); + assert.equal(1, ts.syllableCount("coals")); + assert.equal(2, ts.syllableCount("coalson")); + assert.equal(2, ts.syllableCount("coate")); + assert.equal(2, ts.syllableCount("coates")); + assert.equal(1, ts.syllableCount("coaxed")); + assert.equal(2, ts.syllableCount("coaxum")); + assert.equal(2, ts.syllableCount("cobbler")); + assert.equal(2, ts.syllableCount("cobblers")); + assert.equal(3, ts.syllableCount("cochlea")); + assert.equal(3, ts.syllableCount("cochlear")); + assert.equal(1, ts.syllableCount("cocke")); + assert.equal(3, ts.syllableCount("cockroaches")); + assert.equal(2, ts.syllableCount("coderre")); + assert.equal(2, ts.syllableCount("coed")); + assert.equal(2, ts.syllableCount("coeds")); + assert.equal(6, ts.syllableCount("coeducational")); + assert.equal(4, ts.syllableCount("coefficient")); + assert.equal(4, ts.syllableCount("coefficients")); + assert.equal(3, ts.syllableCount("coelho")); + assert.equal(3, ts.syllableCount("coello")); + assert.equal(2, ts.syllableCount("coen")); + assert.equal(3, ts.syllableCount("coenen")); + assert.equal(3, ts.syllableCount("coenzyme")); + assert.equal(3, ts.syllableCount("coequal")); + assert.equal(2, ts.syllableCount("coerce")); + assert.equal(2, ts.syllableCount("coerced")); + assert.equal(3, ts.syllableCount("coercing")); + assert.equal(3, ts.syllableCount("coercive")); + assert.equal(1, ts.syllableCount("coeur")); + assert.equal(3, ts.syllableCount("coexist")); + assert.equal(4, ts.syllableCount("coexisted")); + assert.equal(4, ts.syllableCount("coexistence")); + assert.equal(4, ts.syllableCount("coexisting")); + assert.equal(2, ts.syllableCount("coey")); + assert.equal(2, ts.syllableCount("cogema")); + assert.equal(5, ts.syllableCount("coglianese")); + assert.equal(3, ts.syllableCount("cohea")); + assert.equal(2, ts.syllableCount("coia")); + assert.equal(3, ts.syllableCount("coincide")); + assert.equal(4, ts.syllableCount("coincided")); + assert.equal(4, ts.syllableCount("coincidence")); + assert.equal(5, ts.syllableCount("coincidences")); + assert.equal(4, ts.syllableCount("coincident")); + assert.equal(5, ts.syllableCount("coincidental")); + assert.equal(6, ts.syllableCount("coincidentally")); + assert.equal(3, ts.syllableCount("coincides")); + assert.equal(4, ts.syllableCount("coinciding")); + assert.equal(4, ts.syllableCount("coinsurance")); + assert.equal(3, ts.syllableCount("cojuangco")); + assert.equal(4, ts.syllableCount("colaianni")); + assert.equal(3, ts.syllableCount("coldren")); + assert.equal(2, ts.syllableCount("colebank")); + assert.equal(2, ts.syllableCount("colebrook")); + assert.equal(2, ts.syllableCount("colegrove")); + assert.equal(2, ts.syllableCount("coleman")); + assert.equal(2, ts.syllableCount("coleridge")); + assert.equal(2, ts.syllableCount("coleslaw")); + assert.equal(3, ts.syllableCount("colestipol")); + assert.equal(2, ts.syllableCount("colestock")); + assert.equal(3, ts.syllableCount("coleus")); + assert.equal(3, ts.syllableCount("coline")); + assert.equal(4, ts.syllableCount("coliseum")); + assert.equal(2, ts.syllableCount("collapse")); + assert.equal(2, ts.syllableCount("colleague")); + assert.equal(2, ts.syllableCount("colleagues")); + assert.equal(3, ts.syllableCount("collegians")); + assert.equal(3, ts.syllableCount("collegiate")); + assert.equal(2, ts.syllableCount("collier")); + assert.equal(2, ts.syllableCount("colliers")); + assert.equal(4, ts.syllableCount("collodion")); + assert.equal(4, ts.syllableCount("colloquial")); + assert.equal(4, ts.syllableCount("colloquium")); + assert.equal(2, ts.syllableCount("colonel")); + assert.equal(2, ts.syllableCount("colonels")); + assert.equal(3, ts.syllableCount("colorfully")); + assert.equal(4, ts.syllableCount("colosseum")); + assert.equal(4, ts.syllableCount("colourful")); + assert.equal(3, ts.syllableCount("comanches")); + assert.equal(1, ts.syllableCount("combe")); + assert.equal(1, ts.syllableCount("combes")); + assert.equal(2, ts.syllableCount("comeback")); + assert.equal(2, ts.syllableCount("comebacks")); + assert.equal(2, ts.syllableCount("comedown")); + assert.equal(2, ts.syllableCount("comfed")); + assert.equal(4, ts.syllableCount("commemorative")); + assert.equal(4, ts.syllableCount("commercebancorp")); + assert.equal(4, ts.syllableCount("commerciale")); + assert.equal(3, ts.syllableCount("commerical")); + assert.equal(4, ts.syllableCount("commingling")); + assert.equal(4, ts.syllableCount("complementary")); + assert.equal(3, ts.syllableCount("comrie")); + assert.equal(4, ts.syllableCount("comunale")); + assert.equal(2, ts.syllableCount("concorde")); + assert.equal(1, ts.syllableCount("conde")); + assert.equal(2, ts.syllableCount("condense")); + assert.equal(3, ts.syllableCount("condren")); + assert.equal(3, ts.syllableCount("condry")); + assert.equal(3, ts.syllableCount("conduit")); + assert.equal(3, ts.syllableCount("conduits")); + assert.equal(3, ts.syllableCount("coneflower")); + assert.equal(3, ts.syllableCount("conferencing")); + assert.equal(3, ts.syllableCount("confidante")); + assert.equal(7, ts.syllableCount("confidentiality")); + assert.equal(5, ts.syllableCount("confucianism")); + assert.equal(3, ts.syllableCount("congenial")); + assert.equal(2, ts.syllableCount("conquer")); + assert.equal(2, ts.syllableCount("conquers")); + assert.equal(4, ts.syllableCount("consequences")); + assert.equal(2, ts.syllableCount("conserved")); + assert.equal(3, ts.syllableCount("consortiums")); + assert.equal(3, ts.syllableCount("conspire")); + assert.equal(3, ts.syllableCount("conspired")); + assert.equal(5, ts.syllableCount("construcciones")); + assert.equal(3, ts.syllableCount("contagious")); + assert.equal(4, ts.syllableCount("contagiousness")); + assert.equal(1, ts.syllableCount("conte")); + assert.equal(4, ts.syllableCount("contemptuously")); + assert.equal(3, ts.syllableCount("contentious")); + assert.equal(4, ts.syllableCount("contentiousness")); + assert.equal(4, ts.syllableCount("continuum")); + assert.equal(2, ts.syllableCount("converged")); + assert.equal(2, ts.syllableCount("conyer")); + assert.equal(2, ts.syllableCount("conyers")); + assert.equal(3, ts.syllableCount("coogler")); + assert.equal(1, ts.syllableCount("coombe")); + assert.equal(1, ts.syllableCount("coombes")); + assert.equal(4, ts.syllableCount("cooperate")); + assert.equal(5, ts.syllableCount("cooperated")); + assert.equal(4, ts.syllableCount("cooperates")); + assert.equal(5, ts.syllableCount("cooperating")); + assert.equal(5, ts.syllableCount("cooperation")); + assert.equal(5, ts.syllableCount("cooperations")); + assert.equal(5, ts.syllableCount("cooperative")); + assert.equal(4, ts.syllableCount("coordinate")); + assert.equal(5, ts.syllableCount("coordinated")); + assert.equal(4, ts.syllableCount("coordinates")); + assert.equal(5, ts.syllableCount("coordinating")); + assert.equal(5, ts.syllableCount("coordination")); + assert.equal(5, ts.syllableCount("coordinator")); + assert.equal(5, ts.syllableCount("coordinators")); + assert.equal(2, ts.syllableCount("copeland")); + assert.equal(2, ts.syllableCount("copeman")); + assert.equal(3, ts.syllableCount("copiague")); + assert.equal(3, ts.syllableCount("coplen")); + assert.equal(4, ts.syllableCount("copytele")); + assert.equal(3, ts.syllableCount("corbusier")); + assert.equal(1, ts.syllableCount("cordes")); + assert.equal(2, ts.syllableCount("cordial")); + assert.equal(3, ts.syllableCount("cordially")); + assert.equal(3, ts.syllableCount("cordry")); + assert.equal(3, ts.syllableCount("corea")); + assert.equal(2, ts.syllableCount("corestates")); + assert.equal(2, ts.syllableCount("coretech")); + assert.equal(4, ts.syllableCount("Corleone")); + assert.equal(3, ts.syllableCount("cornea")); + assert.equal(3, ts.syllableCount("corneas")); + assert.equal(3, ts.syllableCount("cornelia")); + assert.equal(3, ts.syllableCount("cornelius")); + assert.equal(5, ts.syllableCount("corporacion")); + assert.equal(3, ts.syllableCount("corporatewatch")); + assert.equal(4, ts.syllableCount("corporatewide")); + assert.equal(1, ts.syllableCount("corpse")); + assert.equal(3, ts.syllableCount("corrales")); + assert.equal(3, ts.syllableCount("correa")); + assert.equal(1, ts.syllableCount("corte")); + assert.equal(1, ts.syllableCount("cortes")); + assert.equal(3, ts.syllableCount("cortese")); + assert.equal(3, ts.syllableCount("corzine")); + assert.equal(1, ts.syllableCount("cosme")); + assert.equal(4, ts.syllableCount("cosmetically")); + assert.equal(3, ts.syllableCount("cothren")); + assert.equal(3, ts.syllableCount("cotler")); + assert.equal(3, ts.syllableCount("cotrone")); + assert.equal(3, ts.syllableCount("cottone")); + assert.equal(2, ts.syllableCount("couches")); + assert.equal(2, ts.syllableCount("couillard")); + assert.equal(1, ts.syllableCount("couldnt")); + assert.equal(2, ts.syllableCount("courchesne")); + assert.equal(2, ts.syllableCount("courtemanche")); + assert.equal(3, ts.syllableCount("coval")); + assert.equal(3, ts.syllableCount("coyote")); + assert.equal(3, ts.syllableCount("coyotes")); + assert.equal(3, ts.syllableCount("cozine")); + assert.equal(1, ts.syllableCount("crabbe")); + assert.equal(3, ts.syllableCount("cradling")); + assert.equal(2, ts.syllableCount("cranesbills")); + assert.equal(3, ts.syllableCount("crary")); + assert.equal(3, ts.syllableCount("creager")); + assert.equal(2, ts.syllableCount("create")); + assert.equal(3, ts.syllableCount("created")); + assert.equal(2, ts.syllableCount("creates")); + assert.equal(3, ts.syllableCount("creating")); + assert.equal(3, ts.syllableCount("creation")); + assert.equal(5, ts.syllableCount("creationism")); + assert.equal(3, ts.syllableCount("creations")); + assert.equal(3, ts.syllableCount("creative")); + assert.equal(4, ts.syllableCount("creatively")); + assert.equal(5, ts.syllableCount("creativity")); + assert.equal(3, ts.syllableCount("creator")); + assert.equal(3, ts.syllableCount("creators")); + assert.equal(1, ts.syllableCount("creer")); + assert.equal(1, ts.syllableCount("creque")); + assert.equal(2, ts.syllableCount("cressler")); + assert.equal(3, ts.syllableCount("crimea")); + assert.equal(3, ts.syllableCount("crisler")); + assert.equal(4, ts.syllableCount("cristiani")); + assert.equal(4, ts.syllableCount("cristiano")); + assert.equal(4, ts.syllableCount("criterion")); + assert.equal(4, ts.syllableCount("criticisms")); + assert.equal(2, ts.syllableCount("critique")); + assert.equal(2, ts.syllableCount("critiques")); + assert.equal(3, ts.syllableCount("crnkovich")); + assert.equal(2, ts.syllableCount("croat")); + assert.equal(3, ts.syllableCount("croatia")); + assert.equal(3, ts.syllableCount("croatian")); + assert.equal(3, ts.syllableCount("croatians")); + assert.equal(2, ts.syllableCount("croats")); + assert.equal(2, ts.syllableCount("croce")); + assert.equal(2, ts.syllableCount("crocheted")); + assert.equal(2, ts.syllableCount("cronauer")); + assert.equal(4, ts.syllableCount("cronyism")); + assert.equal(2, ts.syllableCount("crooked")); + assert.equal(1, ts.syllableCount("crounse")); + assert.equal(2, ts.syllableCount("crovl")); + assert.equal(2, ts.syllableCount("crovls")); + assert.equal(1, ts.syllableCount("crowne")); + assert.equal(2, ts.syllableCount("crownx")); + assert.equal(2, ts.syllableCount("crozier")); + assert.equal(3, ts.syllableCount("cruea")); + assert.equal(2, ts.syllableCount("cruel")); + assert.equal(2, ts.syllableCount("cruey")); + assert.equal(3, ts.syllableCount("cruikshank")); + assert.equal(3, ts.syllableCount("crumpler")); + assert.equal(2, ts.syllableCount("crunches")); + assert.equal(3, ts.syllableCount("cryolite")); + assert.equal(3, ts.syllableCount("crysler")); + assert.equal(3, ts.syllableCount("csaszar")); + assert.equal(2, ts.syllableCount("cuddeback")); + assert.equal(3, ts.syllableCount("cuello")); + assert.equal(1, ts.syllableCount("cuffe")); + assert.equal(4, ts.syllableCount("cuneiform")); + assert.equal(2, ts.syllableCount("cunliffe")); + assert.equal(2, ts.syllableCount("cureton")); + assert.equal(4, ts.syllableCount("curiale")); + assert.equal(2, ts.syllableCount("curnutte")); + assert.equal(3, ts.syllableCount("cutaia")); + assert.equal(2, ts.syllableCount("cutesy")); + assert.equal(3, ts.syllableCount("cutrone")); + assert.equal(3, ts.syllableCount("cuvelier")); + assert.equal(3, ts.syllableCount("cxc")); + assert.equal(3, ts.syllableCount("cyclades")); + assert.equal(3, ts.syllableCount("cycling")); + assert.equal(3, ts.syllableCount("cyclist")); + assert.equal(4, ts.syllableCount("cyclopean")); + assert.equal(4, ts.syllableCount("cytherea")); + assert.equal(2, ts.syllableCount("dadeland")); + assert.equal(1, ts.syllableCount("dague")); + assert.equal(2, ts.syllableCount("dahlia")); + assert.equal(1, ts.syllableCount("dahlke")); + assert.equal(1, ts.syllableCount("dahnke")); + assert.equal(3, ts.syllableCount("daiichi")); + assert.equal(3, ts.syllableCount("dalgleish")); + assert.equal(2, ts.syllableCount("dalia")); + assert.equal(1, ts.syllableCount("dalke")); + assert.equal(3, ts.syllableCount("daloia")); + assert.equal(1, ts.syllableCount("dalpe")); + assert.equal(4, ts.syllableCount("dambrosia")); + assert.equal(2, ts.syllableCount("damewood")); + assert.equal(3, ts.syllableCount("damien")); + assert.equal(4, ts.syllableCount("damietta")); + assert.equal(4, ts.syllableCount("dandelion")); + assert.equal(4, ts.syllableCount("dandelions")); + assert.equal(3, ts.syllableCount("dandrea")); + assert.equal(4, ts.syllableCount("dandyism")); + assert.equal(3, ts.syllableCount("danese")); + assert.equal(3, ts.syllableCount("dangler")); + assert.equal(3, ts.syllableCount("dangling")); + assert.equal(3, ts.syllableCount("daniele")); + assert.equal(3, ts.syllableCount("dannemeyer")); + assert.equal(1, ts.syllableCount("danske")); + assert.equal(1, ts.syllableCount("daoud")); + assert.equal(1, ts.syllableCount("daoust")); + assert.equal(3, ts.syllableCount("daredevil")); + assert.equal(3, ts.syllableCount("darien")); + assert.equal(1, ts.syllableCount("darke")); + assert.equal(3, ts.syllableCount("daseke")); + assert.equal(2, ts.syllableCount("dassler")); + assert.equal(3, ts.syllableCount("datapower")); + assert.equal(2, ts.syllableCount("dateline")); + assert.equal(2, ts.syllableCount("datelines")); + assert.equal(3, ts.syllableCount("davide")); + assert.equal(2, ts.syllableCount("dbase")); + assert.equal(3, ts.syllableCount("ddt")); + assert.equal(5, ts.syllableCount("deactivated")); + assert.equal(3, ts.syllableCount("dealba")); + assert.equal(3, ts.syllableCount("deana")); + assert.equal(3, ts.syllableCount("deanda")); + assert.equal(3, ts.syllableCount("deandrade")); + assert.equal(3, ts.syllableCount("deandrea")); + assert.equal(4, ts.syllableCount("deangelis")); + assert.equal(3, ts.syllableCount("deanna")); + assert.equal(4, ts.syllableCount("debiase")); + assert.equal(2, ts.syllableCount("debora")); + assert.equal(2, ts.syllableCount("deborde")); + assert.equal(3, ts.syllableCount("debruin")); + assert.equal(3, ts.syllableCount("debutante")); + assert.equal(3, ts.syllableCount("debutantes")); + assert.equal(2, ts.syllableCount("debuted")); + assert.equal(4, ts.syllableCount("decesare")); + assert.equal(2, ts.syllableCount("declerque")); + assert.equal(3, ts.syllableCount("decorative")); + assert.equal(5, ts.syllableCount("deemphasizing")); + assert.equal(1, ts.syllableCount("deer")); + assert.equal(2, ts.syllableCount("defense")); + assert.equal(3, ts.syllableCount("defenseless")); + assert.equal(4, ts.syllableCount("defiore")); + assert.equal(3, ts.syllableCount("defrates")); + assert.equal(5, ts.syllableCount("degaetano")); + assert.equal(3, ts.syllableCount("degeorge")); + assert.equal(4, ts.syllableCount("degiacomo")); + assert.equal(3, ts.syllableCount("degrace")); + assert.equal(3, ts.syllableCount("degrave")); + assert.equal(3, ts.syllableCount("deguire")); + assert.equal(4, ts.syllableCount("degutare")); + assert.equal(1, ts.syllableCount("dehne")); + assert.equal(5, ts.syllableCount("deification")); + assert.equal(3, ts.syllableCount("deify")); + assert.equal(9, ts.syllableCount("deinstitutionalization")); + assert.equal(3, ts.syllableCount("deisher")); + assert.equal(3, ts.syllableCount("deism")); + assert.equal(2, ts.syllableCount("deist")); + assert.equal(3, ts.syllableCount("deities")); + assert.equal(3, ts.syllableCount("deity")); + assert.equal(2, ts.syllableCount("delatte")); + assert.equal(4, ts.syllableCount("delaurentiis")); + assert.equal(3, ts.syllableCount("delbene")); + assert.equal(3, ts.syllableCount("delcine")); + assert.equal(3, ts.syllableCount("delebarre")); + assert.equal(3, ts.syllableCount("delfine")); + assert.equal(3, ts.syllableCount("delgiorno")); + assert.equal(2, ts.syllableCount("delia")); + assert.equal(3, ts.syllableCount("deline")); + assert.equal(4, ts.syllableCount("delineate")); + assert.equal(5, ts.syllableCount("delineated")); + assert.equal(4, ts.syllableCount("delineates")); + assert.equal(5, ts.syllableCount("delineating")); + assert.equal(5, ts.syllableCount("delineation")); + assert.equal(2, ts.syllableCount("deloitte")); + assert.equal(4, ts.syllableCount("delorean")); + assert.equal(3, ts.syllableCount("delores")); + assert.equal(4, ts.syllableCount("delosreyes")); + assert.equal(3, ts.syllableCount("delphine")); + assert.equal(4, ts.syllableCount("delpriore")); + assert.equal(1, ts.syllableCount("delre")); + assert.equal(4, ts.syllableCount("delsignore")); + assert.equal(3, ts.syllableCount("deltaic")); + assert.equal(3, ts.syllableCount("deluise")); + assert.equal(3, ts.syllableCount("demagogue")); + assert.equal(3, ts.syllableCount("demagogues")); + assert.equal(4, ts.syllableCount("demarest")); + assert.equal(4, ts.syllableCount("dementia")); + assert.equal(5, ts.syllableCount("democratically")); + assert.equal(5, ts.syllableCount("demographically")); + assert.equal(3, ts.syllableCount("denarii")); + assert.equal(4, ts.syllableCount("denatale")); + assert.equal(3, ts.syllableCount("dengler")); + assert.equal(4, ts.syllableCount("denlinger")); + assert.equal(3, ts.syllableCount("denouement")); + assert.equal(1, ts.syllableCount("dense")); + assert.equal(2, ts.syllableCount("densely")); + assert.equal(1, ts.syllableCount("dente")); + assert.equal(7, ts.syllableCount("denuclearization")); + assert.equal(5, ts.syllableCount("denuclearized")); + assert.equal(8, ts.syllableCount("deoxyribonucleic")); + assert.equal(3, ts.syllableCount("dep")); + assert.equal(3, ts.syllableCount("depace")); + assert.equal(4, ts.syllableCount("depascale")); + assert.equal(4, ts.syllableCount("depasquale")); + assert.equal(1, ts.syllableCount("deppe")); + assert.equal(4, ts.syllableCount("depreciable")); + assert.equal(4, ts.syllableCount("depriest")); + assert.equal(3, ts.syllableCount("dercole")); + assert.equal(4, ts.syllableCount("derflinger")); + assert.equal(4, ts.syllableCount("derosia")); + assert.equal(2, ts.syllableCount("derouen")); + assert.equal(2, ts.syllableCount("derouin")); + assert.equal(3, ts.syllableCount("desai")); + assert.equal(5, ts.syllableCount("desantiago")); + assert.equal(2, ts.syllableCount("descartes")); + assert.equal(3, ts.syllableCount("deschler")); + assert.equal(2, ts.syllableCount("deserved")); + assert.equal(4, ts.syllableCount("deservedly")); + assert.equal(2, ts.syllableCount("deshaies")); + assert.equal(4, ts.syllableCount("desimone")); + assert.equal(3, ts.syllableCount("desire")); + assert.equal(3, ts.syllableCount("desired")); + assert.equal(3, ts.syllableCount("desires")); + assert.equal(4, ts.syllableCount("desiring")); + assert.equal(2, ts.syllableCount("deslatte")); + assert.equal(2, ts.syllableCount("desperate")); + assert.equal(3, ts.syllableCount("desroches")); + assert.equal(2, ts.syllableCount("dessauer")); + assert.equal(2, ts.syllableCount("detente")); + assert.equal(5, ts.syllableCount("determinedly")); + assert.equal(3, ts.syllableCount("detore")); + assert.equal(3, ts.syllableCount("dettore")); + assert.equal(2, ts.syllableCount("deutschemark")); + assert.equal(2, ts.syllableCount("deutschemarks")); + assert.equal(3, ts.syllableCount("devere")); + assert.equal(2, ts.syllableCount("devilish")); + assert.equal(3, ts.syllableCount("devillier")); + assert.equal(3, ts.syllableCount("devour")); + assert.equal(3, ts.syllableCount("devoured")); + assert.equal(4, ts.syllableCount("devouring")); + assert.equal(3, ts.syllableCount("devours")); + assert.equal(2, ts.syllableCount("dewilde")); + assert.equal(2, ts.syllableCount("dewitte")); + assert.equal(2, ts.syllableCount("dewolfe")); + assert.equal(4, ts.syllableCount("dhlakama")); + assert.equal(4, ts.syllableCount("diabetes")); + assert.equal(3, ts.syllableCount("dialogue")); + assert.equal(3, ts.syllableCount("dialogues")); + assert.equal(2, ts.syllableCount("diamond")); + assert.equal(2, ts.syllableCount("diamonds")); + assert.equal(2, ts.syllableCount("dianne")); + assert.equal(2, ts.syllableCount("diaper")); + assert.equal(4, ts.syllableCount("diarrhea")); + assert.equal(4, ts.syllableCount("diastole")); + assert.equal(4, ts.syllableCount("dibiase")); + assert.equal(4, ts.syllableCount("dicesare")); + assert.equal(3, ts.syllableCount("dichroic")); + assert.equal(1, ts.syllableCount("dicke")); + assert.equal(1, ts.syllableCount("dickes")); + assert.equal(3, ts.syllableCount("dicomed")); + assert.equal(3, ts.syllableCount("didion")); + assert.equal(3, ts.syllableCount("diego")); + assert.equal(2, ts.syllableCount("diener")); + assert.equal(1, ts.syllableCount("dienst")); + assert.equal(1, ts.syllableCount("dierkes")); + assert.equal(3, ts.syllableCount("dierking")); + assert.equal(4, ts.syllableCount("dietary")); + assert.equal(4, ts.syllableCount("dietetic")); + assert.equal(3, ts.syllableCount("dieting")); + assert.equal(4, ts.syllableCount("dietitian")); + assert.equal(4, ts.syllableCount("dietitians")); + assert.equal(2, ts.syllableCount("dietl")); + assert.equal(2, ts.syllableCount("diets")); + assert.equal(1, ts.syllableCount("Dieu")); + assert.equal(2, ts.syllableCount("diez")); + assert.equal(5, ts.syllableCount("differentiate")); + assert.equal(6, ts.syllableCount("differentiated")); + assert.equal(5, ts.syllableCount("differentiates")); + assert.equal(6, ts.syllableCount("differentiating")); + assert.equal(6, ts.syllableCount("differentiation")); + assert.equal(3, ts.syllableCount("differently")); + assert.equal(4, ts.syllableCount("difiore")); + assert.equal(4, ts.syllableCount("digiacomo")); + assert.equal(3, ts.syllableCount("digioia")); + assert.equal(4, ts.syllableCount("digiovanna")); + assert.equal(4, ts.syllableCount("digiovanni")); + assert.equal(5, ts.syllableCount("diguglielmo")); + assert.equal(3, ts.syllableCount("diianni")); + assert.equal(4, ts.syllableCount("diiorio")); + assert.equal(2, ts.syllableCount("dikeman")); + assert.equal(3, ts.syllableCount("dildine")); + assert.equal(4, ts.syllableCount("diltiazem")); + assert.equal(3, ts.syllableCount("dimare")); + assert.equal(4, ts.syllableCount("dimichele")); + assert.equal(4, ts.syllableCount("dinatale")); + assert.equal(2, ts.syllableCount("dinehart")); + assert.equal(3, ts.syllableCount("dingler")); + assert.equal(4, ts.syllableCount("dinmukhamed")); + assert.equal(1, ts.syllableCount("dinse")); + assert.equal(5, ts.syllableCount("dionisio")); + assert.equal(4, ts.syllableCount("diorio")); + assert.equal(4, ts.syllableCount("dipaola")); + assert.equal(4, ts.syllableCount("dipaolo")); + assert.equal(4, ts.syllableCount("dipasquale")); + assert.equal(5, ts.syllableCount("diplomatically")); + assert.equal(4, ts.syllableCount("directv")); + assert.equal(1, ts.syllableCount("dirkes")); + assert.equal(1, ts.syllableCount("dirkse")); + assert.equal(2, ts.syllableCount("discharged")); + assert.equal(3, ts.syllableCount("discotheque")); + assert.equal(3, ts.syllableCount("dIsere")); + assert.equal(2, ts.syllableCount("disgorged")); + assert.equal(3, ts.syllableCount("disgorgement")); + assert.equal(4, ts.syllableCount("disgruntling")); + assert.equal(4, ts.syllableCount("disimone")); + assert.equal(4, ts.syllableCount("disinterested")); + assert.equal(4, ts.syllableCount("dismantling")); + assert.equal(4, ts.syllableCount("disorient")); + assert.equal(6, ts.syllableCount("disorientation")); + assert.equal(5, ts.syllableCount("disoriented")); + assert.equal(5, ts.syllableCount("disorienting")); + assert.equal(2, ts.syllableCount("dispatched")); + assert.equal(2, ts.syllableCount("dispense")); + assert.equal(1, ts.syllableCount("disque")); + assert.equal(2, ts.syllableCount("dissuade")); + assert.equal(3, ts.syllableCount("dissuaded")); + assert.equal(2, ts.syllableCount("diverged")); + assert.equal(2, ts.syllableCount("divulged")); + assert.equal(2, ts.syllableCount("dk")); + assert.equal(3, ts.syllableCount("dlouhy")); + assert.equal(3, ts.syllableCount("dlugos")); + assert.equal(3, ts.syllableCount("dlugosz")); + assert.equal(3, ts.syllableCount("dmitri")); + assert.equal(3, ts.syllableCount("doable")); + assert.equal(4, ts.syllableCount("dobrzynski")); + assert.equal(1, ts.syllableCount("doepke")); + assert.equal(1, ts.syllableCount("doer")); + assert.equal(3, ts.syllableCount("doerfler")); + assert.equal(4, ts.syllableCount("doerflinger")); + assert.equal(3, ts.syllableCount("doering")); + assert.equal(4, ts.syllableCount("dogmatically")); + assert.equal(1, ts.syllableCount("dohme")); + assert.equal(1, ts.syllableCount("dohse")); + assert.equal(2, ts.syllableCount("doin")); + assert.equal(3, ts.syllableCount("dolores")); + assert.equal(2, ts.syllableCount("domangue")); + assert.equal(4, ts.syllableCount("domestically")); + assert.equal(3, ts.syllableCount("domine")); + assert.equal(2, ts.syllableCount("domingue")); + assert.equal(3, ts.syllableCount("dominique")); + assert.equal(1, ts.syllableCount("domke")); + assert.equal(1, ts.syllableCount("donde")); + assert.equal(4, ts.syllableCount("dondlinger")); + assert.equal(1, ts.syllableCount("donze")); + assert.equal(3, ts.syllableCount("doonesbury")); + assert.equal(2, ts.syllableCount("doppler")); + assert.equal(3, ts.syllableCount("dorea")); + assert.equal(3, ts.syllableCount("dorine")); + assert.equal(3, ts.syllableCount("dorion")); + assert.equal(2, ts.syllableCount("dornier")); + assert.equal(4, ts.syllableCount("dorothea")); + assert.equal(3, ts.syllableCount("dorthea")); + assert.equal(3, ts.syllableCount("dosia")); + assert.equal(2, ts.syllableCount("dossier")); + assert.equal(2, ts.syllableCount("dossiers")); + assert.equal(3, ts.syllableCount("doubtfire")); + assert.equal(3, ts.syllableCount("doubtfires")); + assert.equal(3, ts.syllableCount("douglass")); + assert.equal(2, ts.syllableCount("dour")); + assert.equal(2, ts.syllableCount("dovetail")); + assert.equal(2, ts.syllableCount("dovetailed")); + assert.equal(2, ts.syllableCount("dovetails")); + assert.equal(1, ts.syllableCount("dower")); + assert.equal(1, ts.syllableCount("dowers")); + assert.equal(1, ts.syllableCount("downe")); + assert.equal(1, ts.syllableCount("downes")); + assert.equal(1, ts.syllableCount("dowse")); + assert.equal(4, ts.syllableCount("dramatically")); + assert.equal(3, ts.syllableCount("drastically")); + assert.equal(1, ts.syllableCount("drawer")); + assert.equal(1, ts.syllableCount("drawers")); + assert.equal(3, ts.syllableCount("drechsler")); + assert.equal(1, ts.syllableCount("dreher")); + assert.equal(2, ts.syllableCount("dressler")); + assert.equal(2, ts.syllableCount("driveway")); + assert.equal(2, ts.syllableCount("driveways")); + assert.equal(1, ts.syllableCount("drogue")); + assert.equal(2, ts.syllableCount("drouillard")); + assert.equal(1, ts.syllableCount("drouin")); + assert.equal(3, ts.syllableCount("druella")); + assert.equal(2, ts.syllableCount("druid")); + assert.equal(4, ts.syllableCount("druidism")); + assert.equal(2, ts.syllableCount("druids")); + assert.equal(3, ts.syllableCount("dsouza")); + assert.equal(4, ts.syllableCount("dualisms")); + assert.equal(1, ts.syllableCount("duane")); + assert.equal(2, ts.syllableCount("duarte")); + assert.equal(3, ts.syllableCount("dubilier")); + assert.equal(2, ts.syllableCount("dubreuil")); + assert.equal(2, ts.syllableCount("dubuque")); + assert.equal(2, ts.syllableCount("ducharme")); + assert.equal(2, ts.syllableCount("duel")); + assert.equal(3, ts.syllableCount("duelist")); + assert.equal(2, ts.syllableCount("duels")); + assert.equal(3, ts.syllableCount("duesler")); + assert.equal(2, ts.syllableCount("duet")); + assert.equal(2, ts.syllableCount("duets")); + assert.equal(2, ts.syllableCount("duey")); + assert.equal(2, ts.syllableCount("dufresne")); + assert.equal(2, ts.syllableCount("duis")); + assert.equal(2, ts.syllableCount("dukedom")); + assert.equal(2, ts.syllableCount("dukeman")); + assert.equal(3, ts.syllableCount("dulcea")); + assert.equal(3, ts.syllableCount("dulciana")); + assert.equal(4, ts.syllableCount("dulcinea")); + assert.equal(3, ts.syllableCount("dullea")); + assert.equal(3, ts.syllableCount("dumire")); + assert.equal(2, ts.syllableCount("duncombe")); + assert.equal(3, ts.syllableCount("dunmire")); + assert.equal(2, ts.syllableCount("duo")); + assert.equal(4, ts.syllableCount("duodenal")); + assert.equal(2, ts.syllableCount("duong")); + assert.equal(4, ts.syllableCount("duopoly")); + assert.equal(3, ts.syllableCount("dupler")); + assert.equal(4, ts.syllableCount("dupriest")); + assert.equal(3, ts.syllableCount("dupuis")); + assert.equal(1, ts.syllableCount("duque")); + assert.equal(2, ts.syllableCount("duquesne")); + assert.equal(2, ts.syllableCount("duquette")); + assert.equal(3, ts.syllableCount("duramed")); + assert.equal(4, ts.syllableCount("durflinger")); + assert.equal(3, ts.syllableCount("duvalier")); + assert.equal(3, ts.syllableCount("duvaliers")); + assert.equal(3, ts.syllableCount("dwindling")); + assert.equal(2, ts.syllableCount("dyches")); + assert.equal(2, ts.syllableCount("dykeman")); + assert.equal(3, ts.syllableCount("dyslexia")); + assert.equal(4, ts.syllableCount("dzhirkvelov")); + assert.equal(3, ts.syllableCount("eagleye")); + assert.equal(1, ts.syllableCount("earle")); + assert.equal(1, ts.syllableCount("earles")); + assert.equal(3, ts.syllableCount("easudes")); + assert.equal(2, ts.syllableCount("eavesdrop")); + assert.equal(3, ts.syllableCount("eavesdropping")); + assert.equal(3, ts.syllableCount("eblen")); + assert.equal(1, ts.syllableCount("eckes")); + assert.equal(2, ts.syllableCount("eckl")); + assert.equal(2, ts.syllableCount("eclipse")); + assert.equal(5, ts.syllableCount("ecologically")); + assert.equal(5, ts.syllableCount("economically")); + assert.equal(4, ts.syllableCount("ecstatically")); + assert.equal(3, ts.syllableCount("ecuador")); + assert.equal(4, ts.syllableCount("ecuadoran")); + assert.equal(5, ts.syllableCount("ecuadorian")); + assert.equal(2, ts.syllableCount("edgecomb")); + assert.equal(2, ts.syllableCount("edgecombe")); + assert.equal(2, ts.syllableCount("edgemon")); + assert.equal(2, ts.syllableCount("edgeways")); + assert.equal(2, ts.syllableCount("edgewood")); + assert.equal(2, ts.syllableCount("edgeworth")); + assert.equal(4, ts.syllableCount("edinburgh")); + assert.equal(5, ts.syllableCount("edizione")); + assert.equal(3, ts.syllableCount("edouard")); + assert.equal(3, ts.syllableCount("edrea")); + assert.equal(4, ts.syllableCount("edrington")); + assert.equal(2, ts.syllableCount("eduard")); + assert.equal(3, ts.syllableCount("eduardo")); + assert.equal(2, ts.syllableCount("effler")); + assert.equal(4, ts.syllableCount("egoism")); + assert.equal(3, ts.syllableCount("egregious")); + assert.equal(4, ts.syllableCount("egregiously")); + assert.equal(1, ts.syllableCount("ehle")); + assert.equal(1, ts.syllableCount("ehlke")); + assert.equal(1, ts.syllableCount("ehrke")); + assert.equal(3, ts.syllableCount("eichler")); + assert.equal(2, ts.syllableCount("eiermann")); + assert.equal(3, ts.syllableCount("eifler")); + assert.equal(3, ts.syllableCount("eightieth")); + assert.equal(3, ts.syllableCount("eiichi")); + assert.equal(2, ts.syllableCount("eiseman")); + assert.equal(2, ts.syllableCount("eisemann")); + assert.equal(2, ts.syllableCount("ekkehard")); + assert.equal(3, ts.syllableCount("elaborate")); + assert.equal(4, ts.syllableCount("elaborately")); + assert.equal(2, ts.syllableCount("elapse")); + assert.equal(1, ts.syllableCount("elbe")); + assert.equal(5, ts.syllableCount("electricite")); + assert.equal(3, ts.syllableCount("electrique")); + assert.equal(4, ts.syllableCount("elementary")); + assert.equal(5, ts.syllableCount("eleonore")); + assert.equal(3, ts.syllableCount("eletr")); + assert.equal(4, ts.syllableCount("elinore")); + assert.equal(1, ts.syllableCount("elkes")); + assert.equal(2, ts.syllableCount("ellerbe")); + assert.equal(2, ts.syllableCount("ellesmere")); + assert.equal(2, ts.syllableCount("ellipse")); + assert.equal(3, ts.syllableCount("ellithorpe")); + assert.equal(1, ts.syllableCount("elmes")); + assert.equal(1, ts.syllableCount("else")); + assert.equal(3, ts.syllableCount("elsea")); + assert.equal(3, ts.syllableCount("elsevier")); + assert.equal(2, ts.syllableCount("elsewhere")); + assert.equal(4, ts.syllableCount("elysia")); + assert.equal(4, ts.syllableCount("emanuel")); + assert.equal(5, ts.syllableCount("emanuele")); + assert.equal(2, ts.syllableCount("embler")); + assert.equal(4, ts.syllableCount("embolisms")); + assert.equal(3, ts.syllableCount("embryo")); + assert.equal(4, ts.syllableCount("embryonic")); + assert.equal(3, ts.syllableCount("embryos")); + assert.equal(1, ts.syllableCount("emde")); + assert.equal(2, ts.syllableCount("emerald")); + assert.equal(2, ts.syllableCount("emeralds")); + assert.equal(2, ts.syllableCount("emerged")); + assert.equal(4, ts.syllableCount("eminase")); + assert.equal(4, ts.syllableCount("emmaline")); + assert.equal(4, ts.syllableCount("emmanuel")); + assert.equal(4, ts.syllableCount("emotionally")); + assert.equal(4, ts.syllableCount("emphatically")); + assert.equal(3, ts.syllableCount("emphysema")); + assert.equal(3, ts.syllableCount("empire")); + assert.equal(3, ts.syllableCount("empires")); + assert.equal(3, ts.syllableCount("emslie")); + assert.equal(3, ts.syllableCount("emuil")); + assert.equal(5, ts.syllableCount("encarnacion")); + assert.equal(4, ts.syllableCount("encircling")); + assert.equal(3, ts.syllableCount("encroaches")); + assert.equal(1, ts.syllableCount("ende")); + assert.equal(3, ts.syllableCount("enea")); + assert.equal(5, ts.syllableCount("energetically")); + assert.equal(2, ts.syllableCount("engelke")); + assert.equal(2, ts.syllableCount("engeman")); + assert.equal(3, ts.syllableCount("engler")); + assert.equal(2, ts.syllableCount("enholme")); + assert.equal(1, ts.syllableCount("enke")); + assert.equal(2, ts.syllableCount("enlarged")); + assert.equal(3, ts.syllableCount("enlargement")); + assert.equal(3, ts.syllableCount("enlargements")); + assert.equal(3, ts.syllableCount("ennea")); + assert.equal(3, ts.syllableCount("ennui")); + assert.equal(3, ts.syllableCount("enriches")); + assert.equal(3, ts.syllableCount("enslen")); + assert.equal(4, ts.syllableCount("ensminger")); + assert.equal(5, ts.syllableCount("enthusiasm")); + assert.equal(5, ts.syllableCount("enthusiasms")); + assert.equal(3, ts.syllableCount("entire")); + assert.equal(4, ts.syllableCount("entirely")); + assert.equal(4, ts.syllableCount("entitling")); + assert.equal(3, ts.syllableCount("entrenches")); + assert.equal(4, ts.syllableCount("entringer")); + assert.equal(4, ts.syllableCount("entsminger")); + assert.equal(8, ts.syllableCount("environmentalism")); + assert.equal(5, ts.syllableCount("epicurean")); + assert.equal(3, ts.syllableCount("epilogue")); + assert.equal(4, ts.syllableCount("epitome")); + assert.equal(1, ts.syllableCount("eppes")); + assert.equal(2, ts.syllableCount("eppler")); + assert.equal(5, ts.syllableCount("equiangular")); + assert.equal(3, ts.syllableCount("equity")); + assert.equal(2, ts.syllableCount("eranthe")); + assert.equal(1, ts.syllableCount("erbe")); + assert.equal(1, ts.syllableCount("erbes")); + assert.equal(3, ts.syllableCount("ercole")); + assert.equal(3, ts.syllableCount("erion")); + assert.equal(4, ts.syllableCount("eritrea")); + assert.equal(4, ts.syllableCount("eritrean")); + assert.equal(4, ts.syllableCount("erratically")); + assert.equal(1, ts.syllableCount("erte")); + assert.equal(2, ts.syllableCount("ertl")); + assert.equal(5, ts.syllableCount("erythropoietin")); + assert.equal(3, ts.syllableCount("esler")); + assert.equal(4, ts.syllableCount("eslinger")); + assert.equal(1, ts.syllableCount("esme")); + assert.equal(3, ts.syllableCount("espalier")); + assert.equal(1, ts.syllableCount("espe")); + assert.equal(4, ts.syllableCount("especially")); + assert.equal(2, ts.syllableCount("esquer")); + assert.equal(1, ts.syllableCount("est")); + assert.equal(3, ts.syllableCount("esteves")); + assert.equal(4, ts.syllableCount("etc")); + assert.equal(3, ts.syllableCount("ethnically")); + assert.equal(3, ts.syllableCount("ethyol")); + assert.equal(3, ts.syllableCount("etiquette")); + assert.equal(2, ts.syllableCount("euan")); + assert.equal(2, ts.syllableCount("euchred")); + assert.equal(3, ts.syllableCount("euclea")); + assert.equal(4, ts.syllableCount("eudosia")); + assert.equal(4, ts.syllableCount("euphemisms")); + assert.equal(5, ts.syllableCount("euphemistically")); + assert.equal(3, ts.syllableCount("euphrates")); + assert.equal(5, ts.syllableCount("euromissiles")); + assert.equal(5, ts.syllableCount("euromobiliare")); + assert.equal(4, ts.syllableCount("european")); + assert.equal(4, ts.syllableCount("europeans")); + assert.equal(3, ts.syllableCount("europewide")); + assert.equal(2, ts.syllableCount("eveland")); + assert.equal(2, ts.syllableCount("evening")); + assert.equal(2, ts.syllableCount("evenings")); + assert.equal(4, ts.syllableCount("everybody")); + assert.equal(3, ts.syllableCount("everyday")); + assert.equal(3, ts.syllableCount("everyman")); + assert.equal(3, ts.syllableCount("everything")); + assert.equal(3, ts.syllableCount("everytime")); + assert.equal(3, ts.syllableCount("everywhere")); + assert.equal(6, ts.syllableCount("evidentiary")); + assert.equal(3, ts.syllableCount("exchequer")); + assert.equal(2, ts.syllableCount("expanse")); + assert.equal(4, ts.syllableCount("expeditious")); + assert.equal(5, ts.syllableCount("expeditiously")); + assert.equal(2, ts.syllableCount("expense")); + assert.equal(4, ts.syllableCount("experience")); + assert.equal(4, ts.syllableCount("experienced")); + assert.equal(5, ts.syllableCount("experiences")); + assert.equal(5, ts.syllableCount("experiencing")); + assert.equal(3, ts.syllableCount("expires")); + assert.equal(2, ts.syllableCount("eyepiece")); + assert.equal(2, ts.syllableCount("facedown")); + assert.equal(2, ts.syllableCount("facelift")); + assert.equal(4, ts.syllableCount("facemire")); + assert.equal(3, ts.syllableCount("facetious")); + assert.equal(4, ts.syllableCount("facetiously")); + assert.equal(4, ts.syllableCount("faciane")); + assert.equal(4, ts.syllableCount("facsimile")); + assert.equal(4, ts.syllableCount("facsimiles")); + assert.equal(2, ts.syllableCount("fagundes")); + assert.equal(2, ts.syllableCount("fahnestock")); + assert.equal(3, ts.syllableCount("faiola")); + assert.equal(2, ts.syllableCount("faist")); + assert.equal(3, ts.syllableCount("falcone")); + assert.equal(1, ts.syllableCount("falke")); + assert.equal(1, ts.syllableCount("false")); + assert.equal(2, ts.syllableCount("falsehood")); + assert.equal(2, ts.syllableCount("falsehoods")); + assert.equal(2, ts.syllableCount("falsely")); + assert.equal(3, ts.syllableCount("falzone")); + assert.equal(5, ts.syllableCount("famiglietti")); + assert.equal(3, ts.syllableCount("familial")); + assert.equal(3, ts.syllableCount("familiar")); + assert.equal(5, ts.syllableCount("familiarity")); + assert.equal(4, ts.syllableCount("familiarize")); + assert.equal(4, ts.syllableCount("familiarized")); + assert.equal(3, ts.syllableCount("fansler")); + assert.equal(4, ts.syllableCount("fantastically")); + assert.equal(2, ts.syllableCount("fanueil")); + assert.equal(3, ts.syllableCount("farace")); + assert.equal(4, ts.syllableCount("faraone")); + assert.equal(3, ts.syllableCount("farese")); + assert.equal(2, ts.syllableCount("farewell")); + assert.equal(2, ts.syllableCount("farewells")); + assert.equal(2, ts.syllableCount("farfetched")); + assert.equal(2, ts.syllableCount("farquhar")); + assert.equal(3, ts.syllableCount("farruggia")); + assert.equal(3, ts.syllableCount("farrugia")); + assert.equal(3, ts.syllableCount("fasone")); + assert.equal(2, ts.syllableCount("fassler")); + assert.equal(2, ts.syllableCount("fatigue")); + assert.equal(2, ts.syllableCount("fatigued")); + assert.equal(2, ts.syllableCount("fatigues")); + assert.equal(3, ts.syllableCount("faubion")); + assert.equal(3, ts.syllableCount("favale")); + assert.equal(1, ts.syllableCount("fawkes")); + assert.equal(3, ts.syllableCount("fayetteville")); + assert.equal(2, ts.syllableCount("FDIC")); + assert.equal(3, ts.syllableCount("fealty")); + assert.equal(4, ts.syllableCount("feb")); + assert.equal(1, ts.syllableCount("felde")); + assert.equal(1, ts.syllableCount("felske")); + assert.equal(1, ts.syllableCount("feltes")); + assert.equal(2, ts.syllableCount("fencl")); + assert.equal(1, ts.syllableCount("fenske")); + assert.equal(4, ts.syllableCount("ferraioli")); + assert.equal(1, ts.syllableCount("ferre")); + assert.equal(3, ts.syllableCount("ferriss")); + assert.equal(5, ts.syllableCount("ferrofluidics")); + assert.equal(3, ts.syllableCount("ferrone")); + assert.equal(3, ts.syllableCount("fesler")); + assert.equal(2, ts.syllableCount("fessler")); + assert.equal(3, ts.syllableCount("fiance")); + assert.equal(1, ts.syllableCount("ficke")); + assert.equal(1, ts.syllableCount("fickes")); + assert.equal(3, ts.syllableCount("fictitious")); + assert.equal(3, ts.syllableCount("fidelia")); + assert.equal(3, ts.syllableCount("fidler")); + assert.equal(1, ts.syllableCount("fier")); + assert.equal(3, ts.syllableCount("fieros")); + assert.equal(1, ts.syllableCount("fiers")); + assert.equal(3, ts.syllableCount("fiery")); + assert.equal(3, ts.syllableCount("fiesta")); + assert.equal(3, ts.syllableCount("fiftieth")); + assert.equal(3, ts.syllableCount("figler")); + assert.equal(3, ts.syllableCount("figueira")); + assert.equal(4, ts.syllableCount("figueiredo")); + assert.equal(3, ts.syllableCount("figurehead")); + assert.equal(1, ts.syllableCount("fildes")); + assert.equal(2, ts.syllableCount("filenet")); + assert.equal(4, ts.syllableCount("fillingame")); + assert.equal(3, ts.syllableCount("finale")); + assert.equal(3, ts.syllableCount("financier")); + assert.equal(5, ts.syllableCount("financiera")); + assert.equal(5, ts.syllableCount("financiero")); + assert.equal(3, ts.syllableCount("financiers")); + assert.equal(6, ts.syllableCount("finanziaria")); + assert.equal(2, ts.syllableCount("finarte")); + assert.equal(2, ts.syllableCount("finches")); + assert.equal(1, ts.syllableCount("fincke")); + assert.equal(3, ts.syllableCount("findling")); + assert.equal(2, ts.syllableCount("fineberg")); + assert.equal(2, ts.syllableCount("finefrock")); + assert.equal(2, ts.syllableCount("finegold")); + assert.equal(2, ts.syllableCount("fineman")); + assert.equal(2, ts.syllableCount("finestone")); + assert.equal(2, ts.syllableCount("finevest")); + assert.equal(1, ts.syllableCount("finke")); + assert.equal(3, ts.syllableCount("finklea")); + assert.equal(3, ts.syllableCount("fiore")); + assert.equal(2, ts.syllableCount("fire")); + assert.equal(3, ts.syllableCount("firearm")); + assert.equal(3, ts.syllableCount("firearms")); + assert.equal(2, ts.syllableCount("firebaugh")); + assert.equal(2, ts.syllableCount("firebombed")); + assert.equal(2, ts.syllableCount("firebombs")); + assert.equal(2, ts.syllableCount("fired")); + assert.equal(2, ts.syllableCount("firefight")); + assert.equal(3, ts.syllableCount("firefighter")); + assert.equal(3, ts.syllableCount("firefighting")); + assert.equal(2, ts.syllableCount("fireman")); + assert.equal(2, ts.syllableCount("firemen")); + assert.equal(3, ts.syllableCount("firepower")); + assert.equal(2, ts.syllableCount("fires")); + assert.equal(2, ts.syllableCount("firestone")); + assert.equal(2, ts.syllableCount("firestorm")); + assert.equal(2, ts.syllableCount("fireworks")); + assert.equal(2, ts.syllableCount("firstier")); + assert.equal(2, ts.syllableCount("fischl")); + assert.equal(3, ts.syllableCount("fischler")); + assert.equal(3, ts.syllableCount("fisler")); + assert.equal(4, ts.syllableCount("fitzhenry")); + assert.equal(3, ts.syllableCount("fitzwilliam")); + assert.equal(2, ts.syllableCount("fivecoat")); + assert.equal(2, ts.syllableCount("fivefold")); + assert.equal(2, ts.syllableCount("flaharty")); + assert.equal(2, ts.syllableCount("flaherty")); + assert.equal(3, ts.syllableCount("flamemaster")); + assert.equal(2, ts.syllableCount("flavr")); + assert.equal(1, ts.syllableCount("fleer")); + assert.equal(3, ts.syllableCount("flightsafety")); + assert.equal(3, ts.syllableCount("flirtatious")); + assert.equal(3, ts.syllableCount("florea")); + assert.equal(2, ts.syllableCount("flores")); + assert.equal(3, ts.syllableCount("florine")); + assert.equal(2, ts.syllableCount("flour")); + assert.equal(2, ts.syllableCount("flours")); + assert.equal(2, ts.syllableCount("fluid")); + assert.equal(4, ts.syllableCount("fluidity")); + assert.equal(2, ts.syllableCount("fluids")); + assert.equal(2, ts.syllableCount("fluitt")); + assert.equal(2, ts.syllableCount("fluor")); + assert.equal(3, ts.syllableCount("fogler")); + assert.equal(1, ts.syllableCount("foie")); + assert.equal(2, ts.syllableCount("foiles")); + assert.equal(1, ts.syllableCount("folkes")); + assert.equal(2, ts.syllableCount("folliard")); + assert.equal(1, ts.syllableCount("folse")); + assert.equal(2, ts.syllableCount("foncier")); + assert.equal(5, ts.syllableCount("fondiaria")); + assert.equal(3, ts.syllableCount("fondren")); + assert.equal(1, ts.syllableCount("fonte")); + assert.equal(1, ts.syllableCount("forbes")); + assert.equal(3, ts.syllableCount("forcefulness")); + assert.equal(1, ts.syllableCount("forde")); + assert.equal(3, ts.syllableCount("forensic")); + assert.equal(3, ts.syllableCount("forensics")); + assert.equal(2, ts.syllableCount("forest")); + assert.equal(3, ts.syllableCount("forested")); + assert.equal(3, ts.syllableCount("forester")); + assert.equal(3, ts.syllableCount("foresters")); + assert.equal(3, ts.syllableCount("forestry")); + assert.equal(2, ts.syllableCount("forests")); + assert.equal(2, ts.syllableCount("forex")); + assert.equal(1, ts.syllableCount("forgue")); + assert.equal(4, ts.syllableCount("formulaic")); + assert.equal(2, ts.syllableCount("forquer")); + assert.equal(3, ts.syllableCount("fortieth")); + assert.equal(4, ts.syllableCount("fortuitous")); + assert.equal(3, ts.syllableCount("fosler")); + assert.equal(1, ts.syllableCount("foulke")); + assert.equal(1, ts.syllableCount("foulkes")); + assert.equal(1, ts.syllableCount("foward")); + assert.equal(1, ts.syllableCount("fowkes")); + assert.equal(1, ts.syllableCount("fowlkes")); + assert.equal(2, ts.syllableCount("foxmeyer")); + assert.equal(2, ts.syllableCount("fractious")); + assert.equal(3, ts.syllableCount("fractiousness")); + assert.equal(3, ts.syllableCount("fragale")); + assert.equal(3, ts.syllableCount("fraioli")); + assert.equal(2, ts.syllableCount("framework")); + assert.equal(3, ts.syllableCount("francese")); + assert.equal(1, ts.syllableCount("francke")); + assert.equal(2, ts.syllableCount("francoeur")); + assert.equal(1, ts.syllableCount("franke")); + assert.equal(3, ts.syllableCount("frankincense")); + assert.equal(2, ts.syllableCount("frankl")); + assert.equal(1, ts.syllableCount("franze")); + assert.equal(3, ts.syllableCount("franzese")); + assert.equal(3, ts.syllableCount("franzone")); + assert.equal(2, ts.syllableCount("frashier")); + assert.equal(1, ts.syllableCount("fratzke")); + assert.equal(2, ts.syllableCount("frazier")); + assert.equal(1, ts.syllableCount("freda")); + assert.equal(2, ts.syllableCount("frederic")); + assert.equal(2, ts.syllableCount("frederick")); + assert.equal(2, ts.syllableCount("fredericks")); + assert.equal(3, ts.syllableCount("fredericksburg")); + assert.equal(2, ts.syllableCount("fredette")); + assert.equal(2, ts.syllableCount("freest")); + assert.equal(2, ts.syllableCount("freia")); + assert.equal(1, ts.syllableCount("fricke")); + assert.equal(2, ts.syllableCount("frie")); + assert.equal(2, ts.syllableCount("friedl")); + assert.equal(1, ts.syllableCount("friis")); + assert.equal(1, ts.syllableCount("fritze")); + assert.equal(1, ts.syllableCount("fronde")); + assert.equal(2, ts.syllableCount("frontier")); + assert.equal(2, ts.syllableCount("frontiers")); + assert.equal(2, ts.syllableCount("fruin")); + assert.equal(3, ts.syllableCount("fruition")); + assert.equal(2, ts.syllableCount("fruity")); + assert.equal(1, ts.syllableCount("frunze")); + assert.equal(2, ts.syllableCount("FSLIC")); + assert.equal(2, ts.syllableCount("fuel")); + assert.equal(2, ts.syllableCount("fueled")); + assert.equal(2, ts.syllableCount("fuelled")); + assert.equal(2, ts.syllableCount("fuels")); + assert.equal(1, ts.syllableCount("fuer")); + assert.equal(1, ts.syllableCount("fugue")); + assert.equal(1, ts.syllableCount("fugues")); + assert.equal(3, ts.syllableCount("fukui")); + assert.equal(4, ts.syllableCount("fukuoka")); + assert.equal(4, ts.syllableCount("fullilove")); + assert.equal(2, ts.syllableCount("funches")); + assert.equal(3, ts.syllableCount("funderburke")); + assert.equal(1, ts.syllableCount("funke")); + assert.equal(3, ts.syllableCount("fuoco")); + assert.equal(3, ts.syllableCount("fuselier")); + assert.equal(1, ts.syllableCount("fyffe")); + assert.equal(1, ts.syllableCount("fyffes")); + assert.equal(3, ts.syllableCount("gabbroic")); + assert.equal(2, ts.syllableCount("gabehart")); + assert.equal(3, ts.syllableCount("gabele")); + assert.equal(4, ts.syllableCount("gaboriault")); + assert.equal(3, ts.syllableCount("gabriel")); + assert.equal(4, ts.syllableCount("gabriela")); + assert.equal(3, ts.syllableCount("gabriele")); + assert.equal(3, ts.syllableCount("gabrys")); + assert.equal(1, ts.syllableCount("gaffe")); + assert.equal(1, ts.syllableCount("gaffes")); + assert.equal(4, ts.syllableCount("gaglione")); + assert.equal(2, ts.syllableCount("gaia")); + assert.equal(4, ts.syllableCount("galatea")); + assert.equal(3, ts.syllableCount("galea")); + assert.equal(4, ts.syllableCount("galentine")); + assert.equal(2, ts.syllableCount("galesburg")); + assert.equal(3, ts.syllableCount("galiena")); + assert.equal(4, ts.syllableCount("galilean")); + assert.equal(4, ts.syllableCount("gallentine")); + assert.equal(3, ts.syllableCount("galyon")); + assert.equal(3, ts.syllableCount("gambale")); + assert.equal(2, ts.syllableCount("gambler")); + assert.equal(2, ts.syllableCount("gamblers")); + assert.equal(3, ts.syllableCount("gamesmanship")); + assert.equal(2, ts.syllableCount("gamunde")); + assert.equal(2, ts.syllableCount("gangl")); + assert.equal(1, ts.syllableCount("ganske")); + assert.equal(3, ts.syllableCount("gaona")); + assert.equal(1, ts.syllableCount("garbe")); + assert.equal(1, ts.syllableCount("garde")); + assert.equal(3, ts.syllableCount("gardenia")); + assert.equal(3, ts.syllableCount("gardenias")); + assert.equal(2, ts.syllableCount("gardiner")); + assert.equal(2, ts.syllableCount("garoutte")); + assert.equal(1, ts.syllableCount("garske")); + assert.equal(1, ts.syllableCount("gartzke")); + assert.equal(6, ts.syllableCount("gastrointestinal")); + assert.equal(3, ts.syllableCount("gatekeeper")); + assert.equal(3, ts.syllableCount("gatekeepers")); + assert.equal(2, ts.syllableCount("gateway")); + assert.equal(2, ts.syllableCount("gateways")); + assert.equal(2, ts.syllableCount("gatewood")); + assert.equal(2, ts.syllableCount("gatx")); + assert.equal(1, ts.syllableCount("gatzke")); + assert.equal(2, ts.syllableCount("gauerke")); + assert.equal(1, ts.syllableCount("gaulke")); + assert.equal(1, ts.syllableCount("gawne")); + assert.equal(2, ts.syllableCount("gdansk")); + assert.equal(4, ts.syllableCount("geagea")); + assert.equal(1, ts.syllableCount("geerdes")); + assert.equal(1, ts.syllableCount("gehres")); + assert.equal(1, ts.syllableCount("gehrke")); + assert.equal(2, ts.syllableCount("geissler")); + assert.equal(4, ts.syllableCount("gelasia")); + assert.equal(3, ts.syllableCount("gen")); + assert.equal(2, ts.syllableCount("gendarme")); + assert.equal(5, ts.syllableCount("genealogy")); + assert.equal(4, ts.syllableCount("generales")); + assert.equal(4, ts.syllableCount("generically")); + assert.equal(4, ts.syllableCount("genetically")); + assert.equal(3, ts.syllableCount("gengler")); + assert.equal(2, ts.syllableCount("genial")); + assert.equal(4, ts.syllableCount("genitalia")); + assert.equal(2, ts.syllableCount("genius")); + assert.equal(3, ts.syllableCount("gensia")); + assert.equal(1, ts.syllableCount("genske")); + assert.equal(3, ts.syllableCount("gensler")); + assert.equal(3, ts.syllableCount("gentlest")); + assert.equal(3, ts.syllableCount("genuine")); + assert.equal(4, ts.syllableCount("genuinely")); + assert.equal(2, ts.syllableCount("georges")); + assert.equal(2, ts.syllableCount("georgetown")); + assert.equal(2, ts.syllableCount("georgette")); + assert.equal(2, ts.syllableCount("georgia")); + assert.equal(2, ts.syllableCount("georgian")); + assert.equal(2, ts.syllableCount("georgians")); + assert.equal(2, ts.syllableCount("georgiou")); + assert.equal(3, ts.syllableCount("gerace")); + assert.equal(2, ts.syllableCount("gerdeman")); + assert.equal(1, ts.syllableCount("gerdes")); + assert.equal(2, ts.syllableCount("gericke")); + assert.equal(1, ts.syllableCount("gerke")); + assert.equal(1, ts.syllableCount("germe")); + assert.equal(3, ts.syllableCount("gertler")); + assert.equal(1, ts.syllableCount("geschke")); + assert.equal(3, ts.syllableCount("gfeller")); + assert.equal(3, ts.syllableCount("ghanaian")); + assert.equal(3, ts.syllableCount("ghanaians")); + assert.equal(2, ts.syllableCount("giacco")); + assert.equal(3, ts.syllableCount("giacinta")); + assert.equal(3, ts.syllableCount("giacobbe")); + assert.equal(4, ts.syllableCount("giacomelli")); + assert.equal(4, ts.syllableCount("giacomini")); + assert.equal(3, ts.syllableCount("giacomo")); + assert.equal(4, ts.syllableCount("giacone")); + assert.equal(2, ts.syllableCount("giaimo")); + assert.equal(4, ts.syllableCount("gialanella")); + assert.equal(3, ts.syllableCount("giambalvo")); + assert.equal(2, ts.syllableCount("giambra")); + assert.equal(3, ts.syllableCount("giammarco")); + assert.equal(4, ts.syllableCount("giammarino")); + assert.equal(2, ts.syllableCount("giampa")); + assert.equal(3, ts.syllableCount("giampaolo")); + assert.equal(3, ts.syllableCount("giampietro")); + assert.equal(3, ts.syllableCount("giancola")); + assert.equal(3, ts.syllableCount("gianelli")); + assert.equal(4, ts.syllableCount("gianfrancesco")); + assert.equal(3, ts.syllableCount("giangrande")); + assert.equal(3, ts.syllableCount("gianino")); + assert.equal(5, ts.syllableCount("giannattasio")); + assert.equal(3, ts.syllableCount("giannelli")); + assert.equal(3, ts.syllableCount("giannetti")); + assert.equal(3, ts.syllableCount("giannetto")); + assert.equal(2, ts.syllableCount("gianni")); + assert.equal(3, ts.syllableCount("giannini")); + assert.equal(3, ts.syllableCount("giannola")); + assert.equal(3, ts.syllableCount("giannotti")); + assert.equal(3, ts.syllableCount("gianotti")); + assert.equal(3, ts.syllableCount("giaquinto")); + assert.equal(3, ts.syllableCount("giardina")); + assert.equal(3, ts.syllableCount("giardini")); + assert.equal(3, ts.syllableCount("giardino")); + assert.equal(4, ts.syllableCount("giarratano")); + assert.equal(3, ts.syllableCount("giarrusso")); + assert.equal(1, ts.syllableCount("gier")); + assert.equal(1, ts.syllableCount("gierke")); + assert.equal(2, ts.syllableCount("giesecke")); + assert.equal(3, ts.syllableCount("giesler")); + assert.equal(3, ts.syllableCount("giggly")); + assert.equal(3, ts.syllableCount("giguere")); + assert.equal(2, ts.syllableCount("gilberte")); + assert.equal(4, ts.syllableCount("gilbertine")); + assert.equal(3, ts.syllableCount("gilchrest")); + assert.equal(3, ts.syllableCount("gilcrest")); + assert.equal(1, ts.syllableCount("gilkes")); + assert.equal(2, ts.syllableCount("gioia")); + assert.equal(3, ts.syllableCount("giordani")); + assert.equal(3, ts.syllableCount("giordano")); + assert.equal(2, ts.syllableCount("giorgi")); + assert.equal(2, ts.syllableCount("giorgia")); + assert.equal(4, ts.syllableCount("giovanelli")); + assert.equal(4, ts.syllableCount("giovanetti")); + assert.equal(4, ts.syllableCount("giovannetti")); + assert.equal(4, ts.syllableCount("giovannini")); + assert.equal(4, ts.syllableCount("giovannoni")); + assert.equal(3, ts.syllableCount("giovenco")); + assert.equal(4, ts.syllableCount("giovinazzo")); + assert.equal(2, ts.syllableCount("giraffe")); + assert.equal(2, ts.syllableCount("giraffes")); + assert.equal(3, ts.syllableCount("girdler")); + assert.equal(3, ts.syllableCount("girouard")); + assert.equal(3, ts.syllableCount("gisler")); + assert.equal(2, ts.syllableCount("gittler")); + assert.equal(2, ts.syllableCount("givebacks")); + assert.equal(1, ts.syllableCount("gjerde")); + assert.equal(2, ts.syllableCount("glacier")); + assert.equal(2, ts.syllableCount("glaciers")); + assert.equal(2, ts.syllableCount("glazebrook")); + assert.equal(2, ts.syllableCount("glenfed")); + assert.equal(2, ts.syllableCount("glidewell")); + assert.equal(1, ts.syllableCount("glimpse")); + assert.equal(2, ts.syllableCount("gloucester")); + assert.equal(2, ts.syllableCount("glyndebourne")); + assert.equal(2, ts.syllableCount("goates")); + assert.equal(1, ts.syllableCount("gocke")); + assert.equal(1, ts.syllableCount("goecke")); + assert.equal(1, ts.syllableCount("goedde")); + assert.equal(2, ts.syllableCount("goedecke")); + assert.equal(3, ts.syllableCount("goemon")); + assert.equal(3, ts.syllableCount("goering")); + assert.equal(1, ts.syllableCount("goerke")); + assert.equal(1, ts.syllableCount("goette")); + assert.equal(1, ts.syllableCount("goetze")); + assert.equal(3, ts.syllableCount("goewey")); + assert.equal(1, ts.syllableCount("gohlke")); + assert.equal(1, ts.syllableCount("golde")); + assert.equal(3, ts.syllableCount("goldfinches")); + assert.equal(2, ts.syllableCount("goleman")); + assert.equal(5, ts.syllableCount("golembiewski")); + assert.equal(2, ts.syllableCount("gomes")); + assert.equal(3, ts.syllableCount("gondolier")); + assert.equal(4, ts.syllableCount("gonorrhea")); + assert.equal(2, ts.syllableCount("gonyer")); + assert.equal(3, ts.syllableCount("gonzales")); + assert.equal(2, ts.syllableCount("goosefish")); + assert.equal(2, ts.syllableCount("goosefoot")); + assert.equal(2, ts.syllableCount("goracke")); + assert.equal(4, ts.syllableCount("Gordievsky")); + assert.equal(2, ts.syllableCount("gottesman")); + assert.equal(1, ts.syllableCount("gouin")); + assert.equal(3, ts.syllableCount("govea")); + assert.equal(3, ts.syllableCount("govpx")); + assert.equal(1, ts.syllableCount("grabbe")); + assert.equal(2, ts.syllableCount("graceland")); + assert.equal(1, ts.syllableCount("grahams")); + assert.equal(1, ts.syllableCount("grande")); + assert.equal(2, ts.syllableCount("grapefruit")); + assert.equal(2, ts.syllableCount("grapefruits")); + assert.equal(2, ts.syllableCount("grapeshot")); + assert.equal(2, ts.syllableCount("grapevine")); + assert.equal(2, ts.syllableCount("grapevines")); + assert.equal(3, ts.syllableCount("graphically")); + assert.equal(3, ts.syllableCount("grassia")); + assert.equal(4, ts.syllableCount("gratuities")); + assert.equal(4, ts.syllableCount("gratuitous")); + assert.equal(5, ts.syllableCount("gratuitously")); + assert.equal(1, ts.syllableCount("graue")); + assert.equal(1, ts.syllableCount("graunke")); + assert.equal(2, ts.syllableCount("graveline")); + assert.equal(5, ts.syllableCount("gravitationally")); + assert.equal(2, ts.syllableCount("greasewood")); + assert.equal(3, ts.syllableCount("greeniaus")); + assert.equal(1, ts.syllableCount("greer")); + assert.equal(1, ts.syllableCount("greinke")); + assert.equal(1, ts.syllableCount("greunke")); + assert.equal(3, ts.syllableCount("griesa")); + assert.equal(1, ts.syllableCount("grinde")); + assert.equal(4, ts.syllableCount("grismer")); + assert.equal(2, ts.syllableCount("grobler")); + assert.equal(2, ts.syllableCount("groene")); + assert.equal(3, ts.syllableCount("groening")); + assert.equal(2, ts.syllableCount("grolier")); + assert.equal(2, ts.syllableCount("grosvenor")); + assert.equal(2, ts.syllableCount("groveman")); + assert.equal(2, ts.syllableCount("gruel")); + assert.equal(3, ts.syllableCount("grueling")); + assert.equal(2, ts.syllableCount("gruet")); + assert.equal(1, ts.syllableCount("gruhlke")); + assert.equal(2, ts.syllableCount("gruis")); + assert.equal(1, ts.syllableCount("grulke")); + assert.equal(2, ts.syllableCount("grunebaum")); + assert.equal(3, ts.syllableCount("grzelak")); + assert.equal(4, ts.syllableCount("grzesiak")); + assert.equal(5, ts.syllableCount("grzeskowiak")); + assert.equal(2, ts.syllableCount("grzyb")); + assert.equal(4, ts.syllableCount("grzybowski")); + assert.equal(3, ts.syllableCount("grzywacz")); + assert.equal(4, ts.syllableCount("grzywinski")); + assert.equal(2, ts.syllableCount("gschwind")); + assert.equal(2, ts.syllableCount("gsell")); + assert.equal(2, ts.syllableCount("gtech")); + assert.equal(5, ts.syllableCount("guadarrama")); + assert.equal(3, ts.syllableCount("gucciardo")); + assert.equal(2, ts.syllableCount("guenette")); + assert.equal(1, ts.syllableCount("guerre")); + assert.equal(5, ts.syllableCount("guglielmetti")); + assert.equal(4, ts.syllableCount("guglielmi")); + assert.equal(4, ts.syllableCount("guglielmo")); + assert.equal(3, ts.syllableCount("guiana")); + assert.equal(2, ts.syllableCount("guidebook")); + assert.equal(2, ts.syllableCount("guidebooks")); + assert.equal(2, ts.syllableCount("guideline")); + assert.equal(2, ts.syllableCount("guidelines")); + assert.equal(2, ts.syllableCount("guidepost")); + assert.equal(2, ts.syllableCount("guideposts")); + assert.equal(3, ts.syllableCount("guidone")); + assert.equal(3, ts.syllableCount("guidry")); + assert.equal(2, ts.syllableCount("guillotte")); + assert.equal(2, ts.syllableCount("guinier")); + assert.equal(2, ts.syllableCount("guisewite")); + assert.equal(3, ts.syllableCount("gundry")); + assert.equal(3, ts.syllableCount("gunfire")); + assert.equal(3, ts.syllableCount("gurgling")); + assert.equal(3, ts.syllableCount("gurion")); + assert.equal(3, ts.syllableCount("gurtler")); + assert.equal(2, ts.syllableCount("guseman")); + assert.equal(3, ts.syllableCount("gusler")); + assert.equal(3, ts.syllableCount("gustave")); + assert.equal(2, ts.syllableCount("guzzler")); + assert.equal(4, ts.syllableCount("gymnasia")); + assert.equal(1, ts.syllableCount("haacke")); + assert.equal(3, ts.syllableCount("habeas")); + assert.equal(4, ts.syllableCount("hacienda")); + assert.equal(1, ts.syllableCount("hacke")); + assert.equal(2, ts.syllableCount("hackl")); + assert.equal(3, ts.syllableCount("hackler")); + assert.equal(2, ts.syllableCount("hades")); + assert.equal(3, ts.syllableCount("hadler")); + assert.equal(3, ts.syllableCount("haering")); + assert.equal(2, ts.syllableCount("haeussler")); + assert.equal(2, ts.syllableCount("hafeman")); + assert.equal(2, ts.syllableCount("hageman")); + assert.equal(2, ts.syllableCount("hagemann")); + assert.equal(2, ts.syllableCount("hagewood")); + assert.equal(1, ts.syllableCount("hague")); + assert.equal(1, ts.syllableCount("hahne")); + assert.equal(2, ts.syllableCount("haist")); + assert.equal(3, ts.syllableCount("hajime")); + assert.equal(3, ts.syllableCount("halcyon")); + assert.equal(3, ts.syllableCount("halcyone")); + assert.equal(2, ts.syllableCount("haldeman")); + assert.equal(2, ts.syllableCount("hallbauer")); + assert.equal(2, ts.syllableCount("halteman")); + assert.equal(3, ts.syllableCount("hamblen")); + assert.equal(3, ts.syllableCount("hamler")); + assert.equal(1, ts.syllableCount("hampe")); + assert.equal(3, ts.syllableCount("hamtramck")); + assert.equal(2, ts.syllableCount("hanemann")); + assert.equal(1, ts.syllableCount("hanke")); + assert.equal(1, ts.syllableCount("hankes")); + assert.equal(2, ts.syllableCount("hanneman")); + assert.equal(2, ts.syllableCount("hannemann")); + assert.equal(4, ts.syllableCount("hanseatic")); + assert.equal(2, ts.syllableCount("hapeman")); + assert.equal(1, ts.syllableCount("happe")); + assert.equal(1, ts.syllableCount("haque")); + assert.equal(2, ts.syllableCount("harangue")); + assert.equal(2, ts.syllableCount("harangued")); + assert.equal(2, ts.syllableCount("harangues")); + assert.equal(3, ts.syllableCount("harare")); + assert.equal(4, ts.syllableCount("harclerode")); + assert.equal(2, ts.syllableCount("hardebeck")); + assert.equal(2, ts.syllableCount("hardeman")); + assert.equal(2, ts.syllableCount("hardwicke")); + assert.equal(2, ts.syllableCount("harebrained")); + assert.equal(2, ts.syllableCount("harewood")); + assert.equal(1, ts.syllableCount("harke")); + assert.equal(1, ts.syllableCount("harmes")); + assert.equal(1, ts.syllableCount("harpe")); + assert.equal(1, ts.syllableCount("harre")); + assert.equal(1, ts.syllableCount("harte")); + assert.equal(2, ts.syllableCount("hartl")); + assert.equal(3, ts.syllableCount("haruo")); + assert.equal(1, ts.syllableCount("haschke")); + assert.equal(2, ts.syllableCount("haseman")); + assert.equal(3, ts.syllableCount("hasler")); + assert.equal(2, ts.syllableCount("hass")); + assert.equal(2, ts.syllableCount("hassler")); + assert.equal(2, ts.syllableCount("hatheway")); + assert.equal(3, ts.syllableCount("hatler")); + assert.equal(2, ts.syllableCount("haueter")); + assert.equal(3, ts.syllableCount("hausler")); + assert.equal(2, ts.syllableCount("havelock")); + assert.equal(2, ts.syllableCount("haveman")); + assert.equal(3, ts.syllableCount("hawaii")); + assert.equal(3, ts.syllableCount("hawaiian")); + assert.equal(3, ts.syllableCount("hawaiians")); + assert.equal(1, ts.syllableCount("hawke")); + assert.equal(1, ts.syllableCount("hawkes")); + assert.equal(2, ts.syllableCount("hawkiness")); + assert.equal(2, ts.syllableCount("haydn")); + assert.equal(2, ts.syllableCount("haynesworth")); + assert.equal(2, ts.syllableCount("hbox")); + assert.equal(4, ts.syllableCount("hces")); + assert.equal(3, ts.syllableCount("hebrides")); + assert.equal(2, ts.syllableCount("hedgecock")); + assert.equal(2, ts.syllableCount("hedgehog")); + assert.equal(2, ts.syllableCount("hedgehogs")); + assert.equal(2, ts.syllableCount("hedgepath")); + assert.equal(2, ts.syllableCount("heffler")); + assert.equal(2, ts.syllableCount("hegeman")); + assert.equal(2, ts.syllableCount("hehmeyer")); + assert.equal(2, ts.syllableCount("heideman")); + assert.equal(2, ts.syllableCount("heidemann")); + assert.equal(3, ts.syllableCount("heidler")); + assert.equal(2, ts.syllableCount("heigl")); + assert.equal(2, ts.syllableCount("heikes")); + assert.equal(2, ts.syllableCount("heileman")); + assert.equal(2, ts.syllableCount("heindl")); + assert.equal(2, ts.syllableCount("heinecke")); + assert.equal(2, ts.syllableCount("heineman")); + assert.equal(2, ts.syllableCount("heinemann")); + assert.equal(2, ts.syllableCount("heinicke")); + assert.equal(1, ts.syllableCount("heinke")); + assert.equal(2, ts.syllableCount("heinl")); + assert.equal(3, ts.syllableCount("heinlen")); + assert.equal(1, ts.syllableCount("heintze")); + assert.equal(1, ts.syllableCount("heinze")); + assert.equal(3, ts.syllableCount("heishman")); + assert.equal(3, ts.syllableCount("heisler")); + assert.equal(3, ts.syllableCount("helbling")); + assert.equal(5, ts.syllableCount("helionetics")); + assert.equal(1, ts.syllableCount("helke")); + assert.equal(1, ts.syllableCount("helme")); + assert.equal(1, ts.syllableCount("helmes")); + assert.equal(1, ts.syllableCount("helmke")); + assert.equal(3, ts.syllableCount("hempfling")); + assert.equal(2, ts.syllableCount("henceforth")); + assert.equal(3, ts.syllableCount("hendren")); + assert.equal(3, ts.syllableCount("hendrie")); + assert.equal(1, ts.syllableCount("henke")); + assert.equal(1, ts.syllableCount("henkes")); + assert.equal(3, ts.syllableCount("henneberger")); + assert.equal(2, ts.syllableCount("henneman")); + assert.equal(3, ts.syllableCount("henrie")); + assert.equal(2, ts.syllableCount("henrique")); + assert.equal(1, ts.syllableCount("hense")); + assert.equal(3, ts.syllableCount("hensler")); + assert.equal(1, ts.syllableCount("henze")); + assert.equal(1, ts.syllableCount("heppe")); + assert.equal(2, ts.syllableCount("heppler")); + assert.equal(4, ts.syllableCount("herculean")); + assert.equal(3, ts.syllableCount("hercules")); + assert.equal(2, ts.syllableCount("hereby")); + assert.equal(2, ts.syllableCount("herendeen")); + assert.equal(3, ts.syllableCount("heretofore")); + assert.equal(2, ts.syllableCount("herewith")); + assert.equal(2, ts.syllableCount("hernandes")); + assert.equal(3, ts.syllableCount("heroic")); + assert.equal(3, ts.syllableCount("heroics")); + assert.equal(3, ts.syllableCount("heroin")); + assert.equal(3, ts.syllableCount("heroine")); + assert.equal(3, ts.syllableCount("heroines")); + assert.equal(4, ts.syllableCount("heroism")); + assert.equal(3, ts.syllableCount("heroized")); + assert.equal(1, ts.syllableCount("herre")); + assert.equal(3, ts.syllableCount("hertzler")); + assert.equal(3, ts.syllableCount("hesler")); + assert.equal(2, ts.syllableCount("hessler")); + assert.equal(3, ts.syllableCount("hestia")); + assert.equal(7, ts.syllableCount("heterogeneity")); + assert.equal(2, ts.syllableCount("hettler")); + assert.equal(4, ts.syllableCount("hfdf")); + assert.equal(3, ts.syllableCount("hgh")); + assert.equal(4, ts.syllableCount("hialeah")); + assert.equal(2, ts.syllableCount("hibbler")); + assert.equal(4, ts.syllableCount("hideaki")); + assert.equal(2, ts.syllableCount("hidebound")); + assert.equal(2, ts.syllableCount("hideout")); + assert.equal(2, ts.syllableCount("hideouts")); + assert.equal(4, ts.syllableCount("hierarchy")); + assert.equal(1, ts.syllableCount("hiers")); + assert.equal(1, ts.syllableCount("hilde")); + assert.equal(3, ts.syllableCount("hildegarde")); + assert.equal(3, ts.syllableCount("hildegardes")); + assert.equal(2, ts.syllableCount("hileman")); + assert.equal(2, ts.syllableCount("hilemon")); + assert.equal(2, ts.syllableCount("hilgeman")); + assert.equal(2, ts.syllableCount("hilliard")); + assert.equal(1, ts.syllableCount("hilmes")); + assert.equal(2, ts.syllableCount("hinchcliffe")); + assert.equal(2, ts.syllableCount("hinchliffe")); + assert.equal(1, ts.syllableCount("hinde")); + assert.equal(1, ts.syllableCount("hindes")); + assert.equal(4, ts.syllableCount("hinduism")); + assert.equal(2, ts.syllableCount("hineman")); + assert.equal(1, ts.syllableCount("hintze")); + assert.equal(1, ts.syllableCount("hinze")); + assert.equal(1, ts.syllableCount("hippe")); + assert.equal(2, ts.syllableCount("hippler")); + assert.equal(3, ts.syllableCount("hirai")); + assert.equal(2, ts.syllableCount("hire")); + assert.equal(2, ts.syllableCount("hired")); + assert.equal(2, ts.syllableCount("hires")); + assert.equal(4, ts.syllableCount("hiroaki")); + assert.equal(3, ts.syllableCount("hirose")); + assert.equal(3, ts.syllableCount("hisao")); + assert.equal(2, ts.syllableCount("hitzeman")); + assert.equal(3, ts.syllableCount("HIV")); + assert.equal(2, ts.syllableCount("hjelm")); + assert.equal(2, ts.syllableCount("hjort")); + assert.equal(3, ts.syllableCount("hobbyist")); + assert.equal(3, ts.syllableCount("hobbyists")); + assert.equal(4, ts.syllableCount("hochstedler")); + assert.equal(4, ts.syllableCount("hochstetler")); + assert.equal(1, ts.syllableCount("hodde")); + assert.equal(2, ts.syllableCount("hodgepodge")); + assert.equal(3, ts.syllableCount("hoefler")); + assert.equal(3, ts.syllableCount("hoefling")); + assert.equal(1, ts.syllableCount("hoehne")); + assert.equal(2, ts.syllableCount("hoene")); + assert.equal(2, ts.syllableCount("hoeveler")); + assert.equal(2, ts.syllableCount("hoey")); + assert.equal(1, ts.syllableCount("hogue")); + assert.equal(2, ts.syllableCount("holcombe")); + assert.equal(1, ts.syllableCount("holde")); + assert.equal(2, ts.syllableCount("holdeman")); + assert.equal(3, ts.syllableCount("holdren")); + assert.equal(2, ts.syllableCount("holeman")); + assert.equal(2, ts.syllableCount("holleman")); + assert.equal(1, ts.syllableCount("holme")); + assert.equal(1, ts.syllableCount("holmes")); + assert.equal(1, ts.syllableCount("holste")); + assert.equal(1, ts.syllableCount("holte")); + assert.equal(3, ts.syllableCount("holyoak")); + assert.equal(3, ts.syllableCount("holyoke")); + assert.equal(3, ts.syllableCount("homebuilder")); + assert.equal(3, ts.syllableCount("homebuilders")); + assert.equal(3, ts.syllableCount("homebuilding")); + assert.equal(3, ts.syllableCount("homebuyers")); + assert.equal(2, ts.syllableCount("homecare")); + assert.equal(2, ts.syllableCount("homeclub")); + assert.equal(3, ts.syllableCount("homecoming")); + assert.equal(2, ts.syllableCount("homegrown")); + assert.equal(2, ts.syllableCount("homeland")); + assert.equal(2, ts.syllableCount("homelands")); + assert.equal(3, ts.syllableCount("homelessness")); + assert.equal(2, ts.syllableCount("homelike")); + assert.equal(2, ts.syllableCount("homemade")); + assert.equal(3, ts.syllableCount("homemaker")); + assert.equal(3, ts.syllableCount("homemakers")); + assert.equal(3, ts.syllableCount("homemaking")); + assert.equal(3, ts.syllableCount("homeporting")); + assert.equal(2, ts.syllableCount("homesick")); + assert.equal(3, ts.syllableCount("homesickness")); + assert.equal(2, ts.syllableCount("homesley")); + assert.equal(2, ts.syllableCount("homespun")); + assert.equal(2, ts.syllableCount("homestake")); + assert.equal(2, ts.syllableCount("homestate")); + assert.equal(2, ts.syllableCount("homestead")); + assert.equal(3, ts.syllableCount("homesteaded")); + assert.equal(2, ts.syllableCount("homestretch")); + assert.equal(2, ts.syllableCount("hometown")); + assert.equal(2, ts.syllableCount("homeward")); + assert.equal(2, ts.syllableCount("homewood")); + assert.equal(2, ts.syllableCount("homework")); + assert.equal(3, ts.syllableCount("homeworkers")); + assert.equal(6, ts.syllableCount("homogeneity")); + assert.equal(3, ts.syllableCount("honea")); + assert.equal(1, ts.syllableCount("honse")); + assert.equal(2, ts.syllableCount("hoobler")); + assert.equal(2, ts.syllableCount("hoosier")); + assert.equal(2, ts.syllableCount("hoosiers")); + assert.equal(2, ts.syllableCount("hopefuls")); + assert.equal(3, ts.syllableCount("hopelessness")); + assert.equal(2, ts.syllableCount("hopewell")); + assert.equal(1, ts.syllableCount("hopke")); + assert.equal(1, ts.syllableCount("hoppe")); + assert.equal(1, ts.syllableCount("hoppes")); + assert.equal(3, ts.syllableCount("horatio")); + assert.equal(3, ts.syllableCount("horatius")); + assert.equal(1, ts.syllableCount("horde")); + assert.equal(1, ts.syllableCount("hordes")); + assert.equal(2, ts.syllableCount("horehound")); + assert.equal(2, ts.syllableCount("hornblende")); + assert.equal(2, ts.syllableCount("horseback")); + assert.equal(2, ts.syllableCount("horseflesh")); + assert.equal(2, ts.syllableCount("horsehead")); + assert.equal(2, ts.syllableCount("horseman")); + assert.equal(3, ts.syllableCount("horsemanship")); + assert.equal(2, ts.syllableCount("horsemen")); + assert.equal(2, ts.syllableCount("horseplay")); + assert.equal(3, ts.syllableCount("horsepower")); + assert.equal(3, ts.syllableCount("horseradish")); + assert.equal(2, ts.syllableCount("horseshoe")); + assert.equal(2, ts.syllableCount("horseshoes")); + assert.equal(2, ts.syllableCount("horsetails")); + assert.equal(3, ts.syllableCount("hosea")); + assert.equal(3, ts.syllableCount("hosler")); + assert.equal(4, ts.syllableCount("hosseini")); + assert.equal(4, ts.syllableCount("hostetler")); + assert.equal(4, ts.syllableCount("hostutler")); + assert.equal(3, ts.syllableCount("hotelier")); + assert.equal(3, ts.syllableCount("hoteliers")); + assert.equal(2, ts.syllableCount("hottelet")); + assert.equal(3, ts.syllableCount("hotwired")); + assert.equal(1, ts.syllableCount("hotze")); + assert.equal(2, ts.syllableCount("hour")); + assert.equal(3, ts.syllableCount("hourglass")); + assert.equal(2, ts.syllableCount("hours")); + assert.equal(2, ts.syllableCount("houseboat")); + assert.equal(3, ts.syllableCount("housebroken")); + assert.equal(3, ts.syllableCount("housecleaning")); + assert.equal(2, ts.syllableCount("household")); + assert.equal(3, ts.syllableCount("householder")); + assert.equal(3, ts.syllableCount("householders")); + assert.equal(2, ts.syllableCount("households")); + assert.equal(3, ts.syllableCount("housekeeper")); + assert.equal(3, ts.syllableCount("housekeepers")); + assert.equal(3, ts.syllableCount("housekeeping")); + assert.equal(2, ts.syllableCount("houseknecht")); + assert.equal(2, ts.syllableCount("houseman")); + assert.equal(2, ts.syllableCount("houseware")); + assert.equal(2, ts.syllableCount("housewares")); + assert.equal(2, ts.syllableCount("housewife")); + assert.equal(2, ts.syllableCount("housewives")); + assert.equal(2, ts.syllableCount("housework")); + assert.equal(2, ts.syllableCount("houseworth")); + assert.equal(2, ts.syllableCount("housewright")); + assert.equal(2, ts.syllableCount("houy")); + assert.equal(1, ts.syllableCount("hovde")); + assert.equal(1, ts.syllableCount("howse")); + assert.equal(1, ts.syllableCount("howze")); + assert.equal(3, ts.syllableCount("hrawi")); + assert.equal(3, ts.syllableCount("hrdlicka")); + assert.equal(2, ts.syllableCount("hrncir")); + assert.equal(3, ts.syllableCount("hrubik")); + assert.equal(1, ts.syllableCount("hsiao")); + assert.equal(2, ts.syllableCount("hsieh")); + assert.equal(3, ts.syllableCount("huachuca")); + assert.equal(3, ts.syllableCount("huallaga")); + assert.equal(1, ts.syllableCount("huan")); + assert.equal(2, ts.syllableCount("huaneng")); + assert.equal(1, ts.syllableCount("huang")); + assert.equal(1, ts.syllableCount("huard")); + assert.equal(1, ts.syllableCount("hucke")); + assert.equal(3, ts.syllableCount("hudler")); + assert.equal(3, ts.syllableCount("huetta")); + assert.equal(1, ts.syllableCount("huette")); + assert.equal(2, ts.syllableCount("huey")); + assert.equal(4, ts.syllableCount("huffstetler")); + assert.equal(4, ts.syllableCount("huffstutler")); + assert.equal(4, ts.syllableCount("hufstedler")); + assert.equal(4, ts.syllableCount("hufstetler")); + assert.equal(2, ts.syllableCount("huggler")); + assert.equal(2, ts.syllableCount("hui")); + assert.equal(2, ts.syllableCount("huibregtse")); + assert.equal(2, ts.syllableCount("huish")); + assert.equal(1, ts.syllableCount("hulme")); + assert.equal(1, ts.syllableCount("hulse")); + assert.equal(3, ts.syllableCount("humblest")); + assert.equal(3, ts.syllableCount("humfry")); + assert.equal(2, ts.syllableCount("huml")); + assert.equal(3, ts.syllableCount("humphries")); + assert.equal(2, ts.syllableCount("hunches")); + assert.equal(1, ts.syllableCount("hunke")); + assert.equal(1, ts.syllableCount("hunte")); + assert.equal(2, ts.syllableCount("huot")); + assert.equal(3, ts.syllableCount("hurdler")); + assert.equal(3, ts.syllableCount("hurdling")); + assert.equal(2, ts.syllableCount("huseman")); + assert.equal(3, ts.syllableCount("hustler")); + assert.equal(3, ts.syllableCount("hustlers")); + assert.equal(3, ts.syllableCount("hustling")); + assert.equal(3, ts.syllableCount("hyades")); + assert.equal(5, ts.syllableCount("hydroelectric")); + assert.equal(3, ts.syllableCount("hydropower")); + assert.equal(3, ts.syllableCount("hygeia")); + assert.equal(4, ts.syllableCount("hyperbole")); + assert.equal(5, ts.syllableCount("hyperborean")); + assert.equal(5, ts.syllableCount("hypothetically")); + assert.equal(4, ts.syllableCount("hysterically")); + assert.equal(2, ts.syllableCount("hyun")); + assert.equal(4, ts.syllableCount("iafrate")); + assert.equal(2, ts.syllableCount("iain")); + assert.equal(5, ts.syllableCount("iannaccone")); + assert.equal(5, ts.syllableCount("iannacone")); + assert.equal(4, ts.syllableCount("iannone")); + assert.equal(5, ts.syllableCount("iavarone")); + assert.equal(2, ts.syllableCount("ibn")); + assert.equal(2, ts.syllableCount("iceberg")); + assert.equal(2, ts.syllableCount("icebergs")); + assert.equal(2, ts.syllableCount("icebox")); + assert.equal(3, ts.syllableCount("icebreaker")); + assert.equal(3, ts.syllableCount("icebreakers")); + assert.equal(2, ts.syllableCount("iceland")); + assert.equal(3, ts.syllableCount("icelandair")); + assert.equal(3, ts.syllableCount("icelandic")); + assert.equal(3, ts.syllableCount("iceskating")); + assert.equal(1, ts.syllableCount("ickes")); + assert.equal(3, ts.syllableCount("idalia")); + assert.equal(5, ts.syllableCount("idealistic")); + assert.equal(4, ts.syllableCount("idealized")); + assert.equal(3, ts.syllableCount("ideas")); + assert.equal(5, ts.syllableCount("ideologist")); + assert.equal(5, ts.syllableCount("ideology")); + assert.equal(5, ts.syllableCount("ideonomy")); + assert.equal(5, ts.syllableCount("idiotically")); + assert.equal(3, ts.syllableCount("idler")); + assert.equal(3, ts.syllableCount("idling")); + assert.equal(4, ts.syllableCount("ierardi")); + assert.equal(3, ts.syllableCount("iezzi")); + assert.equal(4, ts.syllableCount("iglesia")); + assert.equal(3, ts.syllableCount("ignatius")); + assert.equal(1, ts.syllableCount("ihde")); + assert.equal(1, ts.syllableCount("ihrke")); + assert.equal(2, ts.syllableCount("iiams")); + assert.equal(2, ts.syllableCount("iida")); + assert.equal(2, ts.syllableCount("iie")); + assert.equal(3, ts.syllableCount("ijames")); + assert.equal(3, ts.syllableCount("ikea")); + assert.equal(4, ts.syllableCount("ileana")); + assert.equal(4, ts.syllableCount("iliescu")); + assert.equal(1, ts.syllableCount("ilse")); + assert.equal(3, ts.syllableCount("imageries")); + assert.equal(3, ts.syllableCount("imagery")); + assert.equal(3, ts.syllableCount("imbroglio")); + assert.equal(3, ts.syllableCount("imm")); + assert.equal(2, ts.syllableCount("immense")); + assert.equal(3, ts.syllableCount("immensely")); + assert.equal(3, ts.syllableCount("immunetech")); + assert.equal(6, ts.syllableCount("impartiality")); + assert.equal(5, ts.syllableCount("imperiale")); + assert.equal(3, ts.syllableCount("impetuous")); + assert.equal(3, ts.syllableCount("impoverish")); + assert.equal(3, ts.syllableCount("impoverished")); + assert.equal(4, ts.syllableCount("impoverishes")); + assert.equal(4, ts.syllableCount("impoverishment")); + assert.equal(2, ts.syllableCount("impulse")); + assert.equal(3, ts.syllableCount("imrie")); + assert.equal(5, ts.syllableCount("inalienable")); + assert.equal(2, ts.syllableCount("incense")); + assert.equal(3, ts.syllableCount("incestuous")); + assert.equal(2, ts.syllableCount("inches")); + assert.equal(4, ts.syllableCount("incipient")); + assert.equal(4, ts.syllableCount("inconspicuous")); + assert.equal(6, ts.syllableCount("incoordination")); + assert.equal(4, ts.syllableCount("incorvaia")); + assert.equal(5, ts.syllableCount("indianians")); + assert.equal(3, ts.syllableCount("indifferent")); + assert.equal(4, ts.syllableCount("indosuez")); + assert.equal(2, ts.syllableCount("indulged")); + assert.equal(5, ts.syllableCount("industriale")); + assert.equal(4, ts.syllableCount("inequity")); + assert.equal(2, ts.syllableCount("ines")); + assert.equal(5, ts.syllableCount("inexperience")); + assert.equal(5, ts.syllableCount("inexperienced")); + assert.equal(3, ts.syllableCount("infectious")); + assert.equal(3, ts.syllableCount("ingenious")); + assert.equal(4, ts.syllableCount("ingeniously")); + assert.equal(3, ts.syllableCount("inglish")); + assert.equal(4, ts.syllableCount("ingratiate")); + assert.equal(5, ts.syllableCount("ingratiating")); + assert.equal(4, ts.syllableCount("initiate")); + assert.equal(5, ts.syllableCount("initiated")); + assert.equal(4, ts.syllableCount("initiates")); + assert.equal(5, ts.syllableCount("initiating")); + assert.equal(5, ts.syllableCount("initiation")); + assert.equal(5, ts.syllableCount("initiator")); + assert.equal(5, ts.syllableCount("initiators")); + assert.equal(7, ts.syllableCount("inmobiliaria")); + assert.equal(3, ts.syllableCount("inouye")); + assert.equal(3, ts.syllableCount("inquired")); + assert.equal(3, ts.syllableCount("inquires")); + assert.equal(4, ts.syllableCount("inquiries")); + assert.equal(4, ts.syllableCount("inquiring")); + assert.equal(3, ts.syllableCount("inscore")); + assert.equal(3, ts.syllableCount("inspired")); + assert.equal(6, ts.syllableCount("institucional")); + assert.equal(3, ts.syllableCount("intaglio")); + assert.equal(6, ts.syllableCount("intelligentsia")); + assert.equal(2, ts.syllableCount("intense")); + assert.equal(3, ts.syllableCount("intensely")); + assert.equal(5, ts.syllableCount("intercollegiate")); + assert.equal(3, ts.syllableCount("interdictes")); + assert.equal(2, ts.syllableCount("interest")); + assert.equal(3, ts.syllableCount("interested")); + assert.equal(3, ts.syllableCount("interesting")); + assert.equal(2, ts.syllableCount("interests")); + assert.equal(5, ts.syllableCount("intermingling")); + assert.equal(6, ts.syllableCount("internationale")); + assert.equal(2, ts.syllableCount("intrigue")); + assert.equal(2, ts.syllableCount("intrigued")); + assert.equal(2, ts.syllableCount("intrigues")); + assert.equal(3, ts.syllableCount("intuit")); + assert.equal(4, ts.syllableCount("intuition")); + assert.equal(4, ts.syllableCount("intuitive")); + assert.equal(5, ts.syllableCount("intuitively")); + assert.equal(4, ts.syllableCount("invaluable")); + assert.equal(3, ts.syllableCount("iole")); + assert.equal(3, ts.syllableCount("ione")); + assert.equal(4, ts.syllableCount("iorio")); + assert.equal(3, ts.syllableCount("iou")); + assert.equal(4, ts.syllableCount("iovine")); + assert.equal(4, ts.syllableCount("ironically")); + assert.equal(2, ts.syllableCount("ironton")); + assert.equal(3, ts.syllableCount("iroquois")); + assert.equal(4, ts.syllableCount("isadore")); + assert.equal(3, ts.syllableCount("isaiah")); + assert.equal(3, ts.syllableCount("isautier")); + assert.equal(2, ts.syllableCount("iseman")); + assert.equal(2, ts.syllableCount("isms")); + assert.equal(6, ts.syllableCount("isoelectronic")); + assert.equal(4, ts.syllableCount("isosceles")); + assert.equal(3, ts.syllableCount("israel")); + assert.equal(3, ts.syllableCount("italian")); + assert.equal(4, ts.syllableCount("italianate")); + assert.equal(3, ts.syllableCount("italians")); + assert.equal(2, ts.syllableCount("itll")); + assert.equal(3, ts.syllableCount("ixion")); + assert.equal(3, ts.syllableCount("izquierdo")); + assert.equal(4, ts.syllableCount("izvestia")); + assert.equal(2, ts.syllableCount("jacinthe")); + assert.equal(4, ts.syllableCount("jacobean")); + assert.equal(1, ts.syllableCount("jacque")); + assert.equal(1, ts.syllableCount("jacques")); + assert.equal(2, ts.syllableCount("jacquie")); + assert.equal(2, ts.syllableCount("jaenicke")); + assert.equal(1, ts.syllableCount("jahnke")); + assert.equal(2, ts.syllableCount("jaime")); + assert.equal(2, ts.syllableCount("jaimes")); + assert.equal(2, ts.syllableCount("jakeway")); + assert.equal(2, ts.syllableCount("jameson")); + assert.equal(2, ts.syllableCount("jamestown")); + assert.equal(2, ts.syllableCount("jamesway")); + assert.equal(2, ts.syllableCount("janeway")); + assert.equal(2, ts.syllableCount("janicke")); + assert.equal(1, ts.syllableCount("janke")); + assert.equal(1, ts.syllableCount("jaques")); + assert.equal(2, ts.syllableCount("jared")); + assert.equal(2, ts.syllableCount("jayme")); + assert.equal(2, ts.syllableCount("jaymes")); + assert.equal(1, ts.syllableCount("jeers")); + assert.equal(2, ts.syllableCount("jefferies")); + assert.equal(4, ts.syllableCount("jeopardizes")); + assert.equal(3, ts.syllableCount("jerboas")); + assert.equal(1, ts.syllableCount("jerde")); + assert.equal(2, ts.syllableCount("jere")); + assert.equal(4, ts.syllableCount("jeroboam")); + assert.equal(3, ts.syllableCount("jerrome")); + assert.equal(1, ts.syllableCount("jeschke")); + assert.equal(3, ts.syllableCount("jesmer")); + assert.equal(3, ts.syllableCount("jesuit")); + assert.equal(3, ts.syllableCount("jesuits")); + assert.equal(1, ts.syllableCount("jewkes")); + assert.equal(1, ts.syllableCount("jiang")); + assert.equal(2, ts.syllableCount("jiangsu")); + assert.equal(2, ts.syllableCount("jiawen")); + assert.equal(4, ts.syllableCount("jingoism")); + assert.equal(4, ts.syllableCount("jingoistic")); + assert.equal(3, ts.syllableCount("joachim")); + assert.equal(3, ts.syllableCount("joachims")); + assert.equal(2, ts.syllableCount("joann")); + assert.equal(3, ts.syllableCount("joanna")); + assert.equal(2, ts.syllableCount("jocelin")); + assert.equal(2, ts.syllableCount("joceline")); + assert.equal(2, ts.syllableCount("jocelyn")); + assert.equal(2, ts.syllableCount("jocelyne")); + assert.equal(2, ts.syllableCount("jocylan")); + assert.equal(2, ts.syllableCount("joedicke")); + assert.equal(2, ts.syllableCount("joel")); + assert.equal(2, ts.syllableCount("joey")); + assert.equal(1, ts.syllableCount("joffe")); + assert.equal(1, ts.syllableCount("joie")); + assert.equal(3, ts.syllableCount("jolicoeur")); + assert.equal(2, ts.syllableCount("jolliffe")); + assert.equal(1, ts.syllableCount("jorde")); + assert.equal(2, ts.syllableCount("jose")); + assert.equal(2, ts.syllableCount("joycelyn")); + assert.equal(2, ts.syllableCount("jr")); + assert.equal(2, ts.syllableCount("jua")); + assert.equal(2, ts.syllableCount("judishe")); + assert.equal(2, ts.syllableCount("juedes")); + assert.equal(2, ts.syllableCount("juenemann")); + assert.equal(1, ts.syllableCount("juhnke")); + assert.equal(4, ts.syllableCount("julietta")); + assert.equal(3, ts.syllableCount("jurgensmeyer")); + assert.equal(2, ts.syllableCount("juul")); + assert.equal(3, ts.syllableCount("kadrmas")); + assert.equal(3, ts.syllableCount("kahane")); + assert.equal(1, ts.syllableCount("kahle")); + assert.equal(1, ts.syllableCount("kahre")); + assert.equal(3, ts.syllableCount("kalliel")); + assert.equal(1, ts.syllableCount("kalthoff")); + assert.equal(4, ts.syllableCount("kamakau")); + assert.equal(4, ts.syllableCount("kamikaze")); + assert.equal(3, ts.syllableCount("kamler")); + assert.equal(1, ts.syllableCount("kampe")); + assert.equal(4, ts.syllableCount("Kampuchea")); + assert.equal(3, ts.syllableCount("kanade")); + assert.equal(4, ts.syllableCount("kaniewski")); + assert.equal(4, ts.syllableCount("kanouse")); + assert.equal(3, ts.syllableCount("kantian")); + assert.equal(4, ts.syllableCount("kaohsiung")); + assert.equal(3, ts.syllableCount("kapler")); + assert.equal(1, ts.syllableCount("kappes")); + assert.equal(2, ts.syllableCount("kappler")); + assert.equal(4, ts.syllableCount("karaoke")); + assert.equal(3, ts.syllableCount("karate")); + assert.equal(3, ts.syllableCount("kardashian")); + assert.equal(1, ts.syllableCount("kartes")); + assert.equal(2, ts.syllableCount("kaseman")); + assert.equal(3, ts.syllableCount("kasler")); + assert.equal(3, ts.syllableCount("kasprzak")); + assert.equal(3, ts.syllableCount("kasprzyk")); + assert.equal(3, ts.syllableCount("kasriel")); + assert.equal(2, ts.syllableCount("kassler")); + assert.equal(3, ts.syllableCount("kastenmeier")); + assert.equal(2, ts.syllableCount("kastl")); + assert.equal(4, ts.syllableCount("kataoka")); + assert.equal(2, ts.syllableCount("katharine")); + assert.equal(3, ts.syllableCount("katia")); + assert.equal(3, ts.syllableCount("kawai")); + assert.equal(3, ts.syllableCount("kawate")); + assert.equal(3, ts.syllableCount("kazuo")); + assert.equal(2, ts.syllableCount("keay")); + assert.equal(2, ts.syllableCount("keebler")); + assert.equal(1, ts.syllableCount("keeffe")); + assert.equal(1, ts.syllableCount("kehne")); + assert.equal(1, ts.syllableCount("kehres")); + assert.equal(3, ts.syllableCount("keiichi")); + assert.equal(2, ts.syllableCount("keio")); + assert.equal(3, ts.syllableCount("keisler")); + assert.equal(3, ts.syllableCount("keisling")); + assert.equal(3, ts.syllableCount("keister")); + assert.equal(3, ts.syllableCount("keisuke")); + assert.equal(2, ts.syllableCount("keleman")); + assert.equal(2, ts.syllableCount("kelemen")); + assert.equal(1, ts.syllableCount("kempe")); + assert.equal(1, ts.syllableCount("kempke")); + assert.equal(4, ts.syllableCount("kenealy")); + assert.equal(2, ts.syllableCount("kennebeck")); + assert.equal(2, ts.syllableCount("kennemore")); + assert.equal(3, ts.syllableCount("kensler")); + assert.equal(4, ts.syllableCount("keplinger")); + assert.equal(2, ts.syllableCount("keppler")); + assert.equal(3, ts.syllableCount("kerien")); + assert.equal(3, ts.syllableCount("Kerouac")); + assert.equal(4, ts.syllableCount("kerpedjiev")); + assert.equal(3, ts.syllableCount("kesler")); + assert.equal(3, ts.syllableCount("kesling")); + assert.equal(2, ts.syllableCount("kessler")); + assert.equal(4, ts.syllableCount("kganakga")); + assert.equal(3, ts.syllableCount("kgori")); + assert.equal(2, ts.syllableCount("Khaled")); + assert.equal(1, ts.syllableCount("kibbe")); + assert.equal(1, ts.syllableCount("kidde")); + assert.equal(1, ts.syllableCount("kiehne")); + assert.equal(1, ts.syllableCount("kier")); + assert.equal(2, ts.syllableCount("kiev")); + assert.equal(3, ts.syllableCount("kigale")); + assert.equal(4, ts.syllableCount("kightlinger")); + assert.equal(2, ts.syllableCount("killian")); + assert.equal(4, ts.syllableCount("killilea")); + assert.equal(2, ts.syllableCount("kimbler")); + assert.equal(3, ts.syllableCount("kimbriel")); + assert.equal(3, ts.syllableCount("kimler")); + assert.equal(3, ts.syllableCount("kindler")); + assert.equal(3, ts.syllableCount("kingry")); + assert.equal(3, ts.syllableCount("kinsler")); + assert.equal(4, ts.syllableCount("kinzlmaier")); + assert.equal(4, ts.syllableCount("kiplinger")); + assert.equal(1, ts.syllableCount("kippes")); + assert.equal(3, ts.syllableCount("kirouac")); + assert.equal(3, ts.syllableCount("kisler")); + assert.equal(3, ts.syllableCount("kisling")); + assert.equal(2, ts.syllableCount("kissler")); + assert.equal(2, ts.syllableCount("kjar")); + assert.equal(2, ts.syllableCount("kjos")); + assert.equal(2, ts.syllableCount("klabunde")); + assert.equal(1, ts.syllableCount("kleer")); + assert.equal(2, ts.syllableCount("kleindienst")); + assert.equal(1, ts.syllableCount("klenke")); + assert.equal(1, ts.syllableCount("kleppe")); + assert.equal(2, ts.syllableCount("kliethermes")); + assert.equal(3, ts.syllableCount("klingler")); + assert.equal(1, ts.syllableCount("klinke")); + assert.equal(1, ts.syllableCount("klitzke")); + assert.equal(1, ts.syllableCount("klocke")); + assert.equal(2, ts.syllableCount("kmart")); + assert.equal(2, ts.syllableCount("kmetz")); + assert.equal(2, ts.syllableCount("kmiec")); + assert.equal(3, ts.syllableCount("kmiecik")); + assert.equal(1, ts.syllableCount("knapke")); + assert.equal(1, ts.syllableCount("kneer")); + assert.equal(3, ts.syllableCount("knievel")); + assert.equal(2, ts.syllableCount("knifelike")); + assert.equal(1, ts.syllableCount("knobbe")); + assert.equal(3, ts.syllableCount("knoedler")); + assert.equal(3, ts.syllableCount("knowledgeware")); + assert.equal(1, ts.syllableCount("knowles")); + assert.equal(2, ts.syllableCount("Knute")); + assert.equal(3, ts.syllableCount("koala")); + assert.equal(4, ts.syllableCount("kociemba")); + assert.equal(3, ts.syllableCount("koegler")); + assert.equal(1, ts.syllableCount("koehne")); + assert.equal(1, ts.syllableCount("koepke")); + assert.equal(1, ts.syllableCount("koeppe")); + assert.equal(3, ts.syllableCount("koestler")); + assert.equal(1, ts.syllableCount("koetje")); + assert.equal(3, ts.syllableCount("kofler")); + assert.equal(3, ts.syllableCount("kogler")); + assert.equal(1, ts.syllableCount("kohne")); + assert.equal(1, ts.syllableCount("kohnke")); + assert.equal(3, ts.syllableCount("koichi")); + assert.equal(3, ts.syllableCount("kokate")); + assert.equal(1, ts.syllableCount("kolbe")); + assert.equal(5, ts.syllableCount("kolodziejski")); + assert.equal(2, ts.syllableCount("kooy")); + assert.equal(3, ts.syllableCount("kooyman")); + assert.equal(1, ts.syllableCount("kopke")); + assert.equal(1, ts.syllableCount("koppe")); + assert.equal(1, ts.syllableCount("koppes")); + assert.equal(3, ts.syllableCount("korea")); + assert.equal(4, ts.syllableCount("koreagate")); + assert.equal(3, ts.syllableCount("korean")); + assert.equal(3, ts.syllableCount("koreans")); + assert.equal(3, ts.syllableCount("koreas")); + assert.equal(1, ts.syllableCount("korte")); + assert.equal(5, ts.syllableCount("korzeniewski")); + assert.equal(2, ts.syllableCount("kosanke")); + assert.equal(4, ts.syllableCount("kostrzewski")); + assert.equal(3, ts.syllableCount("koteles")); + assert.equal(3, ts.syllableCount("kotler")); + assert.equal(2, ts.syllableCount("kottler")); + assert.equal(3, ts.syllableCount("kouri")); + assert.equal(2, ts.syllableCount("kowalke")); + assert.equal(1, ts.syllableCount("krabbe")); + assert.equal(1, ts.syllableCount("kracke")); + assert.equal(2, ts.syllableCount("kraeutler")); + assert.equal(2, ts.syllableCount("krajina")); + assert.equal(1, ts.syllableCount("krampe")); + assert.equal(1, ts.syllableCount("kratzke")); + assert.equal(1, ts.syllableCount("krauer")); + assert.equal(1, ts.syllableCount("kreher")); + assert.equal(3, ts.syllableCount("kreidler")); + assert.equal(3, ts.syllableCount("kreisher")); + assert.equal(1, ts.syllableCount("krenke")); + assert.equal(2, ts.syllableCount("kressler")); + assert.equal(1, ts.syllableCount("krienke")); + assert.equal(1, ts.syllableCount("kriete")); + assert.equal(1, ts.syllableCount("krinke")); + assert.equal(2, ts.syllableCount("kristoffe")); + assert.equal(3, ts.syllableCount("kroening")); + assert.equal(1, ts.syllableCount("kroenke")); + assert.equal(2, ts.syllableCount("krone")); + assert.equal(2, ts.syllableCount("kruckeberg")); + assert.equal(1, ts.syllableCount("kruschke")); + assert.equal(4, ts.syllableCount("ksiazek")); + assert.equal(2, ts.syllableCount("kuala")); + assert.equal(1, ts.syllableCount("kuan")); + assert.equal(3, ts.syllableCount("kuchler")); + assert.equal(3, ts.syllableCount("kudrna")); + assert.equal(3, ts.syllableCount("kuechler")); + assert.equal(1, ts.syllableCount("kuehne")); + assert.equal(3, ts.syllableCount("kugler")); + assert.equal(1, ts.syllableCount("kuhne")); + assert.equal(1, ts.syllableCount("kuhnke")); + assert.equal(4, ts.syllableCount("kumagai")); + assert.equal(1, ts.syllableCount("kunde")); + assert.equal(1, ts.syllableCount("kuntze")); + assert.equal(1, ts.syllableCount("kunze")); + assert.equal(2, ts.syllableCount("kuo")); + assert.equal(3, ts.syllableCount("kusler")); + assert.equal(2, ts.syllableCount("kuzniar")); + assert.equal(2, ts.syllableCount("kvale")); + assert.equal(2, ts.syllableCount("kvam")); + assert.equal(4, ts.syllableCount("kvasnicka")); + assert.equal(2, ts.syllableCount("kvetch")); + assert.equal(3, ts.syllableCount("kveton")); + assert.equal(3, ts.syllableCount("kvistad")); + assert.equal(4, ts.syllableCount("kvitsinsky")); + assert.equal(5, ts.syllableCount("kwh")); + assert.equal(1, ts.syllableCount("labbe")); + assert.equal(3, ts.syllableCount("labine")); + assert.equal(2, ts.syllableCount("labonte")); + assert.equal(4, ts.syllableCount("laboratories")); + assert.equal(4, ts.syllableCount("laboratory")); + assert.equal(2, ts.syllableCount("laborde")); + assert.equal(4, ts.syllableCount("labossiere")); + assert.equal(2, ts.syllableCount("labouisse")); + assert.equal(2, ts.syllableCount("labrecque")); + assert.equal(3, ts.syllableCount("labrie")); + assert.equal(3, ts.syllableCount("lacaze")); + assert.equal(2, ts.syllableCount("lacefield")); + assert.equal(2, ts.syllableCount("lacewell")); + assert.equal(4, ts.syllableCount("lacoursiere")); + assert.equal(2, ts.syllableCount("lacquer")); + assert.equal(3, ts.syllableCount("laduke")); + assert.equal(4, ts.syllableCount("laferriere")); + assert.equal(2, ts.syllableCount("laffitte")); + assert.equal(2, ts.syllableCount("lafitte")); + assert.equal(3, ts.syllableCount("lafler")); + assert.equal(2, ts.syllableCount("laforte")); + assert.equal(4, ts.syllableCount("lafreniere")); + assert.equal(3, ts.syllableCount("lagace")); + assert.equal(3, ts.syllableCount("lagrone")); + assert.equal(1, ts.syllableCount("lague")); + assert.equal(2, ts.syllableCount("lahaie")); + assert.equal(2, ts.syllableCount("laimbeer")); + assert.equal(3, ts.syllableCount("laity")); + assert.equal(2, ts.syllableCount("lajoie")); + assert.equal(2, ts.syllableCount("lakefield")); + assert.equal(2, ts.syllableCount("lakefront")); + assert.equal(2, ts.syllableCount("lakeland")); + assert.equal(2, ts.syllableCount("lakeman")); + assert.equal(2, ts.syllableCount("lakeshore")); + assert.equal(2, ts.syllableCount("lakeview")); + assert.equal(2, ts.syllableCount("lakewood")); + assert.equal(3, ts.syllableCount("lalone")); + assert.equal(3, ts.syllableCount("lamaist")); + assert.equal(1, ts.syllableCount("lambe")); + assert.equal(4, ts.syllableCount("lambiase")); + assert.equal(3, ts.syllableCount("lamere")); + assert.equal(2, ts.syllableCount("lamonte")); + assert.equal(2, ts.syllableCount("lamotte")); + assert.equal(1, ts.syllableCount("lampe")); + assert.equal(2, ts.syllableCount("lampl")); + assert.equal(2, ts.syllableCount("lancelet")); + assert.equal(1, ts.syllableCount("lande")); + assert.equal(1, ts.syllableCount("landes")); + assert.equal(3, ts.syllableCount("landfried")); + assert.equal(2, ts.syllableCount("lanehart")); + assert.equal(3, ts.syllableCount("lanese")); + assert.equal(3, ts.syllableCount("langelier")); + assert.equal(3, ts.syllableCount("langone")); + assert.equal(2, ts.syllableCount("lanier")); + assert.equal(2, ts.syllableCount("lanphier")); + assert.equal(2, ts.syllableCount("lansdowne")); + assert.equal(2, ts.syllableCount("laos")); + assert.equal(3, ts.syllableCount("laotian")); + assert.equal(3, ts.syllableCount("lapine")); + assert.equal(2, ts.syllableCount("lapointe")); + assert.equal(2, ts.syllableCount("laporte")); + assert.equal(1, ts.syllableCount("lappe")); + assert.equal(3, ts.syllableCount("laprade")); + assert.equal(1, ts.syllableCount("lapse")); + assert.equal(3, ts.syllableCount("laraia")); + assert.equal(4, ts.syllableCount("lareina")); + assert.equal(3, ts.syllableCount("larine")); + assert.equal(4, ts.syllableCount("lariviere")); + assert.equal(1, ts.syllableCount("larke")); + assert.equal(2, ts.syllableCount("larocque")); + assert.equal(2, ts.syllableCount("laroque")); + assert.equal(3, ts.syllableCount("larose")); + assert.equal(3, ts.syllableCount("larrea")); + assert.equal(3, ts.syllableCount("larroquette")); + assert.equal(4, ts.syllableCount("laryngeal")); + assert.equal(3, ts.syllableCount("lastrapes")); + assert.equal(3, ts.syllableCount("latticework")); + assert.equal(2, ts.syllableCount("launches")); + assert.equal(3, ts.syllableCount("laureate")); + assert.equal(3, ts.syllableCount("laureates")); + assert.equal(3, ts.syllableCount("laurentiis")); + assert.equal(4, ts.syllableCount("laverdiere")); + assert.equal(4, ts.syllableCount("laverdure")); + assert.equal(3, ts.syllableCount("lavere")); + assert.equal(2, ts.syllableCount("lavergne")); + assert.equal(3, ts.syllableCount("lavine")); + assert.equal(3, ts.syllableCount("lavinia")); + assert.equal(2, ts.syllableCount("lavoie")); + assert.equal(3, ts.syllableCount("lawrenceburg")); + assert.equal(1, ts.syllableCount("lawshe")); + assert.equal(2, ts.syllableCount("lawyer")); + assert.equal(3, ts.syllableCount("lawyerly")); + assert.equal(2, ts.syllableCount("lawyers")); + assert.equal(3, ts.syllableCount("lazare")); + assert.equal(3, ts.syllableCount("lcs")); + assert.equal(3, ts.syllableCount("ldbrinkman")); + assert.equal(2, ts.syllableCount("leaches")); + assert.equal(1, ts.syllableCount("league")); + assert.equal(2, ts.syllableCount("leaguer")); + assert.equal(2, ts.syllableCount("leaguers")); + assert.equal(1, ts.syllableCount("leagues")); + assert.equal(2, ts.syllableCount("leah")); + assert.equal(3, ts.syllableCount("leander")); + assert.equal(3, ts.syllableCount("leandro")); + assert.equal(2, ts.syllableCount("leann")); + assert.equal(2, ts.syllableCount("leapfrogged")); + assert.equal(2, ts.syllableCount("leaseback")); + assert.equal(2, ts.syllableCount("leasebacks")); + assert.equal(2, ts.syllableCount("leasehold")); + assert.equal(2, ts.syllableCount("leaseway")); + assert.equal(2, ts.syllableCount("lebegue")); + assert.equal(2, ts.syllableCount("leboeuf")); + assert.equal(2, ts.syllableCount("lebouef")); + assert.equal(3, ts.syllableCount("leccese")); + assert.equal(2, ts.syllableCount("lecompte")); + assert.equal(2, ts.syllableCount("lecomte")); + assert.equal(3, ts.syllableCount("lecrone")); + assert.equal(2, ts.syllableCount("leeches")); + assert.equal(2, ts.syllableCount("leeuwen")); + assert.equal(2, ts.syllableCount("leffler")); + assert.equal(3, ts.syllableCount("legare")); + assert.equal(2, ts.syllableCount("legrande")); + assert.equal(1, ts.syllableCount("lehne")); + assert.equal(1, ts.syllableCount("lehrke")); + assert.equal(3, ts.syllableCount("leibfried")); + assert.equal(2, ts.syllableCount("leibler")); + assert.equal(2, ts.syllableCount("leicester")); + assert.equal(3, ts.syllableCount("leino")); + assert.equal(2, ts.syllableCount("leist")); + assert.equal(1, ts.syllableCount("leitzke")); + assert.equal(2, ts.syllableCount("lelia")); + assert.equal(1, ts.syllableCount("lembcke")); + assert.equal(1, ts.syllableCount("lembke")); + assert.equal(1, ts.syllableCount("lemcke")); + assert.equal(2, ts.syllableCount("lemieux")); + assert.equal(3, ts.syllableCount("lemire")); + assert.equal(1, ts.syllableCount("lempke")); + assert.equal(2, ts.syllableCount("lendl")); + assert.equal(3, ts.syllableCount("lenient")); + assert.equal(1, ts.syllableCount("lenke")); + assert.equal(3, ts.syllableCount("lentine")); + assert.equal(2, ts.syllableCount("leonelle")); + assert.equal(3, ts.syllableCount("lepere")); + assert.equal(3, ts.syllableCount("lepine")); + assert.equal(3, ts.syllableCount("lepore")); + assert.equal(3, ts.syllableCount("lequire")); + assert.equal(3, ts.syllableCount("lereah")); + assert.equal(3, ts.syllableCount("lesane")); + assert.equal(2, ts.syllableCount("lesesne")); + assert.equal(2, ts.syllableCount("letarte")); + assert.equal(4, ts.syllableCount("letitia")); + assert.equal(3, ts.syllableCount("lettiere")); + assert.equal(2, ts.syllableCount("leveque")); + assert.equal(3, ts.syllableCount("leveraging")); + assert.equal(4, ts.syllableCount("leverone")); + assert.equal(3, ts.syllableCount("levien")); + assert.equal(2, ts.syllableCount("levitte")); + assert.equal(2, ts.syllableCount("lezotte")); + assert.equal(3, ts.syllableCount("lhommedieu")); + assert.equal(3, ts.syllableCount("liaison")); + assert.equal(3, ts.syllableCount("liaisons")); + assert.equal(1, ts.syllableCount("lian")); + assert.equal(1, ts.syllableCount("liang")); + assert.equal(2, ts.syllableCount("liao")); + assert.equal(2, ts.syllableCount("liasson")); + assert.equal(5, ts.syllableCount("liberalization")); + assert.equal(5, ts.syllableCount("liberatore")); + assert.equal(3, ts.syllableCount("licciardi")); + assert.equal(3, ts.syllableCount("licea")); + assert.equal(2, ts.syllableCount("license")); + assert.equal(3, ts.syllableCount("licentious")); + assert.equal(1, ts.syllableCount("lichte")); + assert.equal(2, ts.syllableCount("liebler")); + assert.equal(1, ts.syllableCount("lieu")); + assert.equal(2, ts.syllableCount("lieurance")); + assert.equal(3, ts.syllableCount("Lieut")); + assert.equal(3, ts.syllableCount("lieutenant")); + assert.equal(3, ts.syllableCount("lieutenants")); + assert.equal(2, ts.syllableCount("lifeblood")); + assert.equal(2, ts.syllableCount("lifeboat")); + assert.equal(2, ts.syllableCount("lifeboats")); + assert.equal(2, ts.syllableCount("lifeco")); + assert.equal(2, ts.syllableCount("lifeguard")); + assert.equal(2, ts.syllableCount("lifelike")); + assert.equal(2, ts.syllableCount("lifeline")); + assert.equal(2, ts.syllableCount("lifelines")); + assert.equal(2, ts.syllableCount("lifelong")); + assert.equal(3, ts.syllableCount("lifesaver")); + assert.equal(3, ts.syllableCount("lifesavers")); + assert.equal(3, ts.syllableCount("lifesaving")); + assert.equal(2, ts.syllableCount("lifespan")); + assert.equal(2, ts.syllableCount("lifestyle")); + assert.equal(2, ts.syllableCount("lifestyles")); + assert.equal(2, ts.syllableCount("lifetime")); + assert.equal(2, ts.syllableCount("lifetimes")); + assert.equal(1, ts.syllableCount("liffe")); + assert.equal(3, ts.syllableCount("likelier")); + assert.equal(3, ts.syllableCount("likeliest")); + assert.equal(3, ts.syllableCount("likelihood")); + assert.equal(2, ts.syllableCount("likewise")); + assert.equal(3, ts.syllableCount("lilienthal")); + assert.equal(2, ts.syllableCount("limehouse")); + assert.equal(2, ts.syllableCount("limelight")); + assert.equal(2, ts.syllableCount("limestone")); + assert.equal(2, ts.syllableCount("limestones")); + assert.equal(1, ts.syllableCount("linde")); + assert.equal(2, ts.syllableCount("lindeman")); + assert.equal(3, ts.syllableCount("lineage")); + assert.equal(4, ts.syllableCount("lineages")); + assert.equal(3, ts.syllableCount("lineal")); + assert.equal(3, ts.syllableCount("linear")); + assert.equal(4, ts.syllableCount("linearly")); + assert.equal(2, ts.syllableCount("lineback")); + assert.equal(3, ts.syllableCount("linebacker")); + assert.equal(3, ts.syllableCount("linebackers")); + assert.equal(3, ts.syllableCount("lineberger")); + assert.equal(2, ts.syllableCount("lineman")); + assert.equal(2, ts.syllableCount("linemen")); + assert.equal(3, ts.syllableCount("lineweaver")); + assert.equal(4, ts.syllableCount("linguistically")); + assert.equal(1, ts.syllableCount("linke")); + assert.equal(3, ts.syllableCount("linnea")); + assert.equal(2, ts.syllableCount("linneman")); + assert.equal(2, ts.syllableCount("linnemann")); + assert.equal(4, ts.syllableCount("linoleum")); + assert.equal(1, ts.syllableCount("linse")); + assert.equal(1, ts.syllableCount("lipke")); + assert.equal(1, ts.syllableCount("lippe")); + assert.equal(2, ts.syllableCount("liqueur")); + assert.equal(2, ts.syllableCount("liqueurs")); + assert.equal(2, ts.syllableCount("lire")); + assert.equal(3, ts.syllableCount("litalien")); + assert.equal(3, ts.syllableCount("litigious")); + assert.equal(3, ts.syllableCount("littlest")); + assert.equal(1, ts.syllableCount("liu")); + assert.equal(3, ts.syllableCount("livelier")); + assert.equal(3, ts.syllableCount("liveliest")); + assert.equal(3, ts.syllableCount("livelihood")); + assert.equal(3, ts.syllableCount("liveliness")); + assert.equal(2, ts.syllableCount("liveried")); + assert.equal(2, ts.syllableCount("livestock")); + assert.equal(3, ts.syllableCount("livonia")); + assert.equal(2, ts.syllableCount("lizotte")); + assert.equal(3, ts.syllableCount("llorens")); + assert.equal(4, ts.syllableCount("loaiza")); + assert.equal(3, ts.syllableCount("lobbyist")); + assert.equal(3, ts.syllableCount("lobbyists")); + assert.equal(1, ts.syllableCount("locke")); + assert.equal(2, ts.syllableCount("lockyer")); + assert.equal(2, ts.syllableCount("lodestar")); + assert.equal(2, ts.syllableCount("lodestone")); + assert.equal(2, ts.syllableCount("lodgepole")); + assert.equal(2, ts.syllableCount("loeffler")); + assert.equal(3, ts.syllableCount("loella")); + assert.equal(2, ts.syllableCount("loess")); + assert.equal(2, ts.syllableCount("loew")); + assert.equal(3, ts.syllableCount("loewen")); + assert.equal(4, ts.syllableCount("loewenstein")); + assert.equal(4, ts.syllableCount("loewenthal")); + assert.equal(4, ts.syllableCount("logarithms")); + assert.equal(3, ts.syllableCount("logically")); + assert.equal(4, ts.syllableCount("logistically")); + assert.equal(3, ts.syllableCount("logiudice")); + assert.equal(1, ts.syllableCount("logue")); + assert.equal(1, ts.syllableCount("lohnes")); + assert.equal(1, ts.syllableCount("lohse")); + assert.equal(4, ts.syllableCount("loiacano")); + assert.equal(4, ts.syllableCount("loiacono")); + assert.equal(2, ts.syllableCount("lois")); + assert.equal(2, ts.syllableCount("loise")); + assert.equal(3, ts.syllableCount("loneliness")); + assert.equal(2, ts.syllableCount("lonetree")); + assert.equal(3, ts.syllableCount("longenecker")); + assert.equal(3, ts.syllableCount("longshoremen")); + assert.equal(2, ts.syllableCount("loosestrife")); + assert.equal(2, ts.syllableCount("loosestrifes")); + assert.equal(2, ts.syllableCount("lopeman")); + assert.equal(3, ts.syllableCount("lorean")); + assert.equal(1, ts.syllableCount("lotte")); + assert.equal(1, ts.syllableCount("lottes")); + assert.equal(1, ts.syllableCount("lotze")); + assert.equal(3, ts.syllableCount("louanna")); + assert.equal(2, ts.syllableCount("louart")); + assert.equal(2, ts.syllableCount("louisette")); + assert.equal(1, ts.syllableCount("louque")); + assert.equal(1, ts.syllableCount("lourdes")); + assert.equal(3, ts.syllableCount("louviere")); + assert.equal(2, ts.syllableCount("loveday")); + assert.equal(2, ts.syllableCount("lovegrove")); + assert.equal(2, ts.syllableCount("lovejoy")); + assert.equal(2, ts.syllableCount("loveland")); + assert.equal(2, ts.syllableCount("loveridge")); + assert.equal(2, ts.syllableCount("lovewell")); + assert.equal(2, ts.syllableCount("lowekamp")); + assert.equal(2, ts.syllableCount("lp")); + assert.equal(3, ts.syllableCount("lpn")); + assert.equal(2, ts.syllableCount("ls")); + assert.equal(3, ts.syllableCount("lsd")); + assert.equal(3, ts.syllableCount("ltd")); + assert.equal(1, ts.syllableCount("lubke")); + assert.equal(3, ts.syllableCount("lucchese")); + assert.equal(3, ts.syllableCount("luciani")); + assert.equal(3, ts.syllableCount("lucianna")); + assert.equal(3, ts.syllableCount("lucien")); + assert.equal(1, ts.syllableCount("lucke")); + assert.equal(2, ts.syllableCount("luckiest")); + assert.equal(2, ts.syllableCount("ludeman")); + assert.equal(2, ts.syllableCount("ludemann")); + assert.equal(1, ts.syllableCount("luebbe")); + assert.equal(1, ts.syllableCount("luebke")); + assert.equal(2, ts.syllableCount("lueck")); + assert.equal(1, ts.syllableCount("luecke")); + assert.equal(2, ts.syllableCount("luedecke")); + assert.equal(3, ts.syllableCount("luella")); + assert.equal(3, ts.syllableCount("luera")); + assert.equal(4, ts.syllableCount("luevano")); + assert.equal(2, ts.syllableCount("lui")); + assert.equal(3, ts.syllableCount("luigi")); + assert.equal(2, ts.syllableCount("luis")); + assert.equal(3, ts.syllableCount("luisa")); + assert.equal(2, ts.syllableCount("lukehart")); + assert.equal(2, ts.syllableCount("lukewarm")); + assert.equal(3, ts.syllableCount("luncheonette")); + assert.equal(2, ts.syllableCount("lunches")); + assert.equal(1, ts.syllableCount("lunde")); + assert.equal(3, ts.syllableCount("luoma")); + assert.equal(2, ts.syllableCount("luong")); + assert.equal(3, ts.syllableCount("luongo")); + assert.equal(1, ts.syllableCount("luque")); + assert.equal(2, ts.syllableCount("luquette")); + assert.equal(1, ts.syllableCount("lutze")); + assert.equal(1, ts.syllableCount("lutzke")); + assert.equal(2, ts.syllableCount("luu")); + assert.equal(1, ts.syllableCount("lynde")); + assert.equal(2, ts.syllableCount("lyon")); + assert.equal(3, ts.syllableCount("lyondell")); + assert.equal(3, ts.syllableCount("lyonnais")); + assert.equal(3, ts.syllableCount("lyonnaise")); + assert.equal(2, ts.syllableCount("lyons")); + assert.equal(3, ts.syllableCount("lyphomed")); + assert.equal(1, ts.syllableCount("lysne")); + assert.equal(3, ts.syllableCount("mabry")); + assert.equal(2, ts.syllableCount("macaques")); + assert.equal(4, ts.syllableCount("maccabean")); + assert.equal(3, ts.syllableCount("macdiarmid")); + assert.equal(3, ts.syllableCount("machete")); + assert.equal(3, ts.syllableCount("machetes")); + assert.equal(6, ts.syllableCount("machiavellian")); + assert.equal(4, ts.syllableCount("machinea")); + assert.equal(2, ts.syllableCount("maciag")); + assert.equal(3, ts.syllableCount("maciejewski")); + assert.equal(1, ts.syllableCount("macke")); + assert.equal(4, ts.syllableCount("mackiewicz")); + assert.equal(2, ts.syllableCount("macmahon")); + assert.equal(2, ts.syllableCount("macqueen")); + assert.equal(3, ts.syllableCount("macrame")); + assert.equal(3, ts.syllableCount("macwilliams")); + assert.equal(2, ts.syllableCount("madl")); + assert.equal(3, ts.syllableCount("madlen")); + assert.equal(3, ts.syllableCount("madore")); + assert.equal(3, ts.syllableCount("maeda")); + assert.equal(4, ts.syllableCount("maekawa")); + assert.equal(3, ts.syllableCount("maenza")); + assert.equal(3, ts.syllableCount("maestri")); + assert.equal(2, ts.syllableCount("maez")); + assert.equal(4, ts.syllableCount("maglione")); + assert.equal(3, ts.syllableCount("magnolia")); + assert.equal(3, ts.syllableCount("magnolias")); + assert.equal(3, ts.syllableCount("magnone")); + assert.equal(2, ts.syllableCount("magouirk")); + assert.equal(1, ts.syllableCount("maher")); + assert.equal(1, ts.syllableCount("mahnke")); + assert.equal(2, ts.syllableCount("maia")); + assert.equal(4, ts.syllableCount("mainichi")); + assert.equal(2, ts.syllableCount("maio")); + assert.equal(3, ts.syllableCount("maiolo")); + assert.equal(4, ts.syllableCount("maiorana")); + assert.equal(4, ts.syllableCount("maiorano")); + assert.equal(4, ts.syllableCount("maiorino")); + assert.equal(2, ts.syllableCount("maish")); + assert.equal(3, ts.syllableCount("majure")); + assert.equal(2, ts.syllableCount("makegoods")); + assert.equal(2, ts.syllableCount("makeshift")); + assert.equal(3, ts.syllableCount("malave")); + assert.equal(2, ts.syllableCount("malinde")); + assert.equal(3, ts.syllableCount("maline")); + assert.equal(3, ts.syllableCount("malkiel")); + assert.equal(6, ts.syllableCount("malleability")); + assert.equal(4, ts.syllableCount("malleable")); + assert.equal(2, ts.syllableCount("mandl")); + assert.equal(2, ts.syllableCount("manfred")); + assert.equal(5, ts.syllableCount("mangiaracina")); + assert.equal(3, ts.syllableCount("mangine")); + assert.equal(3, ts.syllableCount("mangling")); + assert.equal(3, ts.syllableCount("mangone")); + assert.equal(3, ts.syllableCount("mangope")); + assert.equal(1, ts.syllableCount("manke")); + assert.equal(4, ts.syllableCount("mannerisms")); + assert.equal(2, ts.syllableCount("manrique")); + assert.equal(1, ts.syllableCount("manske")); + assert.equal(1, ts.syllableCount("manthe")); + assert.equal(4, ts.syllableCount("mantione")); + assert.equal(4, ts.syllableCount("manzanares")); + assert.equal(4, ts.syllableCount("manzione")); + assert.equal(3, ts.syllableCount("maoris")); + assert.equal(3, ts.syllableCount("mapplethorpe")); + assert.equal(4, ts.syllableCount("maraline")); + assert.equal(4, ts.syllableCount("marcelline")); + assert.equal(3, ts.syllableCount("marchese")); + assert.equal(4, ts.syllableCount("marchione")); + assert.equal(3, ts.syllableCount("marcial")); + assert.equal(3, ts.syllableCount("marciante")); + assert.equal(3, ts.syllableCount("marcone")); + assert.equal(2, ts.syllableCount("marcotte")); + assert.equal(4, ts.syllableCount("margeotes")); + assert.equal(3, ts.syllableCount("margiotta")); + assert.equal(3, ts.syllableCount("mariel")); + assert.equal(5, ts.syllableCount("marielitos")); + assert.equal(4, ts.syllableCount("marijuana")); + assert.equal(3, ts.syllableCount("marineland")); + assert.equal(3, ts.syllableCount("marion")); + assert.equal(1, ts.syllableCount("marje")); + assert.equal(1, ts.syllableCount("marke")); + assert.equal(3, ts.syllableCount("markedly")); + assert.equal(2, ts.syllableCount("marotte")); + assert.equal(1, ts.syllableCount("marque")); + assert.equal(2, ts.syllableCount("marquee")); + assert.equal(2, ts.syllableCount("marquees")); + assert.equal(1, ts.syllableCount("marques")); + assert.equal(2, ts.syllableCount("marquette")); + assert.equal(3, ts.syllableCount("marriages")); + assert.equal(3, ts.syllableCount("marrone")); + assert.equal(1, ts.syllableCount("marschke")); + assert.equal(1, ts.syllableCount("marte")); + assert.equal(1, ts.syllableCount("marthe")); + assert.equal(3, ts.syllableCount("martinique")); + assert.equal(3, ts.syllableCount("martire")); + assert.equal(3, ts.syllableCount("martone")); + assert.equal(3, ts.syllableCount("marui")); + assert.equal(4, ts.syllableCount("masaaki")); + assert.equal(3, ts.syllableCount("masai")); + assert.equal(3, ts.syllableCount("masao")); + assert.equal(1, ts.syllableCount("maschke")); + assert.equal(4, ts.syllableCount("masciarelli")); + assert.equal(3, ts.syllableCount("mascioli")); + assert.equal(2, ts.syllableCount("masefield")); + assert.equal(3, ts.syllableCount("maslen")); + assert.equal(4, ts.syllableCount("massacring")); + assert.equal(3, ts.syllableCount("massicotte")); + assert.equal(4, ts.syllableCount("massingale")); + assert.equal(4, ts.syllableCount("mastandrea")); + assert.equal(5, ts.syllableCount("mastrogiovanni")); + assert.equal(4, ts.syllableCount("mastroianni")); + assert.equal(4, ts.syllableCount("matarese")); + assert.equal(4, ts.syllableCount("materiel")); + assert.equal(3, ts.syllableCount("mathai")); + assert.equal(3, ts.syllableCount("mathea")); + assert.equal(2, ts.syllableCount("mathieu")); + assert.equal(2, ts.syllableCount("mathilde")); + assert.equal(5, ts.syllableCount("matrilineal")); + assert.equal(3, ts.syllableCount("matsui")); + assert.equal(3, ts.syllableCount("matsuo")); + assert.equal(4, ts.syllableCount("matsuoka")); + assert.equal(4, ts.syllableCount("matsuura")); + assert.equal(1, ts.syllableCount("matte")); + assert.equal(1, ts.syllableCount("mattes")); + assert.equal(3, ts.syllableCount("matthea")); + assert.equal(1, ts.syllableCount("matthes")); + assert.equal(1, ts.syllableCount("matzke")); + assert.equal(3, ts.syllableCount("maurine")); + assert.equal(4, ts.syllableCount("mausoleum")); + assert.equal(2, ts.syllableCount("mawr")); + assert.equal(3, ts.syllableCount("maxion")); + assert.equal(3, ts.syllableCount("maxzide")); + assert.equal(2, ts.syllableCount("maybe")); + assert.equal(5, ts.syllableCount("mazowiecki")); + assert.equal(3, ts.syllableCount("mazzei")); + assert.equal(3, ts.syllableCount("mazzone")); + assert.equal(2, ts.syllableCount("mbank")); + assert.equal(3, ts.syllableCount("mcalinden")); + assert.equal(3, ts.syllableCount("mcauliffe")); + assert.equal(3, ts.syllableCount("mcbrien")); + assert.equal(3, ts.syllableCount("mccaffery")); + assert.equal(2, ts.syllableCount("mccague")); + assert.equal(2, ts.syllableCount("mccahan")); + assert.equal(5, ts.syllableCount("mccarthyism")); + assert.equal(2, ts.syllableCount("mccaughan")); + assert.equal(2, ts.syllableCount("mccluer")); + assert.equal(3, ts.syllableCount("mccuin")); + assert.equal(3, ts.syllableCount("mcdiarmid")); + assert.equal(2, ts.syllableCount("mcgeough")); + assert.equal(3, ts.syllableCount("mcgoey")); + assert.equal(2, ts.syllableCount("mchargue")); + assert.equal(2, ts.syllableCount("mckeague")); + assert.equal(3, ts.syllableCount("mcmillian")); + assert.equal(4, ts.syllableCount("mcmurtrie")); + assert.equal(2, ts.syllableCount("mcneer")); + assert.equal(3, ts.syllableCount("mcqueary")); + assert.equal(2, ts.syllableCount("mcqueen")); + assert.equal(3, ts.syllableCount("mcqueeney")); + assert.equal(2, ts.syllableCount("mctague")); + assert.equal(2, ts.syllableCount("mcteer")); + assert.equal(2, ts.syllableCount("mctigue")); + assert.equal(3, ts.syllableCount("mcwilliam")); + assert.equal(3, ts.syllableCount("mcwilliams")); + assert.equal(1, ts.syllableCount("meagher")); + assert.equal(3, ts.syllableCount("meander")); + assert.equal(3, ts.syllableCount("meandered")); + assert.equal(4, ts.syllableCount("meandering")); + assert.equal(3, ts.syllableCount("meanders")); + assert.equal(4, ts.syllableCount("mechanically")); + assert.equal(4, ts.syllableCount("mechanisms")); + assert.equal(1, ts.syllableCount("meckes")); + assert.equal(3, ts.syllableCount("medically")); + assert.equal(6, ts.syllableCount("mediterranean")); + assert.equal(3, ts.syllableCount("medlen")); + assert.equal(1, ts.syllableCount("meetze")); + assert.equal(4, ts.syllableCount("megacarriers")); + assert.equal(2, ts.syllableCount("megace")); + assert.equal(6, ts.syllableCount("megalomaniacal")); + assert.equal(2, ts.syllableCount("meidl")); + assert.equal(2, ts.syllableCount("meierfeld")); + assert.equal(1, ts.syllableCount("meincke")); + assert.equal(2, ts.syllableCount("meindl")); + assert.equal(2, ts.syllableCount("meinecke")); + assert.equal(1, ts.syllableCount("meinke")); + assert.equal(3, ts.syllableCount("meiosis")); + assert.equal(3, ts.syllableCount("meisler")); + assert.equal(3, ts.syllableCount("melamed")); + assert.equal(3, ts.syllableCount("meloche")); + assert.equal(3, ts.syllableCount("melone")); + assert.equal(5, ts.syllableCount("memorabilia")); + assert.equal(4, ts.syllableCount("menapace")); + assert.equal(4, ts.syllableCount("menasion")); + assert.equal(1, ts.syllableCount("mende")); + assert.equal(3, ts.syllableCount("Mengele")); + assert.equal(1, ts.syllableCount("menke")); + assert.equal(1, ts.syllableCount("menkes")); + assert.equal(3, ts.syllableCount("menstruation")); + assert.equal(1, ts.syllableCount("mente")); + assert.equal(1, ts.syllableCount("menze")); + assert.equal(3, ts.syllableCount("mercedes")); + assert.equal(3, ts.syllableCount("mercure")); + assert.equal(6, ts.syllableCount("meridionale")); + assert.equal(3, ts.syllableCount("merion")); + assert.equal(1, ts.syllableCount("merle")); + assert.equal(1, ts.syllableCount("meschke")); + assert.equal(4, ts.syllableCount("meserole")); + assert.equal(3, ts.syllableCount("mesler")); + assert.equal(4, ts.syllableCount("mesozoic")); + assert.equal(3, ts.syllableCount("messagepad")); + assert.equal(2, ts.syllableCount("messler")); + assert.equal(2, ts.syllableCount("messrs")); + assert.equal(5, ts.syllableCount("metabolisms")); + assert.equal(2, ts.syllableCount("metcalfe")); + assert.equal(4, ts.syllableCount("methodisms")); + assert.equal(2, ts.syllableCount("metier")); + assert.equal(2, ts.syllableCount("mettler")); + assert.equal(1, ts.syllableCount("metze")); + assert.equal(3, ts.syllableCount("mfume")); + assert.equal(3, ts.syllableCount("micale")); + assert.equal(3, ts.syllableCount("micciche")); + assert.equal(2, ts.syllableCount("michener")); + assert.equal(2, ts.syllableCount("michl")); + assert.equal(1, ts.syllableCount("micke")); + assert.equal(4, ts.syllableCount("microcosm")); + assert.equal(4, ts.syllableCount("micrografx")); + assert.equal(6, ts.syllableCount("microorganisms")); + assert.equal(5, ts.syllableCount("microscopically")); + assert.equal(2, ts.syllableCount("midyette")); + assert.equal(2, ts.syllableCount("miert")); + assert.equal(4, ts.syllableCount("migliore")); + assert.equal(3, ts.syllableCount("mignone")); + assert.equal(3, ts.syllableCount("mijares")); + assert.equal(3, ts.syllableCount("mildrid")); + assert.equal(2, ts.syllableCount("milestone")); + assert.equal(2, ts.syllableCount("milestones")); + assert.equal(2, ts.syllableCount("milieu")); + assert.equal(1, ts.syllableCount("milke")); + assert.equal(1, ts.syllableCount("milne")); + assert.equal(1, ts.syllableCount("milnes")); + assert.equal(4, ts.syllableCount("minamide")); + assert.equal(2, ts.syllableCount("mincemeat")); + assert.equal(3, ts.syllableCount("minea")); + assert.equal(4, ts.syllableCount("minebea")); + assert.equal(2, ts.syllableCount("minefield")); + assert.equal(2, ts.syllableCount("minehart")); + assert.equal(3, ts.syllableCount("minesweeper")); + assert.equal(3, ts.syllableCount("minesweepers")); + assert.equal(3, ts.syllableCount("mineworkers")); + assert.equal(3, ts.syllableCount("mingling")); + assert.equal(2, ts.syllableCount("miniard")); + assert.equal(4, ts.syllableCount("miniaturized")); + assert.equal(3, ts.syllableCount("minjares")); + assert.equal(1, ts.syllableCount("minke")); + assert.equal(5, ts.syllableCount("minneapolis")); + assert.equal(3, ts.syllableCount("minoan")); + assert.equal(2, ts.syllableCount("minogue")); + assert.equal(2, ts.syllableCount("minteer")); + assert.equal(3, ts.syllableCount("minuet")); + assert.equal(3, ts.syllableCount("minuteman")); + assert.equal(3, ts.syllableCount("mireles")); + assert.equal(4, ts.syllableCount("misbehavior")); + assert.equal(4, ts.syllableCount("miscarriages")); + assert.equal(2, ts.syllableCount("mischarged")); + assert.equal(1, ts.syllableCount("mischke")); + assert.equal(3, ts.syllableCount("mischler")); + assert.equal(3, ts.syllableCount("miscreant")); + assert.equal(3, ts.syllableCount("miscreants")); + assert.equal(4, ts.syllableCount("miscreations")); + assert.equal(3, ts.syllableCount("misfire")); + assert.equal(2, ts.syllableCount("misled")); + assert.equal(2, ts.syllableCount("mismatched")); + assert.equal(4, ts.syllableCount("missildine")); + assert.equal(2, ts.syllableCount("missler")); + assert.equal(1, ts.syllableCount("mitschke")); + assert.equal(3, ts.syllableCount("mitsui")); + assert.equal(2, ts.syllableCount("mittler")); + assert.equal(1, ts.syllableCount("mixte")); + assert.equal(3, ts.syllableCount("miyake")); + assert.equal(3, ts.syllableCount("mkhatshwa")); + assert.equal(2, ts.syllableCount("moab")); + assert.equal(3, ts.syllableCount("moammar")); + assert.equal(2, ts.syllableCount("moates")); + assert.equal(3, ts.syllableCount("mobiliare")); + assert.equal(4, ts.syllableCount("modestine")); + assert.equal(3, ts.syllableCount("moening")); + assert.equal(1, ts.syllableCount("moerbe")); + assert.equal(1, ts.syllableCount("moerke")); + assert.equal(3, ts.syllableCount("moerman")); + assert.equal(2, ts.syllableCount("moet")); + assert.equal(3, ts.syllableCount("mohamed")); + assert.equal(3, ts.syllableCount("mohammed")); + assert.equal(3, ts.syllableCount("mojave")); + assert.equal(2, ts.syllableCount("molehill")); + assert.equal(2, ts.syllableCount("molelike")); + assert.equal(2, ts.syllableCount("molesworth")); + assert.equal(3, ts.syllableCount("moncure")); + assert.equal(1, ts.syllableCount("monde")); + assert.equal(3, ts.syllableCount("monisms")); + assert.equal(1, ts.syllableCount("monje")); + assert.equal(3, ts.syllableCount("monologue")); + assert.equal(3, ts.syllableCount("monologues")); + assert.equal(5, ts.syllableCount("mononuclear")); + assert.equal(5, ts.syllableCount("monotheism")); + assert.equal(2, ts.syllableCount("monsieur")); + assert.equal(2, ts.syllableCount("monsieurs")); + assert.equal(3, ts.syllableCount("montagnier")); + assert.equal(5, ts.syllableCount("montefiore")); + assert.equal(5, ts.syllableCount("monteleone")); + assert.equal(3, ts.syllableCount("montgomery")); + assert.equal(3, ts.syllableCount("montiel")); + assert.equal(3, ts.syllableCount("montien")); + assert.equal(3, ts.syllableCount("montieth")); + assert.equal(3, ts.syllableCount("montone")); + assert.equal(2, ts.syllableCount("moorehead")); + assert.equal(2, ts.syllableCount("moorehouse")); + assert.equal(2, ts.syllableCount("moorestown")); + assert.equal(2, ts.syllableCount("moosehead")); + assert.equal(1, ts.syllableCount("moppes")); + assert.equal(3, ts.syllableCount("morace")); + assert.equal(3, ts.syllableCount("morea")); + assert.equal(2, ts.syllableCount("morehead")); + assert.equal(2, ts.syllableCount("morehouse")); + assert.equal(2, ts.syllableCount("moreland")); + assert.equal(2, ts.syllableCount("moreman")); + assert.equal(2, ts.syllableCount("mores")); + assert.equal(2, ts.syllableCount("morever")); + assert.equal(1, ts.syllableCount("morgue")); + assert.equal(3, ts.syllableCount("morine")); + assert.equal(3, ts.syllableCount("morones")); + assert.equal(3, ts.syllableCount("morriss")); + assert.equal(3, ts.syllableCount("morrone")); + assert.equal(3, ts.syllableCount("mortgagepower")); + assert.equal(1, ts.syllableCount("morze")); + assert.equal(3, ts.syllableCount("mosaic")); + assert.equal(4, ts.syllableCount("mosaical")); + assert.equal(3, ts.syllableCount("mosaics")); + assert.equal(2, ts.syllableCount("moseley")); + assert.equal(2, ts.syllableCount("moseman")); + assert.equal(2, ts.syllableCount("mosier")); + assert.equal(3, ts.syllableCount("mosler")); + assert.equal(3, ts.syllableCount("mothershed")); + assert.equal(2, ts.syllableCount("motl")); + assert.equal(5, ts.syllableCount("motorcyclist")); + assert.equal(5, ts.syllableCount("motorcyclists")); + assert.equal(1, ts.syllableCount("motte")); + assert.equal(2, ts.syllableCount("mousehole")); + assert.equal(2, ts.syllableCount("mousetrap")); + assert.equal(3, ts.syllableCount("mozambique")); + assert.equal(4, ts.syllableCount("mozartean")); + assert.equal(2, ts.syllableCount("mpeg")); + assert.equal(3, ts.syllableCount("mpg")); + assert.equal(3, ts.syllableCount("mph")); + assert.equal(2, ts.syllableCount("mr")); + assert.equal(2, ts.syllableCount("mrs")); + assert.equal(3, ts.syllableCount("msgr")); + assert.equal(2, ts.syllableCount("mssrs")); + assert.equal(2, ts.syllableCount("mtel")); + assert.equal(1, ts.syllableCount("muecke")); + assert.equal(2, ts.syllableCount("muehlebach")); + assert.equal(2, ts.syllableCount("muffler")); + assert.equal(2, ts.syllableCount("mufflers")); + assert.equal(3, ts.syllableCount("mugabe")); + assert.equal(3, ts.syllableCount("muhamed")); + assert.equal(3, ts.syllableCount("muhammed")); + assert.equal(2, ts.syllableCount("mui")); + assert.equal(3, ts.syllableCount("mukai")); + assert.equal(2, ts.syllableCount("mulches")); + assert.equal(2, ts.syllableCount("mulqueen")); + assert.equal(5, ts.syllableCount("multiemployer")); + assert.equal(2, ts.syllableCount("mulvehill")); + assert.equal(2, ts.syllableCount("mungia")); + assert.equal(3, ts.syllableCount("munguia")); + assert.equal(4, ts.syllableCount("muraoka")); + assert.equal(4, ts.syllableCount("muratore")); + assert.equal(3, ts.syllableCount("murguia")); + assert.equal(3, ts.syllableCount("muriel")); + assert.equal(2, ts.syllableCount("murrelet")); + assert.equal(3, ts.syllableCount("murrieta")); + assert.equal(3, ts.syllableCount("muscling")); + assert.equal(3, ts.syllableCount("museum")); + assert.equal(3, ts.syllableCount("museums")); + assert.equal(3, ts.syllableCount("musically")); + assert.equal(3, ts.syllableCount("mustaches")); + assert.equal(4, ts.syllableCount("mustachioed")); + assert.equal(1, ts.syllableCount("myhre")); + assert.equal(5, ts.syllableCount("myocardial")); + assert.equal(5, ts.syllableCount("myocardium")); + assert.equal(4, ts.syllableCount("myopia")); + assert.equal(3, ts.syllableCount("myopic")); + assert.equal(3, ts.syllableCount("myosin")); + assert.equal(4, ts.syllableCount("myotrophin")); + assert.equal(2, ts.syllableCount("mystique")); + assert.equal(6, ts.syllableCount("NAACP")); + assert.equal(4, ts.syllableCount("nacional")); + assert.equal(1, ts.syllableCount("nacke")); + assert.equal(4, ts.syllableCount("nacogdoches")); + assert.equal(3, ts.syllableCount("nadal")); + assert.equal(3, ts.syllableCount("nadler")); + assert.equal(3, ts.syllableCount("nagai")); + assert.equal(3, ts.syllableCount("nagao")); + assert.equal(2, ts.syllableCount("naim")); + assert.equal(2, ts.syllableCount("naish")); + assert.equal(2, ts.syllableCount("naive")); + assert.equal(3, ts.syllableCount("naively")); + assert.equal(4, ts.syllableCount("naivete")); + assert.equal(3, ts.syllableCount("nakai")); + assert.equal(3, ts.syllableCount("nakao")); + assert.equal(4, ts.syllableCount("nakasone")); + assert.equal(2, ts.syllableCount("naked")); + assert.equal(2, ts.syllableCount("nameplate")); + assert.equal(2, ts.syllableCount("nameplates")); + assert.equal(2, ts.syllableCount("namesake")); + assert.equal(1, ts.syllableCount("nantes")); + assert.equal(3, ts.syllableCount("naoma")); + assert.equal(3, ts.syllableCount("naomi")); + assert.equal(3, ts.syllableCount("napea")); + assert.equal(3, ts.syllableCount("nardone")); + assert.equal(3, ts.syllableCount("narvaez")); + assert.equal(4, ts.syllableCount("nasional")); + assert.equal(2, ts.syllableCount("nasr")); + assert.equal(3, ts.syllableCount("natale")); + assert.equal(3, ts.syllableCount("natalia")); + assert.equal(4, ts.syllableCount("nationale")); + assert.equal(4, ts.syllableCount("nationales")); + assert.equal(1, ts.syllableCount("natzke")); + assert.equal(3, ts.syllableCount("nausea")); + assert.equal(4, ts.syllableCount("nauseated")); + assert.equal(4, ts.syllableCount("nauseating")); + assert.equal(3, ts.syllableCount("nauta")); + assert.equal(3, ts.syllableCount("navellier")); + assert.equal(5, ts.syllableCount("nazionale")); + assert.equal(4, ts.syllableCount("neanderthal")); + assert.equal(4, ts.syllableCount("neanderthals")); + assert.equal(5, ts.syllableCount("neapolitan")); + assert.equal(3, ts.syllableCount("nedlloyd")); + assert.equal(3, ts.syllableCount("needler")); + assert.equal(1, ts.syllableCount("neer")); + assert.equal(4, ts.syllableCount("negotiate")); + assert.equal(5, ts.syllableCount("negotiated")); + assert.equal(4, ts.syllableCount("negotiates")); + assert.equal(5, ts.syllableCount("negotiating")); + assert.equal(5, ts.syllableCount("negotiation")); + assert.equal(5, ts.syllableCount("negotiations")); + assert.equal(5, ts.syllableCount("negotiator")); + assert.equal(5, ts.syllableCount("negotiators")); + assert.equal(2, ts.syllableCount("neidl")); + assert.equal(4, ts.syllableCount("neidlinger")); + assert.equal(3, ts.syllableCount("neisler")); + assert.equal(1, ts.syllableCount("neitzke")); + assert.equal(3, ts.syllableCount("nemean")); + assert.equal(3, ts.syllableCount("neoax")); + assert.equal(3, ts.syllableCount("neorx")); + assert.equal(2, ts.syllableCount("nepl")); + assert.equal(3, ts.syllableCount("nesler")); + assert.equal(2, ts.syllableCount("nessler")); + assert.equal(3, ts.syllableCount("nestea")); + assert.equal(3, ts.syllableCount("nestler")); + assert.equal(3, ts.syllableCount("neuendorffer")); + assert.equal(4, ts.syllableCount("neuroscience")); + assert.equal(2, ts.syllableCount("newcombe")); + assert.equal(3, ts.syllableCount("newgateway")); + assert.equal(2, ts.syllableCount("newtowne")); + assert.equal(3, ts.syllableCount("ngema")); + assert.equal(3, ts.syllableCount("niagara")); + assert.equal(2, ts.syllableCount("niaid")); + assert.equal(1, ts.syllableCount("niall")); + assert.equal(1, ts.syllableCount("nibbe")); + assert.equal(2, ts.syllableCount("niches")); + assert.equal(4, ts.syllableCount("niclaneshia")); + assert.equal(4, ts.syllableCount("nicolai")); + assert.equal(4, ts.syllableCount("nicoline")); + assert.equal(4, ts.syllableCount("nicosia")); + assert.equal(3, ts.syllableCount("nienhuis")); + assert.equal(3, ts.syllableCount("nieves")); + assert.equal(3, ts.syllableCount("NIH")); + assert.equal(2, ts.syllableCount("niihau")); + assert.equal(2, ts.syllableCount("nike")); + assert.equal(2, ts.syllableCount("ninefold")); + assert.equal(2, ts.syllableCount("nineteen")); + assert.equal(2, ts.syllableCount("nineteenth")); + assert.equal(2, ts.syllableCount("nineties")); + assert.equal(2, ts.syllableCount("ninety")); + assert.equal(2, ts.syllableCount("ninneman")); + assert.equal(2, ts.syllableCount("niquette")); + assert.equal(5, ts.syllableCount("nitrosamines")); + assert.equal(1, ts.syllableCount("nitschke")); + assert.equal(3, ts.syllableCount("njt")); + assert.equal(2, ts.syllableCount("noah")); + assert.equal(1, ts.syllableCount("nobbe")); + assert.equal(3, ts.syllableCount("nobuo")); + assert.equal(3, ts.syllableCount("nodine")); + assert.equal(2, ts.syllableCount("noel")); + assert.equal(1, ts.syllableCount("noffke")); + assert.equal(3, ts.syllableCount("nogales")); + assert.equal(3, ts.syllableCount("nogueira")); + assert.equal(2, ts.syllableCount("noire")); + assert.equal(1, ts.syllableCount("nolde")); + assert.equal(1, ts.syllableCount("nolte")); + assert.equal(3, ts.syllableCount("noncorporate")); + assert.equal(3, ts.syllableCount("nondefense")); + assert.equal(3, ts.syllableCount("noninterest")); + assert.equal(4, ts.syllableCount("nonlinear")); + assert.equal(4, ts.syllableCount("nonnuclear")); + assert.equal(4, ts.syllableCount("nonreligious")); + assert.equal(2, ts.syllableCount("nonsense")); + assert.equal(3, ts.syllableCount("nordine")); + assert.equal(3, ts.syllableCount("nordling")); + assert.equal(4, ts.syllableCount("noriega")); + assert.equal(4, ts.syllableCount("noriegas")); + assert.equal(2, ts.syllableCount("norsemen")); + assert.equal(1, ts.syllableCount("norte")); + assert.equal(3, ts.syllableCount("norwegian")); + assert.equal(3, ts.syllableCount("norwegians")); + assert.equal(2, ts.syllableCount("nosebleed")); + assert.equal(2, ts.syllableCount("nosedive")); + assert.equal(2, ts.syllableCount("nosedived")); + assert.equal(3, ts.syllableCount("noseworthy")); + assert.equal(3, ts.syllableCount("nostalgia")); + assert.equal(2, ts.syllableCount("notebook")); + assert.equal(2, ts.syllableCount("notebooks")); + assert.equal(3, ts.syllableCount("noteholders")); + assert.equal(4, ts.syllableCount("notestine")); + assert.equal(2, ts.syllableCount("noteware")); + assert.equal(3, ts.syllableCount("noteworthy")); + assert.equal(1, ts.syllableCount("notte")); + assert.equal(3, ts.syllableCount("nov")); + assert.equal(2, ts.syllableCount("noxema")); + assert.equal(2, ts.syllableCount("noxious")); + assert.equal(3, ts.syllableCount("nuclear")); + assert.equal(4, ts.syllableCount("nucleation")); + assert.equal(3, ts.syllableCount("nuclei")); + assert.equal(3, ts.syllableCount("nucleic")); + assert.equal(3, ts.syllableCount("nucleus")); + assert.equal(2, ts.syllableCount("numed")); + assert.equal(4, ts.syllableCount("numerically")); + assert.equal(3, ts.syllableCount("nunemaker")); + assert.equal(2, ts.syllableCount("nunsense")); + assert.equal(1, ts.syllableCount("nurre")); + assert.equal(3, ts.syllableCount("nusbaum")); + assert.equal(3, ts.syllableCount("nutrient")); + assert.equal(3, ts.syllableCount("nutrients")); + assert.equal(3, ts.syllableCount("nutritious")); + assert.equal(3, ts.syllableCount("nvhomes")); + assert.equal(3, ts.syllableCount("nvryan")); + assert.equal(1, ts.syllableCount("nyers")); + assert.equal(3, ts.syllableCount("oad")); + assert.equal(3, ts.syllableCount("oahu")); + assert.equal(3, ts.syllableCount("oases")); + assert.equal(3, ts.syllableCount("oasis")); + assert.equal(3, ts.syllableCount("obermaier")); + assert.equal(2, ts.syllableCount("oblique")); + assert.equal(3, ts.syllableCount("obliquely")); + assert.equal(4, ts.syllableCount("oblivion")); + assert.equal(3, ts.syllableCount("obnoxious")); + assert.equal(3, ts.syllableCount("oboist")); + assert.equal(3, ts.syllableCount("obrien")); + assert.equal(4, ts.syllableCount("obscenely")); + assert.equal(2, ts.syllableCount("observed")); + assert.equal(3, ts.syllableCount("ocain")); + assert.equal(3, ts.syllableCount("occupiers")); + assert.equal(4, ts.syllableCount("oceanic")); + assert.equal(3, ts.syllableCount("oct")); + assert.equal(2, ts.syllableCount("oddler")); + assert.equal(3, ts.syllableCount("odele")); + assert.equal(3, ts.syllableCount("odp")); + assert.equal(4, ts.syllableCount("odysseus")); + assert.equal(1, ts.syllableCount("oehlke")); + assert.equal(1, ts.syllableCount("oehme")); + assert.equal(3, ts.syllableCount("oeien")); + assert.equal(1, ts.syllableCount("oelke")); + assert.equal(2, ts.syllableCount("oest")); + assert.equal(2, ts.syllableCount("oeuvre")); + assert.equal(3, ts.syllableCount("ofc")); + assert.equal(2, ts.syllableCount("offense")); + assert.equal(4, ts.syllableCount("officeholder")); + assert.equal(4, ts.syllableCount("officeholders")); + assert.equal(3, ts.syllableCount("officemax")); + assert.equal(3, ts.syllableCount("oglethorpe")); + assert.equal(4, ts.syllableCount("ognibene")); + assert.equal(3, ts.syllableCount("oguin")); + assert.equal(3, ts.syllableCount("ohare")); + assert.equal(2, ts.syllableCount("ohlmeyer")); + assert.equal(1, ts.syllableCount("oie")); + assert.equal(3, ts.syllableCount("oishi")); + assert.equal(2, ts.syllableCount("ok")); + assert.equal(3, ts.syllableCount("okabe")); + assert.equal(3, ts.syllableCount("okane")); + assert.equal(3, ts.syllableCount("okayed")); + assert.equal(2, ts.syllableCount("okeeffe")); + assert.equal(3, ts.syllableCount("oken")); + assert.equal(5, ts.syllableCount("okoniewski")); + assert.equal(2, ts.syllableCount("olague")); + assert.equal(1, ts.syllableCount("olde")); + assert.equal(3, ts.syllableCount("olea")); + assert.equal(4, ts.syllableCount("oleander")); + assert.equal(4, ts.syllableCount("oleaster")); + assert.equal(4, ts.syllableCount("oligarchs")); + assert.equal(2, ts.syllableCount("olinde")); + assert.equal(4, ts.syllableCount("olivares")); + assert.equal(2, ts.syllableCount("omelet")); + assert.equal(2, ts.syllableCount("omelets")); + assert.equal(3, ts.syllableCount("oncale")); + assert.equal(4, ts.syllableCount("oncogenes")); + assert.equal(2, ts.syllableCount("onecomm")); + assert.equal(2, ts.syllableCount("oneself")); + assert.equal(2, ts.syllableCount("onetime")); + assert.equal(1, ts.syllableCount("oooh")); + assert.equal(1, ts.syllableCount("ooohs")); + assert.equal(4, ts.syllableCount("ooten")); + assert.equal(2, ts.syllableCount("opaque")); + assert.equal(2, ts.syllableCount("opera")); + assert.equal(2, ts.syllableCount("operas")); + assert.equal(3, ts.syllableCount("ophelia")); + assert.equal(4, ts.syllableCount("oplinger")); + assert.equal(3, ts.syllableCount("optically")); + assert.equal(3, ts.syllableCount("orangeburg")); + assert.equal(3, ts.syllableCount("orea")); + assert.equal(4, ts.syllableCount("organically")); + assert.equal(4, ts.syllableCount("organisms")); + assert.equal(3, ts.syllableCount("orgasms")); + assert.equal(3, ts.syllableCount("orient")); + assert.equal(4, ts.syllableCount("oriental")); + assert.equal(4, ts.syllableCount("orientals")); + assert.equal(5, ts.syllableCount("orientation")); + assert.equal(4, ts.syllableCount("oriented")); + assert.equal(3, ts.syllableCount("orion")); + assert.equal(3, ts.syllableCount("oriordan")); + assert.equal(3, ts.syllableCount("orleans")); + assert.equal(1, ts.syllableCount("orme")); + assert.equal(1, ts.syllableCount("ormes")); + assert.equal(2, ts.syllableCount("ormonde")); + assert.equal(2, ts.syllableCount("orourke")); + assert.equal(3, ts.syllableCount("orpheum")); + assert.equal(3, ts.syllableCount("orpheus")); + assert.equal(5, ts.syllableCount("orthodontia")); + assert.equal(3, ts.syllableCount("osake")); + assert.equal(3, ts.syllableCount("oshea")); + assert.equal(3, ts.syllableCount("osmer")); + assert.equal(2, ts.syllableCount("osred")); + assert.equal(4, ts.syllableCount("ostentatious")); + assert.equal(5, ts.syllableCount("ostentatiously")); + assert.equal(6, ts.syllableCount("osteoarthritis")); + assert.equal(3, ts.syllableCount("ostia")); + assert.equal(3, ts.syllableCount("ostling")); + assert.equal(3, ts.syllableCount("ostriches")); + assert.equal(1, ts.syllableCount("otte")); + assert.equal(2, ts.syllableCount("ouimet")); + assert.equal(2, ts.syllableCount("ouimette")); + assert.equal(2, ts.syllableCount("our")); + assert.equal(4, ts.syllableCount("ourada")); + assert.equal(2, ts.syllableCount("ours")); + assert.equal(3, ts.syllableCount("ourself")); + assert.equal(3, ts.syllableCount("outler")); + assert.equal(2, ts.syllableCount("outstretched")); + assert.equal(5, ts.syllableCount("overambitious")); + assert.equal(3, ts.syllableCount("Overbye")); + assert.equal(3, ts.syllableCount("overcharged")); + assert.equal(3, ts.syllableCount("overmatched")); + assert.equal(4, ts.syllableCount("overreaches")); + assert.equal(4, ts.syllableCount("overreact")); + assert.equal(5, ts.syllableCount("overreacted")); + assert.equal(5, ts.syllableCount("overreacting")); + assert.equal(5, ts.syllableCount("overreaction")); + assert.equal(4, ts.syllableCount("oviedo")); + assert.equal(3, ts.syllableCount("pacemaker")); + assert.equal(3, ts.syllableCount("pacemakers")); + assert.equal(3, ts.syllableCount("pacesetter")); + assert.equal(2, ts.syllableCount("paceway")); + assert.equal(2, ts.syllableCount("paez")); + assert.equal(3, ts.syllableCount("pagemaker")); + assert.equal(2, ts.syllableCount("pai")); + assert.equal(3, ts.syllableCount("painewebber")); + assert.equal(2, ts.syllableCount("paiute")); + assert.equal(3, ts.syllableCount("palauans")); + assert.equal(5, ts.syllableCount("paleozoic")); + assert.equal(3, ts.syllableCount("palese")); + assert.equal(3, ts.syllableCount("pallone")); + assert.equal(1, ts.syllableCount("palme")); + assert.equal(4, ts.syllableCount("palmieri")); + assert.equal(4, ts.syllableCount("palmstierna")); + assert.equal(4, ts.syllableCount("palomares")); + assert.equal(4, ts.syllableCount("panacea")); + assert.equal(3, ts.syllableCount("pancreas")); + assert.equal(4, ts.syllableCount("pancreatic")); + assert.equal(3, ts.syllableCount("pannone")); + assert.equal(3, ts.syllableCount("panthea")); + assert.equal(4, ts.syllableCount("pantheistic")); + assert.equal(4, ts.syllableCount("paolella")); + assert.equal(4, ts.syllableCount("paoletti")); + assert.equal(4, ts.syllableCount("paolillo")); + assert.equal(4, ts.syllableCount("paolini")); + assert.equal(4, ts.syllableCount("paolino")); + assert.equal(4, ts.syllableCount("paolucci")); + assert.equal(2, ts.syllableCount("paone")); + assert.equal(4, ts.syllableCount("paonessa")); + assert.equal(3, ts.syllableCount("papale")); + assert.equal(4, ts.syllableCount("papandrea")); + assert.equal(2, ts.syllableCount("papier")); + assert.equal(1, ts.syllableCount("papke")); + assert.equal(1, ts.syllableCount("paque")); + assert.equal(2, ts.syllableCount("paquette")); + assert.equal(5, ts.syllableCount("paradoxically")); + assert.equal(4, ts.syllableCount("paranoia")); + assert.equal(4, ts.syllableCount("paranoiac")); + assert.equal(5, ts.syllableCount("paraphernalia")); + assert.equal(4, ts.syllableCount("paratore")); + assert.equal(1, ts.syllableCount("parde")); + assert.equal(3, ts.syllableCount("paredes")); + assert.equal(5, ts.syllableCount("parimutuel")); + assert.equal(1, ts.syllableCount("parke")); + assert.equal(1, ts.syllableCount("parkes")); + assert.equal(3, ts.syllableCount("parliament")); + assert.equal(5, ts.syllableCount("parliamentary")); + assert.equal(3, ts.syllableCount("parliaments")); + assert.equal(3, ts.syllableCount("parmele")); + assert.equal(4, ts.syllableCount("paroxysm")); + assert.equal(7, ts.syllableCount("partecipazioni")); + assert.equal(5, ts.syllableCount("partiality")); + assert.equal(4, ts.syllableCount("parziale")); + assert.equal(1, ts.syllableCount("paschke")); + assert.equal(3, ts.syllableCount("pasquale")); + assert.equal(3, ts.syllableCount("passageway")); + assert.equal(3, ts.syllableCount("passaic")); + assert.equal(3, ts.syllableCount("pastiches")); + assert.equal(3, ts.syllableCount("patnaude")); + assert.equal(3, ts.syllableCount("patrie")); + assert.equal(5, ts.syllableCount("patrilineal")); + assert.equal(3, ts.syllableCount("patrone")); + assert.equal(1, ts.syllableCount("patzke")); + assert.equal(3, ts.syllableCount("pautler")); + assert.equal(3, ts.syllableCount("pavese")); + assert.equal(3, ts.syllableCount("peacefulness")); + assert.equal(3, ts.syllableCount("peacekeeper")); + assert.equal(3, ts.syllableCount("peacekeepers")); + assert.equal(3, ts.syllableCount("peacekeeping")); + assert.equal(3, ts.syllableCount("peacemaker")); + assert.equal(3, ts.syllableCount("peacemakers")); + assert.equal(3, ts.syllableCount("peacemaking")); + assert.equal(2, ts.syllableCount("peacetime")); + assert.equal(2, ts.syllableCount("peaches")); + assert.equal(1, ts.syllableCount("pearle")); + assert.equal(3, ts.syllableCount("pecore")); + assert.equal(3, ts.syllableCount("peculiar")); + assert.equal(4, ts.syllableCount("peculiarly")); + assert.equal(2, ts.syllableCount("peddler")); + assert.equal(2, ts.syllableCount("peddlers")); + assert.equal(3, ts.syllableCount("pedone")); + assert.equal(2, ts.syllableCount("peebler")); + assert.equal(1, ts.syllableCount("peer")); + assert.equal(2, ts.syllableCount("peerless")); + assert.equal(1, ts.syllableCount("peers")); + assert.equal(4, ts.syllableCount("peinado")); + assert.equal(3, ts.syllableCount("pelaez")); + assert.equal(3, ts.syllableCount("pelagia")); + assert.equal(2, ts.syllableCount("pele")); + assert.equal(3, ts.syllableCount("pelletier")); + assert.equal(4, ts.syllableCount("penelope")); + assert.equal(4, ts.syllableCount("pennsylvania")); + assert.equal(1, ts.syllableCount("pense")); + assert.equal(3, ts.syllableCount("penthea")); + assert.equal(2, ts.syllableCount("peopled")); + assert.equal(2, ts.syllableCount("pepe")); + assert.equal(5, ts.syllableCount("pepenadores")); + assert.equal(2, ts.syllableCount("peppler")); + assert.equal(4, ts.syllableCount("peragine")); + assert.equal(4, ts.syllableCount("peraino")); + assert.equal(3, ts.syllableCount("perales")); + assert.equal(3, ts.syllableCount("perea")); + assert.equal(2, ts.syllableCount("peres")); + assert.equal(2, ts.syllableCount("pergande")); + assert.equal(3, ts.syllableCount("perine")); + assert.equal(1, ts.syllableCount("perle")); + assert.equal(6, ts.syllableCount("permeability")); + assert.equal(3, ts.syllableCount("permeate")); + assert.equal(4, ts.syllableCount("permeated")); + assert.equal(3, ts.syllableCount("permeates")); + assert.equal(4, ts.syllableCount("perniciaro")); + assert.equal(4, ts.syllableCount("perricone")); + assert.equal(3, ts.syllableCount("perrine")); + assert.equal(3, ts.syllableCount("perrone")); + assert.equal(3, ts.syllableCount("perseus")); + assert.equal(4, ts.syllableCount("persuadable")); + assert.equal(2, ts.syllableCount("persuade")); + assert.equal(3, ts.syllableCount("persuaded")); + assert.equal(2, ts.syllableCount("persuades")); + assert.equal(3, ts.syllableCount("persuading")); + assert.equal(3, ts.syllableCount("persuasion")); + assert.equal(3, ts.syllableCount("persuasions")); + assert.equal(3, ts.syllableCount("persuasive")); + assert.equal(4, ts.syllableCount("persuasively")); + assert.equal(4, ts.syllableCount("persuasiveness")); + assert.equal(4, ts.syllableCount("pescatore")); + assert.equal(1, ts.syllableCount("peschke")); + assert.equal(3, ts.syllableCount("petrea")); + assert.equal(4, ts.syllableCount("petroleum")); + assert.equal(3, ts.syllableCount("petrone")); + assert.equal(5, ts.syllableCount("petrovietnam")); + assert.equal(2, ts.syllableCount("petteway")); + assert.equal(3, ts.syllableCount("pettine")); + assert.equal(2, ts.syllableCount("pevehouse")); + assert.equal(2, ts.syllableCount("pfiester")); + assert.equal(2, ts.syllableCount("ph")); + assert.equal(4, ts.syllableCount("pharaonic")); + assert.equal(5, ts.syllableCount("pharisaism")); + assert.equal(2, ts.syllableCount("phaseout")); + assert.equal(2, ts.syllableCount("phebe")); + assert.equal(4, ts.syllableCount("philistia")); + assert.equal(2, ts.syllableCount("phillippe")); + assert.equal(3, ts.syllableCount("phineas")); + assert.equal(4, ts.syllableCount("phlcorp")); + assert.equal(2, ts.syllableCount("phoebe")); + assert.equal(2, ts.syllableCount("phonemate")); + assert.equal(4, ts.syllableCount("phonetically")); + assert.equal(5, ts.syllableCount("photoelectric")); + assert.equal(5, ts.syllableCount("photovoltaic")); + assert.equal(5, ts.syllableCount("photovoltaics")); + assert.equal(2, ts.syllableCount("phuong")); + assert.equal(2, ts.syllableCount("physique")); + assert.equal(3, ts.syllableCount("piccone")); + assert.equal(3, ts.syllableCount("pichler")); + assert.equal(3, ts.syllableCount("pickler")); + assert.equal(3, ts.syllableCount("pickren")); + assert.equal(2, ts.syllableCount("picotte")); + assert.equal(2, ts.syllableCount("picower")); + assert.equal(3, ts.syllableCount("picturetel")); + assert.equal(2, ts.syllableCount("piecemeal")); + assert.equal(2, ts.syllableCount("piecework")); + assert.equal(2, ts.syllableCount("piedboeuf")); + assert.equal(1, ts.syllableCount("pier")); + assert.equal(2, ts.syllableCount("pierette")); + assert.equal(3, ts.syllableCount("pierrelouis")); + assert.equal(1, ts.syllableCount("piers")); + assert.equal(3, ts.syllableCount("pieties")); + assert.equal(3, ts.syllableCount("pietro")); + assert.equal(4, ts.syllableCount("pietruski")); + assert.equal(3, ts.syllableCount("pietrzak")); + assert.equal(3, ts.syllableCount("pietrzyk")); + assert.equal(1, ts.syllableCount("piette")); + assert.equal(3, ts.syllableCount("piety")); + assert.equal(3, ts.syllableCount("pignone")); + assert.equal(1, ts.syllableCount("pigue")); + assert.equal(2, ts.syllableCount("pilotte")); + assert.equal(4, ts.syllableCount("pingitore")); + assert.equal(3, ts.syllableCount("pipefishes")); + assert.equal(2, ts.syllableCount("pipeline")); + assert.equal(2, ts.syllableCount("pipelines")); + assert.equal(2, ts.syllableCount("pipetec")); + assert.equal(1, ts.syllableCount("pique")); + assert.equal(1, ts.syllableCount("piqued")); + assert.equal(2, ts.syllableCount("piquette")); + assert.equal(2, ts.syllableCount("pirkl")); + assert.equal(3, ts.syllableCount("pirrone")); + assert.equal(2, ts.syllableCount("pisces")); + assert.equal(1, ts.syllableCount("pischke")); + assert.equal(3, ts.syllableCount("pisciotta")); + assert.equal(2, ts.syllableCount("pitchblende")); + assert.equal(4, ts.syllableCount("pitiable")); + assert.equal(5, ts.syllableCount("pituitary")); + assert.equal(2, ts.syllableCount("placeway")); + assert.equal(1, ts.syllableCount("placke")); + assert.equal(4, ts.syllableCount("plagiarism")); + assert.equal(1, ts.syllableCount("plague")); + assert.equal(1, ts.syllableCount("plagued")); + assert.equal(1, ts.syllableCount("plagues")); + assert.equal(2, ts.syllableCount("plaia")); + assert.equal(3, ts.syllableCount("plaisted")); + assert.equal(1, ts.syllableCount("plante")); + assert.equal(1, ts.syllableCount("plaque")); + assert.equal(1, ts.syllableCount("plaques")); + assert.equal(3, ts.syllableCount("plateauing")); + assert.equal(2, ts.syllableCount("platelets")); + assert.equal(2, ts.syllableCount("platelike")); + assert.equal(2, ts.syllableCount("platinum")); + assert.equal(1, ts.syllableCount("platte")); + assert.equal(3, ts.syllableCount("plebeians")); + assert.equal(2, ts.syllableCount("pleiad")); + assert.equal(2, ts.syllableCount("pleiads")); + assert.equal(2, ts.syllableCount("plenmeer")); + assert.equal(1, ts.syllableCount("plouffe")); + assert.equal(1, ts.syllableCount("plourde")); + assert.equal(2, ts.syllableCount("pm")); + assert.equal(3, ts.syllableCount("pneumonia")); + assert.equal(2, ts.syllableCount("poage")); + assert.equal(3, ts.syllableCount("pocius")); + assert.equal(2, ts.syllableCount("poel")); + assert.equal(2, ts.syllableCount("poem")); + assert.equal(2, ts.syllableCount("poems")); + assert.equal(2, ts.syllableCount("poeschl")); + assert.equal(2, ts.syllableCount("poet")); + assert.equal(3, ts.syllableCount("poetic")); + assert.equal(3, ts.syllableCount("poetry")); + assert.equal(2, ts.syllableCount("poets")); + assert.equal(3, ts.syllableCount("poggioli")); + assert.equal(1, ts.syllableCount("pogue")); + assert.equal(4, ts.syllableCount("poinsettia")); + assert.equal(4, ts.syllableCount("poinsettias")); + assert.equal(1, ts.syllableCount("pointe")); + assert.equal(2, ts.syllableCount("poitier")); + assert.equal(2, ts.syllableCount("pokeweed")); + assert.equal(2, ts.syllableCount("polecat")); + assert.equal(2, ts.syllableCount("polecats")); + assert.equal(2, ts.syllableCount("poleward")); + assert.equal(3, ts.syllableCount("policeman")); + assert.equal(3, ts.syllableCount("policemen")); + assert.equal(2, ts.syllableCount("politte")); + assert.equal(5, ts.syllableCount("polytheism")); + assert.equal(5, ts.syllableCount("polytheistic")); + assert.equal(5, ts.syllableCount("polyurethane")); + assert.equal(2, ts.syllableCount("pomrenze")); + assert.equal(2, ts.syllableCount("ponce")); + assert.equal(1, ts.syllableCount("ponte")); + assert.equal(3, ts.syllableCount("pontiac")); + assert.equal(3, ts.syllableCount("pontiacs")); + assert.equal(3, ts.syllableCount("pontikes")); + assert.equal(2, ts.syllableCount("pontious")); + assert.equal(2, ts.syllableCount("pooches")); + assert.equal(2, ts.syllableCount("popejoy")); + assert.equal(5, ts.syllableCount("popieluszko")); + assert.equal(4, ts.syllableCount("popolare")); + assert.equal(1, ts.syllableCount("poppe")); + assert.equal(3, ts.syllableCount("poppea")); + assert.equal(2, ts.syllableCount("poquette")); + assert.equal(3, ts.syllableCount("portales")); + assert.equal(1, ts.syllableCount("porte")); + assert.equal(5, ts.syllableCount("possiblity")); + assert.equal(4, ts.syllableCount("postindustrial")); + assert.equal(2, ts.syllableCount("pottebaum")); + assert.equal(2, ts.syllableCount("pouches")); + assert.equal(4, ts.syllableCount("poudrier")); + assert.equal(3, ts.syllableCount("pourciau")); + assert.equal(2, ts.syllableCount("powercise")); + assert.equal(3, ts.syllableCount("powerfully")); + assert.equal(4, ts.syllableCount("powerpc")); + assert.equal(4, ts.syllableCount("powerpcs")); + assert.equal(2, ts.syllableCount("powertrain")); + assert.equal(3, ts.syllableCount("ppm")); + assert.equal(3, ts.syllableCount("practically")); + assert.equal(1, ts.syllableCount("prague")); + assert.equal(3, ts.syllableCount("praiseworthy")); + assert.equal(1, ts.syllableCount("pratte")); + assert.equal(1, ts.syllableCount("prayer")); + assert.equal(1, ts.syllableCount("prayers")); + assert.equal(2, ts.syllableCount("prechtl")); + assert.equal(3, ts.syllableCount("preciado")); + assert.equal(2, ts.syllableCount("premier")); + assert.equal(2, ts.syllableCount("premiers")); + assert.equal(3, ts.syllableCount("prentnieks")); + assert.equal(3, ts.syllableCount("preponderance")); + assert.equal(3, ts.syllableCount("prescience")); + assert.equal(3, ts.syllableCount("prescient")); + assert.equal(2, ts.syllableCount("preserved")); + assert.equal(3, ts.syllableCount("presler")); + assert.equal(1, ts.syllableCount("presse")); + assert.equal(2, ts.syllableCount("pressler")); + assert.equal(5, ts.syllableCount("prestigiacomo")); + assert.equal(3, ts.syllableCount("prestigious")); + assert.equal(2, ts.syllableCount("pretense")); + assert.equal(3, ts.syllableCount("pretentious")); + assert.equal(2, ts.syllableCount("prevatte")); + assert.equal(2, ts.syllableCount("pridemore")); + assert.equal(1, ts.syllableCount("priest")); + assert.equal(2, ts.syllableCount("priester")); + assert.equal(2, ts.syllableCount("priestly")); + assert.equal(2, ts.syllableCount("prieta")); + assert.equal(2, ts.syllableCount("prieto")); + assert.equal(2, ts.syllableCount("primebank")); + assert.equal(2, ts.syllableCount("primeco")); + assert.equal(2, ts.syllableCount("primenews")); + assert.equal(2, ts.syllableCount("primestar")); + assert.equal(2, ts.syllableCount("primetime")); + assert.equal(2, ts.syllableCount("princeton")); + assert.equal(3, ts.syllableCount("principally")); + assert.equal(3, ts.syllableCount("principe")); + assert.equal(2, ts.syllableCount("prindl")); + assert.equal(3, ts.syllableCount("priore")); + assert.equal(2, ts.syllableCount("pritzl")); + assert.equal(3, ts.syllableCount("privileges")); + assert.equal(3, ts.syllableCount("prizewinner")); + assert.equal(3, ts.syllableCount("prizewinners")); + assert.equal(3, ts.syllableCount("prizewinning")); + assert.equal(2, ts.syllableCount("prizm")); + assert.equal(3, ts.syllableCount("procreate")); + assert.equal(3, ts.syllableCount("procreates")); + assert.equal(4, ts.syllableCount("procreation")); + assert.equal(3, ts.syllableCount("prodigious")); + assert.equal(4, ts.syllableCount("prodigiously")); + assert.equal(2, ts.syllableCount("proia")); + assert.equal(2, ts.syllableCount("proj")); + assert.equal(4, ts.syllableCount("prolifically")); + assert.equal(4, ts.syllableCount("prolinea")); + assert.equal(2, ts.syllableCount("prologue")); + assert.equal(3, ts.syllableCount("promiscuous")); + assert.equal(3, ts.syllableCount("propitious")); + assert.equal(3, ts.syllableCount("prosaic")); + assert.equal(2, ts.syllableCount("proskauer")); + assert.equal(1, ts.syllableCount("proske")); + assert.equal(3, ts.syllableCount("protean")); + assert.equal(3, ts.syllableCount("protease")); + assert.equal(3, ts.syllableCount("protege")); + assert.equal(4, ts.syllableCount("protozoan")); + assert.equal(4, ts.syllableCount("protozoans")); + assert.equal(3, ts.syllableCount("provincetown")); + assert.equal(3, ts.syllableCount("provine")); + assert.equal(1, ts.syllableCount("prowse")); + assert.equal(2, ts.syllableCount("prudente")); + assert.equal(5, ts.syllableCount("prudentialbache")); + assert.equal(2, ts.syllableCount("pruitt")); + assert.equal(2, ts.syllableCount("prunedale")); + assert.equal(3, ts.syllableCount("prurient")); + assert.equal(2, ts.syllableCount("pryor")); + assert.equal(3, ts.syllableCount("przybyl")); + assert.equal(4, ts.syllableCount("przybyla")); + assert.equal(4, ts.syllableCount("przybylski")); + assert.equal(3, ts.syllableCount("przybysz")); + assert.equal(4, ts.syllableCount("przywara")); + assert.equal(4, ts.syllableCount("pseudoscience")); + assert.equal(6, ts.syllableCount("pseudoscientific")); + assert.equal(2, ts.syllableCount("psyche")); + assert.equal(2, ts.syllableCount("psyches")); + assert.equal(6, ts.syllableCount("psychoanalysis")); + assert.equal(5, ts.syllableCount("psychoanalyst")); + assert.equal(6, ts.syllableCount("psychoanalytic")); + assert.equal(5, ts.syllableCount("psychologically")); + assert.equal(4, ts.syllableCount("ptolemaic")); + assert.equal(4, ts.syllableCount("pucciarelli")); + assert.equal(1, ts.syllableCount("puente")); + assert.equal(4, ts.syllableCount("pugliese")); + assert.equal(1, ts.syllableCount("pulse")); + assert.equal(2, ts.syllableCount("punches")); + assert.equal(2, ts.syllableCount("purebreds")); + assert.equal(5, ts.syllableCount("puritanisms")); + assert.equal(2, ts.syllableCount("puzzler")); + assert.equal(1, ts.syllableCount("pylant")); + assert.equal(2, ts.syllableCount("qiao")); + assert.equal(2, ts.syllableCount("qiaotou")); + assert.equal(2, ts.syllableCount("qmax")); + assert.equal(4, ts.syllableCount("quadrupling")); + assert.equal(3, ts.syllableCount("quagmire")); + assert.equal(1, ts.syllableCount("quarles")); + assert.equal(1, ts.syllableCount("quarre")); + assert.equal(3, ts.syllableCount("quassia")); + assert.equal(3, ts.syllableCount("quattrone")); + assert.equal(2, ts.syllableCount("quealy")); + assert.equal(3, ts.syllableCount("queasiness")); + assert.equal(2, ts.syllableCount("queasy")); + assert.equal(1, ts.syllableCount("queen")); + assert.equal(2, ts.syllableCount("queena")); + assert.equal(2, ts.syllableCount("queenan")); + assert.equal(2, ts.syllableCount("queener")); + assert.equal(2, ts.syllableCount("queenfish")); + assert.equal(2, ts.syllableCount("queenie")); + assert.equal(1, ts.syllableCount("queens")); + assert.equal(3, ts.syllableCount("queensberry")); + assert.equal(2, ts.syllableCount("queensland")); + assert.equal(2, ts.syllableCount("queensway")); + assert.equal(1, ts.syllableCount("queer")); + assert.equal(2, ts.syllableCount("queerer")); + assert.equal(1, ts.syllableCount("queue")); + assert.equal(1, ts.syllableCount("queues")); + assert.equal(1, ts.syllableCount("quiett")); + assert.equal(2, ts.syllableCount("quiles")); + assert.equal(2, ts.syllableCount("quillian")); + assert.equal(1, ts.syllableCount("quilmes")); + assert.equal(3, ts.syllableCount("quirion")); + assert.equal(1, ts.syllableCount("quirke")); + assert.equal(3, ts.syllableCount("quixote")); + assert.equal(3, ts.syllableCount("racamier")); + assert.equal(2, ts.syllableCount("racehorse")); + assert.equal(2, ts.syllableCount("racetrack")); + assert.equal(2, ts.syllableCount("racetracks")); + assert.equal(2, ts.syllableCount("raceway")); + assert.equal(3, ts.syllableCount("racioppi")); + assert.equal(2, ts.syllableCount("rackliffe")); + assert.equal(2, ts.syllableCount("radcliffe")); + assert.equal(1, ts.syllableCount("radde")); + assert.equal(3, ts.syllableCount("rademaker")); + assert.equal(2, ts.syllableCount("radiance")); + assert.equal(3, ts.syllableCount("radically")); + assert.equal(3, ts.syllableCount("radioed")); + assert.equal(3, ts.syllableCount("radler")); + assert.equal(3, ts.syllableCount("rafael")); + assert.equal(4, ts.syllableCount("raffaele")); + assert.equal(4, ts.syllableCount("raffaelli")); + assert.equal(2, ts.syllableCount("raffety")); + assert.equal(3, ts.syllableCount("rafuse")); + assert.equal(3, ts.syllableCount("ragone")); + assert.equal(4, ts.syllableCount("ragonese")); + assert.equal(2, ts.syllableCount("rai")); + assert.equal(2, ts.syllableCount("raia")); + assert.equal(2, ts.syllableCount("rainier")); + assert.equal(2, ts.syllableCount("rakestraw")); + assert.equal(2, ts.syllableCount("rambler")); + assert.equal(2, ts.syllableCount("ramblers")); + assert.equal(3, ts.syllableCount("rambunctious")); + assert.equal(3, ts.syllableCount("ramires")); + assert.equal(2, ts.syllableCount("ranches")); + assert.equal(4, ts.syllableCount("ranieri")); + assert.equal(1, ts.syllableCount("ranke")); + assert.equal(2, ts.syllableCount("rapeseed")); + assert.equal(3, ts.syllableCount("raphael")); + assert.equal(1, ts.syllableCount("rappe")); + assert.equal(1, ts.syllableCount("raschke")); + assert.equal(3, ts.syllableCount("rasia")); + assert.equal(2, ts.syllableCount("ratcliffe")); + assert.equal(2, ts.syllableCount("rateliff")); + assert.equal(3, ts.syllableCount("ratepayer")); + assert.equal(3, ts.syllableCount("ratepayers")); + assert.equal(1, ts.syllableCount("rathje")); + assert.equal(1, ts.syllableCount("rathke")); + assert.equal(2, ts.syllableCount("ratier")); + assert.equal(2, ts.syllableCount("ratliffe")); + assert.equal(1, ts.syllableCount("ratte")); + assert.equal(2, ts.syllableCount("rauls")); + assert.equal(1, ts.syllableCount("rawles")); + assert.equal(2, ts.syllableCount("rb")); + assert.equal(2, ts.syllableCount("reaches")); + assert.equal(3, ts.syllableCount("reacquire")); + assert.equal(3, ts.syllableCount("reacquired")); + assert.equal(2, ts.syllableCount("react")); + assert.equal(3, ts.syllableCount("reacted")); + assert.equal(3, ts.syllableCount("reacting")); + assert.equal(3, ts.syllableCount("reaction")); + assert.equal(4, ts.syllableCount("reactivate")); + assert.equal(5, ts.syllableCount("reactivated")); + assert.equal(5, ts.syllableCount("reactivating")); + assert.equal(3, ts.syllableCount("reactive")); + assert.equal(5, ts.syllableCount("reactivity")); + assert.equal(3, ts.syllableCount("reactor")); + assert.equal(3, ts.syllableCount("reactors")); + assert.equal(2, ts.syllableCount("reacts")); + assert.equal(3, ts.syllableCount("readjust")); + assert.equal(4, ts.syllableCount("readjusted")); + assert.equal(4, ts.syllableCount("readjusting")); + assert.equal(4, ts.syllableCount("readjustment")); + assert.equal(4, ts.syllableCount("readjustments")); + assert.equal(4, ts.syllableCount("readmitted")); + assert.equal(6, ts.syllableCount("reaffiliation")); + assert.equal(3, ts.syllableCount("reaffirm")); + assert.equal(5, ts.syllableCount("reaffirmation")); + assert.equal(3, ts.syllableCount("reaffirmed")); + assert.equal(4, ts.syllableCount("reaffirming")); + assert.equal(3, ts.syllableCount("reaffirms")); + assert.equal(3, ts.syllableCount("reagents")); + assert.equal(3, ts.syllableCount("reappear")); + assert.equal(4, ts.syllableCount("reappearance")); + assert.equal(3, ts.syllableCount("reappeared")); + assert.equal(3, ts.syllableCount("reappears")); + assert.equal(3, ts.syllableCount("reapply")); + assert.equal(3, ts.syllableCount("reappoint")); + assert.equal(4, ts.syllableCount("reappointed")); + assert.equal(4, ts.syllableCount("reappointment")); + assert.equal(5, ts.syllableCount("reapportionment")); + assert.equal(4, ts.syllableCount("reappraisal")); + assert.equal(3, ts.syllableCount("reappraise")); + assert.equal(2, ts.syllableCount("rearm")); + assert.equal(4, ts.syllableCount("rearmament")); + assert.equal(3, ts.syllableCount("rearrange")); + assert.equal(3, ts.syllableCount("rearranged")); + assert.equal(4, ts.syllableCount("rearranging")); + assert.equal(4, ts.syllableCount("rearrested")); + assert.equal(4, ts.syllableCount("reassemble")); + assert.equal(4, ts.syllableCount("reassembled")); + assert.equal(3, ts.syllableCount("reassert")); + assert.equal(4, ts.syllableCount("reasserted")); + assert.equal(4, ts.syllableCount("reasserting")); + assert.equal(4, ts.syllableCount("reassertion")); + assert.equal(3, ts.syllableCount("reasserts")); + assert.equal(3, ts.syllableCount("reassess")); + assert.equal(3, ts.syllableCount("reassessed")); + assert.equal(4, ts.syllableCount("reassessing")); + assert.equal(4, ts.syllableCount("reassessment")); + assert.equal(3, ts.syllableCount("reassign")); + assert.equal(3, ts.syllableCount("reassigned")); + assert.equal(4, ts.syllableCount("reassigning")); + assert.equal(4, ts.syllableCount("reassignment")); + assert.equal(4, ts.syllableCount("reassignments")); + assert.equal(3, ts.syllableCount("reassume")); + assert.equal(3, ts.syllableCount("reassumed")); + assert.equal(4, ts.syllableCount("reassurance")); + assert.equal(5, ts.syllableCount("reassurances")); + assert.equal(3, ts.syllableCount("reassure")); + assert.equal(3, ts.syllableCount("reassured")); + assert.equal(3, ts.syllableCount("reassures")); + assert.equal(4, ts.syllableCount("reassuring")); + assert.equal(5, ts.syllableCount("reassuringly")); + assert.equal(3, ts.syllableCount("reatta")); + assert.equal(4, ts.syllableCount("reawakened")); + assert.equal(5, ts.syllableCount("reawakening")); + assert.equal(3, ts.syllableCount("rebellious")); + assert.equal(2, ts.syllableCount("recharged")); + assert.equal(3, ts.syllableCount("recine")); + assert.equal(3, ts.syllableCount("recipe")); + assert.equal(3, ts.syllableCount("recipes")); + assert.equal(4, ts.syllableCount("recipient")); + assert.equal(4, ts.syllableCount("recipients")); + assert.equal(3, ts.syllableCount("recompense")); + assert.equal(3, ts.syllableCount("recore")); + assert.equal(3, ts.syllableCount("recreate")); + assert.equal(4, ts.syllableCount("recreated")); + assert.equal(3, ts.syllableCount("recreates")); + assert.equal(4, ts.syllableCount("recreating")); + assert.equal(4, ts.syllableCount("recreation")); + assert.equal(5, ts.syllableCount("recreational")); + assert.equal(4, ts.syllableCount("recycling")); + assert.equal(2, ts.syllableCount("redactes")); + assert.equal(4, ts.syllableCount("rediscovery")); + assert.equal(4, ts.syllableCount("redlinger")); + assert.equal(4, ts.syllableCount("reelected")); + assert.equal(4, ts.syllableCount("reelection")); + assert.equal(4, ts.syllableCount("reemergence")); + assert.equal(4, ts.syllableCount("reemployment")); + assert.equal(4, ts.syllableCount("reenacted")); + assert.equal(4, ts.syllableCount("reenactment")); + assert.equal(4, ts.syllableCount("reenactments")); + assert.equal(3, ts.syllableCount("reenacts")); + assert.equal(5, ts.syllableCount("reengineering")); + assert.equal(3, ts.syllableCount("reenter")); + assert.equal(4, ts.syllableCount("reentering")); + assert.equal(3, ts.syllableCount("reentry")); + assert.equal(4, ts.syllableCount("reestablish")); + assert.equal(5, ts.syllableCount("reestablishing")); + assert.equal(5, ts.syllableCount("reevaluate")); + assert.equal(6, ts.syllableCount("reevaluating")); + assert.equal(6, ts.syllableCount("reevaluation")); + assert.equal(6, ts.syllableCount("reexamination")); + assert.equal(4, ts.syllableCount("reexamine")); + assert.equal(4, ts.syllableCount("reexamined")); + assert.equal(5, ts.syllableCount("reexamining")); + assert.equal(3, ts.syllableCount("reexport")); + assert.equal(3, ts.syllableCount("reexports")); + assert.equal(3, ts.syllableCount("refenes")); + assert.equal(2, ts.syllableCount("reflagged")); + assert.equal(3, ts.syllableCount("refuel")); + assert.equal(3, ts.syllableCount("refueled")); + assert.equal(4, ts.syllableCount("refueling")); + assert.equal(3, ts.syllableCount("refusenik")); + assert.equal(3, ts.syllableCount("refuseniks")); + assert.equal(3, ts.syllableCount("regalia")); + assert.equal(1, ts.syllableCount("reher")); + assert.equal(3, ts.syllableCount("rehired")); + assert.equal(3, ts.syllableCount("reichart")); + assert.equal(2, ts.syllableCount("reichl")); + assert.equal(3, ts.syllableCount("reichling")); + assert.equal(3, ts.syllableCount("reignite")); + assert.equal(4, ts.syllableCount("reignited")); + assert.equal(4, ts.syllableCount("reigniting")); + assert.equal(4, ts.syllableCount("reimagine")); + assert.equal(3, ts.syllableCount("reimburse")); + assert.equal(3, ts.syllableCount("reimbursed")); + assert.equal(4, ts.syllableCount("reimburses")); + assert.equal(4, ts.syllableCount("reimbursing")); + assert.equal(3, ts.syllableCount("reimpose")); + assert.equal(4, ts.syllableCount("reimposing")); + assert.equal(5, ts.syllableCount("reimposition")); + assert.equal(3, ts.syllableCount("reina")); + assert.equal(5, ts.syllableCount("reincarnated")); + assert.equal(5, ts.syllableCount("reincarnation")); + assert.equal(1, ts.syllableCount("reincke")); + assert.equal(5, ts.syllableCount("reincorporate")); + assert.equal(6, ts.syllableCount("reincorporating")); + assert.equal(6, ts.syllableCount("reincorporation")); + assert.equal(2, ts.syllableCount("reindeer")); + assert.equal(2, ts.syllableCount("reindl")); + assert.equal(2, ts.syllableCount("reinecke")); + assert.equal(3, ts.syllableCount("reinforce")); + assert.equal(3, ts.syllableCount("reinforced")); + assert.equal(4, ts.syllableCount("reinforces")); + assert.equal(4, ts.syllableCount("reinforcing")); + assert.equal(1, ts.syllableCount("reinke")); + assert.equal(4, ts.syllableCount("reinspection")); + assert.equal(3, ts.syllableCount("reinstate")); + assert.equal(4, ts.syllableCount("reinstated")); + assert.equal(4, ts.syllableCount("reinstating")); + assert.equal(4, ts.syllableCount("reinstitute")); + assert.equal(5, ts.syllableCount("reinstituted")); + assert.equal(5, ts.syllableCount("reinstituting")); + assert.equal(4, ts.syllableCount("reinsurance")); + assert.equal(3, ts.syllableCount("reinsure")); + assert.equal(3, ts.syllableCount("reinsured")); + assert.equal(4, ts.syllableCount("reinsurer")); + assert.equal(4, ts.syllableCount("reinsurers")); + assert.equal(5, ts.syllableCount("reintegrated")); + assert.equal(4, ts.syllableCount("reinterpret")); + assert.equal(6, ts.syllableCount("reinterpretation")); + assert.equal(5, ts.syllableCount("reinterpreted")); + assert.equal(5, ts.syllableCount("reinterpreting")); + assert.equal(4, ts.syllableCount("reintroduce")); + assert.equal(4, ts.syllableCount("reintroduced")); + assert.equal(5, ts.syllableCount("reintroduces")); + assert.equal(5, ts.syllableCount("reintroducing")); + assert.equal(5, ts.syllableCount("reintroduction")); + assert.equal(3, ts.syllableCount("reinvent")); + assert.equal(4, ts.syllableCount("reinvented")); + assert.equal(4, ts.syllableCount("reinventing")); + assert.equal(3, ts.syllableCount("reinvest")); + assert.equal(4, ts.syllableCount("reinvested")); + assert.equal(4, ts.syllableCount("reinvesting")); + assert.equal(4, ts.syllableCount("reinvestment")); + assert.equal(3, ts.syllableCount("reinvests")); + assert.equal(5, ts.syllableCount("reinvigorate")); + assert.equal(6, ts.syllableCount("reinvigorated")); + assert.equal(6, ts.syllableCount("reinvigorating")); + assert.equal(6, ts.syllableCount("reinvigoration")); + assert.equal(2, ts.syllableCount("reischauer")); + assert.equal(2, ts.syllableCount("reish")); + assert.equal(3, ts.syllableCount("reissue")); + assert.equal(3, ts.syllableCount("reissued")); + assert.equal(4, ts.syllableCount("reissuing")); + assert.equal(2, ts.syllableCount("reist")); + assert.equal(3, ts.syllableCount("reister")); + assert.equal(4, ts.syllableCount("reitano")); + assert.equal(4, ts.syllableCount("reiterate")); + assert.equal(5, ts.syllableCount("reiterated")); + assert.equal(4, ts.syllableCount("reiterates")); + assert.equal(5, ts.syllableCount("reiterating")); + assert.equal(5, ts.syllableCount("reiteration")); + assert.equal(2, ts.syllableCount("relapse")); + assert.equal(5, ts.syllableCount("religione")); + assert.equal(3, ts.syllableCount("religious")); + assert.equal(4, ts.syllableCount("religiously")); + assert.equal(3, ts.syllableCount("relying")); + assert.equal(4, ts.syllableCount("reminisces")); + assert.equal(4, ts.syllableCount("remlinger")); + assert.equal(1, ts.syllableCount("rempe")); + assert.equal(3, ts.syllableCount("renate")); + assert.equal(1, ts.syllableCount("rende")); + assert.equal(2, ts.syllableCount("rene")); + assert.equal(5, ts.syllableCount("renegotiate")); + assert.equal(6, ts.syllableCount("renegotiated")); + assert.equal(6, ts.syllableCount("renegotiating")); + assert.equal(6, ts.syllableCount("renegotiation")); + assert.equal(6, ts.syllableCount("renegotiations")); + assert.equal(2, ts.syllableCount("renfred")); + assert.equal(3, ts.syllableCount("renschler")); + assert.equal(3, ts.syllableCount("rensselaer")); + assert.equal(4, ts.syllableCount("reorient")); + assert.equal(4, ts.syllableCount("repetitious")); + assert.equal(2, ts.syllableCount("reponse")); + assert.equal(2, ts.syllableCount("repulse")); + assert.equal(3, ts.syllableCount("require")); + assert.equal(3, ts.syllableCount("required")); + assert.equal(3, ts.syllableCount("requires")); + assert.equal(4, ts.syllableCount("requiring")); + assert.equal(1, ts.syllableCount("reschke")); + assert.equal(2, ts.syllableCount("researched")); + assert.equal(2, ts.syllableCount("resendes")); + assert.equal(2, ts.syllableCount("reserved")); + assert.equal(4, ts.syllableCount("resiliency")); + assert.equal(3, ts.syllableCount("resilient")); + assert.equal(4, ts.syllableCount("resourcefulness")); + assert.equal(2, ts.syllableCount("response")); + assert.equal(3, ts.syllableCount("resseguie")); + assert.equal(2, ts.syllableCount("ressler")); + assert.equal(4, ts.syllableCount("restaino")); + assert.equal(5, ts.syllableCount("retaliatory")); + assert.equal(3, ts.syllableCount("retemeyer")); + assert.equal(4, ts.syllableCount("retroactive")); + assert.equal(5, ts.syllableCount("retroactively")); + assert.equal(6, ts.syllableCount("retroactivity")); + assert.equal(2, ts.syllableCount("reum")); + assert.equal(6, ts.syllableCount("reunification")); + assert.equal(4, ts.syllableCount("reunified")); + assert.equal(4, ts.syllableCount("reunify")); + assert.equal(3, ts.syllableCount("reunion")); + assert.equal(3, ts.syllableCount("reunions")); + assert.equal(3, ts.syllableCount("reunite")); + assert.equal(4, ts.syllableCount("reunited")); + assert.equal(4, ts.syllableCount("reuniting")); + assert.equal(4, ts.syllableCount("reusable")); + assert.equal(2, ts.syllableCount("reuse")); + assert.equal(6, ts.syllableCount("revaluations")); + assert.equal(3, ts.syllableCount("reveles")); + assert.equal(3, ts.syllableCount("reveres")); + assert.equal(8, ts.syllableCount("revolucionario")); + assert.equal(3, ts.syllableCount("rewire")); + assert.equal(3, ts.syllableCount("rewired")); + assert.equal(4, ts.syllableCount("rewiring")); + assert.equal(2, ts.syllableCount("reyes")); + assert.equal(2, ts.syllableCount("rhea")); + assert.equal(4, ts.syllableCount("rhetorically")); + assert.equal(2, ts.syllableCount("rhinehardt")); + assert.equal(2, ts.syllableCount("rhinehart")); + assert.equal(2, ts.syllableCount("rhineland")); + assert.equal(2, ts.syllableCount("rhineman")); + assert.equal(2, ts.syllableCount("rhinesmith")); + assert.equal(2, ts.syllableCount("rhinestone")); + assert.equal(2, ts.syllableCount("rhinestones")); + assert.equal(2, ts.syllableCount("rhodanthe")); + assert.equal(3, ts.syllableCount("rhythmically")); + assert.equal(2, ts.syllableCount("rhythms")); + assert.equal(1, ts.syllableCount("rials")); + assert.equal(4, ts.syllableCount("ricciardelli")); + assert.equal(3, ts.syllableCount("ricciardi")); + assert.equal(3, ts.syllableCount("ricciuti")); + assert.equal(3, ts.syllableCount("richelieu")); + assert.equal(2, ts.syllableCount("riches")); + assert.equal(1, ts.syllableCount("ricke")); + assert.equal(3, ts.syllableCount("ricocheted")); + assert.equal(6, ts.syllableCount("ricostruzione")); + assert.equal(2, ts.syllableCount("rideout")); + assert.equal(2, ts.syllableCount("ridgecrest")); + assert.equal(2, ts.syllableCount("ridgefield")); + assert.equal(2, ts.syllableCount("ridgeway")); + assert.equal(1, ts.syllableCount("riecke")); + assert.equal(2, ts.syllableCount("riedl")); + assert.equal(4, ts.syllableCount("riedlinger")); + assert.equal(2, ts.syllableCount("rietveld")); + assert.equal(1, ts.syllableCount("rietz")); + assert.equal(1, ts.syllableCount("riffe")); + assert.equal(3, ts.syllableCount("rigler")); + assert.equal(2, ts.syllableCount("rigueur")); + assert.equal(2, ts.syllableCount("rijn")); + assert.equal(2, ts.syllableCount("rinehardt")); + assert.equal(2, ts.syllableCount("rinehart")); + assert.equal(3, ts.syllableCount("rinehimer")); + assert.equal(3, ts.syllableCount("ringler")); + assert.equal(2, ts.syllableCount("ringuette")); + assert.equal(1, ts.syllableCount("rinke")); + assert.equal(1, ts.syllableCount("rinse")); + assert.equal(2, ts.syllableCount("riordan")); + assert.equal(1, ts.syllableCount("rioux")); + assert.equal(1, ts.syllableCount("ripke")); + assert.equal(1, ts.syllableCount("rippe")); + assert.equal(2, ts.syllableCount("rissler")); + assert.equal(4, ts.syllableCount("riviera")); + assert.equal(3, ts.syllableCount("riviere")); + assert.equal(3, ts.syllableCount("rivieres")); + assert.equal(2, ts.syllableCount("roaches")); + assert.equal(3, ts.syllableCount("roanoke")); + assert.equal(1, ts.syllableCount("roarke")); + assert.equal(3, ts.syllableCount("robare")); + assert.equal(1, ts.syllableCount("robbe")); + assert.equal(1, ts.syllableCount("rocke")); + assert.equal(1, ts.syllableCount("rocque")); + assert.equal(2, ts.syllableCount("rodarte")); + assert.equal(2, ts.syllableCount("roderick")); + assert.equal(2, ts.syllableCount("rodeway")); + assert.equal(3, ts.syllableCount("rodine")); + assert.equal(2, ts.syllableCount("rodrigue")); + assert.equal(1, ts.syllableCount("roebke")); + assert.equal(2, ts.syllableCount("roedl")); + assert.equal(1, ts.syllableCount("roelke")); + assert.equal(1, ts.syllableCount("roepke")); + assert.equal(3, ts.syllableCount("roesler")); + assert.equal(3, ts.syllableCount("roethler")); + assert.equal(3, ts.syllableCount("roever")); + assert.equal(1, ts.syllableCount("roffe")); + assert.equal(1, ts.syllableCount("rogue")); + assert.equal(1, ts.syllableCount("rogues")); + assert.equal(1, ts.syllableCount("rohde")); + assert.equal(3, ts.syllableCount("rohweder")); + assert.equal(3, ts.syllableCount("roleplaying")); + assert.equal(1, ts.syllableCount("rolfe")); + assert.equal(1, ts.syllableCount("rolfes")); + assert.equal(2, ts.syllableCount("romesburg")); + assert.equal(3, ts.syllableCount("romine")); + assert.equal(1, ts.syllableCount("roque")); + assert.equal(2, ts.syllableCount("roquemore")); + assert.equal(1, ts.syllableCount("rorke")); + assert.equal(2, ts.syllableCount("roseboom")); + assert.equal(3, ts.syllableCount("roseboro")); + assert.equal(3, ts.syllableCount("roseborough")); + assert.equal(2, ts.syllableCount("rosebrock")); + assert.equal(2, ts.syllableCount("rosebrook")); + assert.equal(2, ts.syllableCount("rosebrough")); + assert.equal(2, ts.syllableCount("rosebush")); + assert.equal(2, ts.syllableCount("rosecrans")); + assert.equal(2, ts.syllableCount("rosekrans")); + assert.equal(2, ts.syllableCount("roseland")); + assert.equal(2, ts.syllableCount("roselawn")); + assert.equal(2, ts.syllableCount("roseline")); + assert.equal(2, ts.syllableCount("roseman")); + assert.equal(3, ts.syllableCount("rosemarie")); + assert.equal(3, ts.syllableCount("rosemary")); + assert.equal(2, ts.syllableCount("rosemead")); + assert.equal(3, ts.syllableCount("rosemeyer")); + assert.equal(2, ts.syllableCount("rosemond")); + assert.equal(2, ts.syllableCount("rosemont")); + assert.equal(2, ts.syllableCount("rosenau")); + assert.equal(2, ts.syllableCount("rosevear")); + assert.equal(2, ts.syllableCount("rosewicz")); + assert.equal(2, ts.syllableCount("rosewood")); + assert.equal(2, ts.syllableCount("roshier")); + assert.equal(3, ts.syllableCount("rosine")); + assert.equal(4, ts.syllableCount("ROTC")); + assert.equal(2, ts.syllableCount("rothmeier")); + assert.equal(2, ts.syllableCount("rottler")); + assert.equal(2, ts.syllableCount("rouillard")); + assert.equal(2, ts.syllableCount("roukema")); + assert.equal(1, ts.syllableCount("rourke")); + assert.equal(2, ts.syllableCount("rouyn")); + assert.equal(5, ts.syllableCount("rovaniemi")); + assert.equal(1, ts.syllableCount("rowles")); + assert.equal(1, ts.syllableCount("rowse")); + assert.equal(3, ts.syllableCount("rpm")); + assert.equal(3, ts.syllableCount("rueda")); + assert.equal(3, ts.syllableCount("ruella")); + assert.equal(1, ts.syllableCount("ruhnke")); + assert.equal(2, ts.syllableCount("ruin")); + assert.equal(2, ts.syllableCount("ruined")); + assert.equal(3, ts.syllableCount("ruining")); + assert.equal(3, ts.syllableCount("ruinous")); + assert.equal(2, ts.syllableCount("ruins")); + assert.equal(2, ts.syllableCount("ruis")); + assert.equal(2, ts.syllableCount("ruiz")); + assert.equal(2, ts.syllableCount("rulebook")); + assert.equal(3, ts.syllableCount("rulemaking")); + assert.equal(1, ts.syllableCount("runde")); + assert.equal(1, ts.syllableCount("runte")); + assert.equal(3, ts.syllableCount("ruocco")); + assert.equal(2, ts.syllableCount("ruoff")); + assert.equal(4, ts.syllableCount("ruotolo")); + assert.equal(1, ts.syllableCount("ruppe")); + assert.equal(3, ts.syllableCount("rustlers")); + assert.equal(3, ts.syllableCount("rwanda")); + assert.equal(3, ts.syllableCount("rwandan")); + assert.equal(3, ts.syllableCount("rwandans")); + assert.equal(3, ts.syllableCount("rwandese")); + assert.equal(3, ts.syllableCount("ryobi")); + assert.equal(3, ts.syllableCount("ryohei")); + assert.equal(2, ts.syllableCount("ryon")); + assert.equal(3, ts.syllableCount("ryuzo")); + assert.equal(3, ts.syllableCount("rzasa")); + assert.equal(3, ts.syllableCount("rzepka")); + assert.equal(4, ts.syllableCount("sabatine")); + assert.equal(3, ts.syllableCount("saccone")); + assert.equal(1, ts.syllableCount("sachse")); + assert.equal(4, ts.syllableCount("sacrilegious")); + assert.equal(2, ts.syllableCount("safecard")); + assert.equal(2, ts.syllableCount("safeco")); + assert.equal(2, ts.syllableCount("safeguard")); + assert.equal(3, ts.syllableCount("safeguarding")); + assert.equal(2, ts.syllableCount("safeguards")); + assert.equal(3, ts.syllableCount("safekeeping")); + assert.equal(2, ts.syllableCount("safety")); + assert.equal(2, ts.syllableCount("safeway")); + assert.equal(2, ts.syllableCount("safier")); + assert.equal(2, ts.syllableCount("sagebrush")); + assert.equal(3, ts.syllableCount("sagraves")); + assert.equal(2, ts.syllableCount("saia")); + assert.equal(2, ts.syllableCount("saif")); + assert.equal(4, ts.syllableCount("saitama")); + assert.equal(3, ts.syllableCount("sakai")); + assert.equal(3, ts.syllableCount("sakau")); + assert.equal(4, ts.syllableCount("sakigake")); + assert.equal(4, ts.syllableCount("sakurai")); + assert.equal(2, ts.syllableCount("salesman")); + assert.equal(3, ts.syllableCount("salesmanship")); + assert.equal(2, ts.syllableCount("salesmen")); + assert.equal(3, ts.syllableCount("salespeople")); + assert.equal(3, ts.syllableCount("salesperson")); + assert.equal(3, ts.syllableCount("salisbury")); + assert.equal(3, ts.syllableCount("salome")); + assert.equal(4, ts.syllableCount("salomone")); + assert.equal(4, ts.syllableCount("salvadore")); + assert.equal(4, ts.syllableCount("salvatore")); + assert.equal(2, ts.syllableCount("salzhauer")); + assert.equal(4, ts.syllableCount("samuela")); + assert.equal(3, ts.syllableCount("samuels")); + assert.equal(4, ts.syllableCount("samuelson")); + assert.equal(2, ts.syllableCount("sanches")); + assert.equal(2, ts.syllableCount("sandbagged")); + assert.equal(1, ts.syllableCount("sande")); + assert.equal(3, ts.syllableCount("sandwiches")); + assert.equal(3, ts.syllableCount("sansui")); + assert.equal(4, ts.syllableCount("santacroce")); + assert.equal(2, ts.syllableCount("santerre")); + assert.equal(4, ts.syllableCount("santiago")); + assert.equal(3, ts.syllableCount("santone")); + assert.equal(3, ts.syllableCount("santore")); + assert.equal(3, ts.syllableCount("sanzone")); + assert.equal(2, ts.syllableCount("saone")); + assert.equal(3, ts.syllableCount("sapiens")); + assert.equal(3, ts.syllableCount("sapone")); + assert.equal(3, ts.syllableCount("sapphire")); + assert.equal(4, ts.syllableCount("sarcastically")); + assert.equal(3, ts.syllableCount("sarine")); + assert.equal(1, ts.syllableCount("sarles")); + assert.equal(3, ts.syllableCount("sassone")); + assert.equal(2, ts.syllableCount("satiny")); + assert.equal(3, ts.syllableCount("satire")); + assert.equal(3, ts.syllableCount("satires")); + assert.equal(5, ts.syllableCount("satisfactorily")); + assert.equal(4, ts.syllableCount("satisfactory")); + assert.equal(2, ts.syllableCount("sattler")); + assert.equal(2, ts.syllableCount("saucepan")); + assert.equal(2, ts.syllableCount("saute")); + assert.equal(3, ts.syllableCount("sauter")); + assert.equal(4, ts.syllableCount("savarese")); + assert.equal(2, ts.syllableCount("savior")); + assert.equal(2, ts.syllableCount("saviors")); + assert.equal(3, ts.syllableCount("savoia")); + assert.equal(2, ts.syllableCount("savoie")); + assert.equal(2, ts.syllableCount("savr")); + assert.equal(2, ts.syllableCount("sawyer")); + assert.equal(2, ts.syllableCount("sawyers")); + assert.equal(2, ts.syllableCount("sayed")); + assert.equal(3, ts.syllableCount("sbf")); + assert.equal(4, ts.syllableCount("scaglione")); + assert.equal(3, ts.syllableCount("scalese")); + assert.equal(2, ts.syllableCount("scapegoat")); + assert.equal(3, ts.syllableCount("scapegoating")); + assert.equal(2, ts.syllableCount("scapegoats")); + assert.equal(3, ts.syllableCount("scarpone")); + assert.equal(3, ts.syllableCount("schadler")); + assert.equal(3, ts.syllableCount("schaedler")); + assert.equal(1, ts.syllableCount("schaefers")); + assert.equal(1, ts.syllableCount("scharfe")); + assert.equal(3, ts.syllableCount("schaufler")); + assert.equal(3, ts.syllableCount("schedler")); + assert.equal(3, ts.syllableCount("scheidler")); + assert.equal(3, ts.syllableCount("scheufler")); + assert.equal(2, ts.syllableCount("scheunemann")); + assert.equal(4, ts.syllableCount("schiavone")); + assert.equal(3, ts.syllableCount("schickler")); + assert.equal(3, ts.syllableCount("schickling")); + assert.equal(1, ts.syllableCount("schielke")); + assert.equal(3, ts.syllableCount("schildknecht")); + assert.equal(1, ts.syllableCount("schilke")); + assert.equal(1, ts.syllableCount("schimke")); + assert.equal(1, ts.syllableCount("schinke")); + assert.equal(3, ts.syllableCount("schisler")); + assert.equal(2, ts.syllableCount("schisms")); + assert.equal(3, ts.syllableCount("schloesser")); + assert.equal(2, ts.syllableCount("schmidl")); + assert.equal(3, ts.syllableCount("schmutzler")); + assert.equal(2, ts.syllableCount("schoene")); + assert.equal(3, ts.syllableCount("schoening")); + assert.equal(1, ts.syllableCount("scholtes")); + assert.equal(1, ts.syllableCount("scholze")); + assert.equal(2, ts.syllableCount("schoneman")); + assert.equal(1, ts.syllableCount("schoppe")); + assert.equal(3, ts.syllableCount("schouten")); + assert.equal(2, ts.syllableCount("schreder")); + assert.equal(1, ts.syllableCount("schreyer")); + assert.equal(2, ts.syllableCount("schroedl")); + assert.equal(3, ts.syllableCount("schubring")); + assert.equal(1, ts.syllableCount("schuelke")); + assert.equal(3, ts.syllableCount("schuerman")); + assert.equal(3, ts.syllableCount("schuermann")); + assert.equal(2, ts.syllableCount("schuessler")); + assert.equal(1, ts.syllableCount("schuette")); + assert.equal(1, ts.syllableCount("schuetze")); + assert.equal(1, ts.syllableCount("schulte")); + assert.equal(1, ts.syllableCount("schultes")); + assert.equal(1, ts.syllableCount("schultze")); + assert.equal(1, ts.syllableCount("schulze")); + assert.equal(2, ts.syllableCount("schuneman")); + assert.equal(2, ts.syllableCount("schussler")); + assert.equal(1, ts.syllableCount("schutte")); + assert.equal(2, ts.syllableCount("schuttler")); + assert.equal(1, ts.syllableCount("schwalbe")); + assert.equal(1, ts.syllableCount("schwanke")); + assert.equal(1, ts.syllableCount("schwantes")); + assert.equal(1, ts.syllableCount("schwarze")); + assert.equal(1, ts.syllableCount("schwebke")); + assert.equal(2, ts.syllableCount("schweder")); + assert.equal(1, ts.syllableCount("schweer")); + assert.equal(1, ts.syllableCount("schweers")); + assert.equal(3, ts.syllableCount("schwegler")); + assert.equal(2, ts.syllableCount("schwendeman")); + assert.equal(1, ts.syllableCount("schwenke")); + assert.equal(1, ts.syllableCount("schweppe")); + assert.equal(1, ts.syllableCount("schweppes")); + assert.equal(3, ts.syllableCount("schwoerer")); + assert.equal(2, ts.syllableCount("sciacca")); + assert.equal(3, ts.syllableCount("scialdone")); + assert.equal(2, ts.syllableCount("sciandra")); + assert.equal(2, ts.syllableCount("scianna")); + assert.equal(2, ts.syllableCount("sciara")); + assert.equal(3, ts.syllableCount("sciarrino")); + assert.equal(3, ts.syllableCount("sciclone")); + assert.equal(2, ts.syllableCount("science")); + assert.equal(3, ts.syllableCount("sciences")); + assert.equal(4, ts.syllableCount("scientific")); + assert.equal(6, ts.syllableCount("scientifically")); + assert.equal(4, ts.syllableCount("scientifics")); + assert.equal(3, ts.syllableCount("scientist")); + assert.equal(3, ts.syllableCount("scientists")); + assert.equal(5, ts.syllableCount("scientology")); + assert.equal(4, ts.syllableCount("scintilore")); + assert.equal(4, ts.syllableCount("scipione")); + assert.equal(2, ts.syllableCount("scohier")); + assert.equal(2, ts.syllableCount("scoreboard")); + assert.equal(2, ts.syllableCount("scorecard")); + assert.equal(3, ts.syllableCount("scorekeepers")); + assert.equal(2, ts.syllableCount("scour")); + assert.equal(2, ts.syllableCount("scoured")); + assert.equal(3, ts.syllableCount("scouring")); + assert.equal(2, ts.syllableCount("scours")); + assert.equal(2, ts.syllableCount("screeches")); + assert.equal(2, ts.syllableCount("scribblers")); + assert.equal(2, ts.syllableCount("scrimgeour")); + assert.equal(2, ts.syllableCount("scrivener")); + assert.equal(3, ts.syllableCount("sdn")); + assert.equal(2, ts.syllableCount("se")); + assert.equal(2, ts.syllableCount("seabed")); + assert.equal(1, ts.syllableCount("searle")); + assert.equal(3, ts.syllableCount("seattle")); + assert.equal(5, ts.syllableCount("sebastiana")); + assert.equal(4, ts.syllableCount("sebastiane")); + assert.equal(5, ts.syllableCount("sebastiani")); + assert.equal(3, ts.syllableCount("sechrest")); + assert.equal(3, ts.syllableCount("sechrist")); + assert.equal(3, ts.syllableCount("secrest")); + assert.equal(3, ts.syllableCount("secrist")); + assert.equal(4, ts.syllableCount("securites")); + assert.equal(3, ts.syllableCount("seditious")); + assert.equal(3, ts.syllableCount("sedore")); + assert.equal(1, ts.syllableCount("seer")); + assert.equal(1, ts.syllableCount("seers")); + assert.equal(3, ts.syllableCount("segraves")); + assert.equal(3, ts.syllableCount("segrest")); + assert.equal(1, ts.syllableCount("segue")); + assert.equal(2, ts.syllableCount("seidl")); + assert.equal(3, ts.syllableCount("seifried")); + assert.equal(3, ts.syllableCount("seigler")); + assert.equal(3, ts.syllableCount("Seiichi")); + assert.equal(2, ts.syllableCount("seine")); + assert.equal(4, ts.syllableCount("sekisui")); + assert.equal(1, ts.syllableCount("selbe")); + assert.equal(2, ts.syllableCount("seles")); + assert.equal(1, ts.syllableCount("selke")); + assert.equal(2, ts.syllableCount("sellier")); + assert.equal(3, ts.syllableCount("semele")); + assert.equal(5, ts.syllableCount("semireligious")); + assert.equal(2, ts.syllableCount("semmler")); + assert.equal(3, ts.syllableCount("semones")); + assert.equal(4, ts.syllableCount("senatore")); + assert.equal(2, ts.syllableCount("senior")); + assert.equal(4, ts.syllableCount("seniority")); + assert.equal(3, ts.syllableCount("seniornet")); + assert.equal(2, ts.syllableCount("seniors")); + assert.equal(1, ts.syllableCount("sense")); + assert.equal(2, ts.syllableCount("senseless")); + assert.equal(1, ts.syllableCount("senske")); + assert.equal(1, ts.syllableCount("seoul")); + assert.equal(2, ts.syllableCount("separate")); + assert.equal(3, ts.syllableCount("sequeira")); + assert.equal(3, ts.syllableCount("sequences")); + assert.equal(3, ts.syllableCount("sequoia")); + assert.equal(3, ts.syllableCount("sequoias")); + assert.equal(4, ts.syllableCount("serafine")); + assert.equal(4, ts.syllableCount("seraphine")); + assert.equal(4, ts.syllableCount("serenely")); + assert.equal(3, ts.syllableCount("sergius")); + assert.equal(1, ts.syllableCount("serpe")); + assert.equal(4, ts.syllableCount("serratore")); + assert.equal(3, ts.syllableCount("serviceman")); + assert.equal(4, ts.syllableCount("servicemaster")); + assert.equal(3, ts.syllableCount("servicemen")); + assert.equal(3, ts.syllableCount("sesame")); + assert.equal(2, ts.syllableCount("Sese")); + assert.equal(3, ts.syllableCount("sesler")); + assert.equal(2, ts.syllableCount("sessler")); + assert.equal(2, ts.syllableCount("settlers")); + assert.equal(2, ts.syllableCount("seve")); + assert.equal(4, ts.syllableCount("seventieth")); + assert.equal(2, ts.syllableCount("several")); + assert.equal(3, ts.syllableCount("severally")); + assert.equal(2, ts.syllableCount("sevier")); + assert.equal(3, ts.syllableCount("seyfried")); + assert.equal(2, ts.syllableCount("sh")); + assert.equal(2, ts.syllableCount("shakedown")); + assert.equal(2, ts.syllableCount("shakedowns")); + assert.equal(2, ts.syllableCount("shakeout")); + assert.equal(2, ts.syllableCount("shakespeare")); + assert.equal(2, ts.syllableCount("shampooed")); + assert.equal(3, ts.syllableCount("sharecroppers")); + assert.equal(3, ts.syllableCount("shareholder")); + assert.equal(3, ts.syllableCount("shareholders")); + assert.equal(3, ts.syllableCount("shareholding")); + assert.equal(3, ts.syllableCount("shareholdings")); + assert.equal(2, ts.syllableCount("shareware")); + assert.equal(1, ts.syllableCount("sharpe")); + assert.equal(1, ts.syllableCount("sheer")); + assert.equal(2, ts.syllableCount("sheffler")); + assert.equal(4, ts.syllableCount("shenandoah")); + assert.equal(2, ts.syllableCount("sheneman")); + assert.equal(3, ts.syllableCount("shidler")); + assert.equal(2, ts.syllableCount("shiffler")); + assert.equal(2, ts.syllableCount("shiina")); + assert.equal(4, ts.syllableCount("shiraishi")); + assert.equal(3, ts.syllableCount("shiremanstown")); + assert.equal(3, ts.syllableCount("shisler")); + assert.equal(2, ts.syllableCount("shissler")); + assert.equal(1, ts.syllableCount("shiu")); + assert.equal(3, ts.syllableCount("shoichi")); + assert.equal(4, ts.syllableCount("shoichiro")); + assert.equal(1, ts.syllableCount("shooed")); + assert.equal(1, ts.syllableCount("shoppe")); + assert.equal(1, ts.syllableCount("shoppes")); + assert.equal(2, ts.syllableCount("shor")); + assert.equal(2, ts.syllableCount("shorebird")); + assert.equal(2, ts.syllableCount("shoreham")); + assert.equal(2, ts.syllableCount("shoreward")); + assert.equal(3, ts.syllableCount("shoshone")); + assert.equal(1, ts.syllableCount("shouldnt")); + assert.equal(2, ts.syllableCount("shoveling")); + assert.equal(2, ts.syllableCount("shreffler")); + assert.equal(2, ts.syllableCount("shrikelike")); + assert.equal(2, ts.syllableCount("shryock")); + assert.equal(3, ts.syllableCount("shuddered")); + assert.equal(2, ts.syllableCount("shuey")); + assert.equal(2, ts.syllableCount("shui")); + assert.equal(2, ts.syllableCount("sichuan")); + assert.equal(3, ts.syllableCount("sicilia")); + assert.equal(2, ts.syllableCount("sicotte")); + assert.equal(2, ts.syllableCount("sidetracked")); + assert.equal(3, ts.syllableCount("sidler")); + assert.equal(2, ts.syllableCount("siegecraft")); + assert.equal(3, ts.syllableCount("sienko")); + assert.equal(3, ts.syllableCount("sierra")); + assert.equal(4, ts.syllableCount("sierracin")); + assert.equal(3, ts.syllableCount("sierras")); + assert.equal(1, ts.syllableCount("siers")); + assert.equal(3, ts.syllableCount("siewiorek")); + assert.equal(2, ts.syllableCount("sigl")); + assert.equal(3, ts.syllableCount("sigler")); + assert.equal(3, ts.syllableCount("signore")); + assert.equal(4, ts.syllableCount("simione")); + assert.equal(3, ts.syllableCount("simler")); + assert.equal(3, ts.syllableCount("simpler")); + assert.equal(5, ts.syllableCount("singaporean")); + assert.equal(5, ts.syllableCount("singaporeans")); + assert.equal(3, ts.syllableCount("singler")); + assert.equal(3, ts.syllableCount("singling")); + assert.equal(2, ts.syllableCount("sinuous")); + assert.equal(2, ts.syllableCount("siobhan")); + assert.equal(1, ts.syllableCount("sioux")); + assert.equal(4, ts.syllableCount("siracuse")); + assert.equal(2, ts.syllableCount("sire")); + assert.equal(3, ts.syllableCount("sirrine")); + assert.equal(2, ts.syllableCount("sisemore")); + assert.equal(3, ts.syllableCount("sisler")); + assert.equal(3, ts.syllableCount("sistare")); + assert.equal(3, ts.syllableCount("sitler")); + assert.equal(2, ts.syllableCount("sittler")); + assert.equal(1, ts.syllableCount("sitze")); + assert.equal(3, ts.syllableCount("sixtieth")); + assert.equal(2, ts.syllableCount("sizeler")); + assert.equal(2, ts.syllableCount("sizelove")); + assert.equal(2, ts.syllableCount("sizemore")); + assert.equal(2, ts.syllableCount("sizzler")); + assert.equal(2, ts.syllableCount("skateboard")); + assert.equal(3, ts.syllableCount("skateboarding")); + assert.equal(1, ts.syllableCount("skibbe")); + assert.equal(1, ts.syllableCount("skier")); + assert.equal(3, ts.syllableCount("skrzypek")); + assert.equal(3, ts.syllableCount("sledgehammer")); + assert.equal(2, ts.syllableCount("slouches")); + assert.equal(3, ts.syllableCount("smokejumper")); + assert.equal(3, ts.syllableCount("smokejumpers")); + assert.equal(2, ts.syllableCount("smokescreen")); + assert.equal(2, ts.syllableCount("smokestack")); + assert.equal(2, ts.syllableCount("smokestacks")); + assert.equal(5, ts.syllableCount("smtih")); + assert.equal(2, ts.syllableCount("snakebites")); + assert.equal(2, ts.syllableCount("snakelike")); + assert.equal(1, ts.syllableCount("sneer")); + assert.equal(1, ts.syllableCount("sneers")); + assert.equal(2, ts.syllableCount("soares")); + assert.equal(4, ts.syllableCount("sobieski")); + assert.equal(3, ts.syllableCount("sociable")); + assert.equal(4, ts.syllableCount("societa")); + assert.equal(4, ts.syllableCount("societal")); + assert.equal(4, ts.syllableCount("societe")); + assert.equal(4, ts.syllableCount("societies")); + assert.equal(4, ts.syllableCount("society")); + assert.equal(3, ts.syllableCount("sociopath")); + assert.equal(3, ts.syllableCount("socrates")); + assert.equal(2, ts.syllableCount("sofaer")); + assert.equal(3, ts.syllableCount("solares")); + assert.equal(2, ts.syllableCount("soldier")); + assert.equal(2, ts.syllableCount("soldiers")); + assert.equal(2, ts.syllableCount("soledad")); + assert.equal(2, ts.syllableCount("solesbee")); + assert.equal(4, ts.syllableCount("solimine")); + assert.equal(3, ts.syllableCount("soloist")); + assert.equal(3, ts.syllableCount("soloists")); + assert.equal(1, ts.syllableCount("soltes")); + assert.equal(3, ts.syllableCount("somebody")); + assert.equal(2, ts.syllableCount("someday")); + assert.equal(2, ts.syllableCount("somehow")); + assert.equal(2, ts.syllableCount("something")); + assert.equal(2, ts.syllableCount("somethings")); + assert.equal(2, ts.syllableCount("sometime")); + assert.equal(2, ts.syllableCount("sometimes")); + assert.equal(2, ts.syllableCount("somewhat")); + assert.equal(2, ts.syllableCount("somewhere")); + assert.equal(2, ts.syllableCount("sonia")); + assert.equal(2, ts.syllableCount("sooy")); + assert.equal(2, ts.syllableCount("sophomore")); + assert.equal(2, ts.syllableCount("sophomores")); + assert.equal(3, ts.syllableCount("sosuke")); + assert.equal(3, ts.syllableCount("soulliere")); + assert.equal(2, ts.syllableCount("sour")); + assert.equal(2, ts.syllableCount("sourcebook")); + assert.equal(2, ts.syllableCount("soured")); + assert.equal(3, ts.syllableCount("souring")); + assert.equal(3, ts.syllableCount("sourly")); + assert.equal(2, ts.syllableCount("sours")); + assert.equal(3, ts.syllableCount("Sousuke")); + assert.equal(2, ts.syllableCount("sovereign")); + assert.equal(2, ts.syllableCount("sovereigns")); + assert.equal(3, ts.syllableCount("sovereignty")); + assert.equal(6, ts.syllableCount("sovietologists")); + assert.equal(3, ts.syllableCount("soviets")); + assert.equal(1, ts.syllableCount("sowle")); + assert.equal(1, ts.syllableCount("sowles")); + assert.equal(2, ts.syllableCount("spaceballs")); + assert.equal(2, ts.syllableCount("spacebands")); + assert.equal(2, ts.syllableCount("spacecraft")); + assert.equal(2, ts.syllableCount("spacelink")); + assert.equal(2, ts.syllableCount("spacenet")); + assert.equal(2, ts.syllableCount("spacesuit")); + assert.equal(2, ts.syllableCount("spadework")); + assert.equal(4, ts.syllableCount("spagnuolo")); + assert.equal(3, ts.syllableCount("spangler")); + assert.equal(2, ts.syllableCount("spaniard")); + assert.equal(2, ts.syllableCount("spaniards")); + assert.equal(2, ts.syllableCount("spanier")); + assert.equal(2, ts.syllableCount("spaniol")); + assert.equal(1, ts.syllableCount("sparkes")); + assert.equal(2, ts.syllableCount("spasms")); + assert.equal(3, ts.syllableCount("speciale")); + assert.equal(3, ts.syllableCount("specialities")); + assert.equal(5, ts.syllableCount("speciality")); + assert.equal(4, ts.syllableCount("specifically")); + assert.equal(2, ts.syllableCount("speeches")); + assert.equal(1, ts.syllableCount("speer")); + assert.equal(3, ts.syllableCount("spengler")); + assert.equal(4, ts.syllableCount("speziale")); + assert.equal(2, ts.syllableCount("spieth")); + assert.equal(1, ts.syllableCount("spilde")); + assert.equal(3, ts.syllableCount("spinale")); + assert.equal(3, ts.syllableCount("spindler")); + assert.equal(5, ts.syllableCount("spiritualism")); + assert.equal(3, ts.syllableCount("spitale")); + assert.equal(2, ts.syllableCount("spittler")); + assert.equal(2, ts.syllableCount("spokeman")); + assert.equal(2, ts.syllableCount("spokesman")); + assert.equal(2, ts.syllableCount("spokesmen")); + assert.equal(3, ts.syllableCount("spokespeople")); + assert.equal(3, ts.syllableCount("spokesperson")); + assert.equal(3, ts.syllableCount("sponsler")); + assert.equal(5, ts.syllableCount("spontaneity")); + assert.equal(2, ts.syllableCount("spoonemore")); + assert.equal(4, ts.syllableCount("sporadically")); + assert.equal(2, ts.syllableCount("sporophyte")); + assert.equal(2, ts.syllableCount("sporophytes")); + assert.equal(3, ts.syllableCount("spracklen")); + assert.equal(1, ts.syllableCount("sprague")); + assert.equal(1, ts.syllableCount("spruiell")); + assert.equal(1, ts.syllableCount("squeak")); + assert.equal(1, ts.syllableCount("squeaked")); + assert.equal(2, ts.syllableCount("squeaker")); + assert.equal(2, ts.syllableCount("squeakers")); + assert.equal(2, ts.syllableCount("squeaking")); + assert.equal(1, ts.syllableCount("squeaks")); + assert.equal(2, ts.syllableCount("squeaky")); + assert.equal(1, ts.syllableCount("squeal")); + assert.equal(2, ts.syllableCount("squealing")); + assert.equal(1, ts.syllableCount("squeals")); + assert.equal(2, ts.syllableCount("squeamish")); + assert.equal(3, ts.syllableCount("squeamishness")); + assert.equal(2, ts.syllableCount("squeegee")); + assert.equal(1, ts.syllableCount("squeeze")); + assert.equal(1, ts.syllableCount("squeezed")); + assert.equal(2, ts.syllableCount("squeezing")); + assert.equal(1, ts.syllableCount("squiers")); + assert.equal(2, ts.syllableCount("squires")); + assert.equal(2, ts.syllableCount("sr")); + assert.equal(3, ts.syllableCount("stablest")); + assert.equal(2, ts.syllableCount("staebler")); + assert.equal(1, ts.syllableCount("staehle")); + assert.equal(2, ts.syllableCount("stagecoach")); + assert.equal(2, ts.syllableCount("stagecraft")); + assert.equal(2, ts.syllableCount("stagehands")); + assert.equal(1, ts.syllableCount("stahnke")); + assert.equal(2, ts.syllableCount("stai")); + assert.equal(3, ts.syllableCount("stakeholder")); + assert.equal(3, ts.syllableCount("stakeholders")); + assert.equal(2, ts.syllableCount("stakeout")); + assert.equal(2, ts.syllableCount("stakeouts")); + assert.equal(2, ts.syllableCount("stalemate")); + assert.equal(3, ts.syllableCount("stalemated")); + assert.equal(2, ts.syllableCount("stangl")); + assert.equal(3, ts.syllableCount("stangler")); + assert.equal(1, ts.syllableCount("stanke")); + assert.equal(4, ts.syllableCount("stanzione")); + assert.equal(3, ts.syllableCount("stapler")); + assert.equal(3, ts.syllableCount("staplers")); + assert.equal(3, ts.syllableCount("stapling")); + assert.equal(3, ts.syllableCount("starace")); + assert.equal(1, ts.syllableCount("starke")); + assert.equal(1, ts.syllableCount("starkes")); + assert.equal(2, ts.syllableCount("starpointe")); + assert.equal(2, ts.syllableCount("statecraft")); + assert.equal(2, ts.syllableCount("statehood")); + assert.equal(2, ts.syllableCount("statehouse")); + assert.equal(2, ts.syllableCount("stateroom")); + assert.equal(2, ts.syllableCount("statesman")); + assert.equal(3, ts.syllableCount("statesmanship")); + assert.equal(2, ts.syllableCount("statesmen")); + assert.equal(2, ts.syllableCount("stateswest")); + assert.equal(2, ts.syllableCount("statewide")); + assert.equal(2, ts.syllableCount("stechschulte")); + assert.equal(1, ts.syllableCount("steer")); + assert.equal(1, ts.syllableCount("steers")); + assert.equal(1, ts.syllableCount("steffe")); + assert.equal(1, ts.syllableCount("steffes")); + assert.equal(2, ts.syllableCount("steffler")); + assert.equal(2, ts.syllableCount("stefl")); + assert.equal(2, ts.syllableCount("stegeman")); + assert.equal(2, ts.syllableCount("stegemann")); + assert.equal(2, ts.syllableCount("stegemeier")); + assert.equal(2, ts.syllableCount("steidl")); + assert.equal(1, ts.syllableCount("steinke")); + assert.equal(2, ts.syllableCount("stemmler")); + assert.equal(3, ts.syllableCount("stepien")); + assert.equal(1, ts.syllableCount("steppe")); + assert.equal(1, ts.syllableCount("steppes")); + assert.equal(2, ts.syllableCount("stettler")); + assert.equal(2, ts.syllableCount("steuart")); + assert.equal(3, ts.syllableCount("stickler")); + assert.equal(3, ts.syllableCount("stiegemeier")); + assert.equal(2, ts.syllableCount("stiffler")); + assert.equal(2, ts.syllableCount("stineman")); + assert.equal(2, ts.syllableCount("stiteler")); + assert.equal(1, ts.syllableCount("stobbe")); + assert.equal(1, ts.syllableCount("stocke")); + assert.equal(1, ts.syllableCount("stoeltze")); + assert.equal(3, ts.syllableCount("stoever")); + assert.equal(2, ts.syllableCount("stoia")); + assert.equal(2, ts.syllableCount("stoic")); + assert.equal(4, ts.syllableCount("stoicism")); + assert.equal(2, ts.syllableCount("stoics")); + assert.equal(1, ts.syllableCount("stokke")); + assert.equal(1, ts.syllableCount("stolpe")); + assert.equal(1, ts.syllableCount("stolte")); + assert.equal(1, ts.syllableCount("stolze")); + assert.equal(2, ts.syllableCount("stoneback")); + assert.equal(2, ts.syllableCount("stoneberg")); + assert.equal(3, ts.syllableCount("stoneberger")); + assert.equal(3, ts.syllableCount("stoneburner")); + assert.equal(3, ts.syllableCount("stonecipher")); + assert.equal(3, ts.syllableCount("stonecutters")); + assert.equal(2, ts.syllableCount("stoneham")); + assert.equal(2, ts.syllableCount("stonehenge")); + assert.equal(2, ts.syllableCount("stonehill")); + assert.equal(3, ts.syllableCount("stonehocker")); + assert.equal(2, ts.syllableCount("stonehouse")); + assert.equal(2, ts.syllableCount("stoneking")); + assert.equal(2, ts.syllableCount("stoneman")); + assert.equal(2, ts.syllableCount("stoneridge")); + assert.equal(2, ts.syllableCount("stonerock")); + assert.equal(2, ts.syllableCount("stonestreet")); + assert.equal(2, ts.syllableCount("stonewall")); + assert.equal(2, ts.syllableCount("stonewalled")); + assert.equal(3, ts.syllableCount("stonewalling")); + assert.equal(2, ts.syllableCount("stoneware")); + assert.equal(3, ts.syllableCount("storagetek")); + assert.equal(2, ts.syllableCount("storefront")); + assert.equal(2, ts.syllableCount("storefronts")); + assert.equal(2, ts.syllableCount("storehouse")); + assert.equal(3, ts.syllableCount("storekeepers")); + assert.equal(2, ts.syllableCount("storeroom")); + assert.equal(1, ts.syllableCount("stormes")); + assert.equal(1, ts.syllableCount("stracke")); + assert.equal(2, ts.syllableCount("stragglers")); + assert.equal(1, ts.syllableCount("strande")); + assert.equal(3, ts.syllableCount("strangling")); + assert.equal(4, ts.syllableCount("strategically")); + assert.equal(1, ts.syllableCount("strehle")); + assert.equal(1, ts.syllableCount("striar")); + assert.equal(4, ts.syllableCount("stribling")); + assert.equal(3, ts.syllableCount("stricklen")); + assert.equal(2, ts.syllableCount("strieter")); + assert.equal(3, ts.syllableCount("strikebreakers")); + assert.equal(2, ts.syllableCount("strikeout")); + assert.equal(2, ts.syllableCount("strikeouts")); + assert.equal(1, ts.syllableCount("strubbe")); + assert.equal(4, ts.syllableCount("strzelecki")); + assert.equal(1, ts.syllableCount("stubbe")); + assert.equal(1, ts.syllableCount("stucke")); + assert.equal(1, ts.syllableCount("stumpe")); + assert.equal(2, ts.syllableCount("stutesman")); + assert.equal(4, ts.syllableCount("stylistically")); + assert.equal(1, ts.syllableCount("styron")); + assert.equal(2, ts.syllableCount("suarez")); + assert.equal(2, ts.syllableCount("suasion")); + assert.equal(1, ts.syllableCount("suave")); + assert.equal(2, ts.syllableCount("suazo")); + assert.equal(2, ts.syllableCount("submerged")); + assert.equal(3, ts.syllableCount("subnotebook")); + assert.equal(4, ts.syllableCount("subservience")); + assert.equal(4, ts.syllableCount("subservient")); + assert.equal(4, ts.syllableCount("substantiate")); + assert.equal(5, ts.syllableCount("substantiated")); + assert.equal(4, ts.syllableCount("substantiates")); + assert.equal(5, ts.syllableCount("substantiation")); + assert.equal(5, ts.syllableCount("subterranean")); + assert.equal(3, ts.syllableCount("subtler")); + assert.equal(3, ts.syllableCount("subtly")); + assert.equal(3, ts.syllableCount("sudafed")); + assert.equal(3, ts.syllableCount("sudler")); + assert.equal(2, ts.syllableCount("suey")); + assert.equal(2, ts.syllableCount("suez")); + assert.equal(1, ts.syllableCount("suhre")); + assert.equal(2, ts.syllableCount("sui")); + assert.equal(4, ts.syllableCount("suicidal")); + assert.equal(3, ts.syllableCount("suicide")); + assert.equal(3, ts.syllableCount("suicides")); + assert.equal(2, ts.syllableCount("sumptuous")); + assert.equal(1, ts.syllableCount("sunde")); + assert.equal(2, ts.syllableCount("sundial")); + assert.equal(3, ts.syllableCount("sunobe")); + assert.equal(3, ts.syllableCount("supercharged")); + assert.equal(4, ts.syllableCount("superfamily")); + assert.equal(6, ts.syllableCount("superfluidity")); + assert.equal(3, ts.syllableCount("superfluous")); + assert.equal(4, ts.syllableCount("superstitious")); + assert.equal(3, ts.syllableCount("superx")); + assert.equal(1, ts.syllableCount("suppes")); + assert.equal(4, ts.syllableCount("supremely")); + assert.equal(3, ts.syllableCount("supremes")); + assert.equal(3, ts.syllableCount("surace")); + assert.equal(4, ts.syllableCount("surreptitious")); + assert.equal(5, ts.syllableCount("surreptitiously")); + assert.equal(2, ts.syllableCount("suspense")); + assert.equal(3, ts.syllableCount("suspenseful")); + assert.equal(2, ts.syllableCount("sutcliffe")); + assert.equal(2, ts.syllableCount("suttmeier")); + assert.equal(3, ts.syllableCount("suu")); + assert.equal(1, ts.syllableCount("svelte")); + assert.equal(1, ts.syllableCount("swanke")); + assert.equal(1, ts.syllableCount("sweers")); + assert.equal(3, ts.syllableCount("swindler")); + assert.equal(2, ts.syllableCount("swinehart")); + assert.equal(3, ts.syllableCount("swingler")); + assert.equal(2, ts.syllableCount("swoveland")); + assert.equal(3, ts.syllableCount("synagogue")); + assert.equal(3, ts.syllableCount("synagogues")); + assert.equal(4, ts.syllableCount("synthetically")); + assert.equal(4, ts.syllableCount("sypniewski")); + assert.equal(5, ts.syllableCount("systematically")); + assert.equal(4, ts.syllableCount("systemically")); + assert.equal(1, ts.syllableCount("taaffe")); + assert.equal(3, ts.syllableCount("tabares")); + assert.equal(1, ts.syllableCount("tacke")); + assert.equal(3, ts.syllableCount("tadeusz")); + assert.equal(1, ts.syllableCount("taffe")); + assert.equal(4, ts.syllableCount("taflinger")); + assert.equal(4, ts.syllableCount("tagliaferri")); + assert.equal(1, ts.syllableCount("tague")); + assert.equal(3, ts.syllableCount("taira")); + assert.equal(3, ts.syllableCount("takao")); + assert.equal(2, ts.syllableCount("takecare")); + assert.equal(2, ts.syllableCount("takeout")); + assert.equal(4, ts.syllableCount("takeuchi")); + assert.equal(3, ts.syllableCount("tamales")); + assert.equal(3, ts.syllableCount("tanabe")); + assert.equal(2, ts.syllableCount("tangeman")); + assert.equal(2, ts.syllableCount("tangiers")); + assert.equal(2, ts.syllableCount("tania")); + assert.equal(1, ts.syllableCount("tanke")); + assert.equal(2, ts.syllableCount("tannehill")); + assert.equal(4, ts.syllableCount("taormina")); + assert.equal(1, ts.syllableCount("tappe")); + assert.equal(2, ts.syllableCount("tarleton")); + assert.equal(5, ts.syllableCount("tartaglione")); + assert.equal(1, ts.syllableCount("tarte")); + assert.equal(3, ts.syllableCount("tassone")); + assert.equal(4, ts.syllableCount("tatiana")); + assert.equal(2, ts.syllableCount("tattler")); + assert.equal(2, ts.syllableCount("tattooed")); + assert.equal(3, ts.syllableCount("tavares")); + assert.equal(5, ts.syllableCount("tavoulareas")); + assert.equal(2, ts.syllableCount("tb")); + assert.equal(4, ts.syllableCount("tbilisi")); + assert.equal(4, ts.syllableCount("tcas")); + assert.equal(2, ts.syllableCount("teaches")); + assert.equal(1, ts.syllableCount("teague")); + assert.equal(2, ts.syllableCount("teate")); + assert.equal(1, ts.syllableCount("tebbe")); + assert.equal(4, ts.syllableCount("tebuthiuron")); + assert.equal(2, ts.syllableCount("technique")); + assert.equal(2, ts.syllableCount("techniques")); + assert.equal(1, ts.syllableCount("teer")); + assert.equal(2, ts.syllableCount("tele")); + assert.equal(4, ts.syllableCount("teleconference")); + assert.equal(5, ts.syllableCount("teleconferencing")); + assert.equal(5, ts.syllableCount("telemecanique")); + assert.equal(4, ts.syllableCount("telephoniques")); + assert.equal(5, ts.syllableCount("telesciences")); + assert.equal(3, ts.syllableCount("temperament")); + assert.equal(4, ts.syllableCount("temperamental")); + assert.equal(5, ts.syllableCount("temperamentally")); + assert.equal(3, ts.syllableCount("temperaments")); + assert.equal(2, ts.syllableCount("temperate")); + assert.equal(3, ts.syllableCount("temperature")); + assert.equal(3, ts.syllableCount("temperatures")); + assert.equal(3, ts.syllableCount("templer")); + assert.equal(3, ts.syllableCount("tendentious")); + assert.equal(3, ts.syllableCount("tenn")); + assert.equal(4, ts.syllableCount("tennessean")); + assert.equal(1, ts.syllableCount("tense")); + assert.equal(2, ts.syllableCount("tensely")); + assert.equal(2, ts.syllableCount("termeer")); + assert.equal(3, ts.syllableCount("terrien")); + assert.equal(4, ts.syllableCount("terrifically")); + assert.equal(3, ts.syllableCount("tesler")); + assert.equal(3, ts.syllableCount("tesmer")); + assert.equal(4, ts.syllableCount("tessitore")); + assert.equal(2, ts.syllableCount("tessler")); + assert.equal(3, ts.syllableCount("tetsuo")); + assert.equal(2, ts.syllableCount("th")); + assert.equal(3, ts.syllableCount("thaddeus")); + assert.equal(2, ts.syllableCount("thalia")); + assert.equal(1, ts.syllableCount("tharpe")); + assert.equal(2, ts.syllableCount("thatll")); + assert.equal(2, ts.syllableCount("thea")); + assert.equal(3, ts.syllableCount("theater")); + assert.equal(3, ts.syllableCount("theaters")); + assert.equal(3, ts.syllableCount("theatre")); + assert.equal(3, ts.syllableCount("theatres")); + assert.equal(4, ts.syllableCount("theatrical")); + assert.equal(6, ts.syllableCount("theatricality")); + assert.equal(5, ts.syllableCount("theatrically")); + assert.equal(3, ts.syllableCount("theism")); + assert.equal(4, ts.syllableCount("thematically")); + assert.equal(2, ts.syllableCount("thenceforth")); + assert.equal(2, ts.syllableCount("thereby")); + assert.equal(2, ts.syllableCount("thered")); + assert.equal(2, ts.syllableCount("therefore")); + assert.equal(3, ts.syllableCount("theriault")); + assert.equal(5, ts.syllableCount("thermonuclear")); + assert.equal(3, ts.syllableCount("therriault")); + assert.equal(2, ts.syllableCount("thielemann")); + assert.equal(1, ts.syllableCount("thielke")); + assert.equal(3, ts.syllableCount("thirtieth")); + assert.equal(4, ts.syllableCount("thirtysomething")); + assert.equal(2, ts.syllableCount("thoene")); + assert.equal(4, ts.syllableCount("thomasine")); + assert.equal(1, ts.syllableCount("thorpe")); + assert.equal(4, ts.syllableCount("tiananmen")); + assert.equal(3, ts.syllableCount("tianjin")); + assert.equal(3, ts.syllableCount("tiano")); + assert.equal(3, ts.syllableCount("tiara")); + assert.equal(3, ts.syllableCount("ticklish")); + assert.equal(3, ts.syllableCount("tidewater")); + assert.equal(2, ts.syllableCount("tiedeman")); + assert.equal(2, ts.syllableCount("tiedemann")); + assert.equal(1, ts.syllableCount("tier")); + assert.equal(1, ts.syllableCount("tiers")); + assert.equal(1, ts.syllableCount("tietje")); + assert.equal(2, ts.syllableCount("tietmeyer")); + assert.equal(1, ts.syllableCount("tietze")); + assert.equal(1, ts.syllableCount("tigue")); + assert.equal(3, ts.syllableCount("tijuana")); + assert.equal(2, ts.syllableCount("timeframe")); + assert.equal(3, ts.syllableCount("timeliness")); + assert.equal(2, ts.syllableCount("timeplex")); + assert.equal(2, ts.syllableCount("timeshare")); + assert.equal(3, ts.syllableCount("timetable")); + assert.equal(3, ts.syllableCount("timetables")); + assert.equal(5, ts.syllableCount("timisoara")); + assert.equal(4, ts.syllableCount("timothea")); + assert.equal(1, ts.syllableCount("timpe")); + assert.equal(3, ts.syllableCount("timpone")); + assert.equal(3, ts.syllableCount("tingler")); + assert.equal(3, ts.syllableCount("tingling")); + assert.equal(3, ts.syllableCount("tinkler")); + assert.equal(3, ts.syllableCount("tinkling")); + assert.equal(3, ts.syllableCount("tipler")); + assert.equal(2, ts.syllableCount("tire")); + assert.equal(2, ts.syllableCount("tired")); + assert.equal(3, ts.syllableCount("tireless")); + assert.equal(3, ts.syllableCount("tiremaker")); + assert.equal(2, ts.syllableCount("tires")); + assert.equal(3, ts.syllableCount("tischler")); + assert.equal(3, ts.syllableCount("titania")); + assert.equal(2, ts.syllableCount("tocqueville")); + assert.equal(2, ts.syllableCount("toddler")); + assert.equal(2, ts.syllableCount("toddlers")); + assert.equal(2, ts.syllableCount("toews")); + assert.equal(2, ts.syllableCount("toffler")); + assert.equal(1, ts.syllableCount("tofte")); + assert.equal(3, ts.syllableCount("tokuo")); + assert.equal(3, ts.syllableCount("tokyo")); + assert.equal(4, ts.syllableCount("tomaino")); + assert.equal(4, ts.syllableCount("tomasine")); + assert.equal(1, ts.syllableCount("tongue")); + assert.equal(1, ts.syllableCount("tongued")); + assert.equal(1, ts.syllableCount("tongues")); + assert.equal(2, ts.syllableCount("toniest")); + assert.equal(2, ts.syllableCount("tonnesen")); + assert.equal(1, ts.syllableCount("torme")); + assert.equal(4, ts.syllableCount("tornabene")); + assert.equal(4, ts.syllableCount("tornatore")); + assert.equal(1, ts.syllableCount("torque")); + assert.equal(1, ts.syllableCount("torre")); + assert.equal(2, ts.syllableCount("torturous")); + assert.equal(1, ts.syllableCount("totzke")); + assert.equal(3, ts.syllableCount("touareg")); + assert.equal(2, ts.syllableCount("touches")); + assert.equal(2, ts.syllableCount("tousled")); + assert.equal(1, ts.syllableCount("towle")); + assert.equal(1, ts.syllableCount("towne")); + assert.equal(1, ts.syllableCount("townes")); + assert.equal(3, ts.syllableCount("trachea")); + assert.equal(2, ts.syllableCount("trademark")); + assert.equal(2, ts.syllableCount("trademarked")); + assert.equal(2, ts.syllableCount("trademarks")); + assert.equal(2, ts.syllableCount("tradesmen")); + assert.equal(4, ts.syllableCount("traditionalists")); + assert.equal(1, ts.syllableCount("traer")); + assert.equal(3, ts.syllableCount("tragically")); + assert.equal(1, ts.syllableCount("traipse")); + assert.equal(3, ts.syllableCount("tramiel")); + assert.equal(1, ts.syllableCount("trampe")); + assert.equal(2, ts.syllableCount("tranches")); + assert.equal(3, ts.syllableCount("transience")); + assert.equal(3, ts.syllableCount("transients")); + assert.equal(5, ts.syllableCount("transoceanic")); + assert.equal(3, ts.syllableCount("transpired")); + assert.equal(3, ts.syllableCount("transpires")); + assert.equal(1, ts.syllableCount("trappe")); + assert.equal(3, ts.syllableCount("travelogue")); + assert.equal(3, ts.syllableCount("trbovich")); + assert.equal(3, ts.syllableCount("treichler")); + assert.equal(2, ts.syllableCount("treml")); + assert.equal(2, ts.syllableCount("trenches")); + assert.equal(2, ts.syllableCount("trendier")); + assert.equal(2, ts.syllableCount("trendiest")); + assert.equal(2, ts.syllableCount("tressler")); + assert.equal(2, ts.syllableCount("tribesmen")); + assert.equal(4, ts.syllableCount("triennial")); + assert.equal(1, ts.syllableCount("trieu")); + assert.equal(2, ts.syllableCount("trimedyne")); + assert.equal(1, ts.syllableCount("trimpe")); + assert.equal(2, ts.syllableCount("triomphe")); + assert.equal(3, ts.syllableCount("tripling")); + assert.equal(1, ts.syllableCount("trippe")); + assert.equal(3, ts.syllableCount("trisler")); + assert.equal(2, ts.syllableCount("troia")); + assert.equal(3, ts.syllableCount("troiani")); + assert.equal(3, ts.syllableCount("tropea")); + assert.equal(3, ts.syllableCount("trousdale")); + assert.equal(2, ts.syllableCount("truell")); + assert.equal(2, ts.syllableCount("truest")); + assert.equal(2, ts.syllableCount("truex")); + assert.equal(3, ts.syllableCount("truism")); + assert.equal(3, ts.syllableCount("trulove")); + assert.equal(3, ts.syllableCount("trusler")); + assert.equal(2, ts.syllableCount("tryin")); + assert.equal(2, ts.syllableCount("tryon")); + assert.equal(2, ts.syllableCount("tryout")); + assert.equal(2, ts.syllableCount("tryouts")); + assert.equal(3, ts.syllableCount("trzaska")); + assert.equal(3, ts.syllableCount("trzcinski")); + assert.equal(4, ts.syllableCount("trzeciak")); + assert.equal(2, ts.syllableCount("ts")); + assert.equal(2, ts.syllableCount("tsui")); + assert.equal(1, ts.syllableCount("tufte")); + assert.equal(3, ts.syllableCount("tuinstra")); + assert.equal(3, ts.syllableCount("tuition")); + assert.equal(3, ts.syllableCount("tuitions")); + assert.equal(2, ts.syllableCount("tumbler")); + assert.equal(2, ts.syllableCount("tumblers")); + assert.equal(1, ts.syllableCount("tunde")); + assert.equal(2, ts.syllableCount("tunkelang")); + assert.equal(2, ts.syllableCount("turbeville")); + assert.equal(3, ts.syllableCount("turbocharged")); + assert.equal(2, ts.syllableCount("turcotte")); + assert.equal(2, ts.syllableCount("turquoise")); + assert.equal(4, ts.syllableCount("turrentine")); + assert.equal(2, ts.syllableCount("tvsat")); + assert.equal(3, ts.syllableCount("twentieth")); + assert.equal(3, ts.syllableCount("twinkling")); + assert.equal(2, ts.syllableCount("tyo")); + assert.equal(2, ts.syllableCount("typecast")); + assert.equal(3, ts.syllableCount("typecasting")); + assert.equal(3, ts.syllableCount("typefaces")); + assert.equal(2, ts.syllableCount("typeset")); + assert.equal(3, ts.syllableCount("typesetting")); + assert.equal(3, ts.syllableCount("typewriter")); + assert.equal(3, ts.syllableCount("typewriters")); + assert.equal(3, ts.syllableCount("typewriting")); + assert.equal(3, ts.syllableCount("typewritten")); + assert.equal(3, ts.syllableCount("typically")); + assert.equal(3, ts.syllableCount("uarco")); + assert.equal(2, ts.syllableCount("uart")); + assert.equal(4, ts.syllableCount("ubiquity")); + assert.equal(4, ts.syllableCount("uehara")); + assert.equal(3, ts.syllableCount("ueki")); + assert.equal(4, ts.syllableCount("uemura")); + assert.equal(1, ts.syllableCount("uhde")); + assert.equal(4, ts.syllableCount("ukulele")); + assert.equal(2, ts.syllableCount("ulfred")); + assert.equal(3, ts.syllableCount("umpire")); + assert.equal(3, ts.syllableCount("umpires")); + assert.equal(5, ts.syllableCount("unashamedly")); + assert.equal(7, ts.syllableCount("uncharacteristically")); + assert.equal(4, ts.syllableCount("uncomfortably")); + assert.equal(6, ts.syllableCount("uncooperative")); + assert.equal(6, ts.syllableCount("uncoordinated")); + assert.equal(2, ts.syllableCount("unctuous")); + assert.equal(3, ts.syllableCount("underserved")); + assert.equal(3, ts.syllableCount("undeserved")); + assert.equal(7, ts.syllableCount("undifferentiated")); + assert.equal(2, ts.syllableCount("unearthed")); + assert.equal(4, ts.syllableCount("unexpired")); + assert.equal(4, ts.syllableCount("unfamiliar")); + assert.equal(6, ts.syllableCount("unfamiliarities")); + assert.equal(6, ts.syllableCount("unfamiliarity")); + assert.equal(6, ts.syllableCount("uninitiated")); + assert.equal(4, ts.syllableCount("uninspired")); + assert.equal(4, ts.syllableCount("uninterested")); + assert.equal(4, ts.syllableCount("uninteresting")); + assert.equal(2, ts.syllableCount("unique")); + assert.equal(3, ts.syllableCount("uniquely")); + assert.equal(3, ts.syllableCount("uniqueness")); + assert.equal(2, ts.syllableCount("unmatched")); + assert.equal(2, ts.syllableCount("unnerved")); + assert.equal(2, ts.syllableCount("unplugged")); + assert.equal(4, ts.syllableCount("unpretentious")); + assert.equal(4, ts.syllableCount("unreasonable")); + assert.equal(3, ts.syllableCount("unreasoning")); + assert.equal(4, ts.syllableCount("unreimbursed")); + assert.equal(5, ts.syllableCount("unscientific")); + assert.equal(6, ts.syllableCount("unsubstantiated")); + assert.equal(3, ts.syllableCount("untermeyer")); + assert.equal(4, ts.syllableCount("updegrove")); + assert.equal(4, ts.syllableCount("uplinger")); + assert.equal(3, ts.syllableCount("urea")); + assert.equal(3, ts.syllableCount("uribe")); + assert.equal(2, ts.syllableCount("urquhart")); + assert.equal(3, ts.syllableCount("urrea")); + assert.equal(3, ts.syllableCount("usa")); + assert.equal(3, ts.syllableCount("usair")); + assert.equal(6, ts.syllableCount("usameribancs")); + assert.equal(4, ts.syllableCount("usbancorp")); + assert.equal(3, ts.syllableCount("usefulness")); + assert.equal(2, ts.syllableCount("usenet")); + assert.equal(3, ts.syllableCount("ustrust")); + assert.equal(2, ts.syllableCount("uy")); + assert.equal(1, ts.syllableCount("vague")); + assert.equal(2, ts.syllableCount("vaguely")); + assert.equal(2, ts.syllableCount("vagueness")); + assert.equal(2, ts.syllableCount("vaguer")); + assert.equal(3, ts.syllableCount("valade")); + assert.equal(3, ts.syllableCount("valent")); + assert.equal(2, ts.syllableCount("valiant")); + assert.equal(3, ts.syllableCount("valiantly")); + assert.equal(3, ts.syllableCount("valiente")); + assert.equal(3, ts.syllableCount("valiquette")); + assert.equal(4, ts.syllableCount("valladares")); + assert.equal(3, ts.syllableCount("valliere")); + assert.equal(3, ts.syllableCount("vallone")); + assert.equal(3, ts.syllableCount("valonia")); + assert.equal(3, ts.syllableCount("valores")); + assert.equal(3, ts.syllableCount("valuable")); + assert.equal(3, ts.syllableCount("valuables")); + assert.equal(4, ts.syllableCount("vanacore")); + assert.equal(1, ts.syllableCount("vande")); + assert.equal(4, ts.syllableCount("vanderleest")); + assert.equal(3, ts.syllableCount("vanderlinde")); + assert.equal(3, ts.syllableCount("vandermeer")); + assert.equal(4, ts.syllableCount("vandersluis")); + assert.equal(3, ts.syllableCount("vandervelde")); + assert.equal(3, ts.syllableCount("vandevelde")); + assert.equal(3, ts.syllableCount("vandevoorde")); + assert.equal(3, ts.syllableCount("vandezande")); + assert.equal(3, ts.syllableCount("vanevery")); + assert.equal(2, ts.syllableCount("vanhecke")); + assert.equal(4, ts.syllableCount("vanhouten")); + assert.equal(2, ts.syllableCount("vanleer")); + assert.equal(3, ts.syllableCount("vanleeuwen")); + assert.equal(3, ts.syllableCount("vanliew")); + assert.equal(3, ts.syllableCount("vanscyoc")); + assert.equal(3, ts.syllableCount("vantine")); + assert.equal(2, ts.syllableCount("vardeman")); + assert.equal(3, ts.syllableCount("varietal")); + assert.equal(4, ts.syllableCount("varnadore")); + assert.equal(3, ts.syllableCount("varrone")); + assert.equal(3, ts.syllableCount("vassilios")); + assert.equal(3, ts.syllableCount("vastine")); + assert.equal(3, ts.syllableCount("vaudevillian")); + assert.equal(1, ts.syllableCount("vaughan")); + assert.equal(4, ts.syllableCount("vecchione")); + assert.equal(1, ts.syllableCount("veer")); + assert.equal(1, ts.syllableCount("veers")); + assert.equal(3, ts.syllableCount("vegetable")); + assert.equal(3, ts.syllableCount("vegetables")); + assert.equal(1, ts.syllableCount("velte")); + assert.equal(2, ts.syllableCount("venneman")); + assert.equal(1, ts.syllableCount("venzke")); + assert.equal(3, ts.syllableCount("verdone")); + assert.equal(3, ts.syllableCount("verduin")); + assert.equal(3, ts.syllableCount("verine")); + assert.equal(2, ts.syllableCount("vermeer")); + assert.equal(3, ts.syllableCount("veronique")); + assert.equal(3, ts.syllableCount("versluis")); + assert.equal(3, ts.syllableCount("vertically")); + assert.equal(5, ts.syllableCount("veterinarian")); + assert.equal(5, ts.syllableCount("veterinarians")); + assert.equal(4, ts.syllableCount("veterinary")); + assert.equal(3, ts.syllableCount("vexatious")); + assert.equal(2, ts.syllableCount("viau")); + assert.equal(2, ts.syllableCount("viceroy")); + assert.equal(4, ts.syllableCount("victorine")); + assert.equal(3, ts.syllableCount("vidales")); + assert.equal(3, ts.syllableCount("vidalia")); + assert.equal(3, ts.syllableCount("viejo")); + assert.equal(3, ts.syllableCount("vienna")); + assert.equal(3, ts.syllableCount("viennese")); + assert.equal(1, ts.syllableCount("viers")); + assert.equal(3, ts.syllableCount("vietcong")); + assert.equal(2, ts.syllableCount("vieth")); + assert.equal(3, ts.syllableCount("vietnam")); + assert.equal(4, ts.syllableCount("vietnamese")); + assert.equal(3, ts.syllableCount("vietti")); + assert.equal(3, ts.syllableCount("vieyra")); + assert.equal(2, ts.syllableCount("vigeland")); + assert.equal(4, ts.syllableCount("viglione")); + assert.equal(1, ts.syllableCount("vigue")); + assert.equal(4, ts.syllableCount("villafane")); + assert.equal(5, ts.syllableCount("villasenor")); + assert.equal(2, ts.syllableCount("villiers")); + assert.equal(2, ts.syllableCount("vineland")); + assert.equal(1, ts.syllableCount("vinje")); + assert.equal(4, ts.syllableCount("violations")); + assert.equal(3, ts.syllableCount("VIP")); + assert.equal(3, ts.syllableCount("virginia")); + assert.equal(3, ts.syllableCount("virginian")); + assert.equal(3, ts.syllableCount("virginians")); + assert.equal(3, ts.syllableCount("virkler")); + assert.equal(5, ts.syllableCount("virtuosity")); + assert.equal(4, ts.syllableCount("virtuoso")); + assert.equal(5, ts.syllableCount("visualization")); + assert.equal(3, ts.syllableCount("visualize")); + assert.equal(4, ts.syllableCount("visualizing")); + assert.equal(3, ts.syllableCount("visually")); + assert.equal(2, ts.syllableCount("visuals")); + assert.equal(2, ts.syllableCount("visx")); + assert.equal(3, ts.syllableCount("vitale")); + assert.equal(3, ts.syllableCount("vivien")); + assert.equal(4, ts.syllableCount("vizcaino")); + assert.equal(2, ts.syllableCount("vlcek")); + assert.equal(6, ts.syllableCount("vnesheconombank")); + assert.equal(2, ts.syllableCount("voce")); + assert.equal(1, ts.syllableCount("vocke")); + assert.equal(2, ts.syllableCount("vogl")); + assert.equal(1, ts.syllableCount("vogue")); + assert.equal(2, ts.syllableCount("voicemail")); + assert.equal(2, ts.syllableCount("voiceworks")); + assert.equal(4, ts.syllableCount("volcanically")); + assert.equal(4, ts.syllableCount("volentine")); + assert.equal(1, ts.syllableCount("volpe")); + assert.equal(3, ts.syllableCount("volunteer")); + assert.equal(3, ts.syllableCount("volunteers")); + assert.equal(2, ts.syllableCount("vorhauer")); + assert.equal(3, ts.syllableCount("vosler")); + assert.equal(2, ts.syllableCount("vrba")); + assert.equal(4, ts.syllableCount("vrdolyak")); + assert.equal(2, ts.syllableCount("vs")); + assert.equal(2, ts.syllableCount("vsel")); + assert.equal(3, ts.syllableCount("vuolo")); + assert.equal(2, ts.syllableCount("vuong")); + assert.equal(3, ts.syllableCount("w")); + assert.equal(2, ts.syllableCount("waage")); + assert.equal(2, ts.syllableCount("wageman")); + assert.equal(1, ts.syllableCount("wahle")); + assert.equal(2, ts.syllableCount("waidelich")); + assert.equal(2, ts.syllableCount("wakefield")); + assert.equal(2, ts.syllableCount("wakeham")); + assert.equal(2, ts.syllableCount("wakeland")); + assert.equal(2, ts.syllableCount("wakeley")); + assert.equal(2, ts.syllableCount("wakeman")); + assert.equal(1, ts.syllableCount("walde")); + assert.equal(2, ts.syllableCount("waleson")); + assert.equal(2, ts.syllableCount("walfred")); + assert.equal(1, ts.syllableCount("walke")); + assert.equal(1, ts.syllableCount("wanke")); + assert.equal(3, ts.syllableCount("wannabe")); + assert.equal(3, ts.syllableCount("wannabes")); + assert.equal(3, ts.syllableCount("warbling")); + assert.equal(1, ts.syllableCount("warde")); + assert.equal(2, ts.syllableCount("warehoused")); + assert.equal(2, ts.syllableCount("warnecke")); + assert.equal(2, ts.syllableCount("wass")); + assert.equal(3, ts.syllableCount("wastebasket")); + assert.equal(3, ts.syllableCount("wastebaskets")); + assert.equal(3, ts.syllableCount("wastefulness")); + assert.equal(2, ts.syllableCount("wasteland")); + assert.equal(3, ts.syllableCount("wastepaper")); + assert.equal(3, ts.syllableCount("wastewater")); + assert.equal(4, ts.syllableCount("watanabe")); + assert.equal(3, ts.syllableCount("waterlogged")); + assert.equal(3, ts.syllableCount("watershed")); + assert.equal(3, ts.syllableCount("watling")); + assert.equal(4, ts.syllableCount("watlington")); + assert.equal(1, ts.syllableCount("watne")); + assert.equal(2, ts.syllableCount("wavelength")); + assert.equal(2, ts.syllableCount("wavelengths")); + assert.equal(2, ts.syllableCount("wavetek")); + assert.equal(3, ts.syllableCount("waynesboro")); + assert.equal(2, ts.syllableCount("wedgestone")); + assert.equal(2, ts.syllableCount("wedgewood")); + assert.equal(2, ts.syllableCount("wedgeworth")); + assert.equal(2, ts.syllableCount("wednesday")); + assert.equal(2, ts.syllableCount("wednesdays")); + assert.equal(3, ts.syllableCount("wegrzyn")); + assert.equal(1, ts.syllableCount("wehde")); + assert.equal(2, ts.syllableCount("weiand")); + assert.equal(2, ts.syllableCount("weide")); + assert.equal(2, ts.syllableCount("weideman")); + assert.equal(2, ts.syllableCount("weidemann")); + assert.equal(3, ts.syllableCount("weidler")); + assert.equal(2, ts.syllableCount("weigl")); + assert.equal(2, ts.syllableCount("weinger")); + assert.equal(2, ts.syllableCount("weist")); + assert.equal(1, ts.syllableCount("welke")); + assert.equal(2, ts.syllableCount("wellesley")); + assert.equal(1, ts.syllableCount("welte")); + assert.equal(1, ts.syllableCount("wempe")); + assert.equal(2, ts.syllableCount("wenches")); + assert.equal(1, ts.syllableCount("wende")); + assert.equal(3, ts.syllableCount("wengler")); + assert.equal(1, ts.syllableCount("wenke")); + assert.equal(1, ts.syllableCount("wente")); + assert.equal(2, ts.syllableCount("wenzl")); + assert.equal(2, ts.syllableCount("weppler")); + assert.equal(2, ts.syllableCount("werdesheim")); + assert.equal(4, ts.syllableCount("wereldhave")); + assert.equal(1, ts.syllableCount("werent")); + assert.equal(2, ts.syllableCount("werewolf")); + assert.equal(1, ts.syllableCount("werke")); + assert.equal(3, ts.syllableCount("wermiel")); + assert.equal(2, ts.syllableCount("wernecke")); + assert.equal(2, ts.syllableCount("wernicke")); + assert.equal(1, ts.syllableCount("werre")); + assert.equal(2, ts.syllableCount("weseman")); + assert.equal(2, ts.syllableCount("wesemann")); + assert.equal(3, ts.syllableCount("wesler")); + assert.equal(2, ts.syllableCount("wess")); + assert.equal(2, ts.syllableCount("wessler")); + assert.equal(3, ts.syllableCount("westmoreland")); + assert.equal(3, ts.syllableCount("weyerhaeuser")); + assert.equal(4, ts.syllableCount("whatsoever")); + assert.equal(2, ts.syllableCount("whereby")); + assert.equal(2, ts.syllableCount("wherehouse")); + assert.equal(3, ts.syllableCount("wherewithal")); + assert.equal(2, ts.syllableCount("whitebread")); + assert.equal(3, ts.syllableCount("whitecotton")); + assert.equal(2, ts.syllableCount("whitefield")); + assert.equal(2, ts.syllableCount("whitefish")); + assert.equal(2, ts.syllableCount("whiteford")); + assert.equal(2, ts.syllableCount("whitehair")); + assert.equal(2, ts.syllableCount("whitehall")); + assert.equal(2, ts.syllableCount("whitehead")); + assert.equal(2, ts.syllableCount("whitehill")); + assert.equal(2, ts.syllableCount("whitehorn")); + assert.equal(2, ts.syllableCount("whitehorse")); + assert.equal(2, ts.syllableCount("whitehouse")); + assert.equal(2, ts.syllableCount("whitehurst")); + assert.equal(2, ts.syllableCount("whitelaw")); + assert.equal(2, ts.syllableCount("whiteley")); + assert.equal(2, ts.syllableCount("whitelock")); + assert.equal(2, ts.syllableCount("whiteman")); + assert.equal(2, ts.syllableCount("whitemont")); + assert.equal(2, ts.syllableCount("whitenack")); + assert.equal(2, ts.syllableCount("whiteneir")); + assert.equal(2, ts.syllableCount("whitener")); + assert.equal(2, ts.syllableCount("whitenight")); + assert.equal(3, ts.syllableCount("whitescarver")); + assert.equal(2, ts.syllableCount("whitesel")); + assert.equal(2, ts.syllableCount("whitesell")); + assert.equal(2, ts.syllableCount("whitetail")); + assert.equal(2, ts.syllableCount("whitewash")); + assert.equal(2, ts.syllableCount("whitewashed")); + assert.equal(3, ts.syllableCount("whitewater")); + assert.equal(2, ts.syllableCount("whittemore")); + assert.equal(3, ts.syllableCount("whoever")); + assert.equal(3, ts.syllableCount("wholehearted")); + assert.equal(4, ts.syllableCount("wholeheartedly")); + assert.equal(2, ts.syllableCount("wholesale")); + assert.equal(3, ts.syllableCount("wholesaler")); + assert.equal(3, ts.syllableCount("wholesalers")); + assert.equal(2, ts.syllableCount("wholesales")); + assert.equal(3, ts.syllableCount("wholesaling")); + assert.equal(3, ts.syllableCount("wholesomeness")); + assert.equal(4, ts.syllableCount("whosoever")); + assert.equal(1, ts.syllableCount("wicke")); + assert.equal(1, ts.syllableCount("wickes")); + assert.equal(2, ts.syllableCount("wickliffe")); + assert.equal(3, ts.syllableCount("widebody")); + assert.equal(2, ts.syllableCount("wideman")); + assert.equal(2, ts.syllableCount("widespread")); + assert.equal(2, ts.syllableCount("wiedeman")); + assert.equal(2, ts.syllableCount("wiedemann")); + assert.equal(2, ts.syllableCount("wienecke")); + assert.equal(1, ts.syllableCount("wienke")); + assert.equal(1, ts.syllableCount("wier")); + assert.equal(1, ts.syllableCount("wiers")); + assert.equal(2, ts.syllableCount("wiesemann")); + assert.equal(3, ts.syllableCount("wiggly")); + assert.equal(3, ts.syllableCount("wiitala")); + assert.equal(1, ts.syllableCount("wilde")); + assert.equal(2, ts.syllableCount("wildeman")); + assert.equal(1, ts.syllableCount("wildes")); + assert.equal(3, ts.syllableCount("wildfire")); + assert.equal(3, ts.syllableCount("wildfires")); + assert.equal(2, ts.syllableCount("wildflowers")); + assert.equal(2, ts.syllableCount("wileman")); + assert.equal(2, ts.syllableCount("wilfred")); + assert.equal(1, ts.syllableCount("wilke")); + assert.equal(1, ts.syllableCount("wilkes")); + assert.equal(3, ts.syllableCount("wilkesboro")); + assert.equal(2, ts.syllableCount("william")); + assert.equal(2, ts.syllableCount("williams")); + assert.equal(3, ts.syllableCount("williamsburg")); + assert.equal(3, ts.syllableCount("williamsburgh")); + assert.equal(3, ts.syllableCount("williamsen")); + assert.equal(3, ts.syllableCount("williamson")); + assert.equal(3, ts.syllableCount("williamsport")); + assert.equal(3, ts.syllableCount("williamstown")); + assert.equal(2, ts.syllableCount("williard")); + assert.equal(1, ts.syllableCount("wilmes")); + assert.equal(1, ts.syllableCount("wiltse")); + assert.equal(1, ts.syllableCount("windes")); + assert.equal(2, ts.syllableCount("wineberg")); + assert.equal(3, ts.syllableCount("winegarden")); + assert.equal(2, ts.syllableCount("wineheim")); + assert.equal(2, ts.syllableCount("wineman")); + assert.equal(3, ts.syllableCount("winemiller")); + assert.equal(2, ts.syllableCount("winfred")); + assert.equal(3, ts.syllableCount("wingler")); + assert.equal(3, ts.syllableCount("winifred")); + assert.equal(2, ts.syllableCount("wipeout")); + assert.equal(2, ts.syllableCount("wire")); + assert.equal(2, ts.syllableCount("wired")); + assert.equal(2, ts.syllableCount("wireline")); + assert.equal(2, ts.syllableCount("wireman")); + assert.equal(2, ts.syllableCount("wires")); + assert.equal(2, ts.syllableCount("wiretaps")); + assert.equal(3, ts.syllableCount("wisecarver")); + assert.equal(2, ts.syllableCount("wisecrack")); + assert.equal(3, ts.syllableCount("wisecracking")); + assert.equal(2, ts.syllableCount("wisecracks")); + assert.equal(2, ts.syllableCount("wisecup")); + assert.equal(2, ts.syllableCount("wiseguy")); + assert.equal(2, ts.syllableCount("wisehart")); + assert.equal(2, ts.syllableCount("wiseman")); + assert.equal(3, ts.syllableCount("wisler")); + assert.equal(4, ts.syllableCount("wisniewski")); + assert.equal(2, ts.syllableCount("wissler")); + assert.equal(1, ts.syllableCount("witte")); + assert.equal(2, ts.syllableCount("witteman")); + assert.equal(2, ts.syllableCount("wittler")); + assert.equal(1, ts.syllableCount("witzke")); + assert.equal(4, ts.syllableCount("wlodarczyk")); + assert.equal(4, ts.syllableCount("wlodarski")); + assert.equal(2, ts.syllableCount("wm")); + assert.equal(1, ts.syllableCount("wobbe")); + assert.equal(3, ts.syllableCount("wobbly")); + assert.equal(1, ts.syllableCount("wolfe")); + assert.equal(1, ts.syllableCount("wolke")); + assert.equal(1, ts.syllableCount("wolske")); + assert.equal(3, ts.syllableCount("wolstenholme")); + assert.equal(1, ts.syllableCount("wooed")); + assert.equal(2, ts.syllableCount("worcester")); + assert.equal(3, ts.syllableCount("wotring")); + assert.equal(1, ts.syllableCount("wouldnt")); + assert.equal(1, ts.syllableCount("woulfe")); + assert.equal(3, ts.syllableCount("wrangler")); + assert.equal(3, ts.syllableCount("wranglers")); + assert.equal(3, ts.syllableCount("wrangling")); + assert.equal(2, ts.syllableCount("wrenches")); + assert.equal(3, ts.syllableCount("wrestler")); + assert.equal(3, ts.syllableCount("wrinkling")); + assert.equal(2, ts.syllableCount("writedown")); + assert.equal(2, ts.syllableCount("writedowns")); + assert.equal(4, ts.syllableCount("wrzesinski")); + assert.equal(4, ts.syllableCount("ws")); + assert.equal(2, ts.syllableCount("wuest")); + assert.equal(2, ts.syllableCount("wurdeman")); + assert.equal(2, ts.syllableCount("wussler")); + assert.equal(1, ts.syllableCount("wylde")); + assert.equal(3, ts.syllableCount("wyoming")); + assert.equal(1, ts.syllableCount("xanthe")); + assert.equal(2, ts.syllableCount("xantippe")); + assert.equal(2, ts.syllableCount("xavier")); + assert.equal(4, ts.syllableCount("xaviera")); + assert.equal(1, ts.syllableCount("xian")); + assert.equal(2, ts.syllableCount("xiaoping")); + assert.equal(2, ts.syllableCount("xiaoyun")); + assert.equal(2, ts.syllableCount("xscribe")); + assert.equal(2, ts.syllableCount("xtra")); + assert.equal(1, ts.syllableCount("xuan")); + assert.equal(1, ts.syllableCount("yaffe")); + assert.equal(1, ts.syllableCount("yahnke")); + assert.equal(4, ts.syllableCount("yamaichi")); + assert.equal(3, ts.syllableCount("yamane")); + assert.equal(4, ts.syllableCount("yamatake")); + assert.equal(4, ts.syllableCount("yamauchi")); + assert.equal(1, ts.syllableCount("yanke")); + assert.equal(3, ts.syllableCount("yarbrough")); + assert.equal(1, ts.syllableCount("yarde")); + assert.equal(2, ts.syllableCount("yarmulkes")); + assert.equal(3, ts.syllableCount("yasuo")); + assert.equal(3, ts.syllableCount("yearearlier")); + assert.equal(2, ts.syllableCount("yeates")); + assert.equal(1, ts.syllableCount("yerke")); + assert.equal(3, ts.syllableCount("yingling")); + assert.equal(1, ts.syllableCount("ynez")); + assert.equal(2, ts.syllableCount("ynjiun")); + assert.equal(3, ts.syllableCount("yoichi")); + assert.equal(2, ts.syllableCount("yolande")); + assert.equal(1, ts.syllableCount("yongue")); + assert.equal(1, ts.syllableCount("yonke")); + assert.equal(2, ts.syllableCount("yorio")); + assert.equal(1, ts.syllableCount("yorke")); + assert.equal(4, ts.syllableCount("yosemite")); + assert.equal(2, ts.syllableCount("yuletide")); + assert.equal(3, ts.syllableCount("zaccone")); + assert.equal(2, ts.syllableCount("zaire")); + assert.equal(3, ts.syllableCount("zairean")); + assert.equal(3, ts.syllableCount("zaireans")); + assert.equal(4, ts.syllableCount("zairian")); + assert.equal(4, ts.syllableCount("zairians")); + assert.equal(4, ts.syllableCount("zakrzewski")); + assert.equal(4, ts.syllableCount("zaniewski")); + assert.equal(3, ts.syllableCount("zappone")); + assert.equal(3, ts.syllableCount("zarcone")); + assert.equal(2, ts.syllableCount("zayed")); + assert.equal(3, ts.syllableCount("zeidler")); + assert.equal(3, ts.syllableCount("zeigler")); + assert.equal(3, ts.syllableCount("zeisler")); + assert.equal(3, ts.syllableCount("zeitler")); + assert.equal(1, ts.syllableCount("zemke")); + assert.equal(1, ts.syllableCount("zerbe")); + assert.equal(2, ts.syllableCount("zeringue")); + assert.equal(2, ts.syllableCount("zettler")); + assert.equal(2, ts.syllableCount("zhejiang")); + assert.equal(1, ts.syllableCount("zielke")); + assert.equal(1, ts.syllableCount("ziemke")); + assert.equal(1, ts.syllableCount("zier")); + assert.equal(1, ts.syllableCount("zierke")); + assert.equal(3, ts.syllableCount("ziesmer")); + assert.equal(3, ts.syllableCount("zigler")); + assert.equal(2, ts.syllableCount("zigzagged")); + assert.equal(4, ts.syllableCount("zimbabwean")); + assert.equal(3, ts.syllableCount("zingale")); + assert.equal(3, ts.syllableCount("zingler")); + assert.equal(1, ts.syllableCount("zinke")); + assert.equal(1, ts.syllableCount("zirbes")); + assert.equal(2, ts.syllableCount("zoe")); + assert.equal(2, ts.syllableCount("zoete")); + assert.equal(3, ts.syllableCount("zorine")); + assert.equal(1, ts.syllableCount("zuehlke")); + assert.equal(1, ts.syllableCount("zuelke")); + assert.equal(1, ts.syllableCount("zuhlke")); + assert.equal(4, ts.syllableCount("zuidema")); + }); +}); \ No newline at end of file diff --git a/test/kipling_if.test.js b/test/kipling_if.test.js new file mode 100644 index 0000000..c726d46 --- /dev/null +++ b/test/kipling_if.test.js @@ -0,0 +1,446 @@ +var chai = require('chai'); +var assert = chai.assert; + +/* + + Text + -------------------------------------------------------- + If by Rudyard Kipling + + If you can keep your head when all about you + Are losing theirs and blaming it on you, + If you can trust yourself when all men doubt you + But make allowance for their doubting too, + If you can wait and not be tired by waiting, + Or being lied about, don't deal in lies, + Or being hated, don't give way to hating, + And yet don't look too good, nor talk too wise: + + If you can dream - and not make dreams your master, + If you can think - and not make thoughts your aim; + If you can meet with Triumph and Disaster + And treat those two impostors just the same; + If you can bear to hear the truth you've spoken + Twisted by knaves to make a trap for fools, + Or watch the things you gave your life to, broken, + And stoop and build 'em up with worn-out tools: + + If you can make one heap of all your winnings + And risk it all on one turn of pitch-and-toss, + And lose, and start again at your beginnings + And never breath a word about your loss; + If you can force your heart and nerve and sinew + To serve your turn long after they are gone, + And so hold on when there is nothing in you + Except the Will which says to them: "Hold on" + + If you can talk with crowds and keep your virtue, + Or walk with kings - nor lose the common touch, + If neither foes nor loving friends can hurt you; + If all men count with you, but none too much, + If you can fill the unforgiving minute + With sixty seconds' worth of distance run, + Yours is the Earth and everything that's in it, + And - which is more - you'll be a Man, my son! + + Data + -------------------------------------------------------- + Letter Count: 1125 + Word Count: 292 + 3+ syllables: 6 + Syllable Count: 338 + Sentence Count: 1 + Note: 1 of the 3+ syllable words is a proper noun and + will be ignored by the Gunning-Fog Score. + + Manually Calculated Scores + -------------------------------------------------------- + Flesch-Kincaid Reading Ease + (206.835 - (1.015 * (word_count / sentence_count)) - (84.6 * (syllableCount / word_count))) = -187.47239726027397260273972602738 + + Flesch-Kincaid Grade Level + ((0.39 * (word_count / sentence_count)) + (11.8 * (syllableCount / word_count)) - 15.59) = 111.9489041095890410958904109589 + + Gunning-Fog Score + (((word_count / sentence_count) + (100 * (long_word_count / word_count ))) * 0.4) = 117.48493150684931506849315068493 + + Coleman-Liau Index + ((5.89 * (letter_count / word_count)) - (0.3 * (sentence_count / word_count)) - 15.8) = 6.8916095890410958904109589041096 + + SMOG Index + (1.043 * sqrt((long_word_count * (30 / sentence_count)) + 3.1291)) = 14.114418454399741934838352157075 + + Automated Readability Index + ((4.71 * (letter_count / word_count)) + (0.5 * (word_count / sentence_count)) - 21.43) = 142.7164041095890410958904109589 + +*/ + +var TS = require('../index'); +var ts = TS(); + +var strText = "If you can keep your head when all about you \n Are losing theirs and blaming it on you, \n If you can trust yourself when all men doubt you \n But make allowance for their doubting too, \n If you can wait and not be tired by waiting, \n Or being lied about, don't deal in lies, \n Or being hated, don't give way to hating, \n And yet don't look too good, nor talk too wise: \n\n If you can dream - and not make dreams your master, \n If you can think - and not make thoughts your aim; \n If you can meet with Triumph and Disaster \n And treat those two impostors just the same; \n If you can bear to hear the truth you've spoken \n Twisted by knaves to make a trap for fools, \n Or watch the things you gave your life to, broken, \n And stoop and build 'em up with worn-out tools: \n\n If you can make one heap of all your winnings \n And risk it all on one turn of pitch-and-toss, \n And lose, and start again at your beginnings \n And never breath a word about your loss; \n If you can force your heart and nerve and sinew \n To serve your turn long after they are gone, \n And so hold on when there is nothing in you \n Except the Will which says to them: \"Hold on\" \n\n If you can talk with crowds and keep your virtue, \n Or walk with kings - nor lose the common touch, \n If neither foes nor loving friends can hurt you; \n If all men count with you, but none too much, \n If you can fill the unforgiving minute \n With sixty seconds' worth of distance run, \n Yours is the Earth and everything that's in it, \n And - which is more - you'll be a Man, my son!"; + + +describe('Test Syllables', function(){ + + it('testKiplingSyllables', function(){ // The Words from If, in order + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('can'), 1); + assert.equal(ts.syllableCount('keep'), 1); + assert.equal(ts.syllableCount('your'), 1); + assert.equal(ts.syllableCount('head'), 1); + assert.equal(ts.syllableCount('when'), 1); + assert.equal(ts.syllableCount('all'), 1); + assert.equal(ts.syllableCount('about'), 2); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('Are'), 1); + assert.equal(ts.syllableCount('losing'), 2); + assert.equal(ts.syllableCount('theirs'), 1); + assert.equal(ts.syllableCount('and'), 1); + assert.equal(ts.syllableCount('blaming'), 2); + assert.equal(ts.syllableCount('it'), 1); + assert.equal(ts.syllableCount('on'), 1); + assert.equal(ts.syllableCount('you,'), 1); + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('can'), 1); + assert.equal(ts.syllableCount('trust'), 1); + assert.equal(ts.syllableCount('yourself'), 2); + assert.equal(ts.syllableCount('when'), 1); + assert.equal(ts.syllableCount('all'), 1); + assert.equal(ts.syllableCount('men'), 1); + assert.equal(ts.syllableCount('doubt'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('But'), 1); + assert.equal(ts.syllableCount('make'), 1); + assert.equal(ts.syllableCount('allowance'), 3); + assert.equal(ts.syllableCount('for'), 1); + assert.equal(ts.syllableCount('their'), 1); + assert.equal(ts.syllableCount('doubting'), 2); + assert.equal(ts.syllableCount('too,'), 1); + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('can'), 1); + assert.equal(ts.syllableCount('wait'), 1); + assert.equal(ts.syllableCount('and'), 1); + assert.equal(ts.syllableCount('not'), 1); + assert.equal(ts.syllableCount('be'), 1); + assert.equal(ts.syllableCount('tired'), 1); + assert.equal(ts.syllableCount('by'), 1); + assert.equal(ts.syllableCount('waiting,'), 2); + assert.equal(ts.syllableCount('Or'), 1); + assert.equal(ts.syllableCount('being'), 2); + assert.equal(ts.syllableCount('lied'), 1); + assert.equal(ts.syllableCount('about,'), 2); + assert.equal(ts.syllableCount('don\'t'), 1); + assert.equal(ts.syllableCount('deal'), 1); + assert.equal(ts.syllableCount('in'), 1); + assert.equal(ts.syllableCount('lies,'), 1); + assert.equal(ts.syllableCount('Or'), 1); + assert.equal(ts.syllableCount('being'), 2); + assert.equal(ts.syllableCount('hated,'), 2); + assert.equal(ts.syllableCount('don\'t'), 1); + assert.equal(ts.syllableCount('give'), 1); + assert.equal(ts.syllableCount('way'), 1); + assert.equal(ts.syllableCount('to'), 1); + assert.equal(ts.syllableCount('hating,'), 2); + assert.equal(ts.syllableCount('And'), 1); + assert.equal(ts.syllableCount('yet'), 1); + assert.equal(ts.syllableCount('don\'t'), 1); + assert.equal(ts.syllableCount('look'), 1); + assert.equal(ts.syllableCount('too'), 1); + assert.equal(ts.syllableCount('good,'), 1); + assert.equal(ts.syllableCount('nor'), 1); + assert.equal(ts.syllableCount('talk'), 1); + assert.equal(ts.syllableCount('too'), 1); + assert.equal(ts.syllableCount('wise:'), 1); + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('can'), 1); + assert.equal(ts.syllableCount('dream'), 1); + assert.equal(ts.syllableCount('-and'), 1); + assert.equal(ts.syllableCount('not'), 1); + assert.equal(ts.syllableCount('make'), 1); + assert.equal(ts.syllableCount('dreams'), 1); + assert.equal(ts.syllableCount('your'), 1); + assert.equal(ts.syllableCount('master,'), 2); + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('can'), 1); + assert.equal(ts.syllableCount('think'), 1); + assert.equal(ts.syllableCount('-and'), 1); + assert.equal(ts.syllableCount('not'), 1); + assert.equal(ts.syllableCount('make'), 1); + assert.equal(ts.syllableCount('thoughts'), 1); + assert.equal(ts.syllableCount('your'), 1); + assert.equal(ts.syllableCount('aim;'), 1); + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('can'), 1); + assert.equal(ts.syllableCount('meet'), 1); + assert.equal(ts.syllableCount('with'), 1); + assert.equal(ts.syllableCount('Triumph'), 2); + assert.equal(ts.syllableCount('and'), 1); + assert.equal(ts.syllableCount('Disaster'), 3); + assert.equal(ts.syllableCount('And'), 1); + assert.equal(ts.syllableCount('treat'), 1); + assert.equal(ts.syllableCount('those'), 1); + assert.equal(ts.syllableCount('two'), 1); + assert.equal(ts.syllableCount('impostors'), 3); + assert.equal(ts.syllableCount('just'), 1); + assert.equal(ts.syllableCount('the'), 1); + assert.equal(ts.syllableCount('same;'), 1); + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('can'), 1); + assert.equal(ts.syllableCount('bear'), 1); + assert.equal(ts.syllableCount('to'), 1); + assert.equal(ts.syllableCount('hear'), 1); + assert.equal(ts.syllableCount('the'), 1); + assert.equal(ts.syllableCount('truth'), 1); + assert.equal(ts.syllableCount('you\'ve'), 1); + assert.equal(ts.syllableCount('spoken'), 2); + assert.equal(ts.syllableCount('Twisted'), 2); + assert.equal(ts.syllableCount('by'), 1); + assert.equal(ts.syllableCount('knaves'), 1); + assert.equal(ts.syllableCount('to'), 1); + assert.equal(ts.syllableCount('make'), 1); + assert.equal(ts.syllableCount('a'), 1); + assert.equal(ts.syllableCount('trap'), 1); + assert.equal(ts.syllableCount('for'), 1); + assert.equal(ts.syllableCount('fools,'), 1); + assert.equal(ts.syllableCount('Or'), 1); + assert.equal(ts.syllableCount('watch'), 1); + assert.equal(ts.syllableCount('the'), 1); + assert.equal(ts.syllableCount('things'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('gave'), 1); + assert.equal(ts.syllableCount('your'), 1); + assert.equal(ts.syllableCount('life'), 1); + assert.equal(ts.syllableCount('to,'), 1); + assert.equal(ts.syllableCount('broken,'), 2); + assert.equal(ts.syllableCount('And'), 1); + assert.equal(ts.syllableCount('stoop'), 1); + assert.equal(ts.syllableCount('and'), 1); + assert.equal(ts.syllableCount('build'), 1); + assert.equal(ts.syllableCount('\'em'), 1); + assert.equal(ts.syllableCount('up'), 1); + assert.equal(ts.syllableCount('with'), 1); + assert.equal(ts.syllableCount('worn'), 1); + assert.equal(ts.syllableCount('-out'), 1); + assert.equal(ts.syllableCount('tools:'), 1); + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('can'), 1); + assert.equal(ts.syllableCount('make'), 1); + assert.equal(ts.syllableCount('one'), 1); + assert.equal(ts.syllableCount('heap'), 1); + assert.equal(ts.syllableCount('of'), 1); + assert.equal(ts.syllableCount('all'), 1); + assert.equal(ts.syllableCount('your'), 1); + assert.equal(ts.syllableCount('winnings'), 2); + assert.equal(ts.syllableCount('And'), 1); + assert.equal(ts.syllableCount('risk'), 1); + assert.equal(ts.syllableCount('it'), 1); + assert.equal(ts.syllableCount('all'), 1); + assert.equal(ts.syllableCount('on'), 1); + assert.equal(ts.syllableCount('one'), 1); + assert.equal(ts.syllableCount('turn'), 1); + assert.equal(ts.syllableCount('of'), 1); + assert.equal(ts.syllableCount('pitch'), 1); + assert.equal(ts.syllableCount('-and'), 1); + assert.equal(ts.syllableCount('-toss,'), 1); + assert.equal(ts.syllableCount('And'), 1); + assert.equal(ts.syllableCount('lose,'), 1); + assert.equal(ts.syllableCount('and'), 1); + assert.equal(ts.syllableCount('start'), 1); + assert.equal(ts.syllableCount('again'), 2); + assert.equal(ts.syllableCount('at'), 1); + assert.equal(ts.syllableCount('your'), 1); + assert.equal(ts.syllableCount('beginnings'), 3); + assert.equal(ts.syllableCount('And'), 1); + assert.equal(ts.syllableCount('never'), 2); + assert.equal(ts.syllableCount('breath'), 1); + assert.equal(ts.syllableCount('a'), 1); + assert.equal(ts.syllableCount('word'), 1); + assert.equal(ts.syllableCount('about'), 2); + assert.equal(ts.syllableCount('your'), 1); + assert.equal(ts.syllableCount('loss;'), 1); + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('can'), 1); + assert.equal(ts.syllableCount('force'), 1); + assert.equal(ts.syllableCount('your'), 1); + assert.equal(ts.syllableCount('heart'), 1); + assert.equal(ts.syllableCount('and'), 1); + assert.equal(ts.syllableCount('nerve'), 1); + assert.equal(ts.syllableCount('and'), 1); + assert.equal(ts.syllableCount('sinew'), 2); + assert.equal(ts.syllableCount('To'), 1); + assert.equal(ts.syllableCount('serve'), 1); + assert.equal(ts.syllableCount('your'), 1); + assert.equal(ts.syllableCount('turn'), 1); + assert.equal(ts.syllableCount('long'), 1); + assert.equal(ts.syllableCount('after'), 2); + assert.equal(ts.syllableCount('they'), 1); + assert.equal(ts.syllableCount('are'), 1); + assert.equal(ts.syllableCount('gone,'), 1); + assert.equal(ts.syllableCount('And'), 1); + assert.equal(ts.syllableCount('so'), 1); + assert.equal(ts.syllableCount('hold'), 1); + assert.equal(ts.syllableCount('on'), 1); + assert.equal(ts.syllableCount('when'), 1); + assert.equal(ts.syllableCount('there'), 1); + assert.equal(ts.syllableCount('is'), 1); + assert.equal(ts.syllableCount('nothing'), 2); + assert.equal(ts.syllableCount('in'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('Except'), 2); + assert.equal(ts.syllableCount('the'), 1); + assert.equal(ts.syllableCount('Will'), 1); + assert.equal(ts.syllableCount('which'), 1); + assert.equal(ts.syllableCount('says'), 1); + assert.equal(ts.syllableCount('to'), 1); + assert.equal(ts.syllableCount('them:'), 1); + assert.equal(ts.syllableCount('"Hold'), 1); + assert.equal(ts.syllableCount('on!"'), 1); + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('can'), 1); + assert.equal(ts.syllableCount('talk'), 1); + assert.equal(ts.syllableCount('with'), 1); + assert.equal(ts.syllableCount('crowds'), 1); + assert.equal(ts.syllableCount('and'), 1); + assert.equal(ts.syllableCount('keep'), 1); + assert.equal(ts.syllableCount('your'), 1); + assert.equal(ts.syllableCount('virtue,'), 2); + assert.equal(ts.syllableCount('Or'), 1); + assert.equal(ts.syllableCount('walk'), 1); + assert.equal(ts.syllableCount('with'), 1); + assert.equal(ts.syllableCount('kings'), 1); + assert.equal(ts.syllableCount('-nor'), 1); + assert.equal(ts.syllableCount('lose'), 1); + assert.equal(ts.syllableCount('the'), 1); + assert.equal(ts.syllableCount('common'), 2); + assert.equal(ts.syllableCount('touch,'), 1); + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('neither'), 2); + assert.equal(ts.syllableCount('foes'), 1); + assert.equal(ts.syllableCount('nor'), 1); + assert.equal(ts.syllableCount('loving'), 2); + assert.equal(ts.syllableCount('friends'), 1); + assert.equal(ts.syllableCount('can'), 1); + assert.equal(ts.syllableCount('hurt'), 1); + assert.equal(ts.syllableCount('you;'), 1); + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('all'), 1); + assert.equal(ts.syllableCount('men'), 1); + assert.equal(ts.syllableCount('count'), 1); + assert.equal(ts.syllableCount('with'), 1); + assert.equal(ts.syllableCount('you,'), 1); + assert.equal(ts.syllableCount('but'), 1); + assert.equal(ts.syllableCount('none'), 1); + assert.equal(ts.syllableCount('too'), 1); + assert.equal(ts.syllableCount('much'), 1); + assert.equal(ts.syllableCount('If'), 1); + assert.equal(ts.syllableCount('you'), 1); + assert.equal(ts.syllableCount('can'), 1); + assert.equal(ts.syllableCount('fill'), 1); + assert.equal(ts.syllableCount('the'), 1); + assert.equal(ts.syllableCount('unforgiving'), 4); + assert.equal(ts.syllableCount('minute'), 2); + assert.equal(ts.syllableCount('With'), 1); + assert.equal(ts.syllableCount('sixty'), 2); + assert.equal(ts.syllableCount('seconds\''), 2); + assert.equal(ts.syllableCount('worth'), 1); + assert.equal(ts.syllableCount('of'), 1); + assert.equal(ts.syllableCount('distance'), 2); + assert.equal(ts.syllableCount('run,'), 1); + assert.equal(ts.syllableCount('Yours'), 1); + assert.equal(ts.syllableCount('is'), 1); + assert.equal(ts.syllableCount('the'), 1); + assert.equal(ts.syllableCount('Earth'), 1); + assert.equal(ts.syllableCount('and'), 1); + assert.equal(ts.syllableCount('everything'), 4); + assert.equal(ts.syllableCount('that\'s'), 1); + assert.equal(ts.syllableCount('in'), 1); + assert.equal(ts.syllableCount('it,'), 1); + assert.equal(ts.syllableCount('And'), 1); + assert.equal(ts.syllableCount('which'), 1); + assert.equal(ts.syllableCount('is'), 1); + assert.equal(ts.syllableCount('more'), 1); + assert.equal(ts.syllableCount('you\'ll'), 1); + assert.equal(ts.syllableCount('be'), 1); + assert.equal(ts.syllableCount('a'), 1); + assert.equal(ts.syllableCount('Man,'), 1); + assert.equal(ts.syllableCount('my'), 1); + assert.equal(ts.syllableCount('son!'), 1); + }); + + /* Test Total Letters + -------------------- */ + it('testLetterCount', function(){ + assert.equal(1125, ts.letterCount(strText)); + }); + + /* Test Total Syllables + -------------------- */ + it('testSyllableCount', function(){ + assert.equal(338, ts.totalSyllables(strText)); + }); + + /* Test Words + -------------------- */ + it('testWordCount', function(){ + assert.equal(292, ts.wordCount(strText)); + }); + + /* Test Sentences + -------------------- */ + it('testSentenceCount', function(){ + assert.equal(4, ts.sentenceCount(strText)); + }); + + /* Test Letter Count + -------------------- */ + it('testTextLengthCheck', function(){ + assert.equal(1125, ts.letterCount(strText)); + }); + + /* Test Flesch Kincaid Reading Ease + -------------------- */ + it('testFleschKincaidReadingEase', function(){ + assert.equal(34.8, ts.fleschKincaidReadingEase(strText)); + }); + + /* Test Flesch Kincaid Grade Level + -------------------- */ + it('testFleschKincaidGradeLevel', function(){ + assert.equal(26.5, ts.fleschKincaidGradeLevel(strText)); + }); + + /* Test Gunning Fog Score + -------------------- */ + it('testGunningFogScore', function(){ + assert.equal(29.9, ts.gunningFogScore(strText)); + }); + + /* Test Coleman Liau Index + -------------------- */ + it('testColemanLiauIndex', function(){ + assert.equal(6.9, ts.colemanLiauIndex(strText)); + }); + + /* Test SMOG Index + -------------------- */ + it('testSMOGIndex', function(){ + assert.equal(7.2, ts.smogIndex(strText)); + }); + + /* Test Automated Readability Index + -------------------- */ + it('testAutomatedReadabilityIndex', function(){ + assert.equal(33.2, ts.automatedReadabilityIndex(strText)); + }); +}); \ No newline at end of file diff --git a/test/melville_moby_dick.test.js b/test/melville_moby_dick.test.js new file mode 100644 index 0000000..d31cb7d --- /dev/null +++ b/test/melville_moby_dick.test.js @@ -0,0 +1,315 @@ +var chai = require('chai'); +var assert = chai.assert; + +/* + + Text + -------------------------------------------------------- + Moby Dick by Herman Melville + + Call me Ishmael. Some years ago - never mind how long precisely - having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world. It is a way I have of driving off the spleen, and regulating the circulation. Whenever I find myself growing grim about the mouth; whenever it is a damp, drizzly November in my soul; whenever I find myself involuntarily pausing before coffin warehouses, and bringing up the rear of every funeral I meet; and especially whenever my hypos get such an upper hand of me, that it requires a strong moral principle to prevent me from deliberately stepping into the street, and methodically knocking people's hats off - then, I account it high time to get to sea as soon as I can. This is my substitute for pistol and ball. With a philosophical flourish Cato throws himself upon his sword; I quietly take to the ship. There is nothing surprising in this. If they but knew it, almost all men in their degree, some time or other, cherish very nearly the same feelings towards the ocean with me. + + Data + -------------------------------------------------------- + Letter Count: 884 + Word Count: 201 + 3+ syllables: 23 + Syllable Count: 304 + Sentence Count: 8 + Note: 1 of the 3+ syllable words is a proper noun and + will be ignored by the Gunning-Fog Score. + + Manually Calculated Scores + -------------------------------------------------------- + Flesch-Kincaid Reading Ease + (206.835 - (1.015 * (word_count / sentence_count)) - (84.6 * (syllableCount / word_count))) = 53.380886194029850746268656716418 + + Flesch-Kincaid Grade Level + ((0.39 * (word_count / sentence_count)) + (11.8 * (syllableCount / word_count)) - 15.59) = 12.055516169154228855721393034826 + + Gunning-Fog Score + (((word_count / sentence_count) + (100 * (long_word_count / word_count ))) * 0.4) = 14.428109452736318407960199004975 + + Coleman-Liau Index + ((5.89 * (letter_count / word_count)) - (0.3 * (sentence_count / word_count)) - 15.8) = 10.092338308457711442786069651741 + + SMOG Index + (1.043 * sqrt((long_word_count * (30 / sentence_count)) + 3.1291)) = 9.8605762790974848783982768629462 + + Automated Readability Index + ((4.71 * (letter_count / word_count)) + (0.5 * (word_count / sentence_count)) - 21.43) = 11.847126865671641791044776119403 + +*/ + +var TS = require('../index'); +var ts = TS(); + +var strText = "Call me Ishmael. Some years ago - never mind how long precisely - having little or no money in my purse, and nothing particular to interest me on shore, I thought I would sail about a little and see the watery part of the world. It is a way I have of driving off the spleen, and regulating the circulation. Whenever I find myself growing grim about the mouth; whenever it is a damp, drizzly November in my soul; whenever I find myself involuntarily pausing before coffin warehouses, and bringing up the rear of every funeral I meet; and especially whenever my hypos get such an upper hand of me, that it requires a strong moral principle to prevent me from deliberately stepping into the street, and methodically knocking people's hats off - then, I account it high time to get to sea as soon as I can. This is my substitute for pistol and ball. With a philosophical flourish Cato throws himself upon his sword; I quietly take to the ship. There is nothing surprising in this. If they but knew it, almost all men in their degree, some time or other, cherish very nearly the same feelings towards the ocean with me."; + +describe('Test Syllables', function(){ + + it('testMobyDickSyllables', function(){ // The Words from Moby Dick, in order + assert.equal(1, ts.syllableCount('Call')); + assert.equal(1, ts.syllableCount('me')); + assert.equal(2, ts.syllableCount('Ishmael')); + assert.equal(1, ts.syllableCount('Some')); + assert.equal(1, ts.syllableCount('years')); + assert.equal(2, ts.syllableCount('ago')); + assert.equal(2, ts.syllableCount('never')); + assert.equal(1, ts.syllableCount('mind')); + assert.equal(1, ts.syllableCount('how')); + assert.equal(1, ts.syllableCount('long')); + assert.equal(3, ts.syllableCount('precisely')); + assert.equal(2, ts.syllableCount('having')); + assert.equal(2, ts.syllableCount('little')); + assert.equal(1, ts.syllableCount('or')); + assert.equal(1, ts.syllableCount('no')); + assert.equal(2, ts.syllableCount('money')); + assert.equal(1, ts.syllableCount('in')); + assert.equal(1, ts.syllableCount('my')); + assert.equal(1, ts.syllableCount('purse')); + assert.equal(1, ts.syllableCount('and')); + assert.equal(2, ts.syllableCount('nothing')); + assert.equal(4, ts.syllableCount('particular')); + assert.equal(1, ts.syllableCount('to')); + assert.equal(3, ts.syllableCount('interest')); + assert.equal(1, ts.syllableCount('me')); + assert.equal(1, ts.syllableCount('on')); + assert.equal(1, ts.syllableCount('shore')); + assert.equal(1, ts.syllableCount('I')); + assert.equal(1, ts.syllableCount('thought')); + assert.equal(1, ts.syllableCount('I')); + assert.equal(1, ts.syllableCount('would')); + assert.equal(1, ts.syllableCount('sail')); + assert.equal(2, ts.syllableCount('about')); + assert.equal(1, ts.syllableCount('a')); + assert.equal(2, ts.syllableCount('little')); + assert.equal(1, ts.syllableCount('and')); + assert.equal(1, ts.syllableCount('see')); + assert.equal(1, ts.syllableCount('the')); + assert.equal(3, ts.syllableCount('watery')); + assert.equal(1, ts.syllableCount('part')); + assert.equal(1, ts.syllableCount('of')); + assert.equal(1, ts.syllableCount('the')); + assert.equal(1, ts.syllableCount('world')); + assert.equal(1, ts.syllableCount('It')); + assert.equal(1, ts.syllableCount('is')); + assert.equal(1, ts.syllableCount('a')); + assert.equal(1, ts.syllableCount('way')); + assert.equal(1, ts.syllableCount('I')); + assert.equal(1, ts.syllableCount('have')); + assert.equal(1, ts.syllableCount('of')); + assert.equal(2, ts.syllableCount('driving')); + assert.equal(1, ts.syllableCount('off')); + assert.equal(1, ts.syllableCount('the')); + assert.equal(1, ts.syllableCount('spleen')); + assert.equal(1, ts.syllableCount('and')); + assert.equal(4, ts.syllableCount('regulating')); + assert.equal(1, ts.syllableCount('the')); + assert.equal(4, ts.syllableCount('circulation')); + assert.equal(3, ts.syllableCount('Whenever')); + assert.equal(1, ts.syllableCount('I')); + assert.equal(1, ts.syllableCount('find')); + assert.equal(2, ts.syllableCount('myself')); + assert.equal(2, ts.syllableCount('growing')); + assert.equal(1, ts.syllableCount('grim')); + assert.equal(2, ts.syllableCount('about')); + assert.equal(1, ts.syllableCount('the')); + assert.equal(1, ts.syllableCount('mouth')); + assert.equal(3, ts.syllableCount('whenever')); + assert.equal(1, ts.syllableCount('it')); + assert.equal(1, ts.syllableCount('is')); + assert.equal(1, ts.syllableCount('a')); + assert.equal(1, ts.syllableCount('damp')); + assert.equal(2, ts.syllableCount('drizzly')); + assert.equal(3, ts.syllableCount('November')); + assert.equal(1, ts.syllableCount('in')); + assert.equal(1, ts.syllableCount('my')); + assert.equal(1, ts.syllableCount('soul')); + assert.equal(3, ts.syllableCount('whenever')); + assert.equal(1, ts.syllableCount('I')); + assert.equal(1, ts.syllableCount('find')); + assert.equal(2, ts.syllableCount('myself')); + assert.equal(6, ts.syllableCount('involuntarily')); + assert.equal(2, ts.syllableCount('pausing')); + assert.equal(2, ts.syllableCount('before')); + assert.equal(2, ts.syllableCount('coffin')); + assert.equal(3, ts.syllableCount('warehouses')); + assert.equal(1, ts.syllableCount('and')); + assert.equal(2, ts.syllableCount('bringing')); + assert.equal(1, ts.syllableCount('up')); + assert.equal(1, ts.syllableCount('the')); + assert.equal(1, ts.syllableCount('rear')); + assert.equal(1, ts.syllableCount('of')); + assert.equal(3, ts.syllableCount('every')); + assert.equal(3, ts.syllableCount('funeral')); + assert.equal(1, ts.syllableCount('I')); + assert.equal(1, ts.syllableCount('meet')); + assert.equal(1, ts.syllableCount('and')); + assert.equal(4, ts.syllableCount('especially')); + assert.equal(3, ts.syllableCount('whenever')); + assert.equal(1, ts.syllableCount('my')); + assert.equal(2, ts.syllableCount('hypos')); + assert.equal(1, ts.syllableCount('get')); + assert.equal(1, ts.syllableCount('such')); + assert.equal(1, ts.syllableCount('an')); + assert.equal(2, ts.syllableCount('upper')); + assert.equal(1, ts.syllableCount('hand')); + assert.equal(1, ts.syllableCount('of')); + assert.equal(1, ts.syllableCount('me')); + assert.equal(1, ts.syllableCount('that')); + assert.equal(1, ts.syllableCount('it')); + assert.equal(2, ts.syllableCount('requires')); + assert.equal(1, ts.syllableCount('a')); + assert.equal(1, ts.syllableCount('strong')); + assert.equal(2, ts.syllableCount('moral')); + assert.equal(3, ts.syllableCount('principle')); + assert.equal(1, ts.syllableCount('to')); + assert.equal(2, ts.syllableCount('prevent')); + assert.equal(1, ts.syllableCount('me')); + assert.equal(1, ts.syllableCount('from')); + assert.equal(5, ts.syllableCount('deliberately')); + assert.equal(2, ts.syllableCount('stepping')); + assert.equal(2, ts.syllableCount('into')); + assert.equal(1, ts.syllableCount('the')); + assert.equal(1, ts.syllableCount('street')); + assert.equal(1, ts.syllableCount('and')); + assert.equal(5, ts.syllableCount('methodically')); + assert.equal(2, ts.syllableCount('knocking')); + assert.equal(2, ts.syllableCount('people\'s')); + assert.equal(1, ts.syllableCount('hats')); + assert.equal(1, ts.syllableCount('off')); + assert.equal(1, ts.syllableCount('then')); + assert.equal(1, ts.syllableCount('I')); + assert.equal(2, ts.syllableCount('account')); + assert.equal(1, ts.syllableCount('it')); + assert.equal(1, ts.syllableCount('high')); + assert.equal(1, ts.syllableCount('time')); + assert.equal(1, ts.syllableCount('to')); + assert.equal(1, ts.syllableCount('get')); + assert.equal(1, ts.syllableCount('to')); + assert.equal(1, ts.syllableCount('sea')); + assert.equal(1, ts.syllableCount('as')); + assert.equal(1, ts.syllableCount('soon')); + assert.equal(1, ts.syllableCount('as')); + assert.equal(1, ts.syllableCount('I')); + assert.equal(1, ts.syllableCount('can')); + assert.equal(1, ts.syllableCount('This')); + assert.equal(1, ts.syllableCount('is')); + assert.equal(1, ts.syllableCount('my')); + assert.equal(3, ts.syllableCount('substitute')); + assert.equal(1, ts.syllableCount('for')); + assert.equal(2, ts.syllableCount('pistol')); + assert.equal(1, ts.syllableCount('and')); + assert.equal(1, ts.syllableCount('ball')); + assert.equal(1, ts.syllableCount('With')); + assert.equal(1, ts.syllableCount('a')); + assert.equal(5, ts.syllableCount('philosophical')); + assert.equal(2, ts.syllableCount('flourish')); + assert.equal(2, ts.syllableCount('Cato')); + assert.equal(1, ts.syllableCount('throws')); + assert.equal(2, ts.syllableCount('himself')); + assert.equal(2, ts.syllableCount('upon')); + assert.equal(1, ts.syllableCount('his')); + assert.equal(1, ts.syllableCount('sword')); + assert.equal(1, ts.syllableCount('I')); + assert.equal(3, ts.syllableCount('quietly')); + assert.equal(1, ts.syllableCount('take')); + assert.equal(1, ts.syllableCount('to')); + assert.equal(1, ts.syllableCount('the')); + assert.equal(1, ts.syllableCount('ship')); + assert.equal(1, ts.syllableCount('There')); + assert.equal(1, ts.syllableCount('is')); + assert.equal(2, ts.syllableCount('nothing')); + assert.equal(3, ts.syllableCount('surprising')); + assert.equal(1, ts.syllableCount('in')); + assert.equal(1, ts.syllableCount('this')); + assert.equal(1, ts.syllableCount('If')); + assert.equal(1, ts.syllableCount('they')); + assert.equal(1, ts.syllableCount('but')); + assert.equal(1, ts.syllableCount('knew')); + assert.equal(1, ts.syllableCount('it')); + assert.equal(2, ts.syllableCount('almost')); + assert.equal(1, ts.syllableCount('all')); + assert.equal(1, ts.syllableCount('men')); + assert.equal(1, ts.syllableCount('in')); + assert.equal(1, ts.syllableCount('their')); + assert.equal(2, ts.syllableCount('degree')); + assert.equal(1, ts.syllableCount('some')); + assert.equal(1, ts.syllableCount('time')); + assert.equal(1, ts.syllableCount('or')); + assert.equal(2, ts.syllableCount('other')); + assert.equal(2, ts.syllableCount('cherish')); + assert.equal(2, ts.syllableCount('very')); + assert.equal(2, ts.syllableCount('nearly')); + assert.equal(1, ts.syllableCount('the')); + assert.equal(1, ts.syllableCount('same')); + assert.equal(2, ts.syllableCount('feelings')); + assert.equal(2, ts.syllableCount('towards')); + assert.equal(1, ts.syllableCount('the')); + assert.equal(2, ts.syllableCount('ocean')); + assert.equal(1, ts.syllableCount('with')); + assert.equal(1, ts.syllableCount('me')); + }); + + /* Test Word Count + -------------------- */ + it('testWordCount', function(){ + assert.equal(201, ts.wordCount(strText)); + }); + + /* Test Long Word Count + -------------------- */ + it('testLongWordCount', function(){ + assert.equal(23, ts.wordsWithThreeSyllables(strText, true)); // Include proper nouns + assert.equal(22, ts.wordsWithThreeSyllables(strText, false)); // Don't include proper nouns + }); + + /* Test Sentences + -------------------- */ + it('testSentenceCount', function(){ + assert.equal(8, ts.sentenceCount(strText)); + }); + + /* Test Letter Count + -------------------- */ + it('testTextLengthCheck', function(){ + assert.equal(884, ts.letterCount(strText)); + }); + + /* Test Flesch Kincaid Reading Ease + -------------------- */ + it('testFleschKincaidReadingEase', function(){ + assert.equal(53.4, ts.fleschKincaidReadingEase(strText)); + }); + + /* Test Flesch Kincaid Grade Level + -------------------- */ + it('testFleschKincaidGradeLevel', function(){ + assert.equal(12.1, ts.fleschKincaidGradeLevel(strText)); + }); + + /* Test Gunning Fog Score + -------------------- */ + it('testGunningFogScore', function(){ + assert.equal(14.4, ts.gunningFogScore(strText)); + }); + + /* Test Coleman Liau Index + -------------------- */ + it('testColemanLiauIndex', function(){ + assert.equal(10.1, ts.colemanLiauIndex(strText)); + }); + + /* Test SMOG Index + -------------------- */ + it('testSMOGIndex', function(){ + assert.equal(9.9, ts.smogIndex(strText)); + }); + + /* Test Automated Readability Index + -------------------- */ + it('testAutomatedReadabilityIndex', function(){ + assert.equal(11.8, ts.automatedReadabilityIndex(strText)); + }); +}); \ No newline at end of file diff --git a/test/text_statistics.test.js b/test/text_statistics.test.js new file mode 100644 index 0000000..a355237 --- /dev/null +++ b/test/text_statistics.test.js @@ -0,0 +1,277 @@ +var chai = require('chai'); +var assert = chai.assert; + +/* + This file contains the more basic tests - short sentences, word counts, + sentence counts, and so on. Longer texts are split into their own test + files for convenience. +*/ + +var TS = require('../index'); +var ts = TS(); + + +describe('Test Cleaning of text', function(){ + + it('testCleaning', function(){ + assert.equal('', TS(false).text); + + assert.equal('There once was a little sausage named Baldrick. and he lived happily ever after.', + TS('There once was a little sausage named Baldrick. . . . And he lived happily ever after.!! !??').text); + }); +}); + + +describe('Test Counts', function(){ + + it('testCounts', function(){ + assert.equal(47, ts.characterCount('There once was a little sausage named Baldrick.')); + assert.equal(47, ts.textLength('There once was a little sausage named Baldrick.')); + assert.equal(39, ts.letterCount('There once was a little sausage named Baldrick.')); + assert.equal(0, ts.letterCount('')); + assert.equal(0, ts.letterCount(' ')); + assert.equal(0, ts.wordCount('')); + assert.equal(0, ts.wordCount(' ')); + assert.equal(0, ts.sentenceCount('')); + assert.equal(0, ts.sentenceCount(' ')); + assert.equal(1, ts.letterCount('a')); + assert.equal(0, ts.letterCount('')); + assert.equal(46, ts.letterCount('this sentence has 30 characters, not including the digits')); + }); + +}); + +describe('Test Syllables', function(){ + + it('testSyllableCountBasicWords', function(){ + assert.equal(0, ts.syllableCount('.')); + assert.equal(1, ts.syllableCount('a')); + assert.equal(1, ts.syllableCount('was')); + assert.equal(1, ts.syllableCount('the')); + assert.equal(1, ts.syllableCount('and')); + assert.equal(2, ts.syllableCount('foobar')); + assert.equal(2, ts.syllableCount('hello')); + assert.equal(1, ts.syllableCount('world')); + assert.equal(3, ts.syllableCount('wonderful')); + assert.equal(2, ts.syllableCount('simple')); + assert.equal(2, ts.syllableCount('easy')); + assert.equal(1, ts.syllableCount('hard')); + assert.equal(1, ts.syllableCount('quick')); + assert.equal(1, ts.syllableCount('brown')); + assert.equal(1, ts.syllableCount('fox')); + assert.equal(1, ts.syllableCount('jumped')); + assert.equal(2, ts.syllableCount('over')); + assert.equal(2, ts.syllableCount('lazy')); + assert.equal(1, ts.syllableCount('dog')); + assert.equal(3, ts.syllableCount('camera')); + }); + + it('testSyllableCountComplexWords', function(){ + assert.equal(12, ts.syllableCount('antidisestablishmentarianism')); + assert.equal(14, ts.syllableCount('supercalifragilisticexpialidocious')); + assert.equal(8, ts.syllableCount('chlorofluorocarbonation')); + assert.equal(4, ts.syllableCount('forethoughtfulness')); + assert.equal(4, ts.syllableCount('phosphorescent')); + assert.equal(5, ts.syllableCount('theoretician')); + assert.equal(5, ts.syllableCount('promiscuity')); + assert.equal(4, ts.syllableCount('unbutlering')); + assert.equal(5, ts.syllableCount('continuity')); + assert.equal(1, ts.syllableCount('craunched')); + assert.equal(1, ts.syllableCount('squelched')); + assert.equal(1, ts.syllableCount('scrounge')); + assert.equal(1, ts.syllableCount('coughed')); + assert.equal(1, ts.syllableCount('smile')); + assert.equal(4, ts.syllableCount('monopoly')); + assert.equal(2, ts.syllableCount('doughey')); + assert.equal(3, ts.syllableCount('doughier')); + assert.equal(4, ts.syllableCount('leguminous')); + assert.equal(3, ts.syllableCount('thoroughbreds')); + assert.equal(2, ts.syllableCount('special')); + assert.equal(3, ts.syllableCount('delicious')); + assert.equal(2, ts.syllableCount('spatial')); + assert.equal(4, ts.syllableCount('pacifism')); + assert.equal(4, ts.syllableCount('coagulant')); + assert.equal(2, ts.syllableCount('shouldn\'t')); + assert.equal(3, ts.syllableCount('mcdonald')); + assert.equal(3, ts.syllableCount('audience')); + assert.equal(2, ts.syllableCount('finance')); + assert.equal(3, ts.syllableCount('prevalence')); + assert.equal(5, ts.syllableCount('impropriety')); + assert.equal(3, ts.syllableCount('alien')); + assert.equal(2, ts.syllableCount('dreadnought')); + assert.equal(3, ts.syllableCount('verandah')); + assert.equal(3, ts.syllableCount('similar')); + assert.equal(4, ts.syllableCount('similarly')); + assert.equal(2, ts.syllableCount('central')); + assert.equal(1, ts.syllableCount('cyst')); + assert.equal(1, ts.syllableCount('term')); + assert.equal(2, ts.syllableCount('order')); + assert.equal(1, ts.syllableCount('fur')); + assert.equal(2, ts.syllableCount('sugar')); + assert.equal(2, ts.syllableCount('paper')); + assert.equal(1, ts.syllableCount('make')); + assert.equal(1, ts.syllableCount('gem')); + assert.equal(2, ts.syllableCount('program')); + assert.equal(2, ts.syllableCount('hopeless')); + assert.equal(3, ts.syllableCount('hopelessly')); + assert.equal(2, ts.syllableCount('careful')); + assert.equal(3, ts.syllableCount('carefully')); + assert.equal(2, ts.syllableCount('stuffy')); + assert.equal(2, ts.syllableCount('thistle')); + assert.equal(2, ts.syllableCount('teacher')); + assert.equal(3, ts.syllableCount('unhappy')); + assert.equal(5, ts.syllableCount('ambiguity')); + assert.equal(4, ts.syllableCount('validity')); + assert.equal(4, ts.syllableCount('ambiguous')); + assert.equal(2, ts.syllableCount('deserve')); + assert.equal(2, ts.syllableCount('blooper')); + assert.equal(1, ts.syllableCount('scooped')); + assert.equal(2, ts.syllableCount('deserve')); + assert.equal(1, ts.syllableCount('deal')); + assert.equal(1, ts.syllableCount('death')); + assert.equal(1, ts.syllableCount('dearth')); + assert.equal(1, ts.syllableCount('deign')); + assert.equal(1, ts.syllableCount('reign')); + assert.equal(2, ts.syllableCount('bedsore')); + assert.equal(5, ts.syllableCount('anorexia')); + assert.equal(3, ts.syllableCount('anymore')); + assert.equal(1, ts.syllableCount('cored')); + assert.equal(1, ts.syllableCount('sore')); + assert.equal(2, ts.syllableCount('foremost')); + assert.equal(2, ts.syllableCount('restore')); + assert.equal(2, ts.syllableCount('minute')); + assert.equal(3, ts.syllableCount('manticores')); + assert.equal(4, ts.syllableCount('asparagus')); + assert.equal(3, ts.syllableCount('unexplored')); + assert.equal(4, ts.syllableCount('unexploded')); + assert.equal(3, ts.syllableCount('CAPITALS')); + }); + + it('testSyllableCountProgrammedExceptions', function(){ + assert.equal(3, ts.syllableCount('simile')); + assert.equal(2, ts.syllableCount('shoreline')); + assert.equal(3, ts.syllableCount('forever')); + }); + + it('testAverageSyllablesPerWord', function(){ + assert.equal(1, ts.averageSyllablesPerWord('and then there was one')); + assert.equal(2, ts.averageSyllablesPerWord('because special ducklings deserve rainbows')); + assert.equal(1.5, ts.averageSyllablesPerWord('and then there was one because special ducklings deserve rainbows')); + }); +}); + +describe('Test Words', function(){ + + it('testWordCount', function(){ + assert.equal(9, ts.wordCount('The quick brown fox jumps over the lazy dog')); + assert.equal(9, ts.wordCount('The quick brown fox jumps over the lazy dog.')); + assert.equal(9, ts.wordCount('The quick brown fox jumps over the lazy dog. ')); + assert.equal(9, ts.wordCount(' The quick brown fox jumps over the lazy dog. ')); + assert.equal(9, ts.wordCount(' The quick brown fox jumps over the lazy dog. ')); + assert.equal(2, ts.wordCount('Yes. No.')); + assert.equal(2, ts.wordCount('Yes.No.')); + assert.equal(2, ts.wordCount('Yes.No.')); + assert.equal(2, ts.wordCount('Yes . No.')); + assert.equal(2, ts.wordCount('Yes .No.')); + assert.equal(2, ts.wordCount('Yes - No. ')); + }); + + it('testCheckPercentageWordsWithThreeSyllables', function(){ + assert.equal(9, Math.ceil(ts.percentageWordsWithThreeSyllables('there is just one word with three syllables in this sentence'))); + assert.equal(9, Math.ceil(ts.percentageWordsWithThreeSyllables('there is just one word with three syllables in this sentence', true))); + assert.equal(0, Math.ceil(ts.percentageWordsWithThreeSyllables('there are no valid words with three Syllables in this sentence', false))); + assert.equal(5, Math.ceil(ts.percentageWordsWithThreeSyllables('there is one and only one word with three or more syllables in this long boring sentence of twenty words'))); + assert.equal(10, Math.ceil(ts.percentageWordsWithThreeSyllables('there are two and only two words with three or more syllables in this long sentence of exactly twenty words'))); + assert.equal(5, Math.ceil(ts.percentageWordsWithThreeSyllables('there is Actually only one valid word with three or more syllables in this long sentence of Exactly twenty words', false))); + assert.equal(0, Math.ceil(ts.percentageWordsWithThreeSyllables('no long words in this sentence'))); + assert.equal(0, Math.ceil(ts.percentageWordsWithThreeSyllables('no long valid words in this sentence because the test ignores proper case words like this Behemoth', false))); + }); +}); + +describe('Test Sentences', function(){ + + it('testSentenceCount', function(){ + assert.equal(1, ts.sentenceCount('This is a sentence')); + assert.equal(1, ts.sentenceCount('This is a sentence.')); + assert.equal(1, ts.sentenceCount('This is a sentence!')); + assert.equal(1, ts.sentenceCount('This is a sentence?')); + assert.equal(1, ts.sentenceCount('This is a sentence..')); + assert.equal(2, ts.sentenceCount('This is a sentence. So is this.')); + assert.equal(2, ts.sentenceCount("This is a sentence. \n\n So is this, but this is multi-line!")); + assert.equal(2, ts.sentenceCount('This is a sentence,. So is this.')); + assert.equal(2, ts.sentenceCount('This is a sentence!? So is this.')); + assert.equal(3, ts.sentenceCount('This is a sentence. So is this. And this one as well.')); + assert.equal(1, ts.sentenceCount('This is a sentence - but just one.')); + assert.equal(1, ts.sentenceCount('This is a sentence (but just one).')); + }); + + it('testAverageWordsPerSentence', function(){ + assert.equal(4, ts.averageWordsPerSentence('This is a sentence')); + assert.equal(4, ts.averageWordsPerSentence('This is a sentence.')); + assert.equal(4, ts.averageWordsPerSentence('This is a sentence. ')); + assert.equal(4, ts.averageWordsPerSentence('This is a sentence. This is a sentence')); + assert.equal(4, ts.averageWordsPerSentence('This is a sentence. This is a sentence.')); + assert.equal(4, ts.averageWordsPerSentence('This, is - a sentence . This is a sentence. ')); + assert.equal(5.5, ts.averageWordsPerSentence('This is a sentence with extra text. This is a sentence. ')); + assert.equal(6, ts.averageWordsPerSentence('This is a sentence with some extra text. This is a sentence. ')); + }); +}); + +describe('Test Scores',function(){ + + it('testFleschKincaidReadingEase', function(){ + assert.equal(121.2, ts.fleschKincaidReadingEase('This. Is. A. Nice. Set. Of. Small. Words. Of. One. Part. Each.')); // Best score possible + assert.equal(94.3, ts.fleschKincaidReadingEase('The quick brown fox jumps over the lazy dog.')); + assert.equal(94.3, ts.fleschKincaidReadingEase('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.')); + assert.equal(94.3, ts.fleschKincaidReadingEase('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog')); + assert.equal(94.3, ts.fleschKincaidReadingEase("The quick brown fox jumps over the lazy dog. \n\n The quick brown fox jumps over the lazy dog.")); + assert.equal(50.5, ts.fleschKincaidReadingEase('Now it is time for a more complicated sentence, including several longer words.')); + }); + + it('testFleschKincaidGradeLevel', function(){ + assert.equal(-3.4, ts.fleschKincaidGradeLevel('This. Is. A. Nice. Set. Of. Small. Words. Of. One. Part. Each.')); // Best score possible + assert.equal(2.3, ts.fleschKincaidGradeLevel('The quick brown fox jumps over the lazy dog.')); + assert.equal(2.3, ts.fleschKincaidGradeLevel('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.')); + assert.equal(2.3, ts.fleschKincaidGradeLevel('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog')); + assert.equal(2.3, ts.fleschKincaidGradeLevel("The quick brown fox jumps over the lazy dog. \n\n The quick brown fox jumps over the lazy dog.")); + assert.equal(9.4, ts.fleschKincaidGradeLevel('Now it is time for a more complicated sentence, including several longer words.')); + }); + + + it('testGunningFogScore', function(){ + assert.equal(0.4, ts.gunningFogScore('This. Is. A. Nice. Set. Of. Small. Words. Of. One. Part. Each.')); // Best possible score + assert.equal(3.6, ts.gunningFogScore('The quick brown fox jumps over the lazy dog.')); + assert.equal(3.6, ts.gunningFogScore('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.')); + assert.equal(3.6, ts.gunningFogScore("The quick brown fox jumps over the lazy dog. \n\n The quick brown fox jumps over the lazy dog.")); + assert.equal(3.6, ts.gunningFogScore('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog')); + assert.equal(14.4, ts.gunningFogScore('Now it is time for a more complicated sentence, including several longer words.')); + assert.equal(8.3, ts.gunningFogScore('Now it is time for a more Complicated sentence, including Several longer words.')); // Two proper nouns, ignored + }); + + it('testColemanLiauIndex', function(){ + assert.equal(3.0, ts.colemanLiauIndex('This. Is. A. Nice. Set. Of. Small. Words. Of. One. Part. Each.')); // Best possible score would be if all words were 1 character + assert.equal(7.1, ts.colemanLiauIndex('The quick brown fox jumps over the lazy dog.')); + assert.equal(7.1, ts.colemanLiauIndex('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.')); + assert.equal(7.1, ts.colemanLiauIndex("The quick brown fox jumps over the lazy dog. \n\n The quick brown fox jumps over the lazy dog.")); + assert.equal(7.1, ts.colemanLiauIndex('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog')); + assert.equal(13.6, ts.colemanLiauIndex('Now it is time for a more complicated sentence, including several longer words.')); + }); + + it('testSMOGIndex', function(){ + assert.equal(1.8, ts.smogIndex('This. Is. A. Nice. Set. Of. Small. Words. Of. One. Part. Each.')); // Should be 1.8 for any text with no words of 3+ syllables + assert.equal(1.8, ts.smogIndex('The quick brown fox jumps over the lazy dog.')); + assert.equal(1.8, ts.smogIndex('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.')); + assert.equal(1.8, ts.smogIndex("The quick brown fox jumps over the lazy dog. \n\n The quick brown fox jumps over the lazy dog.")); + assert.equal(1.8, ts.smogIndex('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog')); + assert.equal(10.1, ts.smogIndex('Now it is time for a more complicated sentence, including several longer words.')); + }); + + it('testAutomatedReadabilityIndex', function(){ + assert.equal(-5.6, ts.automatedReadabilityIndex('This. Is. A. Nice. Set. Of. Small. Words. Of. One. Part. Each.')); + assert.equal(1.4, ts.automatedReadabilityIndex('The quick brown fox jumps over the lazy dog.')); + assert.equal(1.4, ts.automatedReadabilityIndex('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.')); + assert.equal(1.4, ts.automatedReadabilityIndex("The quick brown fox jumps over the lazy dog. \n\n The quick brown fox jumps over the lazy dog.")); + assert.equal(1.4, ts.automatedReadabilityIndex('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog')); + assert.equal(8.6, ts.automatedReadabilityIndex('Now it is time for a more complicated sentence, including several longer words.')); + }); +}); \ No newline at end of file