diff --git a/composer.json b/composer.json index fce6738..499d3fc 100644 --- a/composer.json +++ b/composer.json @@ -17,6 +17,19 @@ "source": "http://cgit.drupalcode.org/content_readability" }, "require": { - "davechild/textstatistics": "^1.0.3" + "davechild/textstatistics": "^1.0.3", + "cweagans/composer-patches": "^1.6" + }, + "extra": { + "patches": { + "davechild/textstatistics": { + "3540852 - Deprecated function: Function utf8_decode() is deprecated": "https://patch-diff.githubusercontent.com/raw/DaveChild/Text-Statistics/pull/56.patch" + } + } + }, + "config": { + "allow-plugins": { + "cweagans/composer-patches": true + } } } diff --git a/composer.lock b/composer.lock new file mode 100644 index 0000000..b7f81a5 --- /dev/null +++ b/composer.lock @@ -0,0 +1,123 @@ +{ + "_readme": [ + "This file locks the dependencies of your project to a known state", + "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies", + "This file is @generated automatically" + ], + "content-hash": "76a228abe2d9a26c320cf1b141dbd47a", + "packages": [ + { + "name": "cweagans/composer-patches", + "version": "1.x-dev", + "source": { + "type": "git", + "url": "https://github.com/cweagans/composer-patches.git", + "reference": "37e1b296d8100845c7b10c143cc3e96552d41ab1" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/cweagans/composer-patches/zipball/37e1b296d8100845c7b10c143cc3e96552d41ab1", + "reference": "37e1b296d8100845c7b10c143cc3e96552d41ab1", + "shasum": "" + }, + "require": { + "composer-plugin-api": "^1.0 || ^2.0", + "php": ">=5.3.0" + }, + "require-dev": { + "composer/composer": "~1.0 || ~2.0", + "phpunit/phpunit": "~4.6" + }, + "type": "composer-plugin", + "extra": { + "class": "cweagans\\Composer\\Patches" + }, + "autoload": { + "psr-4": { + "cweagans\\Composer\\": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Cameron Eagans", + "email": "me@cweagans.net" + } + ], + "description": "Provides a way to patch Composer packages.", + "support": { + "issues": "https://github.com/cweagans/composer-patches/issues", + "source": "https://github.com/cweagans/composer-patches/tree/1.x" + }, + "time": "2023-01-26T17:59:26+00:00" + }, + { + "name": "davechild/textstatistics", + "version": "dev-master", + "source": { + "type": "git", + "url": "https://github.com/DaveChild/Text-Statistics.git", + "reference": "b97e243243d18d2dd4c40484c8d2d4c29a8c317e" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/DaveChild/Text-Statistics/zipball/b97e243243d18d2dd4c40484c8d2d4c29a8c317e", + "reference": "b97e243243d18d2dd4c40484c8d2d4c29a8c317e", + "shasum": "" + }, + "require": { + "php": ">=7.2.0" + }, + "require-dev": { + "phpunit/phpunit": "^7" + }, + "suggest": { + "ext-bcmath": "More accurate floating point calculations.", + "ext-mbstring": "Handle multi-byte text properly." + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.0.x-dev" + } + }, + "autoload": { + "psr-0": { + "DaveChild\\TextStatistics": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-2-Clause" + ], + "authors": [ + { + "name": "Dave Child", + "email": "dave@addedbytes.com", + "homepage": "https://www.addedbytes.com/", + "role": "Developer" + } + ], + "description": "PHP package to measure the readability of text according to various algorithms.", + "homepage": "https://github.com/DaveChild/Text-Statistics", + "support": { + "issues": "https://github.com/DaveChild/Text-Statistics/issues", + "source": "https://github.com/DaveChild/Text-Statistics/tree/master" + }, + "time": "2022-09-30T18:57:24+00:00" + } + ], + "packages-dev": [], + "aliases": [], + "minimum-stability": "dev", + "stability-flags": {}, + "prefer-stable": false, + "prefer-lowest": false, + "platform": {}, + "platform-dev": {}, + "plugin-api-version": "2.6.0" +} diff --git a/patches.lock.json b/patches.lock.json new file mode 100644 index 0000000..6aaf065 --- /dev/null +++ b/patches.lock.json @@ -0,0 +1,4 @@ +{ + "_hash": "6142bfcb78f54dfbf5247ae5e463f25bdb8fff1890806e2e45aa81a59c211653", + "patches": [] +} diff --git a/vendor/autoload.php b/vendor/autoload.php new file mode 100644 index 0000000..4397016 --- /dev/null +++ b/vendor/autoload.php @@ -0,0 +1,25 @@ + + * Jordi Boggiano + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +namespace Composer\Autoload; + +/** + * ClassLoader implements a PSR-0, PSR-4 and classmap class loader. + * + * $loader = new \Composer\Autoload\ClassLoader(); + * + * // register classes with namespaces + * $loader->add('Symfony\Component', __DIR__.'/component'); + * $loader->add('Symfony', __DIR__.'/framework'); + * + * // activate the autoloader + * $loader->register(); + * + * // to enable searching the include path (eg. for PEAR packages) + * $loader->setUseIncludePath(true); + * + * In this example, if you try to use a class in the Symfony\Component + * namespace or one of its children (Symfony\Component\Console for instance), + * the autoloader will first look for the class under the component/ + * directory, and it will then fallback to the framework/ directory if not + * found before giving up. + * + * This class is loosely based on the Symfony UniversalClassLoader. + * + * @author Fabien Potencier + * @author Jordi Boggiano + * @see https://www.php-fig.org/psr/psr-0/ + * @see https://www.php-fig.org/psr/psr-4/ + */ +class ClassLoader +{ + /** @var \Closure(string):void */ + private static $includeFile; + + /** @var string|null */ + private $vendorDir; + + // PSR-4 + /** + * @var array> + */ + private $prefixLengthsPsr4 = array(); + /** + * @var array> + */ + private $prefixDirsPsr4 = array(); + /** + * @var list + */ + private $fallbackDirsPsr4 = array(); + + // PSR-0 + /** + * List of PSR-0 prefixes + * + * Structured as array('F (first letter)' => array('Foo\Bar (full prefix)' => array('path', 'path2'))) + * + * @var array>> + */ + private $prefixesPsr0 = array(); + /** + * @var list + */ + private $fallbackDirsPsr0 = array(); + + /** @var bool */ + private $useIncludePath = false; + + /** + * @var array + */ + private $classMap = array(); + + /** @var bool */ + private $classMapAuthoritative = false; + + /** + * @var array + */ + private $missingClasses = array(); + + /** @var string|null */ + private $apcuPrefix; + + /** + * @var array + */ + private static $registeredLoaders = array(); + + /** + * @param string|null $vendorDir + */ + public function __construct($vendorDir = null) + { + $this->vendorDir = $vendorDir; + self::initializeIncludeClosure(); + } + + /** + * @return array> + */ + public function getPrefixes() + { + if (!empty($this->prefixesPsr0)) { + return call_user_func_array('array_merge', array_values($this->prefixesPsr0)); + } + + return array(); + } + + /** + * @return array> + */ + public function getPrefixesPsr4() + { + return $this->prefixDirsPsr4; + } + + /** + * @return list + */ + public function getFallbackDirs() + { + return $this->fallbackDirsPsr0; + } + + /** + * @return list + */ + public function getFallbackDirsPsr4() + { + return $this->fallbackDirsPsr4; + } + + /** + * @return array Array of classname => path + */ + public function getClassMap() + { + return $this->classMap; + } + + /** + * @param array $classMap Class to filename map + * + * @return void + */ + public function addClassMap(array $classMap) + { + if ($this->classMap) { + $this->classMap = array_merge($this->classMap, $classMap); + } else { + $this->classMap = $classMap; + } + } + + /** + * Registers a set of PSR-0 directories for a given prefix, either + * appending or prepending to the ones previously set for this prefix. + * + * @param string $prefix The prefix + * @param list|string $paths The PSR-0 root directories + * @param bool $prepend Whether to prepend the directories + * + * @return void + */ + public function add($prefix, $paths, $prepend = false) + { + $paths = (array) $paths; + if (!$prefix) { + if ($prepend) { + $this->fallbackDirsPsr0 = array_merge( + $paths, + $this->fallbackDirsPsr0 + ); + } else { + $this->fallbackDirsPsr0 = array_merge( + $this->fallbackDirsPsr0, + $paths + ); + } + + return; + } + + $first = $prefix[0]; + if (!isset($this->prefixesPsr0[$first][$prefix])) { + $this->prefixesPsr0[$first][$prefix] = $paths; + + return; + } + if ($prepend) { + $this->prefixesPsr0[$first][$prefix] = array_merge( + $paths, + $this->prefixesPsr0[$first][$prefix] + ); + } else { + $this->prefixesPsr0[$first][$prefix] = array_merge( + $this->prefixesPsr0[$first][$prefix], + $paths + ); + } + } + + /** + * Registers a set of PSR-4 directories for a given namespace, either + * appending or prepending to the ones previously set for this namespace. + * + * @param string $prefix The prefix/namespace, with trailing '\\' + * @param list|string $paths The PSR-4 base directories + * @param bool $prepend Whether to prepend the directories + * + * @throws \InvalidArgumentException + * + * @return void + */ + public function addPsr4($prefix, $paths, $prepend = false) + { + $paths = (array) $paths; + if (!$prefix) { + // Register directories for the root namespace. + if ($prepend) { + $this->fallbackDirsPsr4 = array_merge( + $paths, + $this->fallbackDirsPsr4 + ); + } else { + $this->fallbackDirsPsr4 = array_merge( + $this->fallbackDirsPsr4, + $paths + ); + } + } elseif (!isset($this->prefixDirsPsr4[$prefix])) { + // Register directories for a new namespace. + $length = strlen($prefix); + if ('\\' !== $prefix[$length - 1]) { + throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator."); + } + $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length; + $this->prefixDirsPsr4[$prefix] = $paths; + } elseif ($prepend) { + // Prepend directories for an already registered namespace. + $this->prefixDirsPsr4[$prefix] = array_merge( + $paths, + $this->prefixDirsPsr4[$prefix] + ); + } else { + // Append directories for an already registered namespace. + $this->prefixDirsPsr4[$prefix] = array_merge( + $this->prefixDirsPsr4[$prefix], + $paths + ); + } + } + + /** + * Registers a set of PSR-0 directories for a given prefix, + * replacing any others previously set for this prefix. + * + * @param string $prefix The prefix + * @param list|string $paths The PSR-0 base directories + * + * @return void + */ + public function set($prefix, $paths) + { + if (!$prefix) { + $this->fallbackDirsPsr0 = (array) $paths; + } else { + $this->prefixesPsr0[$prefix[0]][$prefix] = (array) $paths; + } + } + + /** + * Registers a set of PSR-4 directories for a given namespace, + * replacing any others previously set for this namespace. + * + * @param string $prefix The prefix/namespace, with trailing '\\' + * @param list|string $paths The PSR-4 base directories + * + * @throws \InvalidArgumentException + * + * @return void + */ + public function setPsr4($prefix, $paths) + { + if (!$prefix) { + $this->fallbackDirsPsr4 = (array) $paths; + } else { + $length = strlen($prefix); + if ('\\' !== $prefix[$length - 1]) { + throw new \InvalidArgumentException("A non-empty PSR-4 prefix must end with a namespace separator."); + } + $this->prefixLengthsPsr4[$prefix[0]][$prefix] = $length; + $this->prefixDirsPsr4[$prefix] = (array) $paths; + } + } + + /** + * Turns on searching the include path for class files. + * + * @param bool $useIncludePath + * + * @return void + */ + public function setUseIncludePath($useIncludePath) + { + $this->useIncludePath = $useIncludePath; + } + + /** + * Can be used to check if the autoloader uses the include path to check + * for classes. + * + * @return bool + */ + public function getUseIncludePath() + { + return $this->useIncludePath; + } + + /** + * Turns off searching the prefix and fallback directories for classes + * that have not been registered with the class map. + * + * @param bool $classMapAuthoritative + * + * @return void + */ + public function setClassMapAuthoritative($classMapAuthoritative) + { + $this->classMapAuthoritative = $classMapAuthoritative; + } + + /** + * Should class lookup fail if not found in the current class map? + * + * @return bool + */ + public function isClassMapAuthoritative() + { + return $this->classMapAuthoritative; + } + + /** + * APCu prefix to use to cache found/not-found classes, if the extension is enabled. + * + * @param string|null $apcuPrefix + * + * @return void + */ + public function setApcuPrefix($apcuPrefix) + { + $this->apcuPrefix = function_exists('apcu_fetch') && filter_var(ini_get('apc.enabled'), FILTER_VALIDATE_BOOLEAN) ? $apcuPrefix : null; + } + + /** + * The APCu prefix in use, or null if APCu caching is not enabled. + * + * @return string|null + */ + public function getApcuPrefix() + { + return $this->apcuPrefix; + } + + /** + * Registers this instance as an autoloader. + * + * @param bool $prepend Whether to prepend the autoloader or not + * + * @return void + */ + public function register($prepend = false) + { + spl_autoload_register(array($this, 'loadClass'), true, $prepend); + + if (null === $this->vendorDir) { + return; + } + + if ($prepend) { + self::$registeredLoaders = array($this->vendorDir => $this) + self::$registeredLoaders; + } else { + unset(self::$registeredLoaders[$this->vendorDir]); + self::$registeredLoaders[$this->vendorDir] = $this; + } + } + + /** + * Unregisters this instance as an autoloader. + * + * @return void + */ + public function unregister() + { + spl_autoload_unregister(array($this, 'loadClass')); + + if (null !== $this->vendorDir) { + unset(self::$registeredLoaders[$this->vendorDir]); + } + } + + /** + * Loads the given class or interface. + * + * @param string $class The name of the class + * @return true|null True if loaded, null otherwise + */ + public function loadClass($class) + { + if ($file = $this->findFile($class)) { + $includeFile = self::$includeFile; + $includeFile($file); + + return true; + } + + return null; + } + + /** + * Finds the path to the file where the class is defined. + * + * @param string $class The name of the class + * + * @return string|false The path if found, false otherwise + */ + public function findFile($class) + { + // class map lookup + if (isset($this->classMap[$class])) { + return $this->classMap[$class]; + } + if ($this->classMapAuthoritative || isset($this->missingClasses[$class])) { + return false; + } + if (null !== $this->apcuPrefix) { + $file = apcu_fetch($this->apcuPrefix.$class, $hit); + if ($hit) { + return $file; + } + } + + $file = $this->findFileWithExtension($class, '.php'); + + // Search for Hack files if we are running on HHVM + if (false === $file && defined('HHVM_VERSION')) { + $file = $this->findFileWithExtension($class, '.hh'); + } + + if (null !== $this->apcuPrefix) { + apcu_add($this->apcuPrefix.$class, $file); + } + + if (false === $file) { + // Remember that this class does not exist. + $this->missingClasses[$class] = true; + } + + return $file; + } + + /** + * Returns the currently registered loaders keyed by their corresponding vendor directories. + * + * @return array + */ + public static function getRegisteredLoaders() + { + return self::$registeredLoaders; + } + + /** + * @param string $class + * @param string $ext + * @return string|false + */ + private function findFileWithExtension($class, $ext) + { + // PSR-4 lookup + $logicalPathPsr4 = strtr($class, '\\', DIRECTORY_SEPARATOR) . $ext; + + $first = $class[0]; + if (isset($this->prefixLengthsPsr4[$first])) { + $subPath = $class; + while (false !== $lastPos = strrpos($subPath, '\\')) { + $subPath = substr($subPath, 0, $lastPos); + $search = $subPath . '\\'; + if (isset($this->prefixDirsPsr4[$search])) { + $pathEnd = DIRECTORY_SEPARATOR . substr($logicalPathPsr4, $lastPos + 1); + foreach ($this->prefixDirsPsr4[$search] as $dir) { + if (file_exists($file = $dir . $pathEnd)) { + return $file; + } + } + } + } + } + + // PSR-4 fallback dirs + foreach ($this->fallbackDirsPsr4 as $dir) { + if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr4)) { + return $file; + } + } + + // PSR-0 lookup + if (false !== $pos = strrpos($class, '\\')) { + // namespaced class name + $logicalPathPsr0 = substr($logicalPathPsr4, 0, $pos + 1) + . strtr(substr($logicalPathPsr4, $pos + 1), '_', DIRECTORY_SEPARATOR); + } else { + // PEAR-like class name + $logicalPathPsr0 = strtr($class, '_', DIRECTORY_SEPARATOR) . $ext; + } + + if (isset($this->prefixesPsr0[$first])) { + foreach ($this->prefixesPsr0[$first] as $prefix => $dirs) { + if (0 === strpos($class, $prefix)) { + foreach ($dirs as $dir) { + if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) { + return $file; + } + } + } + } + } + + // PSR-0 fallback dirs + foreach ($this->fallbackDirsPsr0 as $dir) { + if (file_exists($file = $dir . DIRECTORY_SEPARATOR . $logicalPathPsr0)) { + return $file; + } + } + + // PSR-0 include paths. + if ($this->useIncludePath && $file = stream_resolve_include_path($logicalPathPsr0)) { + return $file; + } + + return false; + } + + /** + * @return void + */ + private static function initializeIncludeClosure() + { + if (self::$includeFile !== null) { + return; + } + + /** + * Scope isolated include. + * + * Prevents access to $this/self from included files. + * + * @param string $file + * @return void + */ + self::$includeFile = \Closure::bind(static function($file) { + include $file; + }, null, null); + } +} diff --git a/vendor/composer/InstalledVersions.php b/vendor/composer/InstalledVersions.php new file mode 100644 index 0000000..51e734a --- /dev/null +++ b/vendor/composer/InstalledVersions.php @@ -0,0 +1,359 @@ + + * Jordi Boggiano + * + * For the full copyright and license information, please view the LICENSE + * file that was distributed with this source code. + */ + +namespace Composer; + +use Composer\Autoload\ClassLoader; +use Composer\Semver\VersionParser; + +/** + * This class is copied in every Composer installed project and available to all + * + * See also https://getcomposer.org/doc/07-runtime.md#installed-versions + * + * To require its presence, you can require `composer-runtime-api ^2.0` + * + * @final + */ +class InstalledVersions +{ + /** + * @var mixed[]|null + * @psalm-var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array}|array{}|null + */ + private static $installed; + + /** + * @var bool|null + */ + private static $canGetVendors; + + /** + * @var array[] + * @psalm-var array}> + */ + private static $installedByVendor = array(); + + /** + * Returns a list of all package names which are present, either by being installed, replaced or provided + * + * @return string[] + * @psalm-return list + */ + public static function getInstalledPackages() + { + $packages = array(); + foreach (self::getInstalled() as $installed) { + $packages[] = array_keys($installed['versions']); + } + + if (1 === \count($packages)) { + return $packages[0]; + } + + return array_keys(array_flip(\call_user_func_array('array_merge', $packages))); + } + + /** + * Returns a list of all package names with a specific type e.g. 'library' + * + * @param string $type + * @return string[] + * @psalm-return list + */ + public static function getInstalledPackagesByType($type) + { + $packagesByType = array(); + + foreach (self::getInstalled() as $installed) { + foreach ($installed['versions'] as $name => $package) { + if (isset($package['type']) && $package['type'] === $type) { + $packagesByType[] = $name; + } + } + } + + return $packagesByType; + } + + /** + * Checks whether the given package is installed + * + * This also returns true if the package name is provided or replaced by another package + * + * @param string $packageName + * @param bool $includeDevRequirements + * @return bool + */ + public static function isInstalled($packageName, $includeDevRequirements = true) + { + foreach (self::getInstalled() as $installed) { + if (isset($installed['versions'][$packageName])) { + return $includeDevRequirements || !isset($installed['versions'][$packageName]['dev_requirement']) || $installed['versions'][$packageName]['dev_requirement'] === false; + } + } + + return false; + } + + /** + * Checks whether the given package satisfies a version constraint + * + * e.g. If you want to know whether version 2.3+ of package foo/bar is installed, you would call: + * + * Composer\InstalledVersions::satisfies(new VersionParser, 'foo/bar', '^2.3') + * + * @param VersionParser $parser Install composer/semver to have access to this class and functionality + * @param string $packageName + * @param string|null $constraint A version constraint to check for, if you pass one you have to make sure composer/semver is required by your package + * @return bool + */ + public static function satisfies(VersionParser $parser, $packageName, $constraint) + { + $constraint = $parser->parseConstraints((string) $constraint); + $provided = $parser->parseConstraints(self::getVersionRanges($packageName)); + + return $provided->matches($constraint); + } + + /** + * Returns a version constraint representing all the range(s) which are installed for a given package + * + * It is easier to use this via isInstalled() with the $constraint argument if you need to check + * whether a given version of a package is installed, and not just whether it exists + * + * @param string $packageName + * @return string Version constraint usable with composer/semver + */ + public static function getVersionRanges($packageName) + { + foreach (self::getInstalled() as $installed) { + if (!isset($installed['versions'][$packageName])) { + continue; + } + + $ranges = array(); + if (isset($installed['versions'][$packageName]['pretty_version'])) { + $ranges[] = $installed['versions'][$packageName]['pretty_version']; + } + if (array_key_exists('aliases', $installed['versions'][$packageName])) { + $ranges = array_merge($ranges, $installed['versions'][$packageName]['aliases']); + } + if (array_key_exists('replaced', $installed['versions'][$packageName])) { + $ranges = array_merge($ranges, $installed['versions'][$packageName]['replaced']); + } + if (array_key_exists('provided', $installed['versions'][$packageName])) { + $ranges = array_merge($ranges, $installed['versions'][$packageName]['provided']); + } + + return implode(' || ', $ranges); + } + + throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed'); + } + + /** + * @param string $packageName + * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present + */ + public static function getVersion($packageName) + { + foreach (self::getInstalled() as $installed) { + if (!isset($installed['versions'][$packageName])) { + continue; + } + + if (!isset($installed['versions'][$packageName]['version'])) { + return null; + } + + return $installed['versions'][$packageName]['version']; + } + + throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed'); + } + + /** + * @param string $packageName + * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as version, use satisfies or getVersionRanges if you need to know if a given version is present + */ + public static function getPrettyVersion($packageName) + { + foreach (self::getInstalled() as $installed) { + if (!isset($installed['versions'][$packageName])) { + continue; + } + + if (!isset($installed['versions'][$packageName]['pretty_version'])) { + return null; + } + + return $installed['versions'][$packageName]['pretty_version']; + } + + throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed'); + } + + /** + * @param string $packageName + * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as reference + */ + public static function getReference($packageName) + { + foreach (self::getInstalled() as $installed) { + if (!isset($installed['versions'][$packageName])) { + continue; + } + + if (!isset($installed['versions'][$packageName]['reference'])) { + return null; + } + + return $installed['versions'][$packageName]['reference']; + } + + throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed'); + } + + /** + * @param string $packageName + * @return string|null If the package is being replaced or provided but is not really installed, null will be returned as install path. Packages of type metapackages also have a null install path. + */ + public static function getInstallPath($packageName) + { + foreach (self::getInstalled() as $installed) { + if (!isset($installed['versions'][$packageName])) { + continue; + } + + return isset($installed['versions'][$packageName]['install_path']) ? $installed['versions'][$packageName]['install_path'] : null; + } + + throw new \OutOfBoundsException('Package "' . $packageName . '" is not installed'); + } + + /** + * @return array + * @psalm-return array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool} + */ + public static function getRootPackage() + { + $installed = self::getInstalled(); + + return $installed[0]['root']; + } + + /** + * Returns the raw installed.php data for custom implementations + * + * @deprecated Use getAllRawData() instead which returns all datasets for all autoloaders present in the process. getRawData only returns the first dataset loaded, which may not be what you expect. + * @return array[] + * @psalm-return array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array} + */ + public static function getRawData() + { + @trigger_error('getRawData only returns the first dataset loaded, which may not be what you expect. Use getAllRawData() instead which returns all datasets for all autoloaders present in the process.', E_USER_DEPRECATED); + + if (null === self::$installed) { + // only require the installed.php file if this file is loaded from its dumped location, + // and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937 + if (substr(__DIR__, -8, 1) !== 'C') { + self::$installed = include __DIR__ . '/installed.php'; + } else { + self::$installed = array(); + } + } + + return self::$installed; + } + + /** + * Returns the raw data of all installed.php which are currently loaded for custom implementations + * + * @return array[] + * @psalm-return list}> + */ + public static function getAllRawData() + { + return self::getInstalled(); + } + + /** + * Lets you reload the static array from another file + * + * This is only useful for complex integrations in which a project needs to use + * this class but then also needs to execute another project's autoloader in process, + * and wants to ensure both projects have access to their version of installed.php. + * + * A typical case would be PHPUnit, where it would need to make sure it reads all + * the data it needs from this class, then call reload() with + * `require $CWD/vendor/composer/installed.php` (or similar) as input to make sure + * the project in which it runs can then also use this class safely, without + * interference between PHPUnit's dependencies and the project's dependencies. + * + * @param array[] $data A vendor/composer/installed.php data set + * @return void + * + * @psalm-param array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array} $data + */ + public static function reload($data) + { + self::$installed = $data; + self::$installedByVendor = array(); + } + + /** + * @return array[] + * @psalm-return list}> + */ + private static function getInstalled() + { + if (null === self::$canGetVendors) { + self::$canGetVendors = method_exists('Composer\Autoload\ClassLoader', 'getRegisteredLoaders'); + } + + $installed = array(); + + if (self::$canGetVendors) { + foreach (ClassLoader::getRegisteredLoaders() as $vendorDir => $loader) { + if (isset(self::$installedByVendor[$vendorDir])) { + $installed[] = self::$installedByVendor[$vendorDir]; + } elseif (is_file($vendorDir.'/composer/installed.php')) { + /** @var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array} $required */ + $required = require $vendorDir.'/composer/installed.php'; + $installed[] = self::$installedByVendor[$vendorDir] = $required; + if (null === self::$installed && strtr($vendorDir.'/composer', '\\', '/') === strtr(__DIR__, '\\', '/')) { + self::$installed = $installed[count($installed) - 1]; + } + } + } + } + + if (null === self::$installed) { + // only require the installed.php file if this file is loaded from its dumped location, + // and not from its source location in the composer/composer package, see https://github.com/composer/composer/issues/9937 + if (substr(__DIR__, -8, 1) !== 'C') { + /** @var array{root: array{name: string, pretty_version: string, version: string, reference: string|null, type: string, install_path: string, aliases: string[], dev: bool}, versions: array} $required */ + $required = require __DIR__ . '/installed.php'; + self::$installed = $required; + } else { + self::$installed = array(); + } + } + + if (self::$installed !== array()) { + $installed[] = self::$installed; + } + + return $installed; + } +} diff --git a/vendor/composer/LICENSE b/vendor/composer/LICENSE new file mode 100644 index 0000000..f27399a --- /dev/null +++ b/vendor/composer/LICENSE @@ -0,0 +1,21 @@ + +Copyright (c) Nils Adermann, Jordi Boggiano + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is furnished +to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. + diff --git a/vendor/composer/autoload_classmap.php b/vendor/composer/autoload_classmap.php new file mode 100644 index 0000000..0fb0a2c --- /dev/null +++ b/vendor/composer/autoload_classmap.php @@ -0,0 +1,10 @@ + $vendorDir . '/composer/InstalledVersions.php', +); diff --git a/vendor/composer/autoload_namespaces.php b/vendor/composer/autoload_namespaces.php new file mode 100644 index 0000000..9b15d71 --- /dev/null +++ b/vendor/composer/autoload_namespaces.php @@ -0,0 +1,10 @@ + array($vendorDir . '/davechild/textstatistics/src'), +); diff --git a/vendor/composer/autoload_psr4.php b/vendor/composer/autoload_psr4.php new file mode 100644 index 0000000..a9043ee --- /dev/null +++ b/vendor/composer/autoload_psr4.php @@ -0,0 +1,10 @@ + array($vendorDir . '/cweagans/composer-patches/src'), +); diff --git a/vendor/composer/autoload_real.php b/vendor/composer/autoload_real.php new file mode 100644 index 0000000..75d28e6 --- /dev/null +++ b/vendor/composer/autoload_real.php @@ -0,0 +1,38 @@ +register(true); + + return $loader; + } +} diff --git a/vendor/composer/autoload_static.php b/vendor/composer/autoload_static.php new file mode 100644 index 0000000..ba161ee --- /dev/null +++ b/vendor/composer/autoload_static.php @@ -0,0 +1,47 @@ + + array ( + 'cweagans\\Composer\\' => 18, + ), + ); + + public static $prefixDirsPsr4 = array ( + 'cweagans\\Composer\\' => + array ( + 0 => __DIR__ . '/..' . '/cweagans/composer-patches/src', + ), + ); + + public static $prefixesPsr0 = array ( + 'D' => + array ( + 'DaveChild\\TextStatistics' => + array ( + 0 => __DIR__ . '/..' . '/davechild/textstatistics/src', + ), + ), + ); + + public static $classMap = array ( + 'Composer\\InstalledVersions' => __DIR__ . '/..' . '/composer/InstalledVersions.php', + ); + + public static function getInitializer(ClassLoader $loader) + { + return \Closure::bind(function () use ($loader) { + $loader->prefixLengthsPsr4 = ComposerStaticInitcb197d9b4656c8af26686970dae3ad8a::$prefixLengthsPsr4; + $loader->prefixDirsPsr4 = ComposerStaticInitcb197d9b4656c8af26686970dae3ad8a::$prefixDirsPsr4; + $loader->prefixesPsr0 = ComposerStaticInitcb197d9b4656c8af26686970dae3ad8a::$prefixesPsr0; + $loader->classMap = ComposerStaticInitcb197d9b4656c8af26686970dae3ad8a::$classMap; + + }, null, ClassLoader::class); + } +} diff --git a/vendor/composer/installed.json b/vendor/composer/installed.json new file mode 100644 index 0000000..ca57d56 --- /dev/null +++ b/vendor/composer/installed.json @@ -0,0 +1,119 @@ +{ + "packages": [ + { + "name": "cweagans/composer-patches", + "version": "1.x-dev", + "version_normalized": "1.9999999.9999999.9999999-dev", + "source": { + "type": "git", + "url": "https://github.com/cweagans/composer-patches.git", + "reference": "37e1b296d8100845c7b10c143cc3e96552d41ab1" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/cweagans/composer-patches/zipball/37e1b296d8100845c7b10c143cc3e96552d41ab1", + "reference": "37e1b296d8100845c7b10c143cc3e96552d41ab1", + "shasum": "" + }, + "require": { + "composer-plugin-api": "^1.0 || ^2.0", + "php": ">=5.3.0" + }, + "require-dev": { + "composer/composer": "~1.0 || ~2.0", + "phpunit/phpunit": "~4.6" + }, + "time": "2023-01-26T17:59:26+00:00", + "type": "composer-plugin", + "extra": { + "class": "cweagans\\Composer\\Patches" + }, + "installation-source": "dist", + "autoload": { + "psr-4": { + "cweagans\\Composer\\": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Cameron Eagans", + "email": "me@cweagans.net" + } + ], + "description": "Provides a way to patch Composer packages.", + "support": { + "issues": "https://github.com/cweagans/composer-patches/issues", + "source": "https://github.com/cweagans/composer-patches/tree/1.x" + }, + "install-path": "../cweagans/composer-patches" + }, + { + "name": "davechild/textstatistics", + "version": "dev-master", + "version_normalized": "dev-master", + "source": { + "type": "git", + "url": "https://github.com/DaveChild/Text-Statistics.git", + "reference": "b97e243243d18d2dd4c40484c8d2d4c29a8c317e" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/DaveChild/Text-Statistics/zipball/b97e243243d18d2dd4c40484c8d2d4c29a8c317e", + "reference": "b97e243243d18d2dd4c40484c8d2d4c29a8c317e", + "shasum": "" + }, + "require": { + "php": ">=7.2.0" + }, + "require-dev": { + "phpunit/phpunit": "^7" + }, + "suggest": { + "ext-bcmath": "More accurate floating point calculations.", + "ext-mbstring": "Handle multi-byte text properly." + }, + "time": "2022-09-30T18:57:24+00:00", + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.0.x-dev" + }, + "patches_applied": { + "3540852 - Deprecated function: Function utf8_decode() is deprecated": "https://patch-diff.githubusercontent.com/raw/DaveChild/Text-Statistics/pull/56.patch" + } + }, + "installation-source": "dist", + "autoload": { + "psr-0": { + "DaveChild\\TextStatistics": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-2-Clause" + ], + "authors": [ + { + "name": "Dave Child", + "email": "dave@addedbytes.com", + "homepage": "https://www.addedbytes.com/", + "role": "Developer" + } + ], + "description": "PHP package to measure the readability of text according to various algorithms.", + "homepage": "https://github.com/DaveChild/Text-Statistics", + "support": { + "issues": "https://github.com/DaveChild/Text-Statistics/issues", + "source": "https://github.com/DaveChild/Text-Statistics/tree/master" + }, + "install-path": "../davechild/textstatistics" + } + ], + "dev": true, + "dev-package-names": [] +} diff --git a/vendor/composer/installed.php b/vendor/composer/installed.php new file mode 100644 index 0000000..ce0049e --- /dev/null +++ b/vendor/composer/installed.php @@ -0,0 +1,43 @@ + array( + 'name' => 'drupal/content_readability', + 'pretty_version' => '3540852.x-dev', + 'version' => '3540852.9999999.9999999.9999999-dev', + 'reference' => '5f56430ee248a0d6433069a93a5b83994d6f14f4', + 'type' => 'drupal-module', + 'install_path' => __DIR__ . '/../../', + 'aliases' => array(), + 'dev' => true, + ), + 'versions' => array( + 'cweagans/composer-patches' => array( + 'pretty_version' => '1.x-dev', + 'version' => '1.9999999.9999999.9999999-dev', + 'reference' => '37e1b296d8100845c7b10c143cc3e96552d41ab1', + 'type' => 'composer-plugin', + 'install_path' => __DIR__ . '/../cweagans/composer-patches', + 'aliases' => array(), + 'dev_requirement' => false, + ), + 'davechild/textstatistics' => array( + 'pretty_version' => 'dev-master', + 'version' => 'dev-master', + 'reference' => 'b97e243243d18d2dd4c40484c8d2d4c29a8c317e', + 'type' => 'library', + 'install_path' => __DIR__ . '/../davechild/textstatistics', + 'aliases' => array( + 0 => '1.0.x-dev', + ), + 'dev_requirement' => false, + ), + 'drupal/content_readability' => array( + 'pretty_version' => '3540852.x-dev', + 'version' => '3540852.9999999.9999999.9999999-dev', + 'reference' => '5f56430ee248a0d6433069a93a5b83994d6f14f4', + 'type' => 'drupal-module', + 'install_path' => __DIR__ . '/../../', + 'aliases' => array(), + 'dev_requirement' => false, + ), + ), +); diff --git a/vendor/composer/platform_check.php b/vendor/composer/platform_check.php new file mode 100644 index 0000000..589e9e7 --- /dev/null +++ b/vendor/composer/platform_check.php @@ -0,0 +1,26 @@ += 70200)) { + $issues[] = 'Your Composer dependencies require a PHP version ">= 7.2.0". You are running ' . PHP_VERSION . '.'; +} + +if ($issues) { + if (!headers_sent()) { + header('HTTP/1.1 500 Internal Server Error'); + } + if (!ini_get('display_errors')) { + if (PHP_SAPI === 'cli' || PHP_SAPI === 'phpdbg') { + fwrite(STDERR, 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . implode(PHP_EOL, $issues) . PHP_EOL.PHP_EOL); + } elseif (!headers_sent()) { + echo 'Composer detected issues in your platform:' . PHP_EOL.PHP_EOL . str_replace('You are running '.PHP_VERSION.'.', '', implode(PHP_EOL, $issues)) . PHP_EOL.PHP_EOL; + } + } + trigger_error( + 'Composer detected issues in your platform: ' . implode(' ', $issues), + E_USER_ERROR + ); +} diff --git a/vendor/cweagans/composer-patches/.editorconfig b/vendor/cweagans/composer-patches/.editorconfig new file mode 100644 index 0000000..8e82594 --- /dev/null +++ b/vendor/cweagans/composer-patches/.editorconfig @@ -0,0 +1,11 @@ +# This is the top-most .editorconfig file; do not search in parent directories. +root = true + +# All files. +[*] +end_of_line = LF +indent_style = space +indent_size = 2 +charset = utf-8 +trim_trailing_whitespace = true +insert_final_newline = true diff --git a/vendor/cweagans/composer-patches/.gitignore b/vendor/cweagans/composer-patches/.gitignore new file mode 100644 index 0000000..48b8bf9 --- /dev/null +++ b/vendor/cweagans/composer-patches/.gitignore @@ -0,0 +1 @@ +vendor/ diff --git a/vendor/cweagans/composer-patches/LICENSE.md b/vendor/cweagans/composer-patches/LICENSE.md new file mode 100644 index 0000000..d0dad3d --- /dev/null +++ b/vendor/cweagans/composer-patches/LICENSE.md @@ -0,0 +1,9 @@ +Copyright 2013 Cameron Eagans + +Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. +2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. +3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/cweagans/composer-patches/README.md b/vendor/cweagans/composer-patches/README.md new file mode 100644 index 0000000..87f9dc0 --- /dev/null +++ b/vendor/cweagans/composer-patches/README.md @@ -0,0 +1,205 @@ +# composer-patches + +Simple patches plugin for Composer. Applies a patch from a local or remote file to any package required with composer. + +Note that the 1.x versions of Composer Patches are supported on a best-effort +basis due to the imminent release of 2.0.0. You may still be interested in +using 1.x if you need Composer to cooperate with earlier PHP versions. No new +features will be added to 1.x releases, but any security or bug fixes will +still be accepted. + +## Usage + +Example composer.json: + +```json +{ + "require": { + "cweagans/composer-patches": "~1.0", + "drupal/drupal": "~8.2" + }, + "config": { + "preferred-install": "source" + }, + "extra": { + "patches": { + "drupal/drupal": { + "Add startup configuration for PHP server": "https://www.drupal.org/files/issues/add_a_startup-1543858-30.patch" + } + } + } +} + +``` + +## Using an external patch file + +Instead of a patches key in your root composer.json, use a patches-file key. + +```json +{ + "require": { + "cweagans/composer-patches": "~1.0", + "drupal/drupal": "~8.2" + }, + "config": { + "preferred-install": "source" + }, + "extra": { + "patches-file": "local/path/to/your/composer.patches.json" + } +} + +``` + +Then your `composer.patches.json` should look like this: + +``` +{ + "patches": { + "vendor/project": { + "Patch title": "http://example.com/url/to/patch.patch" + } + } +} +``` + +## Allowing patches to be applied from dependencies + +If your project doesn't supply any patches of its own, but you still want to accept patches from dependencies, you must have the following in your composer file: + +```json +{ + "require": { + "cweagans/composer-patches": "^1.5.0" + }, + "extra": { + "enable-patching": true + } +} +``` + +If you do have a `patches` section in your composer file that defines your own set of patches then the `enable-patching` setting will be ignored and patches from dependencies will always be applied. + +## Ignoring patches + +There may be situations in which you want to ignore a patch supplied by a dependency. For example: + +- You use a different more recent version of a dependency, and now a patch isn't applying. +- You have a more up to date patch than the dependency, and want to use yours instead of theirs. +- A dependency's patch adds a feature to a project that you don't need. +- Your patches conflict with a dependency's patches. + +```json +{ + "require": { + "cweagans/composer-patches": "~1.0", + "drupal/drupal": "~8.2", + "drupal/lightning": "~8.1" + }, + "config": { + "preferred-install": "source" + }, + "extra": { + "patches": { + "drupal/drupal": { + "Add startup configuration for PHP server": "https://www.drupal.org/files/issues/add_a_startup-1543858-30.patch" + } + }, + "patches-ignore": { + "drupal/lightning": { + "drupal/panelizer": { + "This patch has known conflicts with our Quick Edit integration": "https://www.drupal.org/files/issues/2664682-49.patch" + } + } + } + } +} +``` + +## Allowing to force the patch level (-pX) + +Some situations require to force the patchLevel used to apply patches on a particular package. +Its useful for packages like drupal/core which packages only a subdir of the original upstream project on which patches are based. + +```json +{ + "extra": { + "patchLevel": { + "drupal/core": "-p2" + } + } +} +``` + +## Using patches from HTTP URLs + +Composer [blocks](https://getcomposer.org/doc/06-config.md#secure-http) you from downloading anything from HTTP URLs, you can disable this for your project by adding a `secure-http` setting in the config section of your `composer.json`. Note that the `config` section should be under the root of your `composer.json`. + +```json +{ + "config": { + "secure-http": false + } +} +``` + +However, it's always advised to setup HTTPS to prevent MITM code injection. + +## Patches containing modifications to composer.json files + +Because patching occurs _after_ Composer calculates dependencies and installs packages, changes to an underlying dependency's `composer.json` file introduced in a patch will have _no effect_ on installed packages. + +If you need to modify a dependency's `composer.json` or its underlying dependencies, you cannot use this plugin. Instead, you must do one of the following: +- Work to get the underlying issue resolved in the upstream package. +- Fork the package and [specify your fork as the package repository](https://getcomposer.org/doc/05-repositories.md#vcs) in your root `composer.json` +- Specify compatible package version requirements in your root `composer.json` + +## Error handling + +If a patch cannot be applied (hunk failed, different line endings, etc.) a message will be shown and the patch will be skipped. + +To enforce throwing an error and stopping package installation/update immediately, you have two available options: + +1. Add `"composer-exit-on-patch-failure": true` option to the `extra` section of your composer.json file. +1. Export `COMPOSER_EXIT_ON_PATCH_FAILURE=1` + +By default, failed patches are skipped. + +## Patches reporting + +When a patch is applied, the plugin writes a report-file `PATCHES.txt` to a patching directory (e.g. `./patch-me/PATCHES.txt`), +which contains a list of applied patches. + +If you want to avoid this behavior, add a specific key to the `extra` section: +```json +"extra": { + "composer-patches-skip-reporting": true +} +``` + +Or provide an environment variable `COMPOSER_PATCHES_SKIP_REPORTING` with a config. + +## Patching composer.json in dependencies + +This doesn't work like you'd want. By the time you're running `composer install`, +the metadata from your dependencies' composer.json has already been aggregated by +packagist (or whatever metadata repo you're using). Unfortunately, this means that +you cannot e.g. patch a dependency to be compatible with an earlier version of PHP +or change the framework version that a plugin depends on. + +@anotherjames over at @computerminds wrote an article about how to work around +that particular problem for a Drupal 8 -> Drupal 9 upgrade: + +[Apply Drupal 9 compatibility patches with Composer](https://www.computerminds.co.uk/articles/apply-drupal-9-compatibility-patches-composer) ([archive](https://web.archive.org/web/20210124171010/https://www.computerminds.co.uk/articles/apply-drupal-9-compatibility-patches-composer)) + +## Difference between this and netresearch/composer-patches-plugin + +- This plugin is much more simple to use and maintain +- This plugin doesn't require you to specify which package version you're patching +- This plugin is easy to use with Drupal modules (which don't use semantic versioning). +- This plugin will gather patches from all dependencies and apply them as if they were in the root composer.json + +## Credits + +A ton of this code is adapted or taken straight from https://github.com/jpstacey/composer-patcher, which is abandoned in favor of https://github.com/netresearch/composer-patches-plugin, which is (IMHO) overly complex and difficult to use. diff --git a/vendor/cweagans/composer-patches/composer.json b/vendor/cweagans/composer-patches/composer.json new file mode 100644 index 0000000..419c110 --- /dev/null +++ b/vendor/cweagans/composer-patches/composer.json @@ -0,0 +1,35 @@ +{ + "name": "cweagans/composer-patches", + "description": "Provides a way to patch Composer packages.", + "minimum-stability": "dev", + "license": "BSD-3-Clause", + "type": "composer-plugin", + "extra": { + "class": "cweagans\\Composer\\Patches" + }, + "authors": [ + { + "name": "Cameron Eagans", + "email": "me@cweagans.net" + } + ], + "require": { + "php": ">=5.3.0", + "composer-plugin-api": "^1.0 || ^2.0" + }, + "require-dev": { + "composer/composer": "~1.0 || ~2.0", + "phpunit/phpunit": "~4.6" + }, + "autoload": { + "psr-4": {"cweagans\\Composer\\": "src"} + }, + "autoload-dev": { + "psr-4": {"cweagans\\Composer\\Tests\\": "tests"} + }, + "config": { + "allow-plugins": { + "phpro/grumphp": true + } + } +} diff --git a/vendor/cweagans/composer-patches/composer.lock b/vendor/cweagans/composer-patches/composer.lock new file mode 100644 index 0000000..db5176c --- /dev/null +++ b/vendor/cweagans/composer-patches/composer.lock @@ -0,0 +1,3474 @@ +{ + "_readme": [ + "This file locks the dependencies of your project to a known state", + "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies", + "This file is @generated automatically" + ], + "content-hash": "4a5c841252204815536a37cad51d347b", + "packages": [], + "packages-dev": [ + { + "name": "composer/ca-bundle", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/composer/ca-bundle.git", + "reference": "74780ccf8c19d6acb8d65c5f39cd72110e132bbd" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/composer/ca-bundle/zipball/74780ccf8c19d6acb8d65c5f39cd72110e132bbd", + "reference": "74780ccf8c19d6acb8d65c5f39cd72110e132bbd", + "shasum": "" + }, + "require": { + "ext-openssl": "*", + "ext-pcre": "*", + "php": "^5.3.2 || ^7.0 || ^8.0" + }, + "require-dev": { + "phpstan/phpstan": "^0.12.55", + "psr/log": "^1.0", + "symfony/phpunit-bridge": "^4.2 || ^5", + "symfony/process": "^2.5 || ^3.0 || ^4.0 || ^5.0 || ^6.0" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "1.x-dev" + } + }, + "autoload": { + "psr-4": { + "Composer\\CaBundle\\": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Jordi Boggiano", + "email": "j.boggiano@seld.be", + "homepage": "http://seld.be" + } + ], + "description": "Lets you find a path to the system CA bundle, and includes a fallback to the Mozilla CA bundle.", + "keywords": [ + "cabundle", + "cacert", + "certificate", + "ssl", + "tls" + ], + "support": { + "irc": "irc://irc.freenode.org/composer", + "issues": "https://github.com/composer/ca-bundle/issues", + "source": "https://github.com/composer/ca-bundle/tree/1.3.5" + }, + "funding": [ + { + "url": "https://packagist.com", + "type": "custom" + }, + { + "url": "https://github.com/composer", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/composer/composer", + "type": "tidelift" + } + ], + "time": "2023-01-11T08:27:00+00:00" + }, + { + "name": "composer/class-map-generator", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/composer/class-map-generator.git", + "reference": "6b90e5568b534f21509d44e12d6eaf72cd098752" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/composer/class-map-generator/zipball/6b90e5568b534f21509d44e12d6eaf72cd098752", + "reference": "6b90e5568b534f21509d44e12d6eaf72cd098752", + "shasum": "" + }, + "require": { + "composer/pcre": "^2 || ^3", + "php": "^7.2 || ^8.0", + "symfony/finder": "^4.4 || ^5.3 || ^6" + }, + "require-dev": { + "phpstan/phpstan": "^1.6", + "phpstan/phpstan-deprecation-rules": "^1", + "phpstan/phpstan-phpunit": "^1", + "phpstan/phpstan-strict-rules": "^1.1", + "symfony/filesystem": "^5.4 || ^6", + "symfony/phpunit-bridge": "^5" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "1.x-dev" + } + }, + "autoload": { + "psr-4": { + "Composer\\ClassMapGenerator\\": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Jordi Boggiano", + "email": "j.boggiano@seld.be", + "homepage": "https://seld.be" + } + ], + "description": "Utilities to scan PHP code and generate class maps.", + "keywords": [ + "classmap" + ], + "support": { + "issues": "https://github.com/composer/class-map-generator/issues", + "source": "https://github.com/composer/class-map-generator/tree/main" + }, + "funding": [ + { + "url": "https://packagist.com", + "type": "custom" + }, + { + "url": "https://github.com/composer", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/composer/composer", + "type": "tidelift" + } + ], + "time": "2022-06-19T12:14:03+00:00" + }, + { + "name": "composer/composer", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/composer/composer.git", + "reference": "f6f972a69909d159326f3b6d81c645bca317bfeb" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/composer/composer/zipball/f6f972a69909d159326f3b6d81c645bca317bfeb", + "reference": "f6f972a69909d159326f3b6d81c645bca317bfeb", + "shasum": "" + }, + "require": { + "composer/ca-bundle": "^1.0", + "composer/class-map-generator": "^1.0", + "composer/metadata-minifier": "^1.0", + "composer/pcre": "^2.1 || ^3.1", + "composer/semver": "^3.0", + "composer/spdx-licenses": "^1.5.7", + "composer/xdebug-handler": "^2.0.2 || ^3.0.3", + "justinrainbow/json-schema": "^5.2.11", + "php": "^7.2.5 || ^8.0", + "psr/log": "^1.0 || ^2.0 || ^3.0", + "react/promise": "^2.8", + "seld/jsonlint": "^1.4", + "seld/phar-utils": "^1.2", + "seld/signal-handler": "^2.0", + "symfony/console": "^5.4.11 || ^6.0.11", + "symfony/filesystem": "^5.4 || ^6.0", + "symfony/finder": "^5.4 || ^6.0", + "symfony/polyfill-php73": "^1.24", + "symfony/polyfill-php80": "^1.24", + "symfony/polyfill-php81": "^1.24", + "symfony/process": "^5.4 || ^6.0" + }, + "require-dev": { + "phpstan/phpstan": "^1.9.3", + "phpstan/phpstan-deprecation-rules": "^1", + "phpstan/phpstan-phpunit": "^1.0", + "phpstan/phpstan-strict-rules": "^1", + "phpstan/phpstan-symfony": "^1.2.10", + "symfony/phpunit-bridge": "^6.0" + }, + "suggest": { + "ext-openssl": "Enabling the openssl extension allows you to access https URLs for repositories and packages", + "ext-zip": "Enabling the zip extension allows you to unzip archives", + "ext-zlib": "Allow gzip compression of HTTP requests" + }, + "default-branch": true, + "bin": [ + "bin/composer" + ], + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "2.5-dev" + }, + "phpstan": { + "includes": [ + "phpstan/rules.neon" + ] + } + }, + "autoload": { + "psr-4": { + "Composer\\": "src/Composer" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Nils Adermann", + "email": "naderman@naderman.de", + "homepage": "https://www.naderman.de" + }, + { + "name": "Jordi Boggiano", + "email": "j.boggiano@seld.be", + "homepage": "https://seld.be" + } + ], + "description": "Composer helps you declare, manage and install dependencies of PHP projects. It ensures you have the right stack everywhere.", + "homepage": "https://getcomposer.org/", + "keywords": [ + "autoload", + "dependency", + "package" + ], + "support": { + "irc": "ircs://irc.libera.chat:6697/composer", + "issues": "https://github.com/composer/composer/issues", + "source": "https://github.com/composer/composer/tree/main" + }, + "funding": [ + { + "url": "https://packagist.com", + "type": "custom" + }, + { + "url": "https://github.com/composer", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/composer/composer", + "type": "tidelift" + } + ], + "time": "2023-01-19T20:42:22+00:00" + }, + { + "name": "composer/metadata-minifier", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/composer/metadata-minifier.git", + "reference": "c549d23829536f0d0e984aaabbf02af91f443207" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/composer/metadata-minifier/zipball/c549d23829536f0d0e984aaabbf02af91f443207", + "reference": "c549d23829536f0d0e984aaabbf02af91f443207", + "shasum": "" + }, + "require": { + "php": "^5.3.2 || ^7.0 || ^8.0" + }, + "require-dev": { + "composer/composer": "^2", + "phpstan/phpstan": "^0.12.55", + "symfony/phpunit-bridge": "^4.2 || ^5" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "1.x-dev" + } + }, + "autoload": { + "psr-4": { + "Composer\\MetadataMinifier\\": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Jordi Boggiano", + "email": "j.boggiano@seld.be", + "homepage": "http://seld.be" + } + ], + "description": "Small utility library that handles metadata minification and expansion.", + "keywords": [ + "composer", + "compression" + ], + "support": { + "issues": "https://github.com/composer/metadata-minifier/issues", + "source": "https://github.com/composer/metadata-minifier/tree/1.0.0" + }, + "funding": [ + { + "url": "https://packagist.com", + "type": "custom" + }, + { + "url": "https://github.com/composer", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/composer/composer", + "type": "tidelift" + } + ], + "time": "2021-04-07T13:37:33+00:00" + }, + { + "name": "composer/pcre", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/composer/pcre.git", + "reference": "4bff79ddd77851fe3cdd11616ed3f92841ba5bd2" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/composer/pcre/zipball/4bff79ddd77851fe3cdd11616ed3f92841ba5bd2", + "reference": "4bff79ddd77851fe3cdd11616ed3f92841ba5bd2", + "shasum": "" + }, + "require": { + "php": "^7.4 || ^8.0" + }, + "require-dev": { + "phpstan/phpstan": "^1.3", + "phpstan/phpstan-strict-rules": "^1.1", + "symfony/phpunit-bridge": "^5" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "3.x-dev" + } + }, + "autoload": { + "psr-4": { + "Composer\\Pcre\\": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Jordi Boggiano", + "email": "j.boggiano@seld.be", + "homepage": "http://seld.be" + } + ], + "description": "PCRE wrapping library that offers type-safe preg_* replacements.", + "keywords": [ + "PCRE", + "preg", + "regex", + "regular expression" + ], + "support": { + "issues": "https://github.com/composer/pcre/issues", + "source": "https://github.com/composer/pcre/tree/3.1.0" + }, + "funding": [ + { + "url": "https://packagist.com", + "type": "custom" + }, + { + "url": "https://github.com/composer", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/composer/composer", + "type": "tidelift" + } + ], + "time": "2022-11-17T09:50:14+00:00" + }, + { + "name": "composer/semver", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/composer/semver.git", + "reference": "fa1ec24f0ab1efe642671ec15c51a3ab879f59bf" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/composer/semver/zipball/fa1ec24f0ab1efe642671ec15c51a3ab879f59bf", + "reference": "fa1ec24f0ab1efe642671ec15c51a3ab879f59bf", + "shasum": "" + }, + "require": { + "php": "^5.3.2 || ^7.0 || ^8.0" + }, + "require-dev": { + "phpstan/phpstan": "^1.4", + "symfony/phpunit-bridge": "^4.2 || ^5" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "3.x-dev" + } + }, + "autoload": { + "psr-4": { + "Composer\\Semver\\": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Nils Adermann", + "email": "naderman@naderman.de", + "homepage": "http://www.naderman.de" + }, + { + "name": "Jordi Boggiano", + "email": "j.boggiano@seld.be", + "homepage": "http://seld.be" + }, + { + "name": "Rob Bast", + "email": "rob.bast@gmail.com", + "homepage": "http://robbast.nl" + } + ], + "description": "Semver library that offers utilities, version constraint parsing and validation.", + "keywords": [ + "semantic", + "semver", + "validation", + "versioning" + ], + "support": { + "irc": "ircs://irc.libera.chat:6697/composer", + "issues": "https://github.com/composer/semver/issues", + "source": "https://github.com/composer/semver/tree/main" + }, + "funding": [ + { + "url": "https://packagist.com", + "type": "custom" + }, + { + "url": "https://github.com/composer", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/composer/composer", + "type": "tidelift" + } + ], + "time": "2023-01-13T15:47:53+00:00" + }, + { + "name": "composer/spdx-licenses", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/composer/spdx-licenses.git", + "reference": "5333493fc3b9f0b7dd3e81db1833b7c9b51519a0" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/composer/spdx-licenses/zipball/5333493fc3b9f0b7dd3e81db1833b7c9b51519a0", + "reference": "5333493fc3b9f0b7dd3e81db1833b7c9b51519a0", + "shasum": "" + }, + "require": { + "php": "^5.3.2 || ^7.0 || ^8.0" + }, + "require-dev": { + "phpstan/phpstan": "^0.12.55", + "symfony/phpunit-bridge": "^4.2 || ^5" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "1.x-dev" + } + }, + "autoload": { + "psr-4": { + "Composer\\Spdx\\": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Nils Adermann", + "email": "naderman@naderman.de", + "homepage": "http://www.naderman.de" + }, + { + "name": "Jordi Boggiano", + "email": "j.boggiano@seld.be", + "homepage": "http://seld.be" + }, + { + "name": "Rob Bast", + "email": "rob.bast@gmail.com", + "homepage": "http://robbast.nl" + } + ], + "description": "SPDX licenses list and validation library.", + "keywords": [ + "license", + "spdx", + "validator" + ], + "support": { + "irc": "ircs://irc.libera.chat:6697/composer", + "issues": "https://github.com/composer/spdx-licenses/issues", + "source": "https://github.com/composer/spdx-licenses/tree/main" + }, + "funding": [ + { + "url": "https://packagist.com", + "type": "custom" + }, + { + "url": "https://github.com/composer", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/composer/composer", + "type": "tidelift" + } + ], + "time": "2023-01-09T12:37:33+00:00" + }, + { + "name": "composer/xdebug-handler", + "version": "3.0.3", + "source": { + "type": "git", + "url": "https://github.com/composer/xdebug-handler.git", + "reference": "ced299686f41dce890debac69273b47ffe98a40c" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/composer/xdebug-handler/zipball/ced299686f41dce890debac69273b47ffe98a40c", + "reference": "ced299686f41dce890debac69273b47ffe98a40c", + "shasum": "" + }, + "require": { + "composer/pcre": "^1 || ^2 || ^3", + "php": "^7.2.5 || ^8.0", + "psr/log": "^1 || ^2 || ^3" + }, + "require-dev": { + "phpstan/phpstan": "^1.0", + "phpstan/phpstan-strict-rules": "^1.1", + "symfony/phpunit-bridge": "^6.0" + }, + "type": "library", + "autoload": { + "psr-4": { + "Composer\\XdebugHandler\\": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "John Stevenson", + "email": "john-stevenson@blueyonder.co.uk" + } + ], + "description": "Restarts a process without Xdebug.", + "keywords": [ + "Xdebug", + "performance" + ], + "support": { + "irc": "irc://irc.freenode.org/composer", + "issues": "https://github.com/composer/xdebug-handler/issues", + "source": "https://github.com/composer/xdebug-handler/tree/3.0.3" + }, + "funding": [ + { + "url": "https://packagist.com", + "type": "custom" + }, + { + "url": "https://github.com/composer", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/composer/composer", + "type": "tidelift" + } + ], + "time": "2022-02-25T21:32:43+00:00" + }, + { + "name": "doctrine/instantiator", + "version": "1.5.x-dev", + "source": { + "type": "git", + "url": "https://github.com/doctrine/instantiator.git", + "reference": "0a0fa9780f5d4e507415a065172d26a98d02047b" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/doctrine/instantiator/zipball/0a0fa9780f5d4e507415a065172d26a98d02047b", + "reference": "0a0fa9780f5d4e507415a065172d26a98d02047b", + "shasum": "" + }, + "require": { + "php": "^7.1 || ^8.0" + }, + "require-dev": { + "doctrine/coding-standard": "^9 || ^11", + "ext-pdo": "*", + "ext-phar": "*", + "phpbench/phpbench": "^0.16 || ^1", + "phpstan/phpstan": "^1.4", + "phpstan/phpstan-phpunit": "^1", + "phpunit/phpunit": "^7.5 || ^8.5 || ^9.5", + "vimeo/psalm": "^4.30 || ^5.4" + }, + "default-branch": true, + "type": "library", + "autoload": { + "psr-4": { + "Doctrine\\Instantiator\\": "src/Doctrine/Instantiator/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Marco Pivetta", + "email": "ocramius@gmail.com", + "homepage": "https://ocramius.github.io/" + } + ], + "description": "A small, lightweight utility to instantiate objects in PHP without invoking their constructors", + "homepage": "https://www.doctrine-project.org/projects/instantiator.html", + "keywords": [ + "constructor", + "instantiate" + ], + "support": { + "issues": "https://github.com/doctrine/instantiator/issues", + "source": "https://github.com/doctrine/instantiator/tree/1.5.0" + }, + "funding": [ + { + "url": "https://www.doctrine-project.org/sponsorship.html", + "type": "custom" + }, + { + "url": "https://www.patreon.com/phpdoctrine", + "type": "patreon" + }, + { + "url": "https://tidelift.com/funding/github/packagist/doctrine%2Finstantiator", + "type": "tidelift" + } + ], + "time": "2022-12-30T00:15:36+00:00" + }, + { + "name": "justinrainbow/json-schema", + "version": "5.x-dev", + "source": { + "type": "git", + "url": "https://github.com/justinrainbow/json-schema.git", + "reference": "ad87d5a5ca981228e0e205c2bc7dfb8e24559b60" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/justinrainbow/json-schema/zipball/ad87d5a5ca981228e0e205c2bc7dfb8e24559b60", + "reference": "ad87d5a5ca981228e0e205c2bc7dfb8e24559b60", + "shasum": "" + }, + "require": { + "php": ">=5.3.3" + }, + "require-dev": { + "friendsofphp/php-cs-fixer": "~2.2.20||~2.15.1", + "json-schema/json-schema-test-suite": "1.2.0", + "phpunit/phpunit": "^4.8.35" + }, + "bin": [ + "bin/validate-json" + ], + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "5.0.x-dev" + } + }, + "autoload": { + "psr-4": { + "JsonSchema\\": "src/JsonSchema/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Bruno Prieto Reis", + "email": "bruno.p.reis@gmail.com" + }, + { + "name": "Justin Rainbow", + "email": "justin.rainbow@gmail.com" + }, + { + "name": "Igor Wiedler", + "email": "igor@wiedler.ch" + }, + { + "name": "Robert Schönthal", + "email": "seroscho@googlemail.com" + } + ], + "description": "A library to validate a json schema.", + "homepage": "https://github.com/justinrainbow/json-schema", + "keywords": [ + "json", + "schema" + ], + "support": { + "issues": "https://github.com/justinrainbow/json-schema/issues", + "source": "https://github.com/justinrainbow/json-schema/tree/5.2.12" + }, + "time": "2022-04-13T08:02:27+00:00" + }, + { + "name": "phpdocumentor/reflection-common", + "version": "dev-master", + "source": { + "type": "git", + "url": "https://github.com/phpDocumentor/ReflectionCommon.git", + "reference": "a0eeab580cbdf4414fef6978732510a36ed0a9d6" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/phpDocumentor/ReflectionCommon/zipball/a0eeab580cbdf4414fef6978732510a36ed0a9d6", + "reference": "a0eeab580cbdf4414fef6978732510a36ed0a9d6", + "shasum": "" + }, + "require": { + "php": ">=7.1" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "2.x-dev" + } + }, + "autoload": { + "psr-4": { + "phpDocumentor\\Reflection\\": "src/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Jaap van Otterdijk", + "email": "opensource@ijaap.nl" + } + ], + "description": "Common reflection classes used by phpdocumentor to reflect the code structure", + "homepage": "http://www.phpdoc.org", + "keywords": [ + "FQSEN", + "phpDocumentor", + "phpdoc", + "reflection", + "static analysis" + ], + "support": { + "issues": "https://github.com/phpDocumentor/ReflectionCommon/issues", + "source": "https://github.com/phpDocumentor/ReflectionCommon/tree/master" + }, + "time": "2021-06-25T13:47:51+00:00" + }, + { + "name": "phpdocumentor/reflection-docblock", + "version": "dev-master", + "source": { + "type": "git", + "url": "https://github.com/phpDocumentor/ReflectionDocBlock.git", + "reference": "566af9fb94c556de91562fcfcbc392f66680111b" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/phpDocumentor/ReflectionDocBlock/zipball/566af9fb94c556de91562fcfcbc392f66680111b", + "reference": "566af9fb94c556de91562fcfcbc392f66680111b", + "shasum": "" + }, + "require": { + "ext-filter": "*", + "php": "^7.2 || ^8.0", + "phpdocumentor/reflection-common": "^2.2", + "phpdocumentor/type-resolver": "1.x-dev@dev", + "phpstan/phpdoc-parser": "^1.7", + "webmozart/assert": "^1.9.1" + }, + "require-dev": { + "mockery/mockery": "~1.3.5", + "phpstan/extension-installer": "^1.1", + "phpstan/phpstan": "^1.8", + "phpstan/phpstan-mockery": "^1.1", + "phpstan/phpstan-webmozart-assert": "^1.2", + "phpunit/phpunit": "^9.5", + "vimeo/psalm": "^4.26" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "5.x-dev" + } + }, + "autoload": { + "psr-4": { + "phpDocumentor\\Reflection\\": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Mike van Riel", + "email": "me@mikevanriel.com" + }, + { + "name": "Jaap van Otterdijk", + "email": "account@ijaap.nl" + } + ], + "description": "With this component, a library can provide support for annotations via DocBlocks or otherwise retrieve information that is embedded in a DocBlock.", + "support": { + "issues": "https://github.com/phpDocumentor/ReflectionDocBlock/issues", + "source": "https://github.com/phpDocumentor/ReflectionDocBlock/tree/master" + }, + "time": "2022-11-19T20:28:46+00:00" + }, + { + "name": "phpdocumentor/type-resolver", + "version": "1.x-dev", + "source": { + "type": "git", + "url": "https://github.com/phpDocumentor/TypeResolver.git", + "reference": "06f36c92b434ac686de06b6563e88046943bccbe" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/phpDocumentor/TypeResolver/zipball/06f36c92b434ac686de06b6563e88046943bccbe", + "reference": "06f36c92b434ac686de06b6563e88046943bccbe", + "shasum": "" + }, + "require": { + "php": "^7.4 || ^8.0", + "phpdocumentor/reflection-common": "^2.0", + "phpstan/phpdoc-parser": "^1.13" + }, + "require-dev": { + "ext-tokenizer": "*", + "phpbench/phpbench": "^1.2", + "phpstan/extension-installer": "^1.1", + "phpstan/phpstan": "^1.8", + "phpstan/phpstan-phpunit": "^1.1", + "phpunit/phpunit": "^9.5", + "rector/rector": "^0.13.9", + "vimeo/psalm": "^4.25" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-1.x": "1.x-dev" + } + }, + "autoload": { + "psr-4": { + "phpDocumentor\\Reflection\\": "src" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Mike van Riel", + "email": "me@mikevanriel.com" + } + ], + "description": "A PSR-5 based resolver of Class names, Types and Structural Element Names", + "support": { + "issues": "https://github.com/phpDocumentor/TypeResolver/issues", + "source": "https://github.com/phpDocumentor/TypeResolver/tree/1.x" + }, + "time": "2022-12-16T10:25:14+00:00" + }, + { + "name": "phpspec/prophecy", + "version": "v1.10.3", + "source": { + "type": "git", + "url": "https://github.com/phpspec/prophecy.git", + "reference": "451c3cd1418cf640de218914901e51b064abb093" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/phpspec/prophecy/zipball/451c3cd1418cf640de218914901e51b064abb093", + "reference": "451c3cd1418cf640de218914901e51b064abb093", + "shasum": "" + }, + "require": { + "doctrine/instantiator": "^1.0.2", + "php": "^5.3|^7.0", + "phpdocumentor/reflection-docblock": "^2.0|^3.0.2|^4.0|^5.0", + "sebastian/comparator": "^1.2.3|^2.0|^3.0|^4.0", + "sebastian/recursion-context": "^1.0|^2.0|^3.0|^4.0" + }, + "require-dev": { + "phpspec/phpspec": "^2.5 || ^3.2", + "phpunit/phpunit": "^4.8.35 || ^5.7 || ^6.5 || ^7.1" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.10.x-dev" + } + }, + "autoload": { + "psr-4": { + "Prophecy\\": "src/Prophecy" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Konstantin Kudryashov", + "email": "ever.zet@gmail.com", + "homepage": "http://everzet.com" + }, + { + "name": "Marcello Duarte", + "email": "marcello.duarte@gmail.com" + } + ], + "description": "Highly opinionated mocking framework for PHP 5.3+", + "homepage": "https://github.com/phpspec/prophecy", + "keywords": [ + "Double", + "Dummy", + "fake", + "mock", + "spy", + "stub" + ], + "support": { + "issues": "https://github.com/phpspec/prophecy/issues", + "source": "https://github.com/phpspec/prophecy/tree/v1.10.3" + }, + "time": "2020-03-05T15:02:03+00:00" + }, + { + "name": "phpstan/phpdoc-parser", + "version": "1.15.3", + "source": { + "type": "git", + "url": "https://github.com/phpstan/phpdoc-parser.git", + "reference": "61800f71a5526081d1b5633766aa88341f1ade76" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/phpstan/phpdoc-parser/zipball/61800f71a5526081d1b5633766aa88341f1ade76", + "reference": "61800f71a5526081d1b5633766aa88341f1ade76", + "shasum": "" + }, + "require": { + "php": "^7.2 || ^8.0" + }, + "require-dev": { + "php-parallel-lint/php-parallel-lint": "^1.2", + "phpstan/extension-installer": "^1.0", + "phpstan/phpstan": "^1.5", + "phpstan/phpstan-phpunit": "^1.1", + "phpstan/phpstan-strict-rules": "^1.0", + "phpunit/phpunit": "^9.5", + "symfony/process": "^5.2" + }, + "type": "library", + "autoload": { + "psr-4": { + "PHPStan\\PhpDocParser\\": [ + "src/" + ] + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "description": "PHPDoc parser with support for nullable, intersection and generic types", + "support": { + "issues": "https://github.com/phpstan/phpdoc-parser/issues", + "source": "https://github.com/phpstan/phpdoc-parser/tree/1.15.3" + }, + "time": "2022-12-20T20:56:55+00:00" + }, + { + "name": "phpunit/php-code-coverage", + "version": "2.2.4", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/php-code-coverage.git", + "reference": "eabf68b476ac7d0f73793aada060f1c1a9bf8979" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/eabf68b476ac7d0f73793aada060f1c1a9bf8979", + "reference": "eabf68b476ac7d0f73793aada060f1c1a9bf8979", + "shasum": "" + }, + "require": { + "php": ">=5.3.3", + "phpunit/php-file-iterator": "~1.3", + "phpunit/php-text-template": "~1.2", + "phpunit/php-token-stream": "~1.3", + "sebastian/environment": "^1.3.2", + "sebastian/version": "~1.0" + }, + "require-dev": { + "ext-xdebug": ">=2.1.4", + "phpunit/phpunit": "~4" + }, + "suggest": { + "ext-dom": "*", + "ext-xdebug": ">=2.2.1", + "ext-xmlwriter": "*" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "2.2.x-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sb@sebastian-bergmann.de", + "role": "lead" + } + ], + "description": "Library that provides collection, processing, and rendering functionality for PHP code coverage information.", + "homepage": "https://github.com/sebastianbergmann/php-code-coverage", + "keywords": [ + "coverage", + "testing", + "xunit" + ], + "support": { + "irc": "irc://irc.freenode.net/phpunit", + "issues": "https://github.com/sebastianbergmann/php-code-coverage/issues", + "source": "https://github.com/sebastianbergmann/php-code-coverage/tree/2.2" + }, + "time": "2015-10-06T15:47:00+00:00" + }, + { + "name": "phpunit/php-file-iterator", + "version": "1.4.x-dev", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/php-file-iterator.git", + "reference": "730b01bc3e867237eaac355e06a36b85dd93a8b4" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/730b01bc3e867237eaac355e06a36b85dd93a8b4", + "reference": "730b01bc3e867237eaac355e06a36b85dd93a8b4", + "shasum": "" + }, + "require": { + "php": ">=5.3.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.4.x-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sb@sebastian-bergmann.de", + "role": "lead" + } + ], + "description": "FilterIterator implementation that filters files based on a list of suffixes.", + "homepage": "https://github.com/sebastianbergmann/php-file-iterator/", + "keywords": [ + "filesystem", + "iterator" + ], + "support": { + "irc": "irc://irc.freenode.net/phpunit", + "issues": "https://github.com/sebastianbergmann/php-file-iterator/issues", + "source": "https://github.com/sebastianbergmann/php-file-iterator/tree/1.4.5" + }, + "time": "2017-11-27T13:52:08+00:00" + }, + { + "name": "phpunit/php-text-template", + "version": "1.2.1", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/php-text-template.git", + "reference": "31f8b717e51d9a2afca6c9f046f5d69fc27c8686" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/31f8b717e51d9a2afca6c9f046f5d69fc27c8686", + "reference": "31f8b717e51d9a2afca6c9f046f5d69fc27c8686", + "shasum": "" + }, + "require": { + "php": ">=5.3.3" + }, + "type": "library", + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "Simple template engine.", + "homepage": "https://github.com/sebastianbergmann/php-text-template/", + "keywords": [ + "template" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/php-text-template/issues", + "source": "https://github.com/sebastianbergmann/php-text-template/tree/1.2.1" + }, + "time": "2015-06-21T13:50:34+00:00" + }, + { + "name": "phpunit/php-timer", + "version": "1.0.x-dev", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/php-timer.git", + "reference": "9513098641797ce5f459dbc1de5a54c29b0ec1fb" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/9513098641797ce5f459dbc1de5a54c29b0ec1fb", + "reference": "9513098641797ce5f459dbc1de5a54c29b0ec1fb", + "shasum": "" + }, + "require": { + "php": "^5.3.3 || ^7.0" + }, + "require-dev": { + "phpunit/phpunit": "^4.8.35 || ^5.7 || ^6.0" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sb@sebastian-bergmann.de", + "role": "lead" + } + ], + "description": "Utility class for timing", + "homepage": "https://github.com/sebastianbergmann/php-timer/", + "keywords": [ + "timer" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/php-timer/issues", + "source": "https://github.com/sebastianbergmann/php-timer/tree/1.0" + }, + "time": "2018-01-06T05:27:16+00:00" + }, + { + "name": "phpunit/php-token-stream", + "version": "1.4.12", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/php-token-stream.git", + "reference": "1ce90ba27c42e4e44e6d8458241466380b51fa16" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/php-token-stream/zipball/1ce90ba27c42e4e44e6d8458241466380b51fa16", + "reference": "1ce90ba27c42e4e44e6d8458241466380b51fa16", + "shasum": "" + }, + "require": { + "ext-tokenizer": "*", + "php": ">=5.3.3" + }, + "require-dev": { + "phpunit/phpunit": "~4.2" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.4-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + } + ], + "description": "Wrapper around PHP's tokenizer extension.", + "homepage": "https://github.com/sebastianbergmann/php-token-stream/", + "keywords": [ + "tokenizer" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/php-token-stream/issues", + "source": "https://github.com/sebastianbergmann/php-token-stream/tree/1.4" + }, + "abandoned": true, + "time": "2017-12-04T08:55:13+00:00" + }, + { + "name": "phpunit/phpunit", + "version": "4.8.36", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/phpunit.git", + "reference": "46023de9a91eec7dfb06cc56cb4e260017298517" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/46023de9a91eec7dfb06cc56cb4e260017298517", + "reference": "46023de9a91eec7dfb06cc56cb4e260017298517", + "shasum": "" + }, + "require": { + "ext-dom": "*", + "ext-json": "*", + "ext-pcre": "*", + "ext-reflection": "*", + "ext-spl": "*", + "php": ">=5.3.3", + "phpspec/prophecy": "^1.3.1", + "phpunit/php-code-coverage": "~2.1", + "phpunit/php-file-iterator": "~1.4", + "phpunit/php-text-template": "~1.2", + "phpunit/php-timer": "^1.0.6", + "phpunit/phpunit-mock-objects": "~2.3", + "sebastian/comparator": "~1.2.2", + "sebastian/diff": "~1.2", + "sebastian/environment": "~1.3", + "sebastian/exporter": "~1.2", + "sebastian/global-state": "~1.0", + "sebastian/version": "~1.0", + "symfony/yaml": "~2.1|~3.0" + }, + "suggest": { + "phpunit/php-invoker": "~1.1" + }, + "bin": [ + "phpunit" + ], + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "4.8.x-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "The PHP Unit Testing framework.", + "homepage": "https://phpunit.de/", + "keywords": [ + "phpunit", + "testing", + "xunit" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/phpunit/issues", + "source": "https://github.com/sebastianbergmann/phpunit/tree/4.8.36" + }, + "time": "2017-06-21T08:07:12+00:00" + }, + { + "name": "phpunit/phpunit-mock-objects", + "version": "2.3.x-dev", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/phpunit-mock-objects.git", + "reference": "ac8e7a3db35738d56ee9a76e78a4e03d97628983" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/phpunit-mock-objects/zipball/ac8e7a3db35738d56ee9a76e78a4e03d97628983", + "reference": "ac8e7a3db35738d56ee9a76e78a4e03d97628983", + "shasum": "" + }, + "require": { + "doctrine/instantiator": "^1.0.2", + "php": ">=5.3.3", + "phpunit/php-text-template": "~1.2", + "sebastian/exporter": "~1.2" + }, + "require-dev": { + "phpunit/phpunit": "~4.4" + }, + "suggest": { + "ext-soap": "*" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "2.3.x-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sb@sebastian-bergmann.de", + "role": "lead" + } + ], + "description": "Mock Object library for PHPUnit", + "homepage": "https://github.com/sebastianbergmann/phpunit-mock-objects/", + "keywords": [ + "mock", + "xunit" + ], + "support": { + "irc": "irc://irc.freenode.net/phpunit", + "issues": "https://github.com/sebastianbergmann/phpunit-mock-objects/issues", + "source": "https://github.com/sebastianbergmann/phpunit-mock-objects/tree/2.3" + }, + "abandoned": true, + "time": "2015-10-02T06:51:40+00:00" + }, + { + "name": "psr/container", + "version": "1.x-dev", + "source": { + "type": "git", + "url": "https://github.com/php-fig/container.git", + "reference": "513e0666f7216c7459170d56df27dfcefe1689ea" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/php-fig/container/zipball/513e0666f7216c7459170d56df27dfcefe1689ea", + "reference": "513e0666f7216c7459170d56df27dfcefe1689ea", + "shasum": "" + }, + "require": { + "php": ">=7.4.0" + }, + "type": "library", + "autoload": { + "psr-4": { + "Psr\\Container\\": "src/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "PHP-FIG", + "homepage": "https://www.php-fig.org/" + } + ], + "description": "Common Container Interface (PHP FIG PSR-11)", + "homepage": "https://github.com/php-fig/container", + "keywords": [ + "PSR-11", + "container", + "container-interface", + "container-interop", + "psr" + ], + "support": { + "issues": "https://github.com/php-fig/container/issues", + "source": "https://github.com/php-fig/container/tree/1.1.2" + }, + "time": "2021-11-05T16:50:12+00:00" + }, + { + "name": "psr/log", + "version": "1.1.4", + "source": { + "type": "git", + "url": "https://github.com/php-fig/log.git", + "reference": "d49695b909c3b7628b6289db5479a1c204601f11" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/php-fig/log/zipball/d49695b909c3b7628b6289db5479a1c204601f11", + "reference": "d49695b909c3b7628b6289db5479a1c204601f11", + "shasum": "" + }, + "require": { + "php": ">=5.3.0" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.1.x-dev" + } + }, + "autoload": { + "psr-4": { + "Psr\\Log\\": "Psr/Log/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "PHP-FIG", + "homepage": "https://www.php-fig.org/" + } + ], + "description": "Common interface for logging libraries", + "homepage": "https://github.com/php-fig/log", + "keywords": [ + "log", + "psr", + "psr-3" + ], + "support": { + "source": "https://github.com/php-fig/log/tree/1.1.4" + }, + "time": "2021-05-03T11:20:27+00:00" + }, + { + "name": "react/promise", + "version": "2.x-dev", + "source": { + "type": "git", + "url": "https://github.com/reactphp/promise.git", + "reference": "d47bd60659fa7ce58f4a7ec3ea959c05326ef7fa" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/reactphp/promise/zipball/d47bd60659fa7ce58f4a7ec3ea959c05326ef7fa", + "reference": "d47bd60659fa7ce58f4a7ec3ea959c05326ef7fa", + "shasum": "" + }, + "require": { + "php": ">=5.4.0" + }, + "require-dev": { + "phpunit/phpunit": "^9.5 || ^5.7 || ^4.8.36" + }, + "type": "library", + "autoload": { + "files": [ + "src/functions_include.php" + ], + "psr-4": { + "React\\Promise\\": "src/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Jan Sorgalla", + "email": "jsorgalla@gmail.com", + "homepage": "https://sorgalla.com/" + }, + { + "name": "Christian Lück", + "email": "christian@clue.engineering", + "homepage": "https://clue.engineering/" + }, + { + "name": "Cees-Jan Kiewiet", + "email": "reactphp@ceesjankiewiet.nl", + "homepage": "https://wyrihaximus.net/" + }, + { + "name": "Chris Boden", + "email": "cboden@gmail.com", + "homepage": "https://cboden.dev/" + } + ], + "description": "A lightweight implementation of CommonJS Promises/A for PHP", + "keywords": [ + "promise", + "promises" + ], + "support": { + "issues": "https://github.com/reactphp/promise/issues", + "source": "https://github.com/reactphp/promise/tree/2.x" + }, + "funding": [ + { + "url": "https://github.com/WyriHaximus", + "type": "github" + }, + { + "url": "https://github.com/clue", + "type": "github" + } + ], + "time": "2022-10-31T09:13:55+00:00" + }, + { + "name": "sebastian/comparator", + "version": "1.2.x-dev", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/comparator.git", + "reference": "18a5d97c25f408f48acaf6d1b9f4079314c5996a" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/18a5d97c25f408f48acaf6d1b9f4079314c5996a", + "reference": "18a5d97c25f408f48acaf6d1b9f4079314c5996a", + "shasum": "" + }, + "require": { + "php": ">=5.3.3", + "sebastian/diff": "~1.2", + "sebastian/exporter": "~1.2 || ~2.0" + }, + "require-dev": { + "phpunit/phpunit": "~4.4" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.2.x-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Jeff Welch", + "email": "whatthejeff@gmail.com" + }, + { + "name": "Volker Dusch", + "email": "github@wallbash.com" + }, + { + "name": "Bernhard Schussek", + "email": "bschussek@2bepublished.at" + }, + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + } + ], + "description": "Provides the functionality to compare PHP values for equality", + "homepage": "http://www.github.com/sebastianbergmann/comparator", + "keywords": [ + "comparator", + "compare", + "equality" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/comparator/issues", + "source": "https://github.com/sebastianbergmann/comparator/tree/1.2" + }, + "time": "2017-03-07T10:34:43+00:00" + }, + { + "name": "sebastian/diff", + "version": "1.4.x-dev", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/diff.git", + "reference": "7f066a26a962dbe58ddea9f72a4e82874a3975a4" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/7f066a26a962dbe58ddea9f72a4e82874a3975a4", + "reference": "7f066a26a962dbe58ddea9f72a4e82874a3975a4", + "shasum": "" + }, + "require": { + "php": "^5.3.3 || ^7.0" + }, + "require-dev": { + "phpunit/phpunit": "^4.8.35 || ^5.7 || ^6.0" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.4-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Kore Nordmann", + "email": "mail@kore-nordmann.de" + }, + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + } + ], + "description": "Diff implementation", + "homepage": "https://github.com/sebastianbergmann/diff", + "keywords": [ + "diff" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/diff/issues", + "source": "https://github.com/sebastianbergmann/diff/tree/1.4" + }, + "time": "2017-05-22T07:24:03+00:00" + }, + { + "name": "sebastian/environment", + "version": "1.3.8", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/environment.git", + "reference": "be2c607e43ce4c89ecd60e75c6a85c126e754aea" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/be2c607e43ce4c89ecd60e75c6a85c126e754aea", + "reference": "be2c607e43ce4c89ecd60e75c6a85c126e754aea", + "shasum": "" + }, + "require": { + "php": "^5.3.3 || ^7.0" + }, + "require-dev": { + "phpunit/phpunit": "^4.8 || ^5.0" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.3.x-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + } + ], + "description": "Provides functionality to handle HHVM/PHP environments", + "homepage": "http://www.github.com/sebastianbergmann/environment", + "keywords": [ + "Xdebug", + "environment", + "hhvm" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/environment/issues", + "source": "https://github.com/sebastianbergmann/environment/tree/1.3" + }, + "time": "2016-08-18T05:49:44+00:00" + }, + { + "name": "sebastian/exporter", + "version": "1.2.2", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/exporter.git", + "reference": "42c4c2eec485ee3e159ec9884f95b431287edde4" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/exporter/zipball/42c4c2eec485ee3e159ec9884f95b431287edde4", + "reference": "42c4c2eec485ee3e159ec9884f95b431287edde4", + "shasum": "" + }, + "require": { + "php": ">=5.3.3", + "sebastian/recursion-context": "~1.0" + }, + "require-dev": { + "ext-mbstring": "*", + "phpunit/phpunit": "~4.4" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.3.x-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Jeff Welch", + "email": "whatthejeff@gmail.com" + }, + { + "name": "Volker Dusch", + "email": "github@wallbash.com" + }, + { + "name": "Bernhard Schussek", + "email": "bschussek@2bepublished.at" + }, + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + }, + { + "name": "Adam Harvey", + "email": "aharvey@php.net" + } + ], + "description": "Provides the functionality to export PHP variables for visualization", + "homepage": "http://www.github.com/sebastianbergmann/exporter", + "keywords": [ + "export", + "exporter" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/exporter/issues", + "source": "https://github.com/sebastianbergmann/exporter/tree/master" + }, + "time": "2016-06-17T09:04:28+00:00" + }, + { + "name": "sebastian/global-state", + "version": "1.1.x-dev", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/global-state.git", + "reference": "cea85a84b00f2795341ebbbca4fa396347f2494e" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/cea85a84b00f2795341ebbbca4fa396347f2494e", + "reference": "cea85a84b00f2795341ebbbca4fa396347f2494e", + "shasum": "" + }, + "require": { + "php": ">=5.3.3" + }, + "require-dev": { + "phpunit/phpunit": "~4.2|~5.0" + }, + "suggest": { + "ext-uopz": "*" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + } + ], + "description": "Snapshotting of global state", + "homepage": "http://www.github.com/sebastianbergmann/global-state", + "keywords": [ + "global state" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/global-state/issues", + "source": "https://github.com/sebastianbergmann/global-state/tree/1.1" + }, + "time": "2017-02-23T14:11:06+00:00" + }, + { + "name": "sebastian/recursion-context", + "version": "1.0.x-dev", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/recursion-context.git", + "reference": "b19cc3298482a335a95f3016d2f8a6950f0fbcd7" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/b19cc3298482a335a95f3016d2f8a6950f0fbcd7", + "reference": "b19cc3298482a335a95f3016d2f8a6950f0fbcd7", + "shasum": "" + }, + "require": { + "php": ">=5.3.3" + }, + "require-dev": { + "phpunit/phpunit": "~4.4" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.0.x-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Jeff Welch", + "email": "whatthejeff@gmail.com" + }, + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + }, + { + "name": "Adam Harvey", + "email": "aharvey@php.net" + } + ], + "description": "Provides functionality to recursively process PHP variables", + "homepage": "http://www.github.com/sebastianbergmann/recursion-context", + "support": { + "issues": "https://github.com/sebastianbergmann/recursion-context/issues", + "source": "https://github.com/sebastianbergmann/recursion-context/tree/master" + }, + "time": "2016-10-03T07:41:43+00:00" + }, + { + "name": "sebastian/version", + "version": "1.0.6", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/version.git", + "reference": "58b3a85e7999757d6ad81c787a1fbf5ff6c628c6" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/version/zipball/58b3a85e7999757d6ad81c787a1fbf5ff6c628c6", + "reference": "58b3a85e7999757d6ad81c787a1fbf5ff6c628c6", + "shasum": "" + }, + "type": "library", + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "Library that helps with managing the version number of Git-hosted PHP projects", + "homepage": "https://github.com/sebastianbergmann/version", + "support": { + "issues": "https://github.com/sebastianbergmann/version/issues", + "source": "https://github.com/sebastianbergmann/version/tree/1.0.6" + }, + "time": "2015-06-21T13:59:46+00:00" + }, + { + "name": "seld/jsonlint", + "version": "1.9.0", + "source": { + "type": "git", + "url": "https://github.com/Seldaek/jsonlint.git", + "reference": "4211420d25eba80712bff236a98960ef68b866b7" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/Seldaek/jsonlint/zipball/4211420d25eba80712bff236a98960ef68b866b7", + "reference": "4211420d25eba80712bff236a98960ef68b866b7", + "shasum": "" + }, + "require": { + "php": "^5.3 || ^7.0 || ^8.0" + }, + "require-dev": { + "phpstan/phpstan": "^1.5", + "phpunit/phpunit": "^4.8.35 || ^5.7 || ^6.0 || ^8.5.13" + }, + "bin": [ + "bin/jsonlint" + ], + "type": "library", + "autoload": { + "psr-4": { + "Seld\\JsonLint\\": "src/Seld/JsonLint/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Jordi Boggiano", + "email": "j.boggiano@seld.be", + "homepage": "http://seld.be" + } + ], + "description": "JSON Linter", + "keywords": [ + "json", + "linter", + "parser", + "validator" + ], + "support": { + "issues": "https://github.com/Seldaek/jsonlint/issues", + "source": "https://github.com/Seldaek/jsonlint/tree/1.9.0" + }, + "funding": [ + { + "url": "https://github.com/Seldaek", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/seld/jsonlint", + "type": "tidelift" + } + ], + "time": "2022-04-01T13:37:23+00:00" + }, + { + "name": "seld/phar-utils", + "version": "1.2.1", + "source": { + "type": "git", + "url": "https://github.com/Seldaek/phar-utils.git", + "reference": "ea2f4014f163c1be4c601b9b7bd6af81ba8d701c" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/Seldaek/phar-utils/zipball/ea2f4014f163c1be4c601b9b7bd6af81ba8d701c", + "reference": "ea2f4014f163c1be4c601b9b7bd6af81ba8d701c", + "shasum": "" + }, + "require": { + "php": ">=5.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.x-dev" + } + }, + "autoload": { + "psr-4": { + "Seld\\PharUtils\\": "src/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Jordi Boggiano", + "email": "j.boggiano@seld.be" + } + ], + "description": "PHAR file format utilities, for when PHP phars you up", + "keywords": [ + "phar" + ], + "support": { + "issues": "https://github.com/Seldaek/phar-utils/issues", + "source": "https://github.com/Seldaek/phar-utils/tree/1.2.1" + }, + "time": "2022-08-31T10:31:18+00:00" + }, + { + "name": "seld/signal-handler", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/Seldaek/signal-handler.git", + "reference": "f69d119511dc0360440cdbdaa71829c149b7be75" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/Seldaek/signal-handler/zipball/f69d119511dc0360440cdbdaa71829c149b7be75", + "reference": "f69d119511dc0360440cdbdaa71829c149b7be75", + "shasum": "" + }, + "require": { + "php": ">=7.2.0" + }, + "require-dev": { + "phpstan/phpstan": "^1", + "phpstan/phpstan-deprecation-rules": "^1.0", + "phpstan/phpstan-phpunit": "^1", + "phpstan/phpstan-strict-rules": "^1.3", + "phpunit/phpunit": "^7.5.20 || ^8.5.23", + "psr/log": "^1 || ^2 || ^3" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "2.x-dev" + } + }, + "autoload": { + "psr-4": { + "Seld\\Signal\\": "src/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Jordi Boggiano", + "email": "j.boggiano@seld.be", + "homepage": "http://seld.be" + } + ], + "description": "Simple unix signal handler that silently fails where signals are not supported for easy cross-platform development", + "keywords": [ + "posix", + "sigint", + "signal", + "sigterm", + "unix" + ], + "support": { + "issues": "https://github.com/Seldaek/signal-handler/issues", + "source": "https://github.com/Seldaek/signal-handler/tree/2.0.1" + }, + "time": "2022-07-20T18:31:45+00:00" + }, + { + "name": "symfony/console", + "version": "5.4.x-dev", + "source": { + "type": "git", + "url": "https://github.com/symfony/console.git", + "reference": "dccb8d251a9017d5994c988b034d3e18aaabf740" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/console/zipball/dccb8d251a9017d5994c988b034d3e18aaabf740", + "reference": "dccb8d251a9017d5994c988b034d3e18aaabf740", + "shasum": "" + }, + "require": { + "php": ">=7.2.5", + "symfony/deprecation-contracts": "^2.1|^3", + "symfony/polyfill-mbstring": "~1.0", + "symfony/polyfill-php73": "^1.9", + "symfony/polyfill-php80": "^1.16", + "symfony/service-contracts": "^1.1|^2|^3", + "symfony/string": "^5.1|^6.0" + }, + "conflict": { + "psr/log": ">=3", + "symfony/dependency-injection": "<4.4", + "symfony/dotenv": "<5.1", + "symfony/event-dispatcher": "<4.4", + "symfony/lock": "<4.4", + "symfony/process": "<4.4" + }, + "provide": { + "psr/log-implementation": "1.0|2.0" + }, + "require-dev": { + "psr/log": "^1|^2", + "symfony/config": "^4.4|^5.0|^6.0", + "symfony/dependency-injection": "^4.4|^5.0|^6.0", + "symfony/event-dispatcher": "^4.4|^5.0|^6.0", + "symfony/lock": "^4.4|^5.0|^6.0", + "symfony/process": "^4.4|^5.0|^6.0", + "symfony/var-dumper": "^4.4|^5.0|^6.0" + }, + "suggest": { + "psr/log": "For using the console logger", + "symfony/event-dispatcher": "", + "symfony/lock": "", + "symfony/process": "" + }, + "type": "library", + "autoload": { + "psr-4": { + "Symfony\\Component\\Console\\": "" + }, + "exclude-from-classmap": [ + "/Tests/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Fabien Potencier", + "email": "fabien@symfony.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Eases the creation of beautiful and testable command line interfaces", + "homepage": "https://symfony.com", + "keywords": [ + "cli", + "command line", + "console", + "terminal" + ], + "support": { + "source": "https://github.com/symfony/console/tree/5.4" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2023-01-01T08:32:19+00:00" + }, + { + "name": "symfony/deprecation-contracts", + "version": "2.5.x-dev", + "source": { + "type": "git", + "url": "https://github.com/symfony/deprecation-contracts.git", + "reference": "e8b495ea28c1d97b5e0c121748d6f9b53d075c66" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/deprecation-contracts/zipball/e8b495ea28c1d97b5e0c121748d6f9b53d075c66", + "reference": "e8b495ea28c1d97b5e0c121748d6f9b53d075c66", + "shasum": "" + }, + "require": { + "php": ">=7.1" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "2.5-dev" + }, + "thanks": { + "name": "symfony/contracts", + "url": "https://github.com/symfony/contracts" + } + }, + "autoload": { + "files": [ + "function.php" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Nicolas Grekas", + "email": "p@tchwork.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "A generic function and convention to trigger deprecation notices", + "homepage": "https://symfony.com", + "support": { + "source": "https://github.com/symfony/deprecation-contracts/tree/2.5" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2022-01-02T09:53:40+00:00" + }, + { + "name": "symfony/filesystem", + "version": "5.4.x-dev", + "source": { + "type": "git", + "url": "https://github.com/symfony/filesystem.git", + "reference": "648bfaca6a494f3e22378123bcee2894045dc9d8" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/filesystem/zipball/648bfaca6a494f3e22378123bcee2894045dc9d8", + "reference": "648bfaca6a494f3e22378123bcee2894045dc9d8", + "shasum": "" + }, + "require": { + "php": ">=7.2.5", + "symfony/polyfill-ctype": "~1.8", + "symfony/polyfill-mbstring": "~1.8", + "symfony/polyfill-php80": "^1.16" + }, + "type": "library", + "autoload": { + "psr-4": { + "Symfony\\Component\\Filesystem\\": "" + }, + "exclude-from-classmap": [ + "/Tests/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Fabien Potencier", + "email": "fabien@symfony.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Provides basic utilities for the filesystem", + "homepage": "https://symfony.com", + "support": { + "source": "https://github.com/symfony/filesystem/tree/5.4" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2023-01-14T19:14:44+00:00" + }, + { + "name": "symfony/finder", + "version": "5.4.x-dev", + "source": { + "type": "git", + "url": "https://github.com/symfony/finder.git", + "reference": "6071aebf810ad13fe8200c224f36103abb37cf1f" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/finder/zipball/6071aebf810ad13fe8200c224f36103abb37cf1f", + "reference": "6071aebf810ad13fe8200c224f36103abb37cf1f", + "shasum": "" + }, + "require": { + "php": ">=7.2.5", + "symfony/deprecation-contracts": "^2.1|^3", + "symfony/polyfill-php80": "^1.16" + }, + "type": "library", + "autoload": { + "psr-4": { + "Symfony\\Component\\Finder\\": "" + }, + "exclude-from-classmap": [ + "/Tests/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Fabien Potencier", + "email": "fabien@symfony.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Finds files and directories via an intuitive fluent interface", + "homepage": "https://symfony.com", + "support": { + "source": "https://github.com/symfony/finder/tree/5.4" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2023-01-14T19:14:44+00:00" + }, + { + "name": "symfony/polyfill-ctype", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/symfony/polyfill-ctype.git", + "reference": "ea208ce43cbb04af6867b4fdddb1bdbf84cc28cb" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/polyfill-ctype/zipball/ea208ce43cbb04af6867b4fdddb1bdbf84cc28cb", + "reference": "ea208ce43cbb04af6867b4fdddb1bdbf84cc28cb", + "shasum": "" + }, + "require": { + "php": ">=7.1" + }, + "provide": { + "ext-ctype": "*" + }, + "suggest": { + "ext-ctype": "For best performance" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "1.28-dev" + }, + "thanks": { + "name": "symfony/polyfill", + "url": "https://github.com/symfony/polyfill" + } + }, + "autoload": { + "files": [ + "bootstrap.php" + ], + "psr-4": { + "Symfony\\Polyfill\\Ctype\\": "" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Gert de Pagter", + "email": "BackEndTea@gmail.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Symfony polyfill for ctype functions", + "homepage": "https://symfony.com", + "keywords": [ + "compatibility", + "ctype", + "polyfill", + "portable" + ], + "support": { + "source": "https://github.com/symfony/polyfill-ctype/tree/main" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2023-01-26T09:26:14+00:00" + }, + { + "name": "symfony/polyfill-intl-grapheme", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/symfony/polyfill-intl-grapheme.git", + "reference": "875e90aeea2777b6f135677f618529449334a612" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/polyfill-intl-grapheme/zipball/875e90aeea2777b6f135677f618529449334a612", + "reference": "875e90aeea2777b6f135677f618529449334a612", + "shasum": "" + }, + "require": { + "php": ">=7.1" + }, + "suggest": { + "ext-intl": "For best performance" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "1.28-dev" + }, + "thanks": { + "name": "symfony/polyfill", + "url": "https://github.com/symfony/polyfill" + } + }, + "autoload": { + "files": [ + "bootstrap.php" + ], + "psr-4": { + "Symfony\\Polyfill\\Intl\\Grapheme\\": "" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Nicolas Grekas", + "email": "p@tchwork.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Symfony polyfill for intl's grapheme_* functions", + "homepage": "https://symfony.com", + "keywords": [ + "compatibility", + "grapheme", + "intl", + "polyfill", + "portable", + "shim" + ], + "support": { + "source": "https://github.com/symfony/polyfill-intl-grapheme/tree/main" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2023-01-26T09:26:14+00:00" + }, + { + "name": "symfony/polyfill-intl-normalizer", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/symfony/polyfill-intl-normalizer.git", + "reference": "8c4ad05dd0120b6a53c1ca374dca2ad0a1c4ed92" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/polyfill-intl-normalizer/zipball/8c4ad05dd0120b6a53c1ca374dca2ad0a1c4ed92", + "reference": "8c4ad05dd0120b6a53c1ca374dca2ad0a1c4ed92", + "shasum": "" + }, + "require": { + "php": ">=7.1" + }, + "suggest": { + "ext-intl": "For best performance" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "1.28-dev" + }, + "thanks": { + "name": "symfony/polyfill", + "url": "https://github.com/symfony/polyfill" + } + }, + "autoload": { + "files": [ + "bootstrap.php" + ], + "psr-4": { + "Symfony\\Polyfill\\Intl\\Normalizer\\": "" + }, + "classmap": [ + "Resources/stubs" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Nicolas Grekas", + "email": "p@tchwork.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Symfony polyfill for intl's Normalizer class and related functions", + "homepage": "https://symfony.com", + "keywords": [ + "compatibility", + "intl", + "normalizer", + "polyfill", + "portable", + "shim" + ], + "support": { + "source": "https://github.com/symfony/polyfill-intl-normalizer/tree/main" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2023-01-26T09:26:14+00:00" + }, + { + "name": "symfony/polyfill-mbstring", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/symfony/polyfill-mbstring.git", + "reference": "fd9e963bb80ccbf5d83ce813f9058aacc67cdb98" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/polyfill-mbstring/zipball/fd9e963bb80ccbf5d83ce813f9058aacc67cdb98", + "reference": "fd9e963bb80ccbf5d83ce813f9058aacc67cdb98", + "shasum": "" + }, + "require": { + "php": ">=7.1" + }, + "provide": { + "ext-mbstring": "*" + }, + "suggest": { + "ext-mbstring": "For best performance" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "1.28-dev" + }, + "thanks": { + "name": "symfony/polyfill", + "url": "https://github.com/symfony/polyfill" + } + }, + "autoload": { + "files": [ + "bootstrap.php" + ], + "psr-4": { + "Symfony\\Polyfill\\Mbstring\\": "" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Nicolas Grekas", + "email": "p@tchwork.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Symfony polyfill for the Mbstring extension", + "homepage": "https://symfony.com", + "keywords": [ + "compatibility", + "mbstring", + "polyfill", + "portable", + "shim" + ], + "support": { + "source": "https://github.com/symfony/polyfill-mbstring/tree/main" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2023-01-26T09:26:14+00:00" + }, + { + "name": "symfony/polyfill-php73", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/symfony/polyfill-php73.git", + "reference": "fe2f306d1d9d346a7fee353d0d5012e401e984b5" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/polyfill-php73/zipball/fe2f306d1d9d346a7fee353d0d5012e401e984b5", + "reference": "fe2f306d1d9d346a7fee353d0d5012e401e984b5", + "shasum": "" + }, + "require": { + "php": ">=7.1" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "1.28-dev" + }, + "thanks": { + "name": "symfony/polyfill", + "url": "https://github.com/symfony/polyfill" + } + }, + "autoload": { + "files": [ + "bootstrap.php" + ], + "psr-4": { + "Symfony\\Polyfill\\Php73\\": "" + }, + "classmap": [ + "Resources/stubs" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Nicolas Grekas", + "email": "p@tchwork.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Symfony polyfill backporting some PHP 7.3+ features to lower PHP versions", + "homepage": "https://symfony.com", + "keywords": [ + "compatibility", + "polyfill", + "portable", + "shim" + ], + "support": { + "source": "https://github.com/symfony/polyfill-php73/tree/main" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2023-01-26T09:26:14+00:00" + }, + { + "name": "symfony/polyfill-php80", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/symfony/polyfill-php80.git", + "reference": "6caa57379c4aec19c0a12a38b59b26487dcfe4b5" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/polyfill-php80/zipball/6caa57379c4aec19c0a12a38b59b26487dcfe4b5", + "reference": "6caa57379c4aec19c0a12a38b59b26487dcfe4b5", + "shasum": "" + }, + "require": { + "php": ">=7.1" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "1.28-dev" + }, + "thanks": { + "name": "symfony/polyfill", + "url": "https://github.com/symfony/polyfill" + } + }, + "autoload": { + "files": [ + "bootstrap.php" + ], + "psr-4": { + "Symfony\\Polyfill\\Php80\\": "" + }, + "classmap": [ + "Resources/stubs" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Ion Bazan", + "email": "ion.bazan@gmail.com" + }, + { + "name": "Nicolas Grekas", + "email": "p@tchwork.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Symfony polyfill backporting some PHP 8.0+ features to lower PHP versions", + "homepage": "https://symfony.com", + "keywords": [ + "compatibility", + "polyfill", + "portable", + "shim" + ], + "support": { + "source": "https://github.com/symfony/polyfill-php80/tree/main" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2023-01-26T09:26:14+00:00" + }, + { + "name": "symfony/polyfill-php81", + "version": "dev-main", + "source": { + "type": "git", + "url": "https://github.com/symfony/polyfill-php81.git", + "reference": "7581cd600fa9fd681b797d00b02f068e2f13263b" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/polyfill-php81/zipball/7581cd600fa9fd681b797d00b02f068e2f13263b", + "reference": "7581cd600fa9fd681b797d00b02f068e2f13263b", + "shasum": "" + }, + "require": { + "php": ">=7.1" + }, + "default-branch": true, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "1.28-dev" + }, + "thanks": { + "name": "symfony/polyfill", + "url": "https://github.com/symfony/polyfill" + } + }, + "autoload": { + "files": [ + "bootstrap.php" + ], + "psr-4": { + "Symfony\\Polyfill\\Php81\\": "" + }, + "classmap": [ + "Resources/stubs" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Nicolas Grekas", + "email": "p@tchwork.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Symfony polyfill backporting some PHP 8.1+ features to lower PHP versions", + "homepage": "https://symfony.com", + "keywords": [ + "compatibility", + "polyfill", + "portable", + "shim" + ], + "support": { + "source": "https://github.com/symfony/polyfill-php81/tree/main" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2023-01-26T09:26:14+00:00" + }, + { + "name": "symfony/process", + "version": "5.4.x-dev", + "source": { + "type": "git", + "url": "https://github.com/symfony/process.git", + "reference": "c5ba874c9b636dbccf761e22ce750e88ec3f55e1" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/process/zipball/c5ba874c9b636dbccf761e22ce750e88ec3f55e1", + "reference": "c5ba874c9b636dbccf761e22ce750e88ec3f55e1", + "shasum": "" + }, + "require": { + "php": ">=7.2.5", + "symfony/polyfill-php80": "^1.16" + }, + "type": "library", + "autoload": { + "psr-4": { + "Symfony\\Component\\Process\\": "" + }, + "exclude-from-classmap": [ + "/Tests/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Fabien Potencier", + "email": "fabien@symfony.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Executes commands in sub-processes", + "homepage": "https://symfony.com", + "support": { + "source": "https://github.com/symfony/process/tree/5.4" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2023-01-01T08:32:19+00:00" + }, + { + "name": "symfony/service-contracts", + "version": "2.5.x-dev", + "source": { + "type": "git", + "url": "https://github.com/symfony/service-contracts.git", + "reference": "4b426aac47d6427cc1a1d0f7e2ac724627f5966c" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/service-contracts/zipball/4b426aac47d6427cc1a1d0f7e2ac724627f5966c", + "reference": "4b426aac47d6427cc1a1d0f7e2ac724627f5966c", + "shasum": "" + }, + "require": { + "php": ">=7.2.5", + "psr/container": "^1.1", + "symfony/deprecation-contracts": "^2.1|^3" + }, + "conflict": { + "ext-psr": "<1.1|>=2" + }, + "suggest": { + "symfony/service-implementation": "" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-main": "2.5-dev" + }, + "thanks": { + "name": "symfony/contracts", + "url": "https://github.com/symfony/contracts" + } + }, + "autoload": { + "psr-4": { + "Symfony\\Contracts\\Service\\": "" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Nicolas Grekas", + "email": "p@tchwork.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Generic abstractions related to writing services", + "homepage": "https://symfony.com", + "keywords": [ + "abstractions", + "contracts", + "decoupling", + "interfaces", + "interoperability", + "standards" + ], + "support": { + "source": "https://github.com/symfony/service-contracts/tree/2.5" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2022-05-30T19:17:29+00:00" + }, + { + "name": "symfony/string", + "version": "5.4.x-dev", + "source": { + "type": "git", + "url": "https://github.com/symfony/string.git", + "reference": "0a01071610fd861cc160dfb7e2682ceec66064cb" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/string/zipball/0a01071610fd861cc160dfb7e2682ceec66064cb", + "reference": "0a01071610fd861cc160dfb7e2682ceec66064cb", + "shasum": "" + }, + "require": { + "php": ">=7.2.5", + "symfony/polyfill-ctype": "~1.8", + "symfony/polyfill-intl-grapheme": "~1.0", + "symfony/polyfill-intl-normalizer": "~1.0", + "symfony/polyfill-mbstring": "~1.0", + "symfony/polyfill-php80": "~1.15" + }, + "conflict": { + "symfony/translation-contracts": ">=3.0" + }, + "require-dev": { + "symfony/error-handler": "^4.4|^5.0|^6.0", + "symfony/http-client": "^4.4|^5.0|^6.0", + "symfony/translation-contracts": "^1.1|^2", + "symfony/var-exporter": "^4.4|^5.0|^6.0" + }, + "type": "library", + "autoload": { + "files": [ + "Resources/functions.php" + ], + "psr-4": { + "Symfony\\Component\\String\\": "" + }, + "exclude-from-classmap": [ + "/Tests/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Nicolas Grekas", + "email": "p@tchwork.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Provides an object-oriented API to strings and deals with bytes, UTF-8 code points and grapheme clusters in a unified way", + "homepage": "https://symfony.com", + "keywords": [ + "grapheme", + "i18n", + "string", + "unicode", + "utf-8", + "utf8" + ], + "support": { + "source": "https://github.com/symfony/string/tree/5.4" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2023-01-01T08:32:19+00:00" + }, + { + "name": "symfony/yaml", + "version": "3.4.x-dev", + "source": { + "type": "git", + "url": "https://github.com/symfony/yaml.git", + "reference": "88289caa3c166321883f67fe5130188ebbb47094" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/symfony/yaml/zipball/88289caa3c166321883f67fe5130188ebbb47094", + "reference": "88289caa3c166321883f67fe5130188ebbb47094", + "shasum": "" + }, + "require": { + "php": "^5.5.9|>=7.0.8", + "symfony/polyfill-ctype": "~1.8" + }, + "conflict": { + "symfony/console": "<3.4" + }, + "require-dev": { + "symfony/console": "~3.4|~4.0" + }, + "suggest": { + "symfony/console": "For validating YAML files using the lint command" + }, + "type": "library", + "autoload": { + "psr-4": { + "Symfony\\Component\\Yaml\\": "" + }, + "exclude-from-classmap": [ + "/Tests/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Fabien Potencier", + "email": "fabien@symfony.com" + }, + { + "name": "Symfony Community", + "homepage": "https://symfony.com/contributors" + } + ], + "description": "Symfony Yaml Component", + "homepage": "https://symfony.com", + "support": { + "source": "https://github.com/symfony/yaml/tree/3.4" + }, + "funding": [ + { + "url": "https://symfony.com/sponsor", + "type": "custom" + }, + { + "url": "https://github.com/fabpot", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/symfony/symfony", + "type": "tidelift" + } + ], + "time": "2020-10-24T10:57:07+00:00" + }, + { + "name": "webmozart/assert", + "version": "1.11.0", + "source": { + "type": "git", + "url": "https://github.com/webmozarts/assert.git", + "reference": "11cb2199493b2f8a3b53e7f19068fc6aac760991" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/webmozarts/assert/zipball/11cb2199493b2f8a3b53e7f19068fc6aac760991", + "reference": "11cb2199493b2f8a3b53e7f19068fc6aac760991", + "shasum": "" + }, + "require": { + "ext-ctype": "*", + "php": "^7.2 || ^8.0" + }, + "conflict": { + "phpstan/phpstan": "<0.12.20", + "vimeo/psalm": "<4.6.1 || 4.6.2" + }, + "require-dev": { + "phpunit/phpunit": "^8.5.13" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.10-dev" + } + }, + "autoload": { + "psr-4": { + "Webmozart\\Assert\\": "src/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Bernhard Schussek", + "email": "bschussek@gmail.com" + } + ], + "description": "Assertions to validate method input/output with nice error messages.", + "keywords": [ + "assert", + "check", + "validate" + ], + "support": { + "issues": "https://github.com/webmozarts/assert/issues", + "source": "https://github.com/webmozarts/assert/tree/1.11.0" + }, + "time": "2022-06-03T18:03:27+00:00" + } + ], + "aliases": [], + "minimum-stability": "dev", + "stability-flags": [], + "prefer-stable": false, + "prefer-lowest": false, + "platform": { + "php": ">=5.3.0", + "composer-plugin-api": "^1.0 || ^2.0" + }, + "platform-dev": [], + "plugin-api-version": "2.3.0" +} diff --git a/vendor/cweagans/composer-patches/phpunit.xml.dist b/vendor/cweagans/composer-patches/phpunit.xml.dist new file mode 100644 index 0000000..62409b3 --- /dev/null +++ b/vendor/cweagans/composer-patches/phpunit.xml.dist @@ -0,0 +1,18 @@ + + + + + + ./tests/ + + + + + + src/ + + + vendor/ + + + diff --git a/vendor/cweagans/composer-patches/src/PatchEvent.php b/vendor/cweagans/composer-patches/src/PatchEvent.php new file mode 100644 index 0000000..31d36f8 --- /dev/null +++ b/vendor/cweagans/composer-patches/src/PatchEvent.php @@ -0,0 +1,70 @@ +package = $package; + $this->url = $url; + $this->description = $description; + } + + /** + * Returns the package that is patched. + * + * @return PackageInterface + */ + public function getPackage() { + return $this->package; + } + + /** + * Returns the url of the patch. + * + * @return string + */ + public function getUrl() { + return $this->url; + } + + /** + * Returns the description of the patch. + * + * @return string + */ + public function getDescription() { + return $this->description; + } + +} diff --git a/vendor/cweagans/composer-patches/src/PatchEvents.php b/vendor/cweagans/composer-patches/src/PatchEvents.php new file mode 100644 index 0000000..ecee947 --- /dev/null +++ b/vendor/cweagans/composer-patches/src/PatchEvents.php @@ -0,0 +1,30 @@ +composer = $composer; + $this->io = $io; + $this->eventDispatcher = $composer->getEventDispatcher(); + $this->executor = new ProcessExecutor($this->io); + $this->patches = array(); + $this->installedPatches = array(); + } + + /** + * Returns an array of event names this subscriber wants to listen to. + */ + public static function getSubscribedEvents() { + return array( + ScriptEvents::PRE_INSTALL_CMD => array('checkPatches'), + ScriptEvents::PRE_UPDATE_CMD => array('checkPatches'), + PackageEvents::PRE_PACKAGE_INSTALL => array('gatherPatches'), + PackageEvents::PRE_PACKAGE_UPDATE => array('gatherPatches'), + // The following is a higher weight for compatibility with + // https://github.com/AydinHassan/magento-core-composer-installer and more generally for compatibility with + // every Composer plugin which deploys downloaded packages to other locations. + // In such cases you want that those plugins deploy patched files so they have to run after + // the "composer-patches" plugin. + // @see: https://github.com/cweagans/composer-patches/pull/153 + PackageEvents::POST_PACKAGE_INSTALL => array('postInstall', 10), + PackageEvents::POST_PACKAGE_UPDATE => array('postInstall', 10), + ); + } + + /** + * Before running composer install, + * @param Event $event + */ + public function checkPatches(Event $event) { + if (!$this->isPatchingEnabled()) { + return; + } + + try { + $repositoryManager = $this->composer->getRepositoryManager(); + $localRepository = $repositoryManager->getLocalRepository(); + $installationManager = $this->composer->getInstallationManager(); + $packages = $localRepository->getPackages(); + + $extra = $this->composer->getPackage()->getExtra(); + $patches_ignore = isset($extra['patches-ignore']) ? $extra['patches-ignore'] : array(); + + $tmp_patches = $this->grabPatches(); + foreach ($packages as $package) { + $extra = $package->getExtra(); + if (isset($extra['patches'])) { + if (isset($patches_ignore[$package->getName()])) { + foreach ($patches_ignore[$package->getName()] as $package_name => $patches) { + if (isset($extra['patches'][$package_name])) { + $extra['patches'][$package_name] = array_diff($extra['patches'][$package_name], $patches); + } + } + } + $this->installedPatches[$package->getName()] = $extra['patches']; + } + $patches = isset($extra['patches']) ? $extra['patches'] : array(); + $tmp_patches = $this->arrayMergeRecursiveDistinct($tmp_patches, $patches); + } + + if ($tmp_patches == FALSE) { + $this->io->write('No patches supplied.'); + return; + } + + // Remove packages for which the patch set has changed. + $promises = array(); + foreach ($packages as $package) { + if (!($package instanceof AliasPackage)) { + $package_name = $package->getName(); + $extra = $package->getExtra(); + $has_patches = isset($tmp_patches[$package_name]); + $has_applied_patches = isset($extra['patches_applied']) && count($extra['patches_applied']) > 0; + if (($has_patches && !$has_applied_patches) + || (!$has_patches && $has_applied_patches) + || ($has_patches && $has_applied_patches && $tmp_patches[$package_name] !== $extra['patches_applied'])) { + $uninstallOperation = new UninstallOperation($package, 'Removing package so it can be re-installed and re-patched.'); + $this->io->write('Removing package ' . $package_name . ' so that it can be re-installed and re-patched.'); + $promises[] = $installationManager->uninstall($localRepository, $uninstallOperation); + } + } + } + $promises = array_filter($promises); + if ($promises) { + $this->composer->getLoop()->wait($promises); + } + } + // If the Locker isn't available, then we don't need to do this. + // It's the first time packages have been installed. + catch (\LogicException $e) { + return; + } + } + + /** + * Gather patches from dependencies and store them for later use. + * + * @param PackageEvent $event + */ + public function gatherPatches(PackageEvent $event) { + // If we've already done this, then don't do it again. + if (isset($this->patches['_patchesGathered'])) { + $this->io->write('Patches already gathered. Skipping', TRUE, IOInterface::VERBOSE); + return; + } + // If patching has been disabled, bail out here. + elseif (!$this->isPatchingEnabled()) { + $this->io->write('Patching is disabled. Skipping.', TRUE, IOInterface::VERBOSE); + return; + } + + $this->patches = $this->grabPatches(); + if (empty($this->patches)) { + $this->io->write('No patches supplied.'); + } + + $extra = $this->composer->getPackage()->getExtra(); + $patches_ignore = isset($extra['patches-ignore']) ? $extra['patches-ignore'] : array(); + + // Now add all the patches from dependencies that will be installed. + $operations = $event->getOperations(); + $this->io->write('Gathering patches for dependencies. This might take a minute.'); + foreach ($operations as $operation) { + if ($operation instanceof InstallOperation || $operation instanceof UpdateOperation) { + $package = $this->getPackageFromOperation($operation); + $extra = $package->getExtra(); + if (isset($extra['patches'])) { + if (isset($patches_ignore[$package->getName()])) { + foreach ($patches_ignore[$package->getName()] as $package_name => $patches) { + if (isset($extra['patches'][$package_name])) { + $extra['patches'][$package_name] = array_diff($extra['patches'][$package_name], $patches); + } + } + } + $this->patches = $this->arrayMergeRecursiveDistinct($this->patches, $extra['patches']); + } + // Unset installed patches for this package + if(isset($this->installedPatches[$package->getName()])) { + unset($this->installedPatches[$package->getName()]); + } + } + } + + // Merge installed patches from dependencies that did not receive an update. + foreach ($this->installedPatches as $patches) { + $this->patches = $this->arrayMergeRecursiveDistinct($this->patches, $patches); + } + + // If we're in verbose mode, list the projects we're going to patch. + if ($this->io->isVerbose()) { + foreach ($this->patches as $package => $patches) { + $number = count($patches); + $this->io->write('Found ' . $number . ' patches for ' . $package . '.'); + } + } + + // Make sure we don't gather patches again. Extra keys in $this->patches + // won't hurt anything, so we'll just stash it there. + $this->patches['_patchesGathered'] = TRUE; + } + + /** + * Get the patches from root composer or external file + * @return Patches + * @throws \Exception + */ + public function grabPatches() { + // First, try to get the patches from the root composer.json. + $extra = $this->composer->getPackage()->getExtra(); + if (isset($extra['patches'])) { + $this->io->write('Gathering patches for root package.'); + $patches = $extra['patches']; + return $patches; + } + // If it's not specified there, look for a patches-file definition. + elseif (isset($extra['patches-file']) && is_string($extra['patches-file'])) { + $this->io->write('Gathering patches from patch file.'); + $patches = file_get_contents($extra['patches-file']); + $patches = json_decode($patches, TRUE); + $error = json_last_error(); + if ($error != 0) { + switch ($error) { + case JSON_ERROR_DEPTH: + $msg = ' - Maximum stack depth exceeded'; + break; + case JSON_ERROR_STATE_MISMATCH: + $msg = ' - Underflow or the modes mismatch'; + break; + case JSON_ERROR_CTRL_CHAR: + $msg = ' - Unexpected control character found'; + break; + case JSON_ERROR_SYNTAX: + $msg = ' - Syntax error, malformed JSON'; + break; + case JSON_ERROR_UTF8: + $msg = ' - Malformed UTF-8 characters, possibly incorrectly encoded'; + break; + default: + $msg = ' - Unknown error'; + break; + } + throw new \Exception('There was an error in the supplied patches file:' . $msg); + } + if (isset($patches['patches'])) { + $patches = $patches['patches']; + return $patches; + } + elseif(!$patches) { + throw new \Exception('There was an error in the supplied patch file'); + } + } + else { + return array(); + } + } + + /** + * @param PackageEvent $event + * @throws \Exception + */ + public function postInstall(PackageEvent $event) { + + // Check if we should exit in failure. + $extra = $this->composer->getPackage()->getExtra(); + $exitOnFailure = getenv('COMPOSER_EXIT_ON_PATCH_FAILURE') || !empty($extra['composer-exit-on-patch-failure']); + $skipReporting = getenv('COMPOSER_PATCHES_SKIP_REPORTING') || !empty($extra['composer-patches-skip-reporting']); + + // Get the package object for the current operation. + $operation = $event->getOperation(); + /** @var PackageInterface $package */ + $package = $this->getPackageFromOperation($operation); + $package_name = $package->getName(); + + if (!isset($this->patches[$package_name])) { + if ($this->io->isVerbose()) { + $this->io->write('No patches found for ' . $package_name . '.'); + } + return; + } + $this->io->write(' - Applying patches for ' . $package_name . ''); + + // Get the install path from the package object. + $manager = $event->getComposer()->getInstallationManager(); + $install_path = $manager->getInstaller($package->getType())->getInstallPath($package); + + // Set up a downloader. + $downloader = new HttpDownloader($this->io, $this->composer->getConfig()); + + // Track applied patches in the package info in installed.json + $localRepository = $this->composer->getRepositoryManager()->getLocalRepository(); + $localPackage = $localRepository->findPackage($package_name, $package->getVersion()); + $extra = $localPackage->getExtra(); + $extra['patches_applied'] = array(); + + foreach ($this->patches[$package_name] as $description => $url) { + $this->io->write(' ' . $url . ' (' . $description. ')'); + try { + $this->eventDispatcher->dispatch(NULL, new PatchEvent(PatchEvents::PRE_PATCH_APPLY, $package, $url, $description)); + $this->getAndApplyPatch($downloader, $install_path, $url, $package); + $this->eventDispatcher->dispatch(NULL, new PatchEvent(PatchEvents::POST_PATCH_APPLY, $package, $url, $description)); + $extra['patches_applied'][$description] = $url; + } + catch (\Exception $e) { + $this->io->write(' Could not apply patch! Skipping. The error was: ' . $e->getMessage() . ''); + if ($exitOnFailure) { + throw new \Exception("Cannot apply patch $description ($url)!"); + } + } + } + $localPackage->setExtra($extra); + + $this->io->write(''); + + if (true !== $skipReporting) { + $this->writePatchReport($this->patches[$package_name], $install_path); + } + } + + /** + * Get a Package object from an OperationInterface object. + * + * @param OperationInterface $operation + * @return PackageInterface + * @throws \Exception + */ + protected function getPackageFromOperation(OperationInterface $operation) { + if ($operation instanceof InstallOperation) { + $package = $operation->getPackage(); + } + elseif ($operation instanceof UpdateOperation) { + $package = $operation->getTargetPackage(); + } + else { + throw new \Exception('Unknown operation: ' . get_class($operation)); + } + + return $package; + } + + /** + * Apply a patch on code in the specified directory. + * + * @param HttpDownloader $downloader + * @param $install_path + * @param $patch_url + * @param PackageInterface $package + * @throws \Exception + */ + protected function getAndApplyPatch(HttpDownloader $downloader, $install_path, $patch_url, PackageInterface $package) { + + // Local patch file. + if (file_exists($patch_url)) { + $filename = realpath($patch_url); + } + else { + // Generate random (but not cryptographically so) filename. + $filename = uniqid(sys_get_temp_dir().'/') . ".patch"; + + try { + $downloader->copy($patch_url, $filename, array()); + } catch (\Exception $e) { + // In case of an exception, retry once as the download might + // have failed due to intermittent network issues. + $downloader->copy($patch_url, $filename, array()); + } + } + + // The order here is intentional. p1 is most likely to apply with git apply. + // p0 is next likely. p2 is extremely unlikely, but for some special cases, + // it might be useful. p4 is useful for Magento 2 patches + $patch_levels = array('-p1', '-p0', '-p2', '-p4'); + + // Check for specified patch level for this package. + $extra = $this->composer->getPackage()->getExtra(); + if (!empty($extra['patchLevel'][$package->getName()])){ + $patch_levels = array($extra['patchLevel'][$package->getName()]); + } + // Attempt to apply with git apply. + $patched = $this->applyPatchWithGit($install_path, $patch_levels, $filename); + + // In some rare cases, git will fail to apply a patch, fallback to using + // the 'patch' command. + if (!$patched) { + foreach ($patch_levels as $patch_level) { + // --no-backup-if-mismatch here is a hack that fixes some + // differences between how patch works on windows and unix. + if ($patched = $this->executeCommand("patch %s --no-backup-if-mismatch -d %s < %s", $patch_level, $install_path, $filename)) { + break; + } + } + } + + // Clean up the temporary patch file. + if (isset($hostname)) { + unlink($filename); + } + // If the patch *still* isn't applied, then give up and throw an Exception. + // Otherwise, let the user know it worked. + if (!$patched) { + throw new \Exception("Cannot apply patch $patch_url"); + } + } + + /** + * Checks if the root package enables patching. + * + * @return bool + * Whether patching is enabled. Defaults to TRUE. + */ + protected function isPatchingEnabled() { + $extra = $this->composer->getPackage()->getExtra(); + + if (empty($extra['patches']) && empty($extra['patches-ignore']) && !isset($extra['patches-file'])) { + // The root package has no patches of its own, so only allow patching if + // it has specifically opted in. + return isset($extra['enable-patching']) ? $extra['enable-patching'] : FALSE; + } + else { + return TRUE; + } + } + + /** + * Writes a patch report to the target directory. + * + * @param array $patches + * @param string $directory + */ + protected function writePatchReport($patches, $directory) { + $output = "This file was automatically generated by Composer Patches (https://github.com/cweagans/composer-patches)\n"; + $output .= "Patches applied to this directory:\n\n"; + foreach ($patches as $description => $url) { + $output .= $description . "\n"; + $output .= 'Source: ' . $url . "\n\n\n"; + } + file_put_contents($directory . "/PATCHES.txt", $output); + } + + /** + * Executes a shell command with escaping. + * + * @param string $cmd + * @return bool + */ + protected function executeCommand($cmd) { + // Shell-escape all arguments except the command. + $args = func_get_args(); + foreach ($args as $index => $arg) { + if ($index !== 0) { + $args[$index] = escapeshellarg($arg); + } + } + + // And replace the arguments. + $command = call_user_func_array('sprintf', $args); + $output = ''; + if ($this->io->isVerbose()) { + $this->io->write('' . $command . ''); + $io = $this->io; + $output = function ($type, $data) use ($io) { + if ($type == Process::ERR) { + $io->write('' . $data . ''); + } + else { + $io->write('' . $data . ''); + } + }; + } + return ($this->executor->execute($command, $output) == 0); + } + + /** + * Recursively merge arrays without changing data types of values. + * + * Does not change the data types of the values in the arrays. Matching keys' + * values in the second array overwrite those in the first array, as is the + * case with array_merge. + * + * @param array $array1 + * The first array. + * @param array $array2 + * The second array. + * @return array + * The merged array. + * + * @see http://php.net/manual/en/function.array-merge-recursive.php#92195 + */ + protected function arrayMergeRecursiveDistinct(array $array1, array $array2) { + $merged = $array1; + + foreach ($array2 as $key => &$value) { + if (is_array($value) && isset($merged[$key]) && is_array($merged[$key])) { + $merged[$key] = $this->arrayMergeRecursiveDistinct($merged[$key], $value); + } + else { + $merged[$key] = $value; + } + } + + return $merged; + } + + /** + * Attempts to apply a patch with git apply. + * + * @param $install_path + * @param $patch_levels + * @param $filename + * + * @return bool + * TRUE if patch was applied, FALSE otherwise. + */ + protected function applyPatchWithGit($install_path, $patch_levels, $filename) { + // Do not use git apply unless the install path is itself a git repo + // @see https://stackoverflow.com/a/27283285 + if (!is_dir($install_path . '/.git')) { + return FALSE; + } + + $patched = FALSE; + foreach ($patch_levels as $patch_level) { + if ($this->io->isVerbose()) { + $comment = 'Testing ability to patch with git apply.'; + $comment .= ' This command may produce errors that can be safely ignored.'; + $this->io->write('' . $comment . ''); + } + $checked = $this->executeCommand('git -C %s apply --check -v %s %s', $install_path, $patch_level, $filename); + $output = $this->executor->getErrorOutput(); + if (substr($output, 0, 7) == 'Skipped') { + // Git will indicate success but silently skip patches in some scenarios. + // + // @see https://github.com/cweagans/composer-patches/pull/165 + $checked = FALSE; + } + if ($checked) { + // Apply the first successful style. + $patched = $this->executeCommand('git -C %s apply %s %s', $install_path, $patch_level, $filename); + break; + } + } + return $patched; + } + + /** + * Indicates if a package has been patched. + * + * @param \Composer\Package\PackageInterface $package + * The package to check. + * + * @return bool + * TRUE if the package has been patched. + */ + public static function isPackagePatched(PackageInterface $package) { + return array_key_exists('patches_applied', $package->getExtra()); + } + + /** + * {@inheritDoc} + */ + public function deactivate(Composer $composer, IOInterface $io) + { + } + + /** + * {@inheritDoc} + */ + public function uninstall(Composer $composer, IOInterface $io) + { + } + +} diff --git a/vendor/cweagans/composer-patches/tests/PatchEventTest.php b/vendor/cweagans/composer-patches/tests/PatchEventTest.php new file mode 100644 index 0000000..0f6adb7 --- /dev/null +++ b/vendor/cweagans/composer-patches/tests/PatchEventTest.php @@ -0,0 +1,39 @@ +assertEquals($event_name, $patch_event->getName()); + $this->assertEquals($package, $patch_event->getPackage()); + $this->assertEquals($url, $patch_event->getUrl()); + $this->assertEquals($description, $patch_event->getDescription()); + } + + public function patchEventDataProvider() { + $prophecy = $this->prophesize('Composer\Package\PackageInterface'); + $package = $prophecy->reveal(); + + return array( + array(PatchEvents::PRE_PATCH_APPLY, $package, 'https://www.drupal.org', 'A test patch'), + array(PatchEvents::POST_PATCH_APPLY, $package, 'https://www.drupal.org', 'A test patch'), + ); + } + +} diff --git a/vendor/davechild/textstatistics/.travis.yml b/vendor/davechild/textstatistics/.travis.yml new file mode 100755 index 0000000..5525346 --- /dev/null +++ b/vendor/davechild/textstatistics/.travis.yml @@ -0,0 +1,10 @@ +language: php +before_script: + - wget http://getcomposer.org/composer.phar + - php composer.phar install --dev +php: + - 7.2 +script: phpunit --coverage-clover=coverage.clover +after_script: + - wget https://scrutinizer-ci.com/ocular.phar + - php ocular.phar code-coverage:upload --format=php-clover coverage.clover diff --git a/vendor/davechild/textstatistics/LICENSE b/vendor/davechild/textstatistics/LICENSE new file mode 100644 index 0000000..795c162 --- /dev/null +++ b/vendor/davechild/textstatistics/LICENSE @@ -0,0 +1,23 @@ +Copyright (c) 2014, Dave Child +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +* Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +* Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" +AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/davechild/textstatistics/README.md b/vendor/davechild/textstatistics/README.md new file mode 100644 index 0000000..34b1d84 --- /dev/null +++ b/vendor/davechild/textstatistics/README.md @@ -0,0 +1,83 @@ +# PHP Text Statistics + +[![Build Status](https://travis-ci.org/DaveChild/Text-Statistics.svg?branch=master)](https://travis-ci.org/DaveChild/Text-Statistics) [![Scrutinizer Code Quality](https://scrutinizer-ci.com/g/DaveChild/Text-Statistics/badges/quality-score.png?b=master)](https://scrutinizer-ci.com/g/DaveChild/Text-Statistics/?branch=master) [![Code Coverage](https://scrutinizer-ci.com/g/DaveChild/Text-Statistics/badges/coverage.png?b=master)](https://scrutinizer-ci.com/g/DaveChild/Text-Statistics/?branch=master) + +The PHP Text Statistics class will help you to indentify issues with your website content, especially with readability. + +It allows you to measure the readability of text using common scoring systems, including: +* Flesch Kincaid Reading Ease +* Flesch Kincaid Grade Level +* Gunning Fog Score +* Coleman Liau Index +* SMOG Index +* Automated Reability Index +* Dale-Chall Readability Score +* Spache Readability Score + +One of the biggest challenges with measuring text readability is the counting of syllables, which can be tricky to work out. There are rules in the Statistics class for working out the syllable count of words, and a large list of words to test these rules against. + +Please feel free to add to the test word list, especially if you can find words whose syllable count is not correctly calculated (even more especially if you can also add code to the class so your word is correctly handled!). + +Homographs are going to be impossible to calculate as they depend on context (i.e., "he moped around the house", "she rode her moped to school), but there are few enough of these not to be a concern. There is a by-no-means-comprehensive list of these in the resources folder. + +## Installation + +### Using Composer +```json + { + "require": { + "davechild/textstatistics": "1.*" + } + } +``` + +> If using a version of PHP < 7.2, specify version 1.0.2. + +### Measuring Readability + +```php +use DaveChild\TextStatistics as TS; +$textStatistics = new TS\TextStatistics; +$text = 'The quick brown fox jumped over the lazy dog.'; +echo 'Flesch-Kincaid Reading Ease: ' . $textStatistics->fleschKincaidReadingEase($text); +``` + +### More Text Shenanigans! + +Included with this package are several classes with static methods which can be called independently. If required, you can pass a text encoding to these methods as a second parameter. + +#### Pluralise and Singularise Words + +```php +echo DaveChild\TextStatistics\Pluralise::getPlural('banana'); // bananas +echo DaveChild\TextStatistics\Pluralise::getSingular('bananas'); // banana +``` + +#### Count Syllables + +```php +echo DaveChild\TextStatistics\Syllables::syllableCount('banana'); // 3 +``` + +#### Letter, Sentence, Word Counts + +```php +echo DaveChild\TextStatistics\Text::textLength('I ate a banana.'); // 15 +echo DaveChild\TextStatistics\Text::letterCount('I ate a banana.'); // 11 +echo DaveChild\TextStatistics\Text::wordCount('I ate a banana.'); // 4 +echo DaveChild\TextStatistics\Text::sentenceCount('I ate a banana.'); // 1 +``` + +## Useful Links + +**Homepage and Live Version** + +https://readable.com/ + +**JavaScript Port** + +https://github.com/cgiffard/TextStatistics.js + +**License** + +http://www.opensource.org/licenses/bsd-license.php diff --git a/vendor/davechild/textstatistics/composer.json b/vendor/davechild/textstatistics/composer.json new file mode 100644 index 0000000..b2be8e0 --- /dev/null +++ b/vendor/davechild/textstatistics/composer.json @@ -0,0 +1,34 @@ +{ + "name": "davechild/textstatistics", + "description": "PHP package to measure the readability of text according to various algorithms.", + "homepage": "https://github.com/DaveChild/Text-Statistics", + "authors": [ + { + "name": "Dave Child", + "email": "dave@addedbytes.com", + "homepage": "https://www.addedbytes.com/", + "role": "Developer" + } + ], + "license": "BSD-2-Clause", + "require": { + "php": ">=7.2.0", + "ext-mbstring": "*" + }, + "require-dev": { + "phpunit/phpunit": "^9" + }, + "autoload": { + "psr-0" : { + "DaveChild\\TextStatistics" : "src" + } + }, + "extra": { + "branch-alias": { + "dev-master": "1.0.x-dev" + } + }, + "suggest": { + "ext-bcmath": "More accurate floating point calculations." + } +} diff --git a/vendor/davechild/textstatistics/composer.lock b/vendor/davechild/textstatistics/composer.lock new file mode 100644 index 0000000..b083fa2 --- /dev/null +++ b/vendor/davechild/textstatistics/composer.lock @@ -0,0 +1,1753 @@ +{ + "_readme": [ + "This file locks the dependencies of your project to a known state", + "Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies", + "This file is @generated automatically" + ], + "content-hash": "dda1072f9425fd70fc84f39d15d049aa", + "packages": [], + "packages-dev": [ + { + "name": "doctrine/instantiator", + "version": "1.5.0", + "source": { + "type": "git", + "url": "https://github.com/doctrine/instantiator.git", + "reference": "0a0fa9780f5d4e507415a065172d26a98d02047b" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/doctrine/instantiator/zipball/0a0fa9780f5d4e507415a065172d26a98d02047b", + "reference": "0a0fa9780f5d4e507415a065172d26a98d02047b", + "shasum": "" + }, + "require": { + "php": "^7.1 || ^8.0" + }, + "require-dev": { + "doctrine/coding-standard": "^9 || ^11", + "ext-pdo": "*", + "ext-phar": "*", + "phpbench/phpbench": "^0.16 || ^1", + "phpstan/phpstan": "^1.4", + "phpstan/phpstan-phpunit": "^1", + "phpunit/phpunit": "^7.5 || ^8.5 || ^9.5", + "vimeo/psalm": "^4.30 || ^5.4" + }, + "type": "library", + "autoload": { + "psr-4": { + "Doctrine\\Instantiator\\": "src/Doctrine/Instantiator/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "authors": [ + { + "name": "Marco Pivetta", + "email": "ocramius@gmail.com", + "homepage": "https://ocramius.github.io/" + } + ], + "description": "A small, lightweight utility to instantiate objects in PHP without invoking their constructors", + "homepage": "https://www.doctrine-project.org/projects/instantiator.html", + "keywords": [ + "constructor", + "instantiate" + ], + "support": { + "issues": "https://github.com/doctrine/instantiator/issues", + "source": "https://github.com/doctrine/instantiator/tree/1.5.0" + }, + "funding": [ + { + "url": "https://www.doctrine-project.org/sponsorship.html", + "type": "custom" + }, + { + "url": "https://www.patreon.com/phpdoctrine", + "type": "patreon" + }, + { + "url": "https://tidelift.com/funding/github/packagist/doctrine%2Finstantiator", + "type": "tidelift" + } + ], + "time": "2022-12-30T00:15:36+00:00" + }, + { + "name": "myclabs/deep-copy", + "version": "1.11.1", + "source": { + "type": "git", + "url": "https://github.com/myclabs/DeepCopy.git", + "reference": "7284c22080590fb39f2ffa3e9057f10a4ddd0e0c" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/myclabs/DeepCopy/zipball/7284c22080590fb39f2ffa3e9057f10a4ddd0e0c", + "reference": "7284c22080590fb39f2ffa3e9057f10a4ddd0e0c", + "shasum": "" + }, + "require": { + "php": "^7.1 || ^8.0" + }, + "conflict": { + "doctrine/collections": "<1.6.8", + "doctrine/common": "<2.13.3 || >=3,<3.2.2" + }, + "require-dev": { + "doctrine/collections": "^1.6.8", + "doctrine/common": "^2.13.3 || ^3.2.2", + "phpunit/phpunit": "^7.5.20 || ^8.5.23 || ^9.5.13" + }, + "type": "library", + "autoload": { + "files": [ + "src/DeepCopy/deep_copy.php" + ], + "psr-4": { + "DeepCopy\\": "src/DeepCopy/" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "MIT" + ], + "description": "Create deep copies (clones) of your objects", + "keywords": [ + "clone", + "copy", + "duplicate", + "object", + "object graph" + ], + "support": { + "issues": "https://github.com/myclabs/DeepCopy/issues", + "source": "https://github.com/myclabs/DeepCopy/tree/1.11.1" + }, + "funding": [ + { + "url": "https://tidelift.com/funding/github/packagist/myclabs/deep-copy", + "type": "tidelift" + } + ], + "time": "2023-03-08T13:26:56+00:00" + }, + { + "name": "nikic/php-parser", + "version": "v4.17.1", + "source": { + "type": "git", + "url": "https://github.com/nikic/PHP-Parser.git", + "reference": "a6303e50c90c355c7eeee2c4a8b27fe8dc8fef1d" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/nikic/PHP-Parser/zipball/a6303e50c90c355c7eeee2c4a8b27fe8dc8fef1d", + "reference": "a6303e50c90c355c7eeee2c4a8b27fe8dc8fef1d", + "shasum": "" + }, + "require": { + "ext-tokenizer": "*", + "php": ">=7.0" + }, + "require-dev": { + "ircmaxell/php-yacc": "^0.0.7", + "phpunit/phpunit": "^6.5 || ^7.0 || ^8.0 || ^9.0" + }, + "bin": [ + "bin/php-parse" + ], + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "4.9-dev" + } + }, + "autoload": { + "psr-4": { + "PhpParser\\": "lib/PhpParser" + } + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Nikita Popov" + } + ], + "description": "A PHP parser written in PHP", + "keywords": [ + "parser", + "php" + ], + "support": { + "issues": "https://github.com/nikic/PHP-Parser/issues", + "source": "https://github.com/nikic/PHP-Parser/tree/v4.17.1" + }, + "time": "2023-08-13T19:53:39+00:00" + }, + { + "name": "phar-io/manifest", + "version": "2.0.3", + "source": { + "type": "git", + "url": "https://github.com/phar-io/manifest.git", + "reference": "97803eca37d319dfa7826cc2437fc020857acb53" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/phar-io/manifest/zipball/97803eca37d319dfa7826cc2437fc020857acb53", + "reference": "97803eca37d319dfa7826cc2437fc020857acb53", + "shasum": "" + }, + "require": { + "ext-dom": "*", + "ext-phar": "*", + "ext-xmlwriter": "*", + "phar-io/version": "^3.0.1", + "php": "^7.2 || ^8.0" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "2.0.x-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Arne Blankerts", + "email": "arne@blankerts.de", + "role": "Developer" + }, + { + "name": "Sebastian Heuer", + "email": "sebastian@phpeople.de", + "role": "Developer" + }, + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "Developer" + } + ], + "description": "Component for reading phar.io manifest information from a PHP Archive (PHAR)", + "support": { + "issues": "https://github.com/phar-io/manifest/issues", + "source": "https://github.com/phar-io/manifest/tree/2.0.3" + }, + "time": "2021-07-20T11:28:43+00:00" + }, + { + "name": "phar-io/version", + "version": "3.2.1", + "source": { + "type": "git", + "url": "https://github.com/phar-io/version.git", + "reference": "4f7fd7836c6f332bb2933569e566a0d6c4cbed74" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/phar-io/version/zipball/4f7fd7836c6f332bb2933569e566a0d6c4cbed74", + "reference": "4f7fd7836c6f332bb2933569e566a0d6c4cbed74", + "shasum": "" + }, + "require": { + "php": "^7.2 || ^8.0" + }, + "type": "library", + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Arne Blankerts", + "email": "arne@blankerts.de", + "role": "Developer" + }, + { + "name": "Sebastian Heuer", + "email": "sebastian@phpeople.de", + "role": "Developer" + }, + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "Developer" + } + ], + "description": "Library for handling version information and constraints", + "support": { + "issues": "https://github.com/phar-io/version/issues", + "source": "https://github.com/phar-io/version/tree/3.2.1" + }, + "time": "2022-02-21T01:04:05+00:00" + }, + { + "name": "phpunit/php-code-coverage", + "version": "9.2.29", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/php-code-coverage.git", + "reference": "6a3a87ac2bbe33b25042753df8195ba4aa534c76" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/php-code-coverage/zipball/6a3a87ac2bbe33b25042753df8195ba4aa534c76", + "reference": "6a3a87ac2bbe33b25042753df8195ba4aa534c76", + "shasum": "" + }, + "require": { + "ext-dom": "*", + "ext-libxml": "*", + "ext-xmlwriter": "*", + "nikic/php-parser": "^4.15", + "php": ">=7.3", + "phpunit/php-file-iterator": "^3.0.3", + "phpunit/php-text-template": "^2.0.2", + "sebastian/code-unit-reverse-lookup": "^2.0.2", + "sebastian/complexity": "^2.0", + "sebastian/environment": "^5.1.2", + "sebastian/lines-of-code": "^1.0.3", + "sebastian/version": "^3.0.1", + "theseer/tokenizer": "^1.2.0" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "suggest": { + "ext-pcov": "PHP extension that provides line coverage", + "ext-xdebug": "PHP extension that provides line coverage as well as branch and path coverage" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "9.2-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "Library that provides collection, processing, and rendering functionality for PHP code coverage information.", + "homepage": "https://github.com/sebastianbergmann/php-code-coverage", + "keywords": [ + "coverage", + "testing", + "xunit" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/php-code-coverage/issues", + "security": "https://github.com/sebastianbergmann/php-code-coverage/security/policy", + "source": "https://github.com/sebastianbergmann/php-code-coverage/tree/9.2.29" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2023-09-19T04:57:46+00:00" + }, + { + "name": "phpunit/php-file-iterator", + "version": "3.0.6", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/php-file-iterator.git", + "reference": "cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/php-file-iterator/zipball/cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf", + "reference": "cf1c2e7c203ac650e352f4cc675a7021e7d1b3cf", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "3.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "FilterIterator implementation that filters files based on a list of suffixes.", + "homepage": "https://github.com/sebastianbergmann/php-file-iterator/", + "keywords": [ + "filesystem", + "iterator" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/php-file-iterator/issues", + "source": "https://github.com/sebastianbergmann/php-file-iterator/tree/3.0.6" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2021-12-02T12:48:52+00:00" + }, + { + "name": "phpunit/php-invoker", + "version": "3.1.1", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/php-invoker.git", + "reference": "5a10147d0aaf65b58940a0b72f71c9ac0423cc67" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/php-invoker/zipball/5a10147d0aaf65b58940a0b72f71c9ac0423cc67", + "reference": "5a10147d0aaf65b58940a0b72f71c9ac0423cc67", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "ext-pcntl": "*", + "phpunit/phpunit": "^9.3" + }, + "suggest": { + "ext-pcntl": "*" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "3.1-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "Invoke callables with a timeout", + "homepage": "https://github.com/sebastianbergmann/php-invoker/", + "keywords": [ + "process" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/php-invoker/issues", + "source": "https://github.com/sebastianbergmann/php-invoker/tree/3.1.1" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2020-09-28T05:58:55+00:00" + }, + { + "name": "phpunit/php-text-template", + "version": "2.0.4", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/php-text-template.git", + "reference": "5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/php-text-template/zipball/5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28", + "reference": "5da5f67fc95621df9ff4c4e5a84d6a8a2acf7c28", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "2.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "Simple template engine.", + "homepage": "https://github.com/sebastianbergmann/php-text-template/", + "keywords": [ + "template" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/php-text-template/issues", + "source": "https://github.com/sebastianbergmann/php-text-template/tree/2.0.4" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2020-10-26T05:33:50+00:00" + }, + { + "name": "phpunit/php-timer", + "version": "5.0.3", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/php-timer.git", + "reference": "5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/php-timer/zipball/5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2", + "reference": "5a63ce20ed1b5bf577850e2c4e87f4aa902afbd2", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "5.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "Utility class for timing", + "homepage": "https://github.com/sebastianbergmann/php-timer/", + "keywords": [ + "timer" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/php-timer/issues", + "source": "https://github.com/sebastianbergmann/php-timer/tree/5.0.3" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2020-10-26T13:16:10+00:00" + }, + { + "name": "phpunit/phpunit", + "version": "9.6.13", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/phpunit.git", + "reference": "f3d767f7f9e191eab4189abe41ab37797e30b1be" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/phpunit/zipball/f3d767f7f9e191eab4189abe41ab37797e30b1be", + "reference": "f3d767f7f9e191eab4189abe41ab37797e30b1be", + "shasum": "" + }, + "require": { + "doctrine/instantiator": "^1.3.1 || ^2", + "ext-dom": "*", + "ext-json": "*", + "ext-libxml": "*", + "ext-mbstring": "*", + "ext-xml": "*", + "ext-xmlwriter": "*", + "myclabs/deep-copy": "^1.10.1", + "phar-io/manifest": "^2.0.3", + "phar-io/version": "^3.0.2", + "php": ">=7.3", + "phpunit/php-code-coverage": "^9.2.28", + "phpunit/php-file-iterator": "^3.0.5", + "phpunit/php-invoker": "^3.1.1", + "phpunit/php-text-template": "^2.0.3", + "phpunit/php-timer": "^5.0.2", + "sebastian/cli-parser": "^1.0.1", + "sebastian/code-unit": "^1.0.6", + "sebastian/comparator": "^4.0.8", + "sebastian/diff": "^4.0.3", + "sebastian/environment": "^5.1.3", + "sebastian/exporter": "^4.0.5", + "sebastian/global-state": "^5.0.1", + "sebastian/object-enumerator": "^4.0.3", + "sebastian/resource-operations": "^3.0.3", + "sebastian/type": "^3.2", + "sebastian/version": "^3.0.2" + }, + "suggest": { + "ext-soap": "To be able to generate mocks based on WSDL files", + "ext-xdebug": "PHP extension that provides line coverage as well as branch and path coverage" + }, + "bin": [ + "phpunit" + ], + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "9.6-dev" + } + }, + "autoload": { + "files": [ + "src/Framework/Assert/Functions.php" + ], + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "The PHP Unit Testing framework.", + "homepage": "https://phpunit.de/", + "keywords": [ + "phpunit", + "testing", + "xunit" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/phpunit/issues", + "security": "https://github.com/sebastianbergmann/phpunit/security/policy", + "source": "https://github.com/sebastianbergmann/phpunit/tree/9.6.13" + }, + "funding": [ + { + "url": "https://phpunit.de/sponsors.html", + "type": "custom" + }, + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + }, + { + "url": "https://tidelift.com/funding/github/packagist/phpunit/phpunit", + "type": "tidelift" + } + ], + "time": "2023-09-19T05:39:22+00:00" + }, + { + "name": "sebastian/cli-parser", + "version": "1.0.1", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/cli-parser.git", + "reference": "442e7c7e687e42adc03470c7b668bc4b2402c0b2" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/cli-parser/zipball/442e7c7e687e42adc03470c7b668bc4b2402c0b2", + "reference": "442e7c7e687e42adc03470c7b668bc4b2402c0b2", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "Library for parsing CLI options", + "homepage": "https://github.com/sebastianbergmann/cli-parser", + "support": { + "issues": "https://github.com/sebastianbergmann/cli-parser/issues", + "source": "https://github.com/sebastianbergmann/cli-parser/tree/1.0.1" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2020-09-28T06:08:49+00:00" + }, + { + "name": "sebastian/code-unit", + "version": "1.0.8", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/code-unit.git", + "reference": "1fc9f64c0927627ef78ba436c9b17d967e68e120" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/code-unit/zipball/1fc9f64c0927627ef78ba436c9b17d967e68e120", + "reference": "1fc9f64c0927627ef78ba436c9b17d967e68e120", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "Collection of value objects that represent the PHP code units", + "homepage": "https://github.com/sebastianbergmann/code-unit", + "support": { + "issues": "https://github.com/sebastianbergmann/code-unit/issues", + "source": "https://github.com/sebastianbergmann/code-unit/tree/1.0.8" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2020-10-26T13:08:54+00:00" + }, + { + "name": "sebastian/code-unit-reverse-lookup", + "version": "2.0.3", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/code-unit-reverse-lookup.git", + "reference": "ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/code-unit-reverse-lookup/zipball/ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5", + "reference": "ac91f01ccec49fb77bdc6fd1e548bc70f7faa3e5", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "2.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + } + ], + "description": "Looks up which function or method a line of code belongs to", + "homepage": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/", + "support": { + "issues": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/issues", + "source": "https://github.com/sebastianbergmann/code-unit-reverse-lookup/tree/2.0.3" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2020-09-28T05:30:19+00:00" + }, + { + "name": "sebastian/comparator", + "version": "4.0.8", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/comparator.git", + "reference": "fa0f136dd2334583309d32b62544682ee972b51a" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/comparator/zipball/fa0f136dd2334583309d32b62544682ee972b51a", + "reference": "fa0f136dd2334583309d32b62544682ee972b51a", + "shasum": "" + }, + "require": { + "php": ">=7.3", + "sebastian/diff": "^4.0", + "sebastian/exporter": "^4.0" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "4.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + }, + { + "name": "Jeff Welch", + "email": "whatthejeff@gmail.com" + }, + { + "name": "Volker Dusch", + "email": "github@wallbash.com" + }, + { + "name": "Bernhard Schussek", + "email": "bschussek@2bepublished.at" + } + ], + "description": "Provides the functionality to compare PHP values for equality", + "homepage": "https://github.com/sebastianbergmann/comparator", + "keywords": [ + "comparator", + "compare", + "equality" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/comparator/issues", + "source": "https://github.com/sebastianbergmann/comparator/tree/4.0.8" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2022-09-14T12:41:17+00:00" + }, + { + "name": "sebastian/complexity", + "version": "2.0.2", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/complexity.git", + "reference": "739b35e53379900cc9ac327b2147867b8b6efd88" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/complexity/zipball/739b35e53379900cc9ac327b2147867b8b6efd88", + "reference": "739b35e53379900cc9ac327b2147867b8b6efd88", + "shasum": "" + }, + "require": { + "nikic/php-parser": "^4.7", + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "2.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "Library for calculating the complexity of PHP code units", + "homepage": "https://github.com/sebastianbergmann/complexity", + "support": { + "issues": "https://github.com/sebastianbergmann/complexity/issues", + "source": "https://github.com/sebastianbergmann/complexity/tree/2.0.2" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2020-10-26T15:52:27+00:00" + }, + { + "name": "sebastian/diff", + "version": "4.0.5", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/diff.git", + "reference": "74be17022044ebaaecfdf0c5cd504fc9cd5a7131" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/diff/zipball/74be17022044ebaaecfdf0c5cd504fc9cd5a7131", + "reference": "74be17022044ebaaecfdf0c5cd504fc9cd5a7131", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.3", + "symfony/process": "^4.2 || ^5" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "4.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + }, + { + "name": "Kore Nordmann", + "email": "mail@kore-nordmann.de" + } + ], + "description": "Diff implementation", + "homepage": "https://github.com/sebastianbergmann/diff", + "keywords": [ + "diff", + "udiff", + "unidiff", + "unified diff" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/diff/issues", + "source": "https://github.com/sebastianbergmann/diff/tree/4.0.5" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2023-05-07T05:35:17+00:00" + }, + { + "name": "sebastian/environment", + "version": "5.1.5", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/environment.git", + "reference": "830c43a844f1f8d5b7a1f6d6076b784454d8b7ed" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/environment/zipball/830c43a844f1f8d5b7a1f6d6076b784454d8b7ed", + "reference": "830c43a844f1f8d5b7a1f6d6076b784454d8b7ed", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "suggest": { + "ext-posix": "*" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "5.1-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + } + ], + "description": "Provides functionality to handle HHVM/PHP environments", + "homepage": "http://www.github.com/sebastianbergmann/environment", + "keywords": [ + "Xdebug", + "environment", + "hhvm" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/environment/issues", + "source": "https://github.com/sebastianbergmann/environment/tree/5.1.5" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2023-02-03T06:03:51+00:00" + }, + { + "name": "sebastian/exporter", + "version": "4.0.5", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/exporter.git", + "reference": "ac230ed27f0f98f597c8a2b6eb7ac563af5e5b9d" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/exporter/zipball/ac230ed27f0f98f597c8a2b6eb7ac563af5e5b9d", + "reference": "ac230ed27f0f98f597c8a2b6eb7ac563af5e5b9d", + "shasum": "" + }, + "require": { + "php": ">=7.3", + "sebastian/recursion-context": "^4.0" + }, + "require-dev": { + "ext-mbstring": "*", + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "4.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + }, + { + "name": "Jeff Welch", + "email": "whatthejeff@gmail.com" + }, + { + "name": "Volker Dusch", + "email": "github@wallbash.com" + }, + { + "name": "Adam Harvey", + "email": "aharvey@php.net" + }, + { + "name": "Bernhard Schussek", + "email": "bschussek@gmail.com" + } + ], + "description": "Provides the functionality to export PHP variables for visualization", + "homepage": "https://www.github.com/sebastianbergmann/exporter", + "keywords": [ + "export", + "exporter" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/exporter/issues", + "source": "https://github.com/sebastianbergmann/exporter/tree/4.0.5" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2022-09-14T06:03:37+00:00" + }, + { + "name": "sebastian/global-state", + "version": "5.0.6", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/global-state.git", + "reference": "bde739e7565280bda77be70044ac1047bc007e34" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/global-state/zipball/bde739e7565280bda77be70044ac1047bc007e34", + "reference": "bde739e7565280bda77be70044ac1047bc007e34", + "shasum": "" + }, + "require": { + "php": ">=7.3", + "sebastian/object-reflector": "^2.0", + "sebastian/recursion-context": "^4.0" + }, + "require-dev": { + "ext-dom": "*", + "phpunit/phpunit": "^9.3" + }, + "suggest": { + "ext-uopz": "*" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "5.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + } + ], + "description": "Snapshotting of global state", + "homepage": "http://www.github.com/sebastianbergmann/global-state", + "keywords": [ + "global state" + ], + "support": { + "issues": "https://github.com/sebastianbergmann/global-state/issues", + "source": "https://github.com/sebastianbergmann/global-state/tree/5.0.6" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2023-08-02T09:26:13+00:00" + }, + { + "name": "sebastian/lines-of-code", + "version": "1.0.3", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/lines-of-code.git", + "reference": "c1c2e997aa3146983ed888ad08b15470a2e22ecc" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/lines-of-code/zipball/c1c2e997aa3146983ed888ad08b15470a2e22ecc", + "reference": "c1c2e997aa3146983ed888ad08b15470a2e22ecc", + "shasum": "" + }, + "require": { + "nikic/php-parser": "^4.6", + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "1.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "Library for counting the lines of code in PHP source code", + "homepage": "https://github.com/sebastianbergmann/lines-of-code", + "support": { + "issues": "https://github.com/sebastianbergmann/lines-of-code/issues", + "source": "https://github.com/sebastianbergmann/lines-of-code/tree/1.0.3" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2020-11-28T06:42:11+00:00" + }, + { + "name": "sebastian/object-enumerator", + "version": "4.0.4", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/object-enumerator.git", + "reference": "5c9eeac41b290a3712d88851518825ad78f45c71" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/object-enumerator/zipball/5c9eeac41b290a3712d88851518825ad78f45c71", + "reference": "5c9eeac41b290a3712d88851518825ad78f45c71", + "shasum": "" + }, + "require": { + "php": ">=7.3", + "sebastian/object-reflector": "^2.0", + "sebastian/recursion-context": "^4.0" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "4.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + } + ], + "description": "Traverses array structures and object graphs to enumerate all referenced objects", + "homepage": "https://github.com/sebastianbergmann/object-enumerator/", + "support": { + "issues": "https://github.com/sebastianbergmann/object-enumerator/issues", + "source": "https://github.com/sebastianbergmann/object-enumerator/tree/4.0.4" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2020-10-26T13:12:34+00:00" + }, + { + "name": "sebastian/object-reflector", + "version": "2.0.4", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/object-reflector.git", + "reference": "b4f479ebdbf63ac605d183ece17d8d7fe49c15c7" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/object-reflector/zipball/b4f479ebdbf63ac605d183ece17d8d7fe49c15c7", + "reference": "b4f479ebdbf63ac605d183ece17d8d7fe49c15c7", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "2.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + } + ], + "description": "Allows reflection of object attributes, including inherited and non-public ones", + "homepage": "https://github.com/sebastianbergmann/object-reflector/", + "support": { + "issues": "https://github.com/sebastianbergmann/object-reflector/issues", + "source": "https://github.com/sebastianbergmann/object-reflector/tree/2.0.4" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2020-10-26T13:14:26+00:00" + }, + { + "name": "sebastian/recursion-context", + "version": "4.0.5", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/recursion-context.git", + "reference": "e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/recursion-context/zipball/e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1", + "reference": "e75bd0f07204fec2a0af9b0f3cfe97d05f92efc1", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "4.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + }, + { + "name": "Jeff Welch", + "email": "whatthejeff@gmail.com" + }, + { + "name": "Adam Harvey", + "email": "aharvey@php.net" + } + ], + "description": "Provides functionality to recursively process PHP variables", + "homepage": "https://github.com/sebastianbergmann/recursion-context", + "support": { + "issues": "https://github.com/sebastianbergmann/recursion-context/issues", + "source": "https://github.com/sebastianbergmann/recursion-context/tree/4.0.5" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2023-02-03T06:07:39+00:00" + }, + { + "name": "sebastian/resource-operations", + "version": "3.0.3", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/resource-operations.git", + "reference": "0f4443cb3a1d92ce809899753bc0d5d5a8dd19a8" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/resource-operations/zipball/0f4443cb3a1d92ce809899753bc0d5d5a8dd19a8", + "reference": "0f4443cb3a1d92ce809899753bc0d5d5a8dd19a8", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.0" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "3.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de" + } + ], + "description": "Provides a list of PHP built-in functions that operate on resources", + "homepage": "https://www.github.com/sebastianbergmann/resource-operations", + "support": { + "issues": "https://github.com/sebastianbergmann/resource-operations/issues", + "source": "https://github.com/sebastianbergmann/resource-operations/tree/3.0.3" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2020-09-28T06:45:17+00:00" + }, + { + "name": "sebastian/type", + "version": "3.2.1", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/type.git", + "reference": "75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/type/zipball/75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7", + "reference": "75e2c2a32f5e0b3aef905b9ed0b179b953b3d7c7", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "require-dev": { + "phpunit/phpunit": "^9.5" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "3.2-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "Collection of value objects that represent the types of the PHP type system", + "homepage": "https://github.com/sebastianbergmann/type", + "support": { + "issues": "https://github.com/sebastianbergmann/type/issues", + "source": "https://github.com/sebastianbergmann/type/tree/3.2.1" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2023-02-03T06:13:03+00:00" + }, + { + "name": "sebastian/version", + "version": "3.0.2", + "source": { + "type": "git", + "url": "https://github.com/sebastianbergmann/version.git", + "reference": "c6c1022351a901512170118436c764e473f6de8c" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/sebastianbergmann/version/zipball/c6c1022351a901512170118436c764e473f6de8c", + "reference": "c6c1022351a901512170118436c764e473f6de8c", + "shasum": "" + }, + "require": { + "php": ">=7.3" + }, + "type": "library", + "extra": { + "branch-alias": { + "dev-master": "3.0-dev" + } + }, + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Sebastian Bergmann", + "email": "sebastian@phpunit.de", + "role": "lead" + } + ], + "description": "Library that helps with managing the version number of Git-hosted PHP projects", + "homepage": "https://github.com/sebastianbergmann/version", + "support": { + "issues": "https://github.com/sebastianbergmann/version/issues", + "source": "https://github.com/sebastianbergmann/version/tree/3.0.2" + }, + "funding": [ + { + "url": "https://github.com/sebastianbergmann", + "type": "github" + } + ], + "time": "2020-09-28T06:39:44+00:00" + }, + { + "name": "theseer/tokenizer", + "version": "1.2.1", + "source": { + "type": "git", + "url": "https://github.com/theseer/tokenizer.git", + "reference": "34a41e998c2183e22995f158c581e7b5e755ab9e" + }, + "dist": { + "type": "zip", + "url": "https://api.github.com/repos/theseer/tokenizer/zipball/34a41e998c2183e22995f158c581e7b5e755ab9e", + "reference": "34a41e998c2183e22995f158c581e7b5e755ab9e", + "shasum": "" + }, + "require": { + "ext-dom": "*", + "ext-tokenizer": "*", + "ext-xmlwriter": "*", + "php": "^7.2 || ^8.0" + }, + "type": "library", + "autoload": { + "classmap": [ + "src/" + ] + }, + "notification-url": "https://packagist.org/downloads/", + "license": [ + "BSD-3-Clause" + ], + "authors": [ + { + "name": "Arne Blankerts", + "email": "arne@blankerts.de", + "role": "Developer" + } + ], + "description": "A small library for converting tokenized PHP source code into XML and potentially other formats", + "support": { + "issues": "https://github.com/theseer/tokenizer/issues", + "source": "https://github.com/theseer/tokenizer/tree/1.2.1" + }, + "funding": [ + { + "url": "https://github.com/theseer", + "type": "github" + } + ], + "time": "2021-07-28T10:34:58+00:00" + } + ], + "aliases": [], + "minimum-stability": "stable", + "stability-flags": [], + "prefer-stable": false, + "prefer-lowest": false, + "platform": { + "php": ">=7.2.0" + }, + "platform-dev": [], + "plugin-api-version": "2.6.0" +} diff --git a/vendor/davechild/textstatistics/phpunit.xml.dist b/vendor/davechild/textstatistics/phpunit.xml.dist new file mode 100644 index 0000000..28d9aca --- /dev/null +++ b/vendor/davechild/textstatistics/phpunit.xml.dist @@ -0,0 +1,11 @@ + + + + + + ./tests/ + + + diff --git a/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/Maths.php b/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/Maths.php new file mode 100644 index 0000000..8972cc1 --- /dev/null +++ b/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/Maths.php @@ -0,0 +1,206 @@ + $max) { + $score = $max; + } elseif ($score < $min) { + $score = $min; + } + $score = self::bcCalc($score, '+', 0, true, $dps); // Round + + return $score; + } + + /** + * Do simple reliable floating point calculations without the risk of wrong results + * @see http://floating-point-gui.de/ + * @see the big red warning on http://php.net/language.types.float.php + * + * @source https://gist.github.com/jrfnl/8449978 + * + * In the rare case that the bcmath extension would not be loaded, it will return the normal calculation results + * + * @param mixed $number1 Scalar (string/int/float/bool) + * @param string $action Calculation action to execute. Valid input: + * '+' or 'add' or 'addition', + * '-' or 'sub' or 'subtract', + * '*' or 'mul' or 'multiply', + * '/' or 'div' or 'divide', + * '%' or 'mod' or 'modulus' + * '=' or 'comp' or 'compare' + * @param mixed $number2 Scalar (string/int/float/bool) + * @param bool $round Whether or not to round the result. Defaults to false. + * Will be disregarded for a compare operation + * @param int $decimals Decimals for rounding operation. Defaults to 0. + * @param int $precision Calculation precision. Defaults to 10. + * @return mixed Calculation result or false if either or the numbers isn't scalar or + * an invalid operation was passed + * - for compare the result will always be an integer + * - for all other operations, the result will either be an integer + * (preferred) or a float + */ + public static function bcCalc($number1, $action, $number2, $round = false, $decimals = 0, $precision = 10) + { + if (!is_scalar($number1) || !is_scalar($number2)) { + return false; + } + + // Check whether bcmath extension is available + if (is_null(self::$blnBcmath)) { + self::$blnBcmath = extension_loaded('bcmath'); + } + + // Check values of input variables + if (self::$blnBcmath) { + $number1 = strval($number1); + $number2 = strval($number2); + } + + if (!is_numeric($number1) || !is_numeric($number2)) { + return false; + } + + // Normalise operator + $action = self::normaliseOperator($action); + + // Perform calculation + return self::performCalc($number1, $action, $number2, $round, $decimals, $precision); + } + + /** + * Normalise operators for bcMath function. + * @param string $operator Operators such as "+", "add" + * @return string + */ + public static function normaliseOperator($operator) + { + switch ($operator) { + case 'add': + case 'addition': + $operator = '+'; + break; + case 'sub': + case 'subtract': + $operator = '-'; + break; + case 'mul': + case 'multiply': + $operator = '*'; + break; + case 'div': + case 'divide': + $operator = '/'; + break; + case 'mod': + case 'modulus': + $operator = '%'; + break; + case 'comp': + case 'compare': + $operator = '='; + break; + } + return $operator; + } + + /** + * Function which performs calculation. + * @param string|integer|float|boolean $number1 See bcCalc description + * @param string $action See bcCalc description + * @param string|integer|float|boolean $number2 See bcCalc description + * @param boolean $round See bcCalc description + * @param integer $decimals See bcCalc description + * @param integer $precision See bcCalc description + * @return integer|float|boolean + */ + private static function performCalc($number1, $action, $number2, $round, $decimals, $precision) + { + $result = null; + $compare = false; + switch ($action) { + case '+': + $result = (self::$blnBcmath) ? bcadd($number1, $number2, $precision) /* string */ : ($number1 + $number2); + break; + case '-': + $result = (self::$blnBcmath) ? bcsub($number1, $number2, $precision) /* string */ : ($number1 - $number2); + break; + case '*': + $result = (self::$blnBcmath) ? bcmul($number1, $number2, $precision) /* string */ : ($number1 * $number2); + break; + case 'sqrt': + $result = (self::$blnBcmath) ? bcsqrt($number1, $precision) /* string */ : sqrt($number1); + break; + case '/': + if ($number2 > 0) { + if (self::$blnBcmath) { + $result = bcdiv($number1, $number2, $precision); // string, or NULL if right_operand is 0 + } else if ($number2 != 0) { + $result = $number1 / $number2; + } + } + + if (!isset($result)) { + $result = 0; + } + break; + case '%': + if (self::$blnBcmath) { + $result = bcmod($number1, $number2); // string, or NULL if modulus is 0. + } else if ($number2 != 0) { + $result = $number1 % $number2; + } + + if (!isset($result)) { + $result = 0; + } + break; + case '=': + $compare = true; + if (self::$blnBcmath) { + $result = bccomp($number1, $number2, $precision); // returns int 0, 1 or -1 + } else { + $result = ($number1 == $number2) ? 0 : (($number1 > $number2) ? 1 : -1); + } + break; + } + + if (isset($result)) { + if ($compare === false) { + if ($round === true) { + $result = round(floatval($result), $decimals); + if ($decimals === 0) { + $result = (int) $result; + } + } else { + $result = (intval($result) == $result) ? intval($result) : floatval($result); + } + } + return $result; + } + + return false; + } +} diff --git a/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/Pluralise.php b/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/Pluralise.php new file mode 100644 index 0000000..505a50f --- /dev/null +++ b/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/Pluralise.php @@ -0,0 +1,185 @@ + "$1zes", + '/^(ox)$/i' => "$1en", + '/([m|l])ouse$/i' => "$1ice", + '/(matrix|vertex|index)$/i'=> "$1ices", + '/(x|ch|ss|sh)$/i' => "$1es", + '/([^aeiouy]|qu)y$/i' => "$1ies", + '/(hive)$/i' => "$1s", + '/(?:([^f])fe|([lr])f)$/i' => "$1$2ves", + '/(shea|lea|loa|thie)f$/i' => "$1ves", + '/sis$/i' => "ses", + '/([ti])um$/i' => "$1a", + '/(tomat|potat|ech|her|vet)o$/i'=> "$1oes", + '/(bu)s$/i' => "$1ses", + '/(alias)$/i' => "$1es", + '/(octop)us$/i' => "$1i", + '/(ax|test)is$/i' => "$1es", + '/(us)$/i' => "$1es", + '/s$/i' => "s" + ); + + private static $singular = array( + '/(quiz)zes$/i' => "$1", + '/(matr)ices$/i' => "$1ix", + '/(vert|ind)ices$/i' => "$1ex", + '/^(ox)en$/i' => "$1", + '/(alias)es$/i' => "$1", + '/(octop|vir)i$/i' => "$1us", + '/(cris|ax|test)es$/i' => "$1is", + '/(shoe)s$/i' => "$1", + '/(o)es$/i' => "$1", + '/(bus)es$/i' => "$1", + '/([m|l])ice$/i' => "$1ouse", + '/(x|ch|ss|sh)es$/i' => "$1", + '/(m)ovies$/i' => "$1ovie", + '/(s)eries$/i' => "$1eries", + '/([^aeiouy]|qu)ies$/i' => "$1y", + '/([lr])ves$/i' => "$1f", + '/(tive)s$/i' => "$1", + '/(hive)s$/i' => "$1", + '/(li|wi|kni)ves$/i' => "$1fe", + '/(shea|loa|lea|thie)ves$/i'=> "$1f", + '/(^analy)ses$/i' => "$1sis", + '/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i' => "$1$2sis", + '/([ti])a$/i' => "$1um", + '/(n)ews$/i' => "$1ews", + '/(h|bl)ouses$/i' => "$1ouse", + '/(corpse)s$/i' => "$1", + '/(us)es$/i' => "$1", + '/s$/i' => "" + ); + + private static $irregular = array( + 'child' => 'children', + 'foot' => 'feet', + 'goose' => 'geese', + 'man' => 'men', + 'mouse' => 'mice', + 'move' => 'moves', + 'person' => 'people', + 'sex' => 'sexes', + 'tooth' => 'teeth', + ); + + // Some words are only uncountable sometimes. For example, "blues" can be + // uncountable when referring to music, but countable when referring to + // multiple colours. + private static $uncountable = array( + 'beef', + 'bison', + 'buffalo', + 'carbon', + 'chemistry', + 'copper', + 'geometry', + 'gold', + 'cs', + 'css', + 'deer', + 'equipment', + 'fish', + 'furniture', + 'information', + 'mathematics', + 'money', + 'moose', + 'nitrogen', + 'oxygen', + 'rice', + 'series', + 'sheep', + 'species', + 'surgery', + 'traffic', + 'water' + ); + + /** + * Get the plural of the word passed in. + * @param string $string Word to pluralise + * @return string Pluralised word + */ + public static function getPlural($string) + { + // save some time in the case that singular and plural are the same + if (in_array(strtolower($string), self::$uncountable)) { + return $string; + } + + // check to see if already plural and irregular + foreach (self::$irregular as $pattern => $result) { + $_pattern = '/' . $result . '$/i'; + if (preg_match($_pattern, $string)) { + return $string; + } + } + + // check for irregular singular forms + foreach (self::$irregular as $pattern => $result) { + $pattern = '/' . $pattern . '$/i'; + if (preg_match($pattern, $string)) { + return preg_replace($pattern, $result, $string); + } + } + + // check for matches using regular expressions + foreach (self::$plural as $pattern => $result) { + if (preg_match($pattern, $string)) { + return preg_replace($pattern, $result, $string); + } + } + + // No pattern match. Add an "s". + return $string . 's'; + } + + /** + * Get the singular of the word passed in. + * @param string $string Word to singularise + * @return string Singularised word + */ + public static function getSingular($string) + { + // save some time in the case that singular and plural are the same + if (in_array(strtolower($string), self::$uncountable)) { + return $string; + } + + // check to see if already singular and irregular + foreach (self::$irregular as $pattern => $result) { + $_pattern = '/' . $pattern . '$/i'; + if (preg_match($_pattern, $string)) { + return $string; + } + } + + // check for irregular plural forms + foreach (self::$irregular as $result => $pattern) { + $pattern = '/' . $pattern . '$/i'; + if (preg_match($pattern, $string)) { + return preg_replace($pattern, $result, $string); + } + } + + // check for matches using regular expressions + foreach (self::$singular as $pattern => $result) { + if (preg_match($pattern, $string)) { + return preg_replace($pattern, $result, $string); + } + } + + return $string; + } +} diff --git a/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/Resource.php b/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/Resource.php new file mode 100644 index 0000000..b0e2a3a --- /dev/null +++ b/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/Resource.php @@ -0,0 +1,55 @@ + 4 + ,'abare' => 3 + ,'abed' => 2 + ,'abruzzese' => 4 + ,'abbruzzese' => 4 + ,'aborigine' => 5 + ,'acreage' => 3 + ,'adame' => 3 + ,'adieu' => 2 + ,'adobe' => 3 + ,'anemone' => 4 + ,'apache' => 3 + ,'aphrodite' => 4 + ,'apostrophe' => 4 + ,'ariadne' => 4 + ,'cafe' => 2 + ,'calliope' => 4 + ,'catastrophe' => 4 + ,'chile' => 2 + ,'chloe' => 2 + ,'circe' => 2 + ,'coyote' => 3 + ,'epitome' => 4 + ,'forever' => 3 + ,'gethsemane' => 4 + ,'guacamole' => 4 + ,'hyperbole' => 4 + ,'jesse' => 2 + ,'jukebox' => 2 + ,'karate' => 3 + ,'machete' => 3 + ,'maybe' => 2 + ,'packed' => 1 + ,'people' => 2 + ,'recipe' => 3 + ,'sesame' => 3 + ,'shoreline' => 2 + ,'simile' => 3 + ,'syncope' => 3 + ,'tamale' => 3 + ,'yosemite' => 4 + ,'daphne' => 2 + ,'eurydice' => 4 + ,'euterpe' => 3 + ,'hermione' => 4 + ,'penelope' => 4 + ,'persephone' => 4 + ,'phoebe' => 2 + ,'zoe' => 2 + ); + + // These syllables would be counted as two but should be one + static public $arrSubSyllables = array( + 'cia(l|$)' // glacial, acacia + ,'tia' + ,'cius' + ,'cious' + ,'[^aeiou]giu' + ,'[aeiouy][^aeiouy]ion' + ,'iou' + ,'sia$' + ,'eous$' + ,'[oa]gue$' + ,'.[^aeiuoycgltdb]{2,}ed$' + ,'.ely$' + //,'[cg]h?ed?$' + //,'rved?$' + //,'[aeiouy][dt]es?$' + //,'^[dr]e[aeiou][^aeiou]+$' // Sorts out deal, deign etc + //,'[aeiouy]rse$' // Purse, hearse + ,'^jua' + //,'nne[ds]?$' // canadienne + ,'uai' // acquainted + ,'eau' // champeau + //,'pagne[ds]?$' // champagne + //,'[aeiouy][^aeiuoytdbcgrnzs]h?e[rsd]?$' + // The following detects words ending with a soft e ending. Don't + // mess with it unless you absolutely have to! The following + // is a list of words you can use to test a new version of + // this rule (add 'r', 's' and 'd' where possible to test + // fully): + // - absolve + // - acquiesce + // - audience + // - ache + // - acquire + // - brunelle + // - byrne + // - canadienne + // - coughed + // - curved + // - champagne + // - designate + // - force + // - lace + // - late + // - lathe + // - make + // - relayed + // - scrounge + // - side + // - sideline + // - some + // - wide + // - taste + ,'[aeiouy](b|c|ch|d|dg|f|g|gh|gn|k|l|ll|lv|m|mm|n|nc|ng|nn|p|r|rc|rn|rs|rv|s|sc|sk|sl|squ|ss|st|t|th|v|y|z)e$' + // For soft e endings with a "d". Test words: + // - crunched + // - forced + // - hated + // - sided + // - sidelined + // - unexploded + // - unexplored + // - scrounged + // - squelched + // - forced + ,'[aeiouy](b|c|ch|dg|f|g|gh|gn|k|l|lch|ll|lv|m|mm|n|nc|ng|nch|nn|p|r|rc|rn|rs|rv|s|sc|sk|sl|squ|ss|th|v|y|z)ed$' + // For soft e endings with a "s". Test words: + // - absences + // - accomplices + // - acknowledges + // - advantages + // - byrnes + // - crunches + // - forces + // - scrounges + // - squelches + ,'[aeiouy](b|ch|d|f|gh|gn|k|l|lch|ll|lv|m|mm|n|nch|nn|p|r|rn|rs|rv|s|sc|sk|sl|squ|ss|st|t|th|v|y)es$' + ,'^busi$' + ); + + // These syllables would be counted as one but should be two + static public $arrAddSyllables = array( + '([^s]|^)ia' + ,'riet' + ,'dien' // audience + ,'iu' + ,'io' + ,'eo($|[b-df-hj-np-tv-z])' + ,'ii' + ,'[ou]a$' + ,'[aeiouym]bl$' + ,'[aeiou]{3}' + ,'[aeiou]y[aeiou]' + ,'^mc' + ,'ism$' + ,'asm$' + ,'thm$' + ,'([^aeiouy])\1l$' + ,'[^l]lien' + ,'^coa[dglx].' + ,'[^gq]ua[^auieo]' + ,'dnt$' + ,'uity$' + ,'[^aeiouy]ie(r|st|t)$' + ,'eings?$' + ,'[aeiouy]sh?e[rsd]$' + ,'iell' + ,'dea$' + ,'real' // real, cereal + ,'[^aeiou]y[ae]' // bryan, byerley + ,'gean$' // aegean + ,'uen' // influence, affluence + ); + + // Single syllable prefixes and suffixes + static public $arrAffix = array( + '`^un`' + ,'`^fore`' + ,'`^ware`' + ,'`^none?`' + ,'`^out`' + ,'`^post`' + ,'`^sub`' + ,'`^pre`' + ,'`^pro`' + ,'`^dis`' + ,'`^side`' + ,'`ly$`' + ,'`less$`' + ,'`some$`' + ,'`ful$`' + ,'`ers?$`' + ,'`ness$`' + ,'`cians?$`' + ,'`ments?$`' + ,'`ettes?$`' + ,'`villes?$`' + ,'`ships?$`' + ,'`sides?$`' + ,'`ports?$`' + ,'`shires?$`' + ,'`tion(ed)?$`' + ); + + // Double syllable prefixes and suffixes + static public $arrDoubleAffix = array( + '`^above`' + ,'`^ant[ie]`' + ,'`^counter`' + ,'`^hyper`' + ,'`^afore`' + ,'`^agri`' + ,'`^in[ft]ra`' + ,'`^inter`' + ,'`^over`' + ,'`^semi`' + ,'`^ultra`' + ,'`^under`' + ,'`^extra`' + ,'`^dia`' + ,'`^micro`' + ,'`^mega`' + ,'`^kilo`' + ,'`^pico`' + ,'`^nano`' + ,'`^macro`' + ,'`berry$`' + ,'`woman$`' + ,'`women$`' + ); + + // Triple syllable prefixes and suffixes + static public $arrTripleAffix = array( + '`ology$`' + ,'`ologist$`' + ,'`onomy$`' + ,'`onomist$`' + ); + + /** + * Returns the number of syllables in the word. + * Based in part on Greg Fast's Perl module Lingua::EN::Syllables + * @param string $strWord Word to be measured + * @param string $strEncoding Encoding of text + * @return int + */ + public static function syllableCount($strWord, $strEncoding = '') + { + + // Trim whitespace + $strWord = trim($strWord); + + // Check we have some letters + if (Text::letterCount(trim($strWord), $strEncoding) == 0) { + return 0; + } + + // $debug is an array containing the basic syllable counting steps for + // this word. + $debug = array(); + $debug['Counting syllables for'] = $strWord; + + // Should be no non-alpha characters and lower case + $strWord = preg_replace('`[^A-Za-z]`', '', $strWord); + $strWord = Text::lowerCase($strWord, $strEncoding); + + // Check for problem words + if (isset(self::$arrProblemWords[$strWord])) { + return self::$arrProblemWords[$strWord]; + } + // Try singular + $singularWord = Pluralise::getSingular($strWord); + if ($singularWord != $strWord) { + if (isset(self::$arrProblemWords[$singularWord])) { + return self::$arrProblemWords[$singularWord]; + } + } + + $debug['After cleaning, lcase'] = $strWord; + + // Remove prefixes and suffixes and count how many were taken + $strWord = preg_replace(self::$arrAffix, '', $strWord, -1, $intAffixCount); + $strWord = preg_replace(self::$arrDoubleAffix, '', $strWord, -1, $intDoubleAffixCount); + $strWord = preg_replace(self::$arrTripleAffix, '', $strWord, -1, $intTripleAffixCount); + + if (($intAffixCount + $intDoubleAffixCount + $intTripleAffixCount) > 0) { + $debug['After Prefix and Suffix Removal'] = $strWord; + $debug['Prefix and suffix counts'] = $intAffixCount . ' * 1 syllable, ' . $intDoubleAffixCount . ' * 2 syllables, ' . $intTripleAffixCount . ' * 3 syllables'; + } + + // Removed non-word characters from word + $arrWordParts = preg_split('`[^aeiouy]+`', $strWord); + $intWordPartCount = 0; + foreach ($arrWordParts as $strWordPart) { + if ($strWordPart <> '') { + $debug['Counting (' . $intWordPartCount . ')'] = $strWordPart; + $intWordPartCount++; + } + } + + // Some syllables do not follow normal rules - check for them + // Thanks to Joe Kovar for correcting a bug in the following lines + $intSyllableCount = $intWordPartCount + $intAffixCount + (2 * $intDoubleAffixCount) + (3 * $intTripleAffixCount); + $debug['Syllables by Vowel Count'] = $intSyllableCount; + + foreach (self::$arrSubSyllables as $strSyllable) { + $_intSyllableCount = $intSyllableCount; + $intSyllableCount -= preg_match('`' . $strSyllable . '`', $strWord); + if ($_intSyllableCount != $intSyllableCount) { + $debug['Subtracting (' . $strSyllable . ')'] = $strSyllable; + } + } + foreach (self::$arrAddSyllables as $strSyllable) { + $_intSyllableCount = $intSyllableCount; + $intSyllableCount += preg_match('`' . $strSyllable . '`', $strWord); + if ($_intSyllableCount != $intSyllableCount) { + $debug['Adding (' . $strSyllable . ')'] = $strSyllable; + } + } + $intSyllableCount = ($intSyllableCount == 0) ? 1 : $intSyllableCount; + + $debug['Result'] = $intSyllableCount; + + return $intSyllableCount; + } + + /** + * Returns total syllable count for text. + * @param string $strText Text to be measured + * @param string $strEncoding Encoding of text + * @return int + */ + public static function totalSyllables($strText, $strEncoding = '') + { + $intSyllableCount = 0; + $arrWords = explode(' ', $strText); + $intWordCount = count($arrWords); + for ($i = 0; $i < $intWordCount; $i++) { + $intSyllableCount += self::syllableCount($arrWords[$i], $strEncoding); + } + + return $intSyllableCount; + } + + /** + * Returns average syllables per word for text. + * @param string $strText Text to be measured + * @param string $strEncoding Encoding of text + * @return int|float + */ + public static function averageSyllablesPerWord($strText, $strEncoding = '') + { + $intSyllableCount = 0; + $intWordCount = Text::wordCount($strText, $strEncoding); + $arrWords = explode(' ', $strText); + for ($i = 0; $i < $intWordCount; $i++) { + $intSyllableCount += self::syllableCount($arrWords[$i], $strEncoding); + } + $averageSyllables = (Maths::bcCalc($intSyllableCount, '/', $intWordCount)); + return $averageSyllables; + } + + /** + * Returns the number of words with more than three syllables + * @param string $strText Text to be measured + * @param bool $blnCountProperNouns Boolean - should proper nouns be included in words count + * @param string $strEncoding Encoding of text + * @return int + */ + public static function wordsWithThreeSyllables($strText, $blnCountProperNouns = true, $strEncoding = '') + { + $intLongWordCount = 0; + $intWordCount = Text::wordCount($strText, $strEncoding); + $arrWords = explode(' ', $strText); + for ($i = 0; $i < $intWordCount; $i++) { + if (Syllables::syllableCount($arrWords[$i], $strEncoding) > 2) { + if ($blnCountProperNouns) { + $intLongWordCount++; + } else { + $strFirstLetter = Text::substring($arrWords[$i], 0, 1, $strEncoding); + if ($strFirstLetter !== Text::upperCase($strFirstLetter, $strEncoding)) { + // First letter is lower case. Count it. + $intLongWordCount++; + } + } + } + } + + return $intLongWordCount; + } + + /** + * Returns the percentage of words with more than three syllables + * @param string $strText Text to be measured + * @param bool $blnCountProperNouns Boolean - should proper nouns be included in words count + * @return int|float + */ + public static function percentageWordsWithThreeSyllables($strText, $blnCountProperNouns = true, $strEncoding = '') + { + $intWordCount = Text::wordCount($strText, $strEncoding); + $intLongWordCount = self::wordsWithThreeSyllables($strText, $blnCountProperNouns, $strEncoding); + $intPercentage = Maths::bcCalc(Maths::bcCalc($intLongWordCount, '/', $intWordCount), '*', 100); + + return $intPercentage; + } +} diff --git a/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/Text.php b/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/Text.php new file mode 100644 index 0000000..6210848 --- /dev/null +++ b/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/Text.php @@ -0,0 +1,274 @@ +(.*?)`is', '', $strText); + $strText = preg_replace('`\]*>`is', '.', $strText); + $strText = html_entity_decode($strText); + $strText = strip_tags($strText); + + // Assume blank lines (i.e., paragraph breaks) end sentences (useful + // for titles in plain text documents) and replace remaining new + // lines with spaces + $strText = preg_replace('`(\r\n|\n\r)`is', "\n", $strText); + $strText = preg_replace('`(\r|\n){2,}`is', ".\n\n", $strText); + $strText = preg_replace('`[ ]*(\n|\r\n|\r)[ ]*`', ' ', $strText); + + // Replace commas, hyphens, quotes etc (count as spaces) + $strText = preg_replace('`[",:;()/\`-]`', ' ', $strText); + + // Unify terminators and spaces + $strText = trim($strText, '. ') . '.'; // Add final terminator. + $strText = preg_replace('`[\.!?]`', '.', $strText); // Unify terminators + $strText = preg_replace('`([\.\s]*\.[\.\s]*)`mis', '. ', $strText); // Merge terminators separated by whitespace. + $strText = preg_replace('`[ ]+`', ' ', $strText); // Remove multiple spaces + $strText = preg_replace('`([\.])[\. ]+`', '$1', $strText); // Check for duplicated terminators + $strText = trim(preg_replace('`[ ]*([\.])`', '$1 ', $strText)); // Pad sentence terminators + + // Lower case all words following terminators (for gunning fog score) + $strText = preg_replace_callback('`\. [^\. ]`', function($matches) { return strtolower($matches[0]); }, $strText); + + $strText = trim($strText); + + // Cache it and return + self::$clean[$key] = $strText; + return $strText; + } + + /** + * Converts string to lower case. Tries mb_strtolower and if that fails uses regular strtolower. + * @param string $strText Text to be transformed + * @param string $strEncoding Encoding of text + * @return string + */ + public static function lowerCase($strText, $strEncoding = '') + { + if ($strEncoding == '') { + $strLowerCaseText = mb_strtolower($strText); + } else { + $strLowerCaseText = mb_strtolower($strText, $strEncoding); + } + + return $strLowerCaseText; + } + + /** + * Converts string to upper case. Tries mb_strtoupper and if that fails uses regular strtoupper. + * @param string $strText Text to be transformed + * @param string $strEncoding Encoding of text + * @return string + */ + public static function upperCase($strText, $strEncoding = '') + { + if ($strEncoding == '') { + $strUpperCaseText = mb_strtoupper($strText); + } else { + $strUpperCaseText = mb_strtoupper($strText, $strEncoding); + } + + return $strUpperCaseText; + } + + /** + * Gets portion of string. Tries mb_substr and if that fails uses regular substr. + * @param string $strText Text to be cut up + * @param int $intStart Start character + * @param int $intLength Length + * @param string $strEncoding Encoding of text + * @return string + */ + public static function substring($strText, $intStart, $intLength, $strEncoding = '') + { + if ($strEncoding == '') { + $strSubstring = mb_substr($strText, $intStart, $intLength); + } else { + $strSubstring = mb_substr($strText, $intStart, $intLength, $strEncoding); + } + + return $strSubstring; + } + + /** + * Gives string length. Tries mb_strlen and if that fails uses regular strlen. + * @param string $strText Text to be measured + * @param string $strEncoding Encoding of text + * @return int + */ + public static function textLength($strText, $strEncoding = '') + { + if ($strEncoding == '') { + $intTextLength = mb_strlen($strText); + } else { + $intTextLength = mb_strlen($strText, $strEncoding); + } + + return $intTextLength; + } + + /** + * Alias for textLength, as "letterCount", "wordCount" etc also used + * @param string $strText Text to be measured + * @param string $strEncoding Encoding of text + * @return int + */ + public static function characterCount($strText, $strEncoding = '') + { + return self::textLength($strText, $strEncoding); + } + + /** + * Gives letter count (ignores all non-letters). Tries mb_strlen and if + * that fails uses regular strlen. + * @param string $strText Text to be measured + * @param string $strEncoding Encoding of text + * @return int + */ + public static function letterCount($strText, $strEncoding = '') + { + if (strlen(trim($strText)) == 0) { + return 0; + } + + $strText = self::cleanText($strText); // To clear out newlines etc + $intTextLength = 0; + $strText = preg_replace('`[^A-Za-z]+`', '', $strText); + if ($strEncoding == '') { + $intTextLength = mb_strlen($strText); + } else { + $intTextLength = mb_strlen($strText, $strEncoding); + } + + return $intTextLength; + } + + /** + * Returns word count for text. + * @param string $strText Text to be measured + * @param string $strEncoding Encoding of text + * @return int + */ + public static function wordCount($strText, $strEncoding = '') + { + if (strlen(trim($strText)) == 0) { + return 0; + } + + // Will be tripped by em dashes with spaces either side, among other similar characters + $intWords = 1 + self::textLength(preg_replace('`[^ ]`', '', preg_replace('`\s+`', ' ', $strText)), $strEncoding); // Space count + 1 is word count + + return $intWords; + } + + /** + * Returns sentence count for text. + * @param string $strText Text to be measured + * @param string $strEncoding Encoding of text + * @return int + */ + public static function sentenceCount($strText, $strEncoding = '') + { + if (strlen(trim($strText)) == 0) { + return 0; + } + + // Will be tripped up by "Mr." or "U.K.". Not a major concern at this point. + $intSentences = max(1, self::textLength(preg_replace('`[^\.!?]`', '', $strText), $strEncoding)); + + return $intSentences; + } + + /** + * Returns average words per sentence for text. + * @param string $strText Text to be measured + * @param string $strEncoding Encoding of text + * @return int|float + */ + public static function averageWordsPerSentence($strText, $strEncoding = '') + { + $intSentenceCount = self::sentenceCount($strText, $strEncoding); + $intWordCount = self::wordCount($strText, $strEncoding); + + $averageWords = (Maths::bcCalc($intWordCount, '/', $intSentenceCount)); + return $averageWords; + } +} diff --git a/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/TextStatistics.php b/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/TextStatistics.php new file mode 100644 index 0000000..7460a3a --- /dev/null +++ b/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/TextStatistics.php @@ -0,0 +1,636 @@ +flesch_kincaid_reading_ease($text); + +*/ + +class TextStatistics +{ + /** + * @var string $strEncoding Used to hold character encoding to be used + * by object, if set + */ + protected $strEncoding = ''; + + /** + * @var Maximum grade level to be reported. Calculated grades above + * this level will be returned as this value. + */ + protected $maxGradeLevel = 12; + + /** + * @var bool $normalise Should the result be normalised? + */ + public $normalise = true; + + /** + * @var int $dps How many decimal places should results be given to? + */ + public $dps = 1; + + /** + * @var string $strText Holds the last text checked. If no text passed to + * function, it will use this text instead. + */ + private static $strText = false; + + /** + * Constructor. + * + * @param string $strEncoding Optional character encoding. + * @return void + */ + public function __construct($strEncoding = '') + { + if ($strEncoding != '') { + // Encoding is given. Use it! + $this->strEncoding = $strEncoding; + } + } + + /** + * Set the text to measure the readability of. + * @param string|boolean $strText Text to be checked + * @return string Cleaned text + */ + public function setText($strText) + { + + // If text passed in, clean it up and store it for subsequent queries + if ($strText !== false) { + self::$strText = Text::cleanText($strText); + } + + return self::$strText; + } + + /** + * Set the encoding of the text being measured. + * @param string $strEncoding New encoding + * @return boolean + */ + public function setEncoding($strEncoding) + { + $this->strEncoding = $strEncoding; + return true; + } + + /** + * Set the maximum grade level for grade-level type indexes + * (Flesch-Kincaid Grade Level, Gunning-Fog, Coleman-Liau, SMOG, Automated Readability) + * @param integer $maxGradeLevel Grade level to use + * @return boolean Success + */ + public function setMaxGradeLevel($maxGradeLevel) + { + $maxGradeLevel = (integer) $maxGradeLevel; + if( $maxGradeLevel ) + { + $this->maxGradeLevel = $maxGradeLevel; + return true; + } + return false; + } + + /** + * Gives the Flesch-Kincaid Reading Ease of text entered rounded to one digit + * @param boolean|string $strText Text to be checked + * @return int|float + */ + public function fleschKincaidReadingEase($strText = false) + { + $strText = $this->setText($strText); + + $score = Maths::bcCalc( + Maths::bcCalc( + 206.835, + '-', + Maths::bcCalc( + 1.015, + '*', + Text::averageWordsPerSentence($strText, $this->strEncoding) + ) + ), + '-', + Maths::bcCalc( + 84.6, + '*', + Syllables::averageSyllablesPerWord($strText, $this->strEncoding) + ) + ); + + if ($this->normalise) { + return Maths::normaliseScore($score, 0, 100, $this->dps); + } else { + return Maths::bcCalc($score, '+', 0, true, $this->dps); + } + } + + /** + * Gives the Flesch-Kincaid Grade level of text entered rounded to one digit + * @param boolean|string $strText Text to be checked + * @return int|float + */ + public function fleschKincaidGradeLevel($strText = false) + { + $strText = $this->setText($strText); + + $score = Maths::bcCalc( + Maths::bcCalc( + 0.39, + '*', + Text::averageWordsPerSentence($strText, $this->strEncoding) + ), + '+', + Maths::bcCalc( + Maths::bcCalc( + 11.8, + '*', + Syllables::averageSyllablesPerWord($strText, $this->strEncoding) + ), + '-', + 15.59 + ) + ); + + if ($this->normalise) { + return Maths::normaliseScore($score, 0, $this->maxGradeLevel, $this->dps); + } else { + return Maths::bcCalc($score, '+', 0, true, $this->dps); + } + } + + /** + * Gives the Gunning-Fog score of text entered rounded to one digit + * @param boolean|string $strText Text to be checked + * @return int|float + */ + public function gunningFogScore($strText = false) + { + $strText = $this->setText($strText); + + $score = Maths::bcCalc( + Maths::bcCalc( + Text::averageWordsPerSentence($strText, $this->strEncoding), + '+', + Syllables::percentageWordsWithThreeSyllables($strText, false, $this->strEncoding) + ), + '*', + '0.4' + ); + + if ($this->normalise) { + return Maths::normaliseScore($score, 0, 19, $this->dps); + } else { + return Maths::bcCalc($score, '+', 0, true, $this->dps); + } + } + + /** + * Gives the Coleman-Liau Index of text entered rounded to one digit + * @param boolean|string $strText Text to be checked + * @return int|float + */ + public function colemanLiauIndex($strText = false) + { + $strText = $this->setText($strText); + + $score = Maths::bcCalc( + Maths::bcCalc( + Maths::bcCalc( + 5.89, + '*', + Maths::bcCalc( + Text::letterCount($strText, $this->strEncoding), + '/', + Text::wordCount($strText, $this->strEncoding) + ) + ), + '-', + Maths::bcCalc( + 0.3, + '*', + Maths::bcCalc( + Text::sentenceCount($strText, $this->strEncoding), + '/', + Text::wordCount($strText, $this->strEncoding) + ) + ) + ), + '-', + 15.8 + ); + + if ($this->normalise) { + return Maths::normaliseScore($score, 0, $this->maxGradeLevel, $this->dps); + } else { + return Maths::bcCalc($score, '+', 0, true, $this->dps); + } + } + + /** + * Gives the SMOG Index of text entered rounded to one digit + * @param boolean|string $strText Text to be checked + * @return int|float + */ + public function smogIndex($strText = false) + { + $strText = $this->setText($strText); + + $score = Maths::bcCalc( + 1.043, + '*', + Maths::bcCalc( + Maths::bcCalc( + Maths::bcCalc( + Syllables::wordsWithThreeSyllables($strText, true, $this->strEncoding), + '*', + Maths::bcCalc( + 30, + '/', + Text::sentenceCount($strText, $this->strEncoding) + ) + ), + 'sqrt', + 0 + ), + '+', + 3.1291 + ) + ); + + if ($this->normalise) { + return Maths::normaliseScore($score, 0, $this->maxGradeLevel, $this->dps); + } else { + return Maths::bcCalc($score, '+', 0, true, $this->dps); + } + } + + /** + * Gives the Automated Readability Index of text entered rounded to one digit + * @param boolean|string $strText Text to be checked + * @return int|float + */ + public function automatedReadabilityIndex($strText = false) + { + $strText = $this->setText($strText); + + $score = Maths::bcCalc( + Maths::bcCalc( + 4.71, + '*', + Maths::bcCalc( + Text::letterCount($strText, $this->strEncoding), + '/', + Text::wordCount($strText, $this->strEncoding) + ) + ), + '+', + Maths::bcCalc( + Maths::bcCalc( + 0.5, + '*', + Maths::bcCalc( + Text::wordCount($strText, $this->strEncoding), + '/', + Text::sentenceCount($strText, $this->strEncoding) + ) + ), + '-', + 21.43 + ) + ); + + if ($this->normalise) { + return Maths::normaliseScore($score, 0, $this->maxGradeLevel, $this->dps); + } else { + return Maths::bcCalc($score, '+', 0, true, $this->dps); + } + } + + /** + * Gives the Dale-Chall readability score of text entered rounded to one digit + * @param boolean|string $strText Text to be checked + * @return int|float + */ + public function daleChallReadabilityScore($strText = false) + { + $strText = $this->setText($strText); + + $score = Maths::bcCalc( + Maths::bcCalc( + 0.1579, + '*', + Maths::bcCalc( + 100, + '*', + Maths::bcCalc( + $this->daleChallDifficultWordCount($strText), + '/', + Text::wordCount($strText, $this->strEncoding) + ) + ) + ), + '+', + Maths::bcCalc( + 0.0496, + '*', + Maths::bcCalc( + Text::wordCount($strText, $this->strEncoding), + '/', + Text::sentenceCount($strText, $this->strEncoding) + ) + ) + ); + + if ($this->normalise) { + return Maths::normaliseScore($score, 0, 10, $this->dps); + } else { + return Maths::bcCalc($score, '+', 0, true, $this->dps); + } + } + + /** + * Gives the Spache readability score of text entered rounded to one digit + * @param boolean|string $strText Text to be checked + * @return int|float + */ + public function spacheReadabilityScore($strText = false) + { + $strText = $this->setText($strText); + + $score = Maths::bcCalc( + Maths::bcCalc( + Maths::bcCalc( + 0.121, + '*', + Maths::bcCalc( + Text::wordCount($strText, $this->strEncoding), + '/', + Text::sentenceCount($strText, $this->strEncoding) + ) + ), + '+', + Maths::bcCalc( + 0.082, + '*', + $this->spacheDifficultWordCount($strText) + ) + ), + '+', + 0.659 + ); + + if ($this->normalise) { + return Maths::normaliseScore($score, 0, 5, $this->dps); // Not really suitable for measuring readability above grade 4 + } else { + return Maths::bcCalc($score, '+', 0, true, $this->dps); + } + } + + /** + * Returns the number of words NOT on the Dale-Chall easy word list + * @param boolean|string $strText Text to be measured + * @return int + */ + public function daleChallDifficultWordCount($strText = false) + { + $strText = $this->setText($strText); + $intDifficultWords = 0; + $arrWords = explode(' ', Text::lowerCase(preg_replace('`[^A-za-z\' ]`', '', $strText), $this->strEncoding)); + + // Fetch Dale-Chall Words + $arrDaleChall = Resource::fetchDaleChallWordList(); + + for ($i = 0, $intWordCount = count($arrWords); $i < $intWordCount; $i++) { + // Single letters are counted as easy + if (strlen(trim($arrWords[$i])) < 2) { + continue; + } + if ((!in_array(Pluralise::getPlural($arrWords[$i]), $arrDaleChall)) && (!in_array(Pluralise::getSingular($arrWords[$i]), $arrDaleChall))) { + $intDifficultWords++; + } + } + + return $intDifficultWords; + } + + /** + * Returns the number of unique words NOT on the Spache easy word list + * @param boolean|string $strText Text to be measured + * @return int + */ + public function spacheDifficultWordCount($strText = false) + { + $strText = $this->setText($strText); + $intDifficultWords = 0; + $arrWords = explode(' ', strtolower(preg_replace('`[^A-za-z\' ]`', '', $strText))); + // Fetch Spache Words + $wordsCounted = array(); + + // Get the Spache word list + $arrSpache = Resource::fetchSpacheWordList(); + + for ($i = 0, $intWordCount = count($arrWords); $i < $intWordCount; $i++) { + // Single letters are counted as easy + if (strlen(trim($arrWords[$i])) < 2) { + continue; + } + $singularWord = Pluralise::getSingular($arrWords[$i]); + if ((!in_array(Pluralise::getPlural($arrWords[$i]), $arrSpache)) && (!in_array($singularWord, $arrSpache))) { + if (!in_array($singularWord, $wordsCounted)) { + $intDifficultWords++; + $wordsCounted[] = $singularWord; + } + } + } + + return $intDifficultWords; + } + + /** + * Returns letter count for text. + * @param boolean|string $strText Text to be measured + * @return int + */ + public function letterCount($strText = false) + { + $strText = $this->setText($strText); + + return Text::letterCount($strText, $this->strEncoding); + } + + /** + * Returns sentence count for text. + * @param boolean|string $strText Text to be measured + * @return int + */ + public function sentenceCount($strText = false) + { + $strText = $this->setText($strText); + + return Text::sentenceCount($strText, $this->strEncoding); + } + + /** + * Returns word count for text. + * @param boolean|string $strText Text to be measured + * @return int + */ + public function wordCount($strText = false) + { + $strText = $this->setText($strText); + + return Text::wordCount($strText, $this->strEncoding); + } + + /** + * Returns average words per sentence for text. + * @param boolean|string $strText Text to be measured + * @return int|float + */ + public function averageWordsPerSentence($strText = false) + { + $strText = $this->setText($strText); + + return Text::averageWordsPerSentence($strText, $this->strEncoding); + } + + /** + * Returns number of syllables in a word + * @param boolean|string $strText Text to be measured + * @return int + */ + public function syllableCount($strText = false) + { + $strText = $this->setText($strText); + + return Syllables::syllableCount($strText, $this->strEncoding); + } + + /** + * Returns total syllable count for text. + * @param boolean|string $strText Text to be measured + * @return int + */ + public function totalSyllables($strText = false) + { + $strText = $this->setText($strText); + + return Syllables::totalSyllables($strText, $this->strEncoding); + } + + /** + * Returns average syllables per word for text. + * @param boolean|string $strText Text to be measured + * @return int|float + */ + public function averageSyllablesPerWord($strText = false) + { + $strText = $this->setText($strText); + + return Syllables::averageSyllablesPerWord($strText, $this->strEncoding); + } + + /** + * Returns the number of words with more than three syllables + * @param boolean|string $strText Text to be measured + * @param bool $blnCountProperNouns Boolean - should proper nouns be included in words count + * @return int + */ + public function wordsWithThreeSyllables($strText = false, $blnCountProperNouns = true) + { + $strText = $this->setText($strText); + + return Syllables::wordsWithThreeSyllables($strText, $blnCountProperNouns, $this->strEncoding); + } + + /** + * Returns the percentage of words with more than three syllables + * @param boolean|string $strText Text to be measured + * @param bool $blnCountProperNouns Boolean - should proper nouns be included in words count + * @return int|float + */ + public function percentageWordsWithThreeSyllables($strText = false, $blnCountProperNouns = true) + { + $strText = $this->setText($strText); + + return Syllables::percentageWordsWithThreeSyllables($strText, $blnCountProperNouns, $this->strEncoding); + } + + /** + * We switched to camel-case but we'll leave these aliases in for + * convenience for anyone switching from the previous version. + */ + public function flesch_kincaid_reading_ease($strText = false) + { + return $this->fleschKincaidReadingEase($strText); + } + + public function flesch_kincaid_grade_level($strText = false) + { + return $this->fleschKincaidGradeLevel($strText); + } + + public function gunning_fog_score($strText = false) + { + return $this->gunningFogScore($strText); + } + + public function coleman_liau_index($strText = false) + { + return $this->colemanLiauIndex($strText); + } + + public function smog_index($strText = false) + { + return $this->smogIndex($strText); + } + + public function automated_readability_index($strText = false) + { + return $this->automatedReadabilityIndex($strText); + } + + public function dale_chall_readability_score($strText = false) + { + return $this->daleChallReadabilityScore($strText); + } + + public function spache_readability_score($strText = false) + { + return $this->spacheReadabilityScore($strText); + } +} diff --git a/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/resources/DaleChallWordList.php b/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/resources/DaleChallWordList.php new file mode 100644 index 0000000..c22115d --- /dev/null +++ b/vendor/davechild/textstatistics/src/DaveChild/TextStatistics/resources/DaleChallWordList.php @@ -0,0 +1,2952 @@ +TextStatistics = new DaveChild\TextStatistics\TextStatistics(); + $this->TextStatistics->normalise = false; + } + + public function tearDown(): void + { + unset($this->objTextStatistics); + } + + /* Test Syllables + -------------------- */ + + public function testSyllableCountFailingCMUWords() + { + $this->assertEquals(4, $this->TextStatistics->syllableCount("abalone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("abare")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("abatement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("abatements")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("abbatiello")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("abbruzzese")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("abed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("abeyance")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("aborigine")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("aborigines")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("abounded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aboveboard")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aboveground")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("abridged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("abruzzese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("absences")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("absoluteness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("absolve")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("absolves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("abuses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("acacia")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("academically")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("academician")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("academicians")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("acceding")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("acceptances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("accion")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("accompaniment")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("accompaniments")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("accomplice")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("accomplices")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("accorded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("accordion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("accuses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("aces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("achievement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("achievements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("achoa")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("acknowledged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("acknowledgement")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("acknowledges")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("acoustically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("acquaint")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("acquaintance")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("acquainted")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("acquiesced")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("acquire")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("acquired")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("acquirer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("acquirers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("acquires")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("acreage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("acuteness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("adabelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("adage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("adame")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("added")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("addeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("addled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("adelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("adieu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("adjudged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("admired")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("adorabelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("advanced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("advancement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("advancements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("advances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("advantage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("advantaged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("advantageous")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("advantages")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("adventuresome")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("advertisement")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("advertisements")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("advertises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("advice")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("advisedly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("advisement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("advises")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aegean")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("aerobically")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("aerodynamically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aerospace")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aerospatiale")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("aesthetically")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("afanasyev")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("affixes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("affluence")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("affluent")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("afforded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aforementioned")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aforesaid")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("afterimage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aftertaste")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("aged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ageless")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ages")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aggrandizement")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aggressiveness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("agius")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("agne")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("agonizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("agreement")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("agribusiness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aguayo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("aherne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aiguebelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("airborne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aircoa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("airspace")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("aisle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("aisles")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("akiyama")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("alarice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("albertville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("albion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("alcoa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("aldred")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aleo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("algeo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("algorithm")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aliases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("alice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("alicia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("allderdice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("allege")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("alleged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("alleges")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("allegiances")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("alles")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("alliances")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("allowances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("allspice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("allwaste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("alsace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("altarpiece")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("altice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("alusuisse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("alveolar")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("alveoli")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("alyce")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("alyea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("alyeska")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amabelle")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("amadea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("amadeo")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("amaryllises")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amaya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amazement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amazes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ambled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ambrosial")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ambrosian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ambulances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amended")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("amezcua")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("amityville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amorette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amperage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amusement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amusements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amuses")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("analyses")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("analyzes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("anaya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("anchorage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("andalusian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("andreoli")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("andreoni")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("andreotti")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("andreozzi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("anette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("angelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("angerer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("angering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("angled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("anisette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("annabelle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("anne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("annette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("annexes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("announced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("announcement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("announcements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("announces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("annoyance")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("annoyances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("anstice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("antaya")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("antiabortion")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("antiapartheid")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("antoinette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("anyplace")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("anzaldua")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aoyama")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("apace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("apiece")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("apologizes")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("apotheosis")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("apparatuses")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("appearances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("appeasement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("appendage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("appendages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("appended")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("appendixes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("applesauce")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("appleyard")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("appliances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("appraises")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("apprehended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("apprentice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("apprenticed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("apprentices")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("apprenticeship")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("approached")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("appropriateness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("araya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("arbed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arbitrage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("arboreal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arceneaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arceo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("archambeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("archambeault")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("archeological")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("archeology")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("arches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ardelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("argonne")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ariella")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("arlette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("armistice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("armitage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("arne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("arnelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("arnette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arouses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("arranged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arrangement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arrangements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arranges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arrearage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("arrearages")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("arreola")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("arriortua")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arroyo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arseneau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arseneault")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("artifice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aryan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ascended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("asiain")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("asian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("asians")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("asiaweek")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("assemblage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("assembled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("assertiveness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("assurances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("astounded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("astuteness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("atalaya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("atlases")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("atonement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("attached")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("attended")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("attentiveness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("attractiveness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("audette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("audiences")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("auguste")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("auspices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("authement")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("authorizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("auyeung")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("auzenne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("avarice")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("avedisian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("avenged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("average")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("averette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("avice")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("avowedly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("awarded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("awareness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("AWOL")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("axes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ayacucho")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ayala")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ayars")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ayatollah")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ayatollahs")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("Ayatullah")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ayerst")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ayo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ayon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ayoub")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ayuso")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ayyad")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("azpurua")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("babbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("babette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("babineau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("babineaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("babyak")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("backhanded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("backstage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("badeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("badeaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("badgering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("badges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baffled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baggage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("baidoa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("balanced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("balances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("balboa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baldrige")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("balle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("balles")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("balliet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("balyeat")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bandage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bandaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bandages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("banded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("banville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baptiste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barbeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barbette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barcia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("baribeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barlage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("barnes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barnette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barrage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barraged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("barrages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barrette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("barrilleaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("barrineau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bartlesville")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("bartolomeo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("basaldua")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("basement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("basements")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bases")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("baskerville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baskette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("basque")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("basques")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("basse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bassette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bastille")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bastogne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("batches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("batesville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bathe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bathed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bathes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("battelle")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("batticaloa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bayard")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bayog")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bayonet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bayonets")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bayou")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bayous")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bayuk")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bayus")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bearded")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("beau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaubien")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beauchaine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beauchamp")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beauchemin")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beauchene")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaudet")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaudette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaudin")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaudoin")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaudreau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaudry")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beauford")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaufort")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaufrere")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beaujolais")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaulac")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beaumier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaumont")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaupre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beauregard")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beausoleil")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beautician")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beauties")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beautiful")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beautify")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beauty")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beauvais")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("beaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bebeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("becherer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bedoya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bedraggled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bedrosian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("Beetlejuice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("befriended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("befuddled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beidaihe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beiges")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("beirne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("belge")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beliveau")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("belle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("belleau")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bellefeuille")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("belles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("belleville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("belliveau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bellville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bellyache")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("belonged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beltsville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("belville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("belyea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("belyeu")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bemusement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bended")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("benne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bennette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bentonville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beowulf")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bereavement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("berges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("berjaya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bernadette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("berne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("berneice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bernice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beseiged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("besiege")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("besieged")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("beske")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bespectacled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("besse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bessette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("beste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bethpage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("betrayal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("betrayals")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beverage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beyond")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("biases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bibeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bibeault")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bicycled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bierbusse")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bille")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("billes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bilodeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bilyeu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("binette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("binges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("biondi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("biondo")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("biondolillo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bionetics")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("birthplace")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bisque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bissette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bissonette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bissonnette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bistodeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bivalve")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bivalves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blanchette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("blaske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blazes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bleau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blended")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blinded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("blindfolded")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("blithe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blithely")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blockage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("blockages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blouses")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("blythe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boarded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("boardinghouses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bobbette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bobsled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boccia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bocian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boggled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("boghosian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bogosian")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("boguslavskaya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boileau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boisseau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("boissonneault")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boldface")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bolle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bolles")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bombarded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bondage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bonded")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bonne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bonneau")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bonnes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bonnette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bonnibelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bonuses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bonville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bookcases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bookshelves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("boomeranged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boonville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("boothe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bordeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bordeaux")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("borealis")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("borges")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("borne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("borneo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("borosage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boscia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bosse")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bothe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boudreau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boudreaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bougainville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boulette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bounces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bounded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bourbeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bourdeau")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bourne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bournonville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boutelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boxes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boyack")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("boyajian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boyan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boyar")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boyett")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("boyington")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boyish")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boyum")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("braces")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("braille")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("brailles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bralorne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bramlage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bramlette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brancheau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("branded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brasseaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brazeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brazzaville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("breakage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("breathe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("breathed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("breathes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("breau")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("breault")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("breaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("breezes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("breon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brescia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bresette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bresse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bressette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brideau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bridgeport")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bridges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bridled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("briefcases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brion")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brissette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("britches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brokerage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("brokerages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brokering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brooksville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brosseau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brossette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brousseau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brownsville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bruegge")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bruges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bruises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brundage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brundige")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bruneau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brunelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brunette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bruske")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("brusque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brusquely")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brusseau")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("brutalizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brutsche")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bryan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bryans")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bryant")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bryars")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brydges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bryen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bua")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bubbled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("Bubiyan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buckled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("budreau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bulges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bundled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bungled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("buoyancy")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buoyant")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("burbage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("burchette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("burdette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bureau")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bureaucracies")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bureaucracy")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bureaucrat")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bureaucratic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bureaucrats")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bureaus")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("burlesque")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("burne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("burnes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("burnette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("burrage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("business")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("businesses")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("buske")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("busse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("butchering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buteau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("buttonville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buyout")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buyouts")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("buysse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("byam")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("byars")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("byas")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("byassee")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("byerley")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("byrne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("byrnes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cabbage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cabbages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cabled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cableone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cabooses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cabotage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cacace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("caccia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cadences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cadorette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cafe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cafes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cages")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cairnes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("caisse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("calif")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("california")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("californian")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("californians")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("calle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("calles")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("calves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cambridgeport")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cambridgeside")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cameo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cameos")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("camerer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("camille")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("camouflage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("camouflaged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("campeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("campion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("campuses")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("canadienne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("candace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("candice")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cannes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cantrelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("canvases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("capece")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("capelle")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("capitalizes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cappiello")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("caprice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("capua")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caravelle")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("caraveo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carbonneau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carcione")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("carded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cardiges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("caresse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cariello")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("carlisle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("carnage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("carne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("carnes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carreon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carrion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carriveau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cartaya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cartersville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("carthage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cartilage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cartrette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cartridges")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("cartusciello")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("carves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("carville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cassette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cassettes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("caste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("castille")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cataloged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cataloguing")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("catches")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("categorizes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cattaneo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caucasian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caucuses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("causes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cawthorne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("caya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cayuses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ceases")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ceausescu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ceder")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ceding")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("celaya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("celeste")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("censuses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("centerpiece")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("centrifuge")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("centrifuges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ceraceous")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cereal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cereals")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cezanne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chadbourne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("challenged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("challenges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chalmette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("chameleon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("champagne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("champagnes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("champeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("champion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("championed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("championing")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("champions")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("championship")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("championships")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("changes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chapelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chappelle")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("characterizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("charasse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("charboneau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("charbonneau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("charette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("charges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("charlemagne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("charmion")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chasm")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("chasse")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("chaste")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chastises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chateau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chateaux")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("chausse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chechnya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chechnyan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cheeses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chelette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chenette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cheong")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chequing")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cherne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chevette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chevrette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chiyoda")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("choices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chooses")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("choreograph")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("choreographed")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("choreographer")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("choreographers")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("choreographic")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("choreography")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("choruses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("christabelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chronicled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chua")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chuckled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("chujitsuya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("churches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cigarette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cigarettes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cilicia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("circled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("circumstances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("circuses")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ciriello")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cirincione")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cirrincione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cistercian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cityplace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("claiborne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("clairvoyance")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("clarabelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clarette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clarice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clarisse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clarksville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clarrisse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("claudette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clauses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clavette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clayborne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("claybourne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clayey")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("clearances")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("clearinghouses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cleavage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cleo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cleopatra")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("climaxes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("clinician")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("clinicians")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("clodoveo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("closeness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("closes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("clothe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("clothed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("clothes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("clubhouses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clutches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clyatt")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coalesced")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coatesville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cobbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coccia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coddled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coercion")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cohesiveness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coinage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cointreau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("colette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("collage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("collages")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("colle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("college")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("colleges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("collegeville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("collette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("colleville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cologne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("colville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("comanche")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("combativeness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("comeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("comeaux")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("comedienne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("commanded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("commenced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("commencement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("commences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("commended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("commingled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("commonplace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("compeau")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("competitiveness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("completeness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("complexes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("composes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("compounded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("comprehended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("comprises")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("compromises")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("conceding")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("concepcion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("concierge")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("concubinage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("condolences")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("conferences")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("confidences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("confinement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("confluence")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("confounded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("confucian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("confuses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("congruence")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("connely")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("consciences")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("constituencies")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("constituency")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("constituent")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("constituents")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("contended")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("continuances")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("contrivances")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("controversial")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("conveniences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("conveyance")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("conveyor")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("conville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("convinced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("convinces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cooperage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coppage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("corabelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("corded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("corette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("corinne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("corne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cornelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cornette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("corresponded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("corriveau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("corsage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("corvette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("corvettes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coscia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cosette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cossette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("coste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cotelle")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cotroneo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cottage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cottages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("countenanced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("countenances")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("counterbalanced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("countercharges")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("counterespionage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coupled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("courage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("courageous")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("courageously")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("courteau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("courthouses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("courville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cousineau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coverage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coverages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("covering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coverings")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coviello")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cowardice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cowering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crackled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("crawfordsville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crayon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crayons")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("creole")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("creoles")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("creolized")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("creosote")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crepeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crevice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("crevices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cribbage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cringes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crippled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("criscione")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crises")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("criticizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("crocuses")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("crosse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crosspiece")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("crosspieces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("croteau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("crotonville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crotteau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crowded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cruces")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("crucifixes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cruises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crumbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crumpled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crutches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cryan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cubbage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cuccia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cuddled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cuddling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cuneo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("curtice")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("curves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cuteness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cuyahoga")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cyacq")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cyanamid")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cyanazine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cyanide")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cyanuric")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cyberspace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cycled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cytoplasm")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dabbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("daigneault")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("daleo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("damage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("damaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("damages")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("damme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dandeneau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("danelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dangled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("daniello")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dansereau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("danville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dapice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("darbonne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("darice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("darrelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("darville")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("databases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("daya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dayan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dazzled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deathbed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deatherage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("debasement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("debrosse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("decapua")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("decelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("decelles")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("decisiveness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("decomposes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("decoteau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("decreases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dedeaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deduce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deduced")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("defaced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("defarges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("defelice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("defended")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("defensiveness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("defeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("degaulle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dehoyos")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dejarnette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("delage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("delbosque")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deleo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deleon")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("deleonardis")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("delfosse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("delgiudice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("delguidice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("delicia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("delisle")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("deliverers")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("delivering")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("delle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("delmed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deluccia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("delucia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deluge")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deluged")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("delve")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("delves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("demanded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dematteo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("demayo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("demeo")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("demilitarizes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("demme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deneau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deneault")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("denice")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("denne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("denomme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("denounced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("denounces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("deodorant")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("deodorants")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("deoliveira")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("depended")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("deployable")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deranged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("derousse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("descended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("descoteaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deserves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("desormeaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("despises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("desselle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("detached")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("deterioration")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("detherage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dettling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deveau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deveaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("develle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("devereaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("device")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("devices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("devises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deyo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deyoe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deyoung")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("diagnoses")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dianthia")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("diaphonia")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("dibartolomeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dibbled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("diceon")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("dideoxycytidine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dieringer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dieses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("diet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dieters")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("difelice")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("differences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("diffuses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dileo")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("dileonardo")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dille")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dimatteo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dimeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dimpled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dinges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("diona")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dione")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("dionysius")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disabled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("disadvantage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("disadvantaged")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("disadvantageous")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("disadvantages")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("disallowances")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("disappearances")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("disassembled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disbanded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disbursement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disbursements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("discarded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("discharges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("discloses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("discourage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("discouraged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("discouragement")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("discourages")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("discovering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("diseases")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("disenfranchisement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disengage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disengaged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("disengagement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("disgrace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("disgraced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disgraceful")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disguises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("diskette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("diskettes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dislodged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disloyal")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("disloyalty")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disparage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disparaged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("disparages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dispatches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("displace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("displaced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("displacement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("displacements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("displaces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disposes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("disregarded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disservice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dissolve")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dissolves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("distanced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("distances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("distaste")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("distasteful")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("distended")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("distinctiveness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("disturbances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ditches")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("divergences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("diverges")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("divisiveness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("divorced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("divorces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dodges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("doenges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("doggedly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dolce")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dolle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("donne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("doralynne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("doraville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dorette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dorice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dOrsay")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dosage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dosages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("doses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("doubled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("doucette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("douville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("downstage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("doyal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("doyel")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("doyen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("doyon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("drainage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dralle")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dramatizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("drapeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dredges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dressage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dribbled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("droste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dubeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duchenne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("duchesneau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dudayev")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("duena")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("duenas")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dukakises")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dulcibelle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dulle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dumbfounded")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dunne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("durette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("duryea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dusseau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dusseault")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dwelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dwindled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dyad")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dyal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dyana")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dyane")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dyansen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dyar")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dyas")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dyatron")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dyazide")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dyess")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("easement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eases")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("eastes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("eau")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("eaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("edges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("edifice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("edithe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("edythe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("effectiveness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("efficiences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("effluent")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("egerer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("Ehud")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eldred")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("electrician")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("electricians")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("electrospace")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("elle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ellesse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ellette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ellice")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("elusiveness")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("elves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("embed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("embedded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("embezzled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("embrace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("embraced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("embraces")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("embryology")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("emerges")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("emeryville")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("eminences")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("emlynne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("emme")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("emphases")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("emphasizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("emplacement")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("employable")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("employee")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("employees")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("empowering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enabled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("encircled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("encourage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("encouraged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("encouragement")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("encourages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("encroached")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("endangering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("endorsement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("endorsements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enfeebled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("enforced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enforcement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enforces")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("enfranchises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("engage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("engaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("engagement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("engagements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("engages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("enhanced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enhancement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enhancements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enhances")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("enjoyable")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enlarges")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ennes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("enrage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("enraged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("enriched")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ensconced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enslavement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("entangled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("enterprises")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enthuses")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("enthusiastically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("entice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("enticed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enticement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enticements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("entourage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("entranced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("entrances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("entrenched")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("envisage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("envisaged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("envisages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eocene")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eoff")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("eohippus")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("eolande")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eons")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("epitomizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("erases")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("erne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("escapement")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("espionage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("espouses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("essayist")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("esse")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("este")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("estelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("estranged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("estrangement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("etches")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ethereal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ettlinger")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("etzioni")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eudocia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eunice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eurasian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("europeenne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("euroyen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eustace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eustacia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eustice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("evansville")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("evenhanded")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("evenhandedly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("everage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("everette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("evidenced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("evidences")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("evinced")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("evolve")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("evolves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("evonne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("exchanged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("exchanges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("excises")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("excitement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("excoa")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("excuses")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("exercises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("exes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("expanded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("expended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("exposes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("expounded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("expunged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("extended")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("extraordinaire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eyerman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ezelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fabled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("faceless")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("faces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("facteau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("falardeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fangled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fantasizes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fariello")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("farmhouses")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("farnes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("faucette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("favreau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("faxes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fayard")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fayez")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("faymonville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("feces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fecteau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fejes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("felice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("felicia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("felrice")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("femme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fences")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("feodor")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("feodora")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("feola")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fertilizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fetches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fettes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fetuses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fiddled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fiddling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fielded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("figaroa")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("figueroa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("filice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("filyaw")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("financed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("financement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("finances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("finesse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fingering")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("finne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fiona")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("firehouses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fireplace")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fireplaces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fisette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fishburne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fiske")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fitzmaurice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fixes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fizzled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("flamboyance")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("flamboyant")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("flamboyantly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("flanges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fleurette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("flexes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("flounces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("flowering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fluency")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fluent")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("flythe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("focuses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("folded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("follette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fontenette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fonville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("foodservice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("footage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("footrace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("forage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("forages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("forces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fordyce")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("forecloses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("foretaste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("forges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("forgette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("forgione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("forgiveness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("formalizes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fornes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("forsythe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("forwarded")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fosse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("founded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("foxes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fradette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fragrances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("franchises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("francia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("francisville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frazzled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frechette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("freckled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("freezes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fregeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frenette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("freon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("freons")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("freya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("freyermuth")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fringes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("friona")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("friscia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("friske")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fromme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frontage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fryar")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fuchsias")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fujiya")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fujiyama")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fukuyama")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fumbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("funded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("furches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("furloughed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("furnace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("furnaces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("furuya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fuselage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fuselages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fuses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fuzes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gabriella")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gabrielli")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gaccione")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gainesville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("galarneau")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("galileo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("galipeau")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("galle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("galleon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("galleons")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("galles")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("galyean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("galyen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gamage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gambled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gamboa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gammage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ganglionic")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("garage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("garages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("garbage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("garbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("garceau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("garces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gardea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gareau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("garges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("garneau")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("garnes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("garnette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("garrette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gases")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gasque")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gastineau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gaudette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gaudreau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gauges")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gaulle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gauthreaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gautreau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gautreaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gauvreau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gazelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gazelles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gazes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gazette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gearboxes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gedeon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("geers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gelette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gelineau")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gelles")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gemayel")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gemme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gendreau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("genoa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("geo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geocentric")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("geochemistry")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geodesic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geodesy")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("geodyne")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geoffrion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("geoffroy")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geographer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geographic")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("geographical")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("geographically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geography")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geologic")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("geological")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geologist")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geologists")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geology")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("geomagnetic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geometric")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("geometrical")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geometries")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geometry")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("geomorphology")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("geon")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("geophysical")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("geopolitical")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("geopolitics")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("geordie")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("georg")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("georgeson")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("georgi")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("georgiades")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geostrophic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geosyncline")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geotaxis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("geotek")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geothermal")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geotropic")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("geotropism")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("geringer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("geske")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("geyelin")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gibeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gibeault")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gideon")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gieske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("giggled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gildea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gilded")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gille")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gilles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gillette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gionet")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("giselle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giudice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("glances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("glanville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("glazes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("glenville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("glitches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("glowering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gobbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goddeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("godette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("goethe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("goldfeder")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("golle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goodreau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gooseberry")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gordeyev")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gorgeous")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gorges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gossage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gosse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goudeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goudreau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goulette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goyim")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("graceful")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gracefully")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("graceless")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("graces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gracia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("graffeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grambling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("granges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("granville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grappled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grappling")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("grasse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gravelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gravette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grayish")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grecian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("greenhouses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("greenpeace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("greenville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("grelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("grenouille")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("grievances")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("grille")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grimaced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("grimaces")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("grimme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grinage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grizzled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("groleau")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("grosse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grotesque")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("grotesquely")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("grothe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grotheer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grounded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("groupement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grouses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grua")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grudges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grumbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guarded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("guardedly")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("guayabera")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("guccione")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guerette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guerrette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guidice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guilbeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guilbeault")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guilbeaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("guillemette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guillette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guilmette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gullette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("guste")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("guyana")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guyett")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guyon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guyot")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gvaryahu")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gwynne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("haberer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hachette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("haggled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("halcion")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("halle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("halve")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("halves")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hamme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hammes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("handed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("handedly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("handled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hannes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hansche")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("haranguing")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hardage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("harleysville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("harnage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("harne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("harriette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hartlage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hartshorne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("harville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("haske")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hasse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hassled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("haste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hatches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hathorne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hauppauge")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hawthorne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hayashi")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hayashida")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hayek")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hayen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hayenga")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hearne")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("heavyhanded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heberer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heckled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hedges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heidbreder")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heiges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("helice")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("helle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hemme")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("hemocyanin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hemorrhage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hemorrhaged")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("henne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("henneberry")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hennes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("henriette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hentges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("henthorne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heralded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("herbaceous")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("herded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heritage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hermitage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("herne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("herriage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("herrlinger")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hesse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hessian")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("heterogeneous")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hicksville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hideo")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hille")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("himalayan")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("himalayas")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hindrances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hinges")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hirayama")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hiroyuki")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("histrionic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("histrionics")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hitches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hoarded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hoarseness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hoaxes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hobbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hodges")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hoelle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("holle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homage")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("homeostasis")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("homeostatic")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("homme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hommes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("horace")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("horne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hoses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hospice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hospices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hostage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hostages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("houdaille")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hounded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("houses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hovering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hoyos")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hua")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("huddled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hugely")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hugette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hughette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hulette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("humbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hundred")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hungering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("huntsville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hurteau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hutcheon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("huyett")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hyacinth")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hyacintha")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("hyacinthia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hyacinthie")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hyacinths")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("hyaluronic")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hyams")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hyannis")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hyatt")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hyena")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hyenas")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hyperion")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hypotheses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hyraxes")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ianniello")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ices")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("iconoclasm")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("idea")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("ideological")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ideologies")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ideologists")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("idette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("idled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("idolizes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ierne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ignace")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("illes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("Ilyich")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("image")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("images")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("imbalances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("imbedded")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("immortalizes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("immunizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("impasse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("impeached")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("impeding")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("imposes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("impounded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("improvement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("improvements")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("inbred")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("incidences")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("inconvenienced")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("inconveniences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("increases")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("indecisiveness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("indexes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("indices")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("indonesian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("induce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("induced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("inducement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("inducements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("induces")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("indulgences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("indulges")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ineffectiveness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("inferences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("influence")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("influenced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("influences")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("influencing")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("influential")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("influenza")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("infrared")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("infringed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("infringement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("infringements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("infringes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("infuses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("injustice")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("injustices")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("innerspace")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("innuendo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("innuendoes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("innuendos")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("instances")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("institutionalizes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("insurances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("intended")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("interacciones")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("interbred")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("interceding")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("interchanges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("interface")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("interfaces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("interlaced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("intermingled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("interoffice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("intervoice")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("intraocular")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("intrauterine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("intriguing")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("intriguingly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("introduce")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("introduced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("introduces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("inveighed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("inventiveness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("invoice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("invoices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("involve")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("involvement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("involves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("iodice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("iona")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ionic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ionics")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ionization")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ionizers")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ionizing")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ionospheric")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ions")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("irette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("irises")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ironizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("irvette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("isabelle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("isle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("isles")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("isocyanate")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("Isozaki")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("issuances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("itches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("jacksonville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jandreau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("janelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("janesville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("janette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jangled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("janice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jarreau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("jasmer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jaundice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jaundiced")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jaya")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("jayashankar")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("jeanbaptiste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jeanette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jeanne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jeannette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jeansonne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jenne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jennette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jenrette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jeske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jetborne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("jeyaretnam")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("joffrion")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jolette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("joliet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("jolivette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jopling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jorge")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("josette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("joshua")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jostes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jostling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("joyal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("joyoni")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("joyous")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("juan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("juana")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("juanita")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("juarez")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("judaism")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("judea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("judeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("judgement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("judgements")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("judges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("judgeship")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("judgeships")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("judice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("juggled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("juices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jukebox")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("julia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("julianne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("juliet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("julius")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jumbled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("jumonville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("juneau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("junette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("junior")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("juniors")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("justice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("justices")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kageyama")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kamerer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kanghua")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kanne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("karges")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("karnes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kasmer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("katayama")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kaya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kayak")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kayaking")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kayaks")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kayo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kemerer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("keo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("keogh")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("keohane")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("keown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kerestes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kernes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kerrville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("keske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("keville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("keynesian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kibodeaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kidded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kiessling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kilborne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kilbourne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kille")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kimche")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kindled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kindred")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kingsville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kinne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kissling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kitchenette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kiyoshi")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kiyotaka")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("klages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kleinpaste")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("klemme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("knicely")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("knoxville")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kobayashi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kocian")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("koelle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kolle")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("Komsomolskaya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("korfhage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kothe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("koyama")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("koyo")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kramme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("krammes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("krasnoyarsk")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("krausse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kresge")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kresse")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("krumme")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kuenheim")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kuenstler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kuenzi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kunayev")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kuske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("labeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("labelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("labranche")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lacayo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("laces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lachapelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lacoste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lacrosse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ladled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lafalce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("laflamme")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lafollette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lafosse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lagesse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lajeunesse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lakeside")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lamarche")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lambaste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lambastes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lamme")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lamontagne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lamoreaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lamothe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lamoureaux")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("lanceolate")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lancia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("landed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("landreneau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("langhorne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("language")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("languages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lanouette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lapage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("larche")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("larded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lareau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("largesse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lariccia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("larochelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lasalle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lashua")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("laske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lasseigne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("latches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("latendresse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lateness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("latexes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lathe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lathes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("latourette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lattice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("laurette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("laurice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lausanne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lavelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("laverne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lavette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lavigne")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("laviolette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lawhorne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lawrenceville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("layborne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("layered")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("layering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("layoff")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("layoffs")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("layout")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("layouts")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("layover")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("layovers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leadville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leakage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leatrice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leavelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lebeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ledges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ledonne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("legette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("legged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leggette")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("legitimizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leifeste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lemelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leoma")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("leominster")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leona")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("leonardo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leonel")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leonerd")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leones")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leonhard")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leoni")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leonid")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("leonora")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leonore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leontine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leopold")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("leopoldine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("leopoldo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leos")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leotard")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lepage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lerette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lesage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("leske")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lespinasse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leticia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("letourneau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lettice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lettuce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leveille")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leverage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leveraged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leverette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("levering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("levesque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lianne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("liberace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("libya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("libyan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("libyans")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("licences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("licorice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lighthouses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("likeness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("likenesses")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lille")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lilyan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("limoges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("linage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lineberry")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("linette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lingering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("linkage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("linkages")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("linne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("linville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lion")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("lionberger")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lionel")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("lionetti")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lionheart")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lionized")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lions")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lirette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lisette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("liske")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("literaturnaya")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lithe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("littlepage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("loathe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("loathed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lodges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loewe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("logarithm")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("logician")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("loguidice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loiselle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lonesome")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("looses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lorette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lorne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("losoya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("louisville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lounges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lovage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lovering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lovette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lowering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loyal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("loyalist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("loyalists")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loyall")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("loyally")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("loyalties")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("loyalty")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("loyola")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lozeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lozenges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lozoya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lua")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lucerne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lucette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lucia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lucian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lucille")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lucrecia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("luelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("luggage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lunges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lurches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lurette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lyall")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lyell")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lyerla")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lynette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lynne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mabelle")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("macfadyen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("macioce")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("macroeconomic")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("macroeconomics")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("macrophage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("macrophages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("madelle")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mademoiselle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maffeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("magician")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("magicians")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mahayana")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mahe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mailboxes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("maille")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mainville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maione")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("majette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("makeover")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("makepeace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("malayan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("malaysian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("malaysians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("maleness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("malice")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("malle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mallette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("malpractice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("malveaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("manage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("managed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("management")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("managements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("manages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mandeville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("manette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("maneuvering")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("maneuverings")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("manganiello")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mangement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("manges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mangione")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mangled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("manhandled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("manne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mannes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("manseau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mantua")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("manuevering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("manville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marantette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maranville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marceau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marceaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marcelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marcia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marcille")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marcoses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("margette")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("marginalizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marianne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mariette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marineau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marketplace")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("marketplaces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marlette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marmion")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marseille")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("martelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("martineau")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("maruyama")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maruyu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marvelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maryann")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marysville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maryville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marzette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("masaya")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("masayoshi")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("masayuki")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mascia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("masiello")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("maske")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("massacred")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("massage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("massaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("massages")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("masse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("masterminded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("masterpiece")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("masterpieces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mataya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("matches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mateo")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("materializes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mathe")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("mathematician")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("mathematicians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("matherne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("matisse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("matteo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mattice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("maurice")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mauriello")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mauthe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("maximizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("maya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mayall")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mayan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("maybelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mayeda")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mayernik")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mayerson")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mayeux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mayo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mayon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mayonnaise")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mayor")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mayoral")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mayoralty")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mayorga")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mayors")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mayville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mazes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mazzeo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mcbryar")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mccarville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mcconville")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mcfadyen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mcginnes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mckeon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mckeone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mckeown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mcneece")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mcneice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mcquaid")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mcquaide")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mcquaig")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mcquain")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("measurement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("measurements")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("meaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("medea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("megahouses")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mehitabelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("meiyuh")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("melanesian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("melbourne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("melded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("melisse")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("melle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("melville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("menace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("menaced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("menaces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meneses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("menezes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("menges")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("menne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("meo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meola")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("meow")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mercedeses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("merdyce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("merges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("merhige")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mersereau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mertice")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("meske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("message")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("messages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("messiaen")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("messineo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meteor")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("meteoric")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("meteorological")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("meteorologist")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("meteorologists")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("meteorology")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meyerhoff")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meyering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meyerman")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("meyerowitz")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meyerson")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("meyo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meyohas")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("micheaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("michelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("microage")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("microamerica")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("microeconomic")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("microeconomics")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("microelectronic")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("microelectronics")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("microelettronica")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("micromanage")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("micromanagement")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("microorganism")); + $this->assertEquals(8, $this->TextStatistics->syllableCount("micropaleontology")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("midges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("midgette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("midpriced")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("miesse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("migneault")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("milbourne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mildred")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mileage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("millage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mille")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("millette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("milliet")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mimeograph")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("minasian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("minassian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("minded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mindedly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mineau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mineo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mineola")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("minette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("minges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mingled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("minibuses")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("minichiello")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("minimizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mintage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("minuses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mion")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mirabelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mirage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mirelle")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miscayuna")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mischarges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mises")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mishandled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("misjudged")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("miske")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mismanaged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mismanagement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mismatches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("misplace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("misplaced")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mispriced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("misstatement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("misstatements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("misuses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mixes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miyagawa")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miyahara")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("miyako")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miyamori")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miyamoto")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miyasaki")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miyasato")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miyashiro")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miyazaki")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miyazawa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mizelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moccia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("modisette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("molded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("molineaux")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("molle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("molyneaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("momayez")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("moncayo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("monceaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mondeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("monette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mongeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mongering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mongooses")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("monopolizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("monroeville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("montage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("montagne")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("montemayor")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("montesdeoca")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("montevideo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("montoya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("montreal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("montville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moragne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moreau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("morice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("morisette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("morissette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("moriya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("morneau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("morneault")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("morreale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("morrisette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("morrissette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("morrisville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mortage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mortages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mortgage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mortgaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mortgages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mortician")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moselle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moses")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mosque")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mosques")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mousse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mousseau")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mouthed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mouthpiece")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mouthpieces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("movement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("movements")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mozelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("Muammar")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("muddled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("muffled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mughniyeh")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mugniyah")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mullineaux")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("multilayered")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("multivalve")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("multiyear")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mumbled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mumme")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("murayama")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("muscled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("muses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("musician")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("musicians")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("muske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mustached")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("muzzled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("myatt")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("myelin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("myreon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("myrtice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nadeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nagoya")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nairne")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nakayama")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nanette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("naperville")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("napoleon")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("napoleonic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("narayan")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("narayanan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("narcisse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nardiello")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nashua")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nashville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nathe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("navarette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("navarrette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("Nazarbayev")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("neault")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nechayev")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("necklace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("necklaces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nedeau")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nederlandsche")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("needled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("neises")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nelle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nelles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nellette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("neo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("neoclassic")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("neoclassical")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("neoconservative")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("neoconservatives")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("neola")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("neoliberal")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("neoliberals")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("neoma")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("neon")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("neonatal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("neons")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("neophyte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("neophytes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("neoplasm")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("neoplatonic")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("neoplatonist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("neoprene")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("neoprobe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("neotenic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("neoteny")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nerice")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nerves")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("neste")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("netterville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("neuroses")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("neutralizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("neuville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("neveau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("neville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("newfangled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("newlywed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("newville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nguyen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nibbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nicely")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("niceness")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("nickelodeon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nicolette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nicolle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nicorette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nieces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nietzsche")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nightstage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nilges")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nilles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ninette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nishiyama")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nixes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("noa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("noblesse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nobuyuki")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nodded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("noises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nolette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nonbusiness")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("noncontroversial")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nonesuch")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nonetheless")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nonmanagement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("norcia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("norville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("noses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("notches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("notice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("noticed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("notices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nottage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nouveau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nouvelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("novice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("novices")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("novoa")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("noyola")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nuanced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nuances")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nucleonics")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nucleotide")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nudges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nuisances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nureyev")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nyack")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nyenhuis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nyerere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("oakville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("obeirne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("oblige")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("obliged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("obliges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("obryan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("obryant")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("observances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("observes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("obstetrician")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("obstetricians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("obyrne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("occhoa")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("occurrences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ochoa")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("odea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("odelette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("odeon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("odette")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("oesterreichische")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("offended")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("office")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("offices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("offstage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ogled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ohanesian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("OHara")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ohbayashi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("olayan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oleo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("olivette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("omnibuses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("oneness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oneok")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("onstage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("oozes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("opposes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("opticians")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("orabelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oranges")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ordinances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oreffice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("orefice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oreo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("organelles")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("organizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("orgasm")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("orifices")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("orne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("orphanage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("orphanages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("orville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("osage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("osages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("osborne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("osbourne")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("osceola")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("osteopathic")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("osteoporosis")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("osterreichische")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ouelette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ouellette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ounces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("outage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("outages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("outhouses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("outpace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("outpaced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("outpaces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("outplacement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("outrage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("outraged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("outrageous")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("outrageously")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("outrages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("outweighed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ovalle")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("overcharges")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("overcrowded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("overdoses")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("overextended")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("overfunded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("overpriced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("overproduce")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("overproduced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("overreached")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("overseer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("overseers")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("oversizes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("overstatement")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("overstatements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oyama")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("oyen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oyola")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ozanne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ozelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("paccione")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("paces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("package")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("packaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("packages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("padded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("paddled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("padua")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pagette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("paille")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("palace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("palaces")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("paleobotany")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paleocene")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("paleontology")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("palette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("paniccia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pantaleo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pantheon")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("panzhihua")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("papaleo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("papaya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("papayas")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("papering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("papineau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("papua")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paradoxes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paraguayan")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paralyzes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("parazoa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("parcplace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("parentage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("parenteau")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("parentheses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pariseau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("parisian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("parizeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("parlette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("parnes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("parsonage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("partridges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pascua")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("paseo")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("paske")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("pasquariello")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pasque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("passage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("passages")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("paste")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pastes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("patches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pathe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("patrice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("patricia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("patrician")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("patricians")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("patronage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("paulette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pauses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pavement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pavements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("payable")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("payables")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("payan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("payeur")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("payoff")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("payoffs")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("payola")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("payout")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("payouts")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peaceful")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("peacefully")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pebereau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peddled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peerage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("peladeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pelayo")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pelle")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("peloponnesian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("penalizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("peonies")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peons")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("peony")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("peoria")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("percentage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("percentages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("perches")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("performances")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("permissiveness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pernice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("perplexes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("perreault")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("perriello")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("persian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("persians")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pervasiveness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("petroleos")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("petrossian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("phalanges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("phantasm")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("phases")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("phileo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("phoenicia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("phoenician")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("phoenicians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("phrases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("phua")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("physician")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("physicians")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("phytogeography")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("picariello")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("picayune")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("piccione")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pichette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pickled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("picturesque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pieces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("piet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pilferage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pilgrimage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pilgrimages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pillage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pillaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pillages")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pille")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pincavage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pineau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pineo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pinette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pinneo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pinsoneault")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pioneer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pioneered")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pioneering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pioneers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("piontek")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("piontkowski")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pirouettes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pitches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("placement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("placements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("placencia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("places")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("plaguing")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("plainclothes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("plascencia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("plasencia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("plasse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("plateau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("plateaued")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("playa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("playoff")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("playoffs")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pleasantville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pleases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pledges")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("plisetskaya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("plodded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("plumage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("plumages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("plunges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pluses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("police")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("policed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("polices")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("policewoman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("politeness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("politician")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("politicians")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pollyanna")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("polyacetylene")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("polyak")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("polyamide")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("polyandrous")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("polyandry")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("polyester")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("polyesters")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("polyethylene")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("polymerizes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("polynesian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pomerleau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pompeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ponsolle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("populace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("porches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("porges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("porpoises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("porsche")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("porsches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("portage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("porterages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("portrayal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("portrayals")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("poses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("postage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("postponement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("postponements")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("postrelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("poultices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("poundage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pounded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("powerhouses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("powering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("practice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("practiced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("practices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("praises")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pralle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prattville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("preaches")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("preadolescent")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("preamble")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prearranged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("preceding")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("precipice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("predaceous")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("preeminence")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("preeminent")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("preempt")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("preempted")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("preemption")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("preemptive")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("preexist")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("preexisted")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("preexisting")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("preexists")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("preface")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prefaced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("preferenced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("preferences")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("preignition")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("preinvasion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("preisler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prejudged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prejudice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prejudiced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("prejudices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("premed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("premiering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("premises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prentice")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("preoccupation")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("preoccupations")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("preoccupied")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("preoccupies")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("preoccupy")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("preordained")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prepackaged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("prerecorded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("presage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("presaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("presages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("presences")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("preserves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prestage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prestige")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("presupposes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pretended")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prevette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("priceless")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prideaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("primeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("primeaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("primroses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("princes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("princeville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("principled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prindiville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prioleau")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("prioritizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("privette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("proactive")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("probusiness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("procurement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("procurements")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prodded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("produce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("produced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("produces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prognoses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("programme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prolonged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("prominences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("promises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pronounced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pronouncement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pronouncements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pronounces")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("propionic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("proposes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("propounded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("proscia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("prospectuses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prostheses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("proteges")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("protozoa")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("protuberances")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("provideniya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("provinces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prudhomme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pruneau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prussian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("puleo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pulice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pumice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("purchases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("purges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("purposes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("purves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("purveyor")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("purveyors")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("puzzled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pyatt")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pyeatt")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("quadrupled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("quai")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("quaid")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("quail")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("quails")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("quain")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("quaint")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("quaintance")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("quaintly")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("quamme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("queau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("quebedeaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("quellette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("quenneville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("queuing")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("quintupled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("quivering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rabideau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("racehorses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("races")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("racette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rachelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("radborne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("radbourne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("radice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ragged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rahe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rainville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("raises")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("raleses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ramage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rambeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rambled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rambling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rameses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rampage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rampaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rampages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ranges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rankled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rapprochement")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("raske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rathburne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rathe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rattling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ravaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ravages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("raya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rayon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rayos")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rayovac")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("raytheon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reabsorbed")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reactionaries")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reactionary")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reactions")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reaganesque")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("realign")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("realigned")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("realigning")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("realignment")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("realignments")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("realistic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("realities")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reality")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("realizable")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("realizes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reallocate")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reallocated")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reallocating")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reallocation")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reallowance")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("realtor")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("realtors")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("realty")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reappraised")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("reaume")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("reaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rebounded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("receding")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("recognizes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("recommended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("recorded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("recovering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("recycled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("redhanded")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("rediscovering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("redoubled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reduce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reduced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reduces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reemerge")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reemerged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reestablished")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("referenced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("references")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("refering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("refinanced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("refinances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("refinement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("refinements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reflexes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("refocuses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("refuge")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("refuges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("refunded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("refuses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("regarded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reimposed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("rejiggering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rejoice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rejoiced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rekindled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("relaunched")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("relaxes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("releases")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("remanded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("remembrances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reminded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reminisced")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reminiscences")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("remittances")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("remme")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("remolded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("remoteness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("remoulded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reneau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("renege")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reneged")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("renne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("renounced")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reoffer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reoffered")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reoffering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reopen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reopened")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reopening")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reopens")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reorder")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reordering")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reorganization")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reorganizations")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reorganize")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reorganized")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reorganizes")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reorganizing")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("repackage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("repackaged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("repackages")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("repayable")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("replace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("replaced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("replacement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("replacements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("replaces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reportage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reprice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("repriced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reprimanded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reproduce")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reproduced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reproduces")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("repurchases")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("requirement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("requirements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rescinded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("researches")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("resemblances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("resembled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reserves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reshuffled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("residences")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("resistiveness")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("reske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("resolve")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("resolves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("resources")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("responded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("responsiveness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("restaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("restatement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("restatements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("restiveness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("restrictiveness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("resurface")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("resurfaced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("retarded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("retirements")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("retrace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("retraced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("retracement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("retrenched")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("retroviruses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reused")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("revelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("revette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("revises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("revolve")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("revolves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rewarded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("rhapsodizes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rheault")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rheaume")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("rhetoricians")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rhodesian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rhythm")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("riddled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rideau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rideaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ridges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("riendeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rifled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("righteous")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("righteously")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("righteousness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rillette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rinne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rion")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("riposte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ripostes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rippeon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rippled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rises")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("riske")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("risse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("riverbed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rivette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("riviello")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("riyad")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("riyadh")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("riyals")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roa")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("robicheaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("robideau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("robinette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("robitaille")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rocheleau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rochelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rochette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rockville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rodeo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rodeos")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roebling")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("roelle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("roeske")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rohleder")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rolle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("romances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("romanesque")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("romaniello")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("romelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("romeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rondeau")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ronne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rosabelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosanne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roseanne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("roseberry")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosettes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roseville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("roske")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rosse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rossiya")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rothe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rototilles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rougeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rouleau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roulette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roulettes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rounded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rounsaville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rousse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rousseau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rousselle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rowlette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roxanne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("royal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("royale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("royalist")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("royall")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("royals")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("royalties")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("royalty")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("royces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("royex")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rozelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rua")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rudelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rudeness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ruffled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rugged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ruggedly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rumage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rumbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rummage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rumpled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ruses")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("russe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("russellville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("russian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("russians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ryal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ryall")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ryals")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ryan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ryanair")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ryans")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ryen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sabotage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sabotaged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sackville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sacred")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sacrifice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sacrificed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sacrifices")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sacrilege")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("saddled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("salemme")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("saleswoman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("saleswomen")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("salle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("salvage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("salvaged")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("salve")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("salves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("samelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sameness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("samoa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sampled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sancia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sandage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sanded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sandwiched")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sannes")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("santaniello")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("santayana")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("santoyo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sanville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sapoa")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sarcasm")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sarette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sarkisian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sarkissian")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sasse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("satirizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sauces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sausage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sausages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sauternes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sauvage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sauvageau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("savage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("savaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("savagely")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("savages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("saville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sawaya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sawtelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sayad")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sayegh")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scaccia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scarface")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("scarves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scherer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schiewe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schnelle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("scholle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sciascia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scion")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scolded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sconces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("scorpion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("scorpions")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scotches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scourges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scoville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scrambled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scratches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scribbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scrimmage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("scrutinizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scuffled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seaborne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("searches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sebaceous")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("seceding")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("seconded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("secretiveness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seduce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seduced")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seepage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("seethe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("seigniorage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("seiyaku")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seiyu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seizes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("selle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("selvage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("selves")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("semiautomatic")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("semionenkov")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("semmes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("senne")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sensitiveness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sentelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sentenced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sentences")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seow")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("separateness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sequoyah")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("serves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("service")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("serviced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("services")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("severing")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sewage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sewerage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sexes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sfernice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shackled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shaquille")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sharpeville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sheathe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sheathed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shelburne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shelbyville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("shelve")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("shelves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shepherded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sherborne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sherbourne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sherburne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shielded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shigeo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("shionogi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shivering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shiyuan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shoelace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shoelaces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shortage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shortages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shortchanged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("showcases")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("showering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("showpiece")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("showplace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shredded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shreveport")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shrinkage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shuffled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shuffling")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("siang")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sias")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sibelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sibille")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sibling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("siblings")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sidekick")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sideline")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sidelined")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sidelines")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sideman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sideshow")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sidestep")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sidestepped")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sidestepping")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sidesteps")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sidestream")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sidetrack")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sidewalk")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sidewalks")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sidewater")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sideways")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sidewinder")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sidewise")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("signage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("silenced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("silences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sileo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("silhouette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("silhouettes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("silverthorne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("simeon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("simeone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("simoneau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("simoneaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("simonette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("simpleminded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("simplesse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sincavage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("Sindayen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("singled")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("singlehandedly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sinuses")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sithe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sixes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sizzled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("skeoch")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sketches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("skewering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("skidded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("skyboxes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("slaughterhouses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("slices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("slippage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("smoothed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("smuggled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("smythe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("snarled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("snatches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sobering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("socia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("softimage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("soileau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sokaiya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("solace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("soldiering")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("solve")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("solves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("somerville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sommerville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sonne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("soothe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("soothed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("soothes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sorbonne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sorcerer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sorcerers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sorice")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sotomayor")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sounded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sources")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sourrouille")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sovetskaya")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("soviet")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("sovietologist")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("soya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("soyars")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("soysauce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("soyuz")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spaceport")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spaces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spaceship")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spaceships")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spangled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sparkled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spasm")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("specializes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("speckled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("splices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spoilage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("spokeswoman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("spokewoman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sponges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sporleder")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spouses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("springerville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sprinkled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("squabbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("squillace")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("stabilizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stacia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("staggering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("staircases")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stampeding")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stances")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stapled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("starches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("starnes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("statement")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("statements")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stateside")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("statistician")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("statisticians")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stayover")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stayovers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("steakhouses")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stearne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("steenkiste")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stephenville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stereo")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("stereographic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stereos")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("stereotype")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("stereotyped")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("stereotypes")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("stereotypical")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("stereotyping")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sterilizes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sterne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("steubenville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stifled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stille")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stinnette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stitches")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("stockbrokerage")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("stockbrokerages")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("stolichnaya")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stolle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stooges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stoppage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stoppages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stopwatches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("storage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("straddled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("straddling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("straggled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("straitlaced")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stranded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("strangeness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("strangled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stretches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stromme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("struggled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("studded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stumbled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stumpage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sturges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stuteville")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("subsidizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("substances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("subsurface")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("subterfuge")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("suffice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sufficed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("suffices")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("suffrage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("suffragettes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("suggestiveness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sugiyama")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("suisse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("suitcases")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sukiyaki")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("summarizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("summerville")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("superseding")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("supervises")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("supposedly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("supposes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("surcharges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("surette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("surface")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("surfaced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("surfaceness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("surfaces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("surges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("surmises")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("surpluses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("surprises")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("surrealisms")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("surrette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("surrounded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("surtaxes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("surveyor")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("surveyors")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("susanne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("susette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("suspended")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("suzanne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("suzette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sverige")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("swaggering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("swatches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("swathed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("swinburnes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("swindled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("switches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sybille")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("symbion")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("symbolizes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("symmes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sympathizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("syringes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tableau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tableaux")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tabled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tackled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tactician")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tacticians")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("taddeo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tafoya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("taiyo")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("takashimaya")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("takayama")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("takeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("talmage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tamayo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tangled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tapering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tasm")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("taste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tasteful")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tastefully")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tasteless")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tastes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tauruses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("taxes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("teases")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tebeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("technician")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("technicians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("teenage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("teenaged")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("telemanagement")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("televideo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("telexes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("telles")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("temme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tended")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("teo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("teodoro")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("teriyaki")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ternes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("terrace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("terraced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("terraces")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("terrorizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("teruya")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("teske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tetreault")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("thaddea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thatches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thebeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("themselves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("theo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theobald")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("theocracy")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("theocratic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theodor")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("theodora")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theodore")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("theodorou")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theodric")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theola")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("theologian")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("theological")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("theology")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("theon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("theone")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("theophania")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("theophila")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theora")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("theoretical")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("theoretically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theorist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theorists")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theorize")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theorized")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("theorizes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("theorizing")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("theses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("thibadeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thibeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thibeault")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thibeaux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("thibedeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("thibodeau")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("thibodeaux")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("thinnes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("thoennes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("thomases")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("thomasville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thoreau")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("thorne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("thoroughbred")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("throneberry")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tickled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tilles")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("timme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tinkled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tithe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("titusville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toddling")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("toelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toggled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toggling")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tokuyama")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tolerances")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tolle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tolles")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tomeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tondreau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tonnage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tonnages")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tonne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tonnes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("toothed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toothpaste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toothpastes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toppled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("torches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("torosian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("torreon")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("torsiello")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tortoises")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tortorice")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("tortoriello")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("toshiyuki")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("toste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("touchette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tourangeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tourville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("towering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("townhouses")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("toyama")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toyo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("toyobo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("toyoda")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toyoo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("toyota")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("toyotas")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("traces")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tracheophytes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trackage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("trageser")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trampled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("transcended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("transimage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("treatises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trebled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trefgarne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("treharne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trembled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trended")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("treon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("triage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tricia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trickled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("trieste")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("triggering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tripled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trivette")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("trivializes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("troubled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("troyan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("troyanos")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("troyat")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("troyu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trudeau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trudges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trundled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tryart")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tsiang")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tsuneo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tuberville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tumbled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tunisian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("turberville")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("turbocharges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("turenne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("turnage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("turville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tussled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tutelage")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("twelve")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("twitches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("udelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ulloa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("umbrage")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("unabashedly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unabridged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unacknowledged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unamended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unannounced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unattached")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unattended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unbalanced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unbounded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unbranded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unbridled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unchallenged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("unchanged")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("uncontroversial")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unconvinced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("uncovering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("undamaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("underage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("underfinanced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("underfunded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("underhanded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("underprice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("underpriced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("understatement")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("unemployable")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("unfenced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unfolded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unfounded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unfunded")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("Ungeheuer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ungerer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unguarded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("unhedged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unheralded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("unhinged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unintended")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unionfed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("uniroyal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unmanage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unmanaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unnoticed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unpayable")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("unplaced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unprincipled")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("unreality")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unrealized")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unrecorded")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unruffled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("unscathed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unshackled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("untouched")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("untroubled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unwavering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("upended")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("upstage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("upstaged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("Ural")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("urges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("Urquart")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("uruguayan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("usage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("usages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("uses")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("uthe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("utilizes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("Uttar")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("utterances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("uyeda")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("uyehara")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("uyeno")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("Uzis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vacaville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("valeo")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("valle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("valleau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vallely")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("valles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vallette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("valve")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("valves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vanasse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vandamme")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vanderslice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vandewalle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vanhorne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vannguyen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vannice")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vanscoyoc")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vantage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vantages")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("variances")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("varnes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("varves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vases")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("vaske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vaudeville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vaxes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vedette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("veillette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("velayati")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("venereal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("venice")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("venne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("venturesome")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("verbiage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("verges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("verhage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vermette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("verne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("vernes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("verrette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("versace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("versailles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("verville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vestige")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vestiges")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("vette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vices")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("video")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("videodisk")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("videodisks")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("videogame")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("videophone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("videos")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("videotape")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("videotaped")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("videotapes")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("videotaping")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("videotex")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("videotext")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("videotron")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vienneau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("viet")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vigneau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vigneault")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vignette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vignettes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("village")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("villages")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("villareal")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("villette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vincelette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("vindictiveness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vingmed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vintage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vintages")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("violation")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("violette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("viruses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("visage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("vitiello")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("viverette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("viyella")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vizcaya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("voges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("voiceless")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("voices")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("volle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("voltage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("voltages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("voyage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("voyaged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("voyager")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("voyagers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("voyages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("voyeur")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("voyeurism")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vremya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wadded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("waffled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("waffling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wagering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wages")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("wakabayashi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wallace")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("walle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("walles")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("wallpapering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("walruses")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wangled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wantage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wantages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("warded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("warehime")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("warehouse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("warehousing")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("warmongering")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("warne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("warnes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("washburne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wasmer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("waste")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wasteful")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wastes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("watches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("waterbed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("waterborne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("watsonville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wavering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("waxes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("Wayans")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("waynesville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wedded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wedges")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("weisse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("welborne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("welded")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("welle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("welles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wentzville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wernette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wesleyan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("westburne")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("westfaelisches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("weyand")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("weyandt")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("weyant")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("whampoa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wheezes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whiteness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whiteside")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitesides")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whittling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wholesome")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wicked")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wickedly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wielded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wilbourne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("willabelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("willamette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wille")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("willes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("willette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wilmette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("winborne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("winded")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("winne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("winterbourne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wion")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("witches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wobbled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("woeste")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wolle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wolves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("worded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("workplace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("workplaces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wounded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wrangled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wreckage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wretched")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wretchedly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wrinkled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wristwatches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wyand")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wyant")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wyatt")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wyeth")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wynne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wythe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("xinhua")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("Yanayev")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yardage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("yasuyoshi")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("yelle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yeo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yeses")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("yeske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yevette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yielded")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ying")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yinger")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yodice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yohe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("yokoyama")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("yoneyama")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yourselves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("youville")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("yuille")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yvette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yvonne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zanoyan")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zaske")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("zaslavskaya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zayac")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zayas")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zeebrugge")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zegeer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zelaya")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zeoli")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zeos")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zieske")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zion")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("zionism")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zionist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zionists")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zions")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zises")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ziyad")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ziyang")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("zoologist")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("zoology")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zornes")); + // Stop here and mark this test as incomplete. + $this->markTestIncomplete( + '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..' + ); + + $this->assertEquals(2, $this->TextStatistics->syllableCount("aguiar")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("aguinaga")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ahmed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aichi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aida")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aidan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aikin")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("airedale")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("aires")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("aithne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aiton")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("albanese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("albea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("albeit")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("albemarle")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("alchemically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aldape")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("aldys")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("aleatory")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("alehouse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aleksandr")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("aleman")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aleshire")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("alethea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("alewife")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("alewine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("alewives")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("alfiero")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("alfonse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("alfonsine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("alfred")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("algebraic")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("algiers")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("algonquian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("algorithms")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("alguire")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("alicea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("alienate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("alire")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("allegedly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("allegiance")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("alleman")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("allender")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("almaguer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aloia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aloisia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aloysia")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("alphabetically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("alphonse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("altaic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("althea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("altomare")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("altruism")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("altruistic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("alvares")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("alysia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("amadeus")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("amalea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amalia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ambience")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ambient")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ambiguities")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ambitious")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ambitiously")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ambler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ambrosine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amelia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ameline")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ameliorate")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("amerine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ammonia")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("amphitheater")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("amphitheaters")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("amphitheatre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("amrhein")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("amyotrophic")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("anachronisms")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("anacostia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("analogue")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("analytically")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("anatomically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("andean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("andrea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("andreas")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("andreini")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("andren")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("angeles")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("angelically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("angelone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("anglen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("angove")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("anguiano")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("annese")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("annuities")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("annunciata")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("anreder")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("anse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("anstine")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("antagonisms")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("antares")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("antenne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("anthea")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("anthes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("anthiel")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("antigone")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("antigones")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("antinuclear")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("antique")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("antiques")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("antiquity")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("antisense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("antone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("antunes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("anxieties")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("anxiety")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("anxious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("anxiously")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("anyon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("anyone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aoki")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("aon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aorta")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("apache")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("apaches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("apelike")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aphorisms")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aphrodites")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("apnea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("apocalypse")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("apologetically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("appalachian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("appalachians")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("appreciable")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("appreciably")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aprea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("aquirre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arabe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arai")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("arakelian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("aravind")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("archaic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("archetypal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("archibeque")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("archimedes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ardine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("arduini")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("area")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("areas")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("arguable")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("arguably")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ariel")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("armbrister")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("armes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("armine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arnone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("arquette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("arrieta")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("artale")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("artcarved")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("artistically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ascii")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("asea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("asean")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aseltine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ashe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("asheville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("asiel")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("askren")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aspires")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("aspirin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("assembler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("assemblers")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("assicurazioni")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("assiduous")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("assiduously")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("assuredly")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("astrogeology")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("astronomically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("atheist")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("atheistic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("atheists")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("athenaios")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("athletically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("attache")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("attaches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("atteberry")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("attebury")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("attire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("audrie")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("aue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("auerback")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("aug")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aurea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("australia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("australian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("australians")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("austroasiatic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("authentically")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("automatically")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("automoviles")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("auxiliary")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ave")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("aveline")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aven")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("averages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("averaging")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("aviazione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aviles")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("avionic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("avionics")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("avions")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("awesome")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("awestruck")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("awfully")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("aydelotte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ayodhya")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("babblers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("babyish")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("baccalaureate")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bacchanalia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bachelors")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("backe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("backes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("backfired")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("backfires")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("backfiring")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("backlogged")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("baer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baez")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bahre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("baidoan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("baidoans")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("baidoas")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baiul")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bakeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bakeware")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bakewell")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bakke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("balaguer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("baldassare")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("balentine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("balfe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("baliles")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("balke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ballentine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ballyhooed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("baltes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bandolier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bandoliers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("banjoist")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("banke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bankes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("banque")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("baoguang")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("baptisms")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("baptistery")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("barbe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barefoot")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bareknuckle")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("barentine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("barfknecht")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("barke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barkeley")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("barkes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("barlettesville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baroque")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("barres")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barrientes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("barriere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("barthelme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("barthes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bartl")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("bartolomei")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bartone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baseball")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baseballs")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baseboard")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baseboards")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baseline")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("baseman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("basically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("basler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("basore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bassler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bateman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bathke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("batte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("battiato")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("batuigas")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("baudoin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("baumler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bayerische")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bazemore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bbc")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bbq")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beaches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beachler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("beaird")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beata")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beato")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beatrice")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beauce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beauchesne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beautifully")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bebe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bedient")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beebe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beebes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("beer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("beers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beforehand")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("begeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("begnoche")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("begonia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("begonias")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("begue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("behavior")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("behavioral")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("behaviorists")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("behaviors")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("behlke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("behne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("behnke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("behringwerke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beidler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beiersdorf")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("beijer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("beilke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beitler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("belfiore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("belgian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("belgians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("belgique")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("belier")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("belke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bellevue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bellone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("belongia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("belote")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("belshe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("belying")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("benavides")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("benches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bendure")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bene")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("benecke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("benequity")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("benes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("benevides")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("bengoechea")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("benke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("benoist")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bente")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beougher")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bequeath")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bequeathed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bequette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("berdine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("berea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beresford")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bergeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bergemann")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("berghuis")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("berke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("berkeley")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("berkes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("berlascone")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("berle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("berlottes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bermea")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("berres")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("berrien")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("berte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bertilde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bertling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bertone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("besler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bessire")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bessler")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("bestiality")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bethea")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bethke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beucler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beumer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beutler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("beuys")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("beverages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bewitched")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("biagioni")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("biaxial")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bichler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bicycling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("biedermeier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("biegler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bielke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bieniek")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("biennale")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("biennial")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bierer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bierly")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("biers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bigler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("billiard")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("billiards")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("biologically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("biomed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("biosafety")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bioscience")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("biosciences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("birchler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("birkeland")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("birkes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("birle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bitesize")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bitler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bivouac")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bizarre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bizarrely")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bjerke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blakeley")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blakeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blakemore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blakeney")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blakeslee")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blakesley")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("blanke")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("blankenbeckler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("blaschke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("blasia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("blasingame")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("blassingame")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("blauer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("blessed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("blitzed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("blonde")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("blondes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bloodshed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("blouin")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bluest")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bluey")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bluish")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("Bnai")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boas")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boaz")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bodine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("boehlke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("boehme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("boehne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("boehnke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("boening")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("boer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("boers")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bogue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("boheme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bohlke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bohne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("boies")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boise")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boleware")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("bollettieri")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bolognese")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bolte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bombardier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bonaparte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bonde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bonebrake")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bonecrusher")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bonecutter")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bonenfant")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bonesteel")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bonet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bonfire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bonfires")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bongiorno")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bongiovanni")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bonine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bonneville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bonnevilles")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bonsignore")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bonte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("booed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bordenave")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bordes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boredom")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("borgia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("borneman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bornemann")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("boroian")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("borre")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boseman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bosler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bottler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bottlers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bottone")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("bougainvillea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bourgeois")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bourgeoisie")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bourke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bournewood")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bourque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boutique")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("boutiques")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("boutte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bovespa")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bowles")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bowne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bowse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bowyer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("boyea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bozeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("braaten")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bracelet")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bracelets")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bracewell")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brakebill")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brakefield")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brakeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brakemen")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("brakke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bramalea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("branches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("brande")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brandeberry")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("brandes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brandl")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("braque")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brasilia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("braziers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brazilian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brazilians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brcko")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("breaches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("breezeway")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("breitling")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("brekke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("brendlinger")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("breneman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brennecke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brenneke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brenneman")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("brentlinger")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bressler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("briarcliff")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bridegroom")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bridesmaid")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bridesmaids")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bridgeforth")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bridgehead")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bridgeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bridgestone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bridgeton")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bridgewater")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brien")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brierley")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("brietzke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brigadier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brigitte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brigode")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brilliance")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brilliant")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brilliantly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("briones")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bristling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brittian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("brizendine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("broerman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bronze")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brookehill")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("brouhard")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brouillard")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brouillet")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brouillette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("browne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("browse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brueggeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brueggemann")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bruella")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bruggeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bruin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bruington")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bruins")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bruinsma")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brunches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("brunke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("brunnhilde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bruynes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bruzzese")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bryon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bt")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bta")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("bucciarelli")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("buchler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("buckler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("budai")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("budde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("buechler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buell")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buffeted")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("buffone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bugling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buick")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buicks")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bulthuis")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bunches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bunde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bundling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bundren")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bungling")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bunke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("bunte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("bunzl")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("buonocore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buoy")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buoyed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buoys")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("burdine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("burdines")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("burke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("burkes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("burres")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("burriss")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buseman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("businessland")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("businesslike")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("businessman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("businessmen")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("businesswoman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("busler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bussiere")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("bustling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("butare")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("butte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("buttler")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("byelorussia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("byington")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("byus")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cabinetry")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cabrales")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cacao")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("caccavale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cacciola")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caceres")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("caches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cacioppo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cacique")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cackling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cadotte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("caesarea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cafiero")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cahouet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caiazzo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("caillouet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caiola")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("calabrese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("calame")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("calcote")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("calderone")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("calliope")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("calliopes")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("caltagirone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("camire")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("campanale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("campfire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("campfires")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("campione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("canace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("canale")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cananea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("candler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cangialosi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("canipe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cannone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cansler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cantone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cantv")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("caouette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("capehart")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("capetown")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("caplinger")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("caporale")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("caracciolo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("caradine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cardinale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cardoen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cardone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("carefree")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caregivers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carelessness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("caremark")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("careplus")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caretaker")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caretakers")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("caribbean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carinii")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("carles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("carleton")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carlone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carlyon")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("carnevale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carnine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("carre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carrere")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carriages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("carriere")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("carrizales")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("carte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("carusone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("casal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("casale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("casares")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("casciato")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cascone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("casebolt")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("caseload")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caseworker")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caseworkers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cashier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cashiers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("casler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cassese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cassia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cassone")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("casstevens")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("castiglione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("castine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("castorena")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cataclysm")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("catalogue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("catalogued")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("catalogues")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("catalonia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("catanese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("catania")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("categorically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("catharine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("catharines")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cathmor")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("catholic")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("catholics")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("causeway")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("causeways")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cautious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cautiously")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cautiousness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cavalier")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cavaliere")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cavalierly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cavaliers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caveat")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("caveats")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("caveman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cawsl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cazares")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cd")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cdebaca")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cecelia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cecere")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cecilia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cedrone")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("celestine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("celia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("celosia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cenozoic")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("centerre")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("centurion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cercone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ceres")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cerone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cerrone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cervone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cesare")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cespedes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cevaxs")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chaidez")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chairez")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chandelier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chandeliers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chaos")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chaotic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chappuis")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("characteristically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("charest")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("charles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("charleston")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("charlestown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("charlotte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("charlottesville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("charlottetown")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("charpentier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cheeseburger")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cheeseburgers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cheesecake")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cheeseman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chemed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chemically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chengxiang")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cheque")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cheques")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chesler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chevalier")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("chevrier")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("chianese")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("chiang")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("chiappone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chiara")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("chicagoans")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chihuahua")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chikane")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("childe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chile")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chilean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chileans")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chisler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("chiu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chloe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chmiel")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("chmielewski")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chmura")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chocolat")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chocolate")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chocolates")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("choiniere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("choir")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chopsuey")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("choquette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("chortling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chouinard")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("chrismer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("christiana")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("christiane")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("christianity")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("christiano")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("christophe")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("chronologically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chrzan")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("chrzanowski")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("chseing")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("chuang")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("chui")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ciaccia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ciaccio")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ciampa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ciampi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cianci")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ciancio")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cianciola")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cianciolo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cianciulli")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ciani")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ciaobella")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ciaramella")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ciaramitaro")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ciaravino")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ciardi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ciarlo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ciavarella")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cicalese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ciccone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cicely")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cinque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ciocca")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ciolino")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ciotti")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("circling")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("circuitous")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("circumference")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cirque")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cisler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cityfed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ciucci")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ciulla")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ciullo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("civilian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("civilians")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("clague")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("claremont")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("clarion")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("clarke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("classically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cleah")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cleanse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cleaveland")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cleveland")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("clevelanders")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clevetrust")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cliche")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cliched")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cliches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cliffe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clinches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("clique")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cliques")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cloey")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("closedown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("closedowns")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clotheshorse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clothestime")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clothier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clothiers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clothilde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clouatre")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cluett")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("clydesdale")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cmon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cmos")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cmx")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coaches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coady")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("coale")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("coals")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coalson")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coate")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coates")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("coaxed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coaxum")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cobbler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cobblers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cochlea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cochlear")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cocke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cockroaches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coderre")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coeds")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("coeducational")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coefficient")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coefficients")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coelho")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coello")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coenen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coenzyme")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coequal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coerce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coerced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coercing")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coercive")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("coeur")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coexist")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coexisted")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coexistence")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coexisting")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coey")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cogema")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("coglianese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cohea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coincide")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coincided")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coincidence")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("coincidences")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coincident")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("coincidental")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("coincidentally")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coincides")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coinciding")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coinsurance")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cojuangco")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("colaianni")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coldren")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("colebank")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("colebrook")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("colegrove")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coleman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coleridge")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coleslaw")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("colestipol")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("colestock")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coleus")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coline")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coliseum")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("collapse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("colleague")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("colleagues")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("collegians")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("collegiate")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("collier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("colliers")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("collodion")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("colloquial")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("colloquium")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("colonel")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("colonels")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("colorfully")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("colosseum")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("colourful")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("comanches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("combe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("combes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("comeback")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("comebacks")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("comedown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("comfed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("commemorative")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("commercebancorp")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("commerciale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("commerical")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("commingling")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("complementary")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("comrie")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("comunale")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("concorde")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("conde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("condense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("condren")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("condry")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("conduit")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("conduits")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coneflower")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("conferencing")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("confidante")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("confidentiality")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("confucianism")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("congenial")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("conquer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("conquers")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("consequences")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("conserved")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("consortiums")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("conspire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("conspired")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("construcciones")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("contagious")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("contagiousness")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("conte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("contemptuously")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("contentious")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("contentiousness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("continuum")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("converged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("conyer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("conyers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coogler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("coombe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("coombes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cooperate")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("cooperated")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cooperates")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("cooperating")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("cooperation")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("cooperations")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("cooperative")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coordinate")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("coordinated")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("coordinates")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("coordinating")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("coordination")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("coordinator")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("coordinators")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("copeland")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("copeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("copiague")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coplen")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("copytele")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("corbusier")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cordes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cordial")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cordially")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cordry")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("corea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("corestates")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("coretech")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("Corleone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cornea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("corneas")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cornelia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cornelius")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("corporacion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("corporatewatch")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("corporatewide")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("corpse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("corrales")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("correa")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("corte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cortes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cortese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("corzine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cosme")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cosmetically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cothren")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cotler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cotrone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cottone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("couches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("couillard")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("couldnt")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("courchesne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("courtemanche")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coval")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coyote")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("coyotes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cozine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("crabbe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cradling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cranesbills")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("crary")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("creager")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("create")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("created")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("creates")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("creating")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("creation")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("creationism")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("creations")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("creative")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("creatively")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("creativity")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("creator")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("creators")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("creer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("creque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cressler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("crimea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("crisler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cristiani")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cristiano")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("criterion")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("criticisms")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("critique")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("critiques")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("crnkovich")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("croat")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("croatia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("croatian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("croatians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("croats")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("croce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crocheted")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cronauer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cronyism")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crooked")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("crounse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crovl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crovls")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("crowne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crownx")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crozier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cruea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cruel")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cruey")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cruikshank")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("crumpler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("crunches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cryolite")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("crysler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("csaszar")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cuddeback")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cuello")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("cuffe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cuneiform")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cunliffe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cureton")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("curiale")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("curnutte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cutaia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("cutesy")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cutrone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cuvelier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cxc")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cyclades")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cycling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("cyclist")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cyclopean")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("cytherea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dadeland")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dague")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dahlia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dahlke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dahnke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("daiichi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dalgleish")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dalia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dalke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("daloia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dalpe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dambrosia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("damewood")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("damien")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("damietta")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dandelion")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dandelions")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dandrea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dandyism")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("danese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dangler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dangling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("daniele")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dannemeyer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("danske")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("daoud")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("daoust")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("daredevil")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("darien")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("darke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("daseke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dassler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("datapower")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dateline")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("datelines")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("davide")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dbase")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ddt")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("deactivated")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dealba")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deana")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deanda")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deandrade")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deandrea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("deangelis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deanna")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("debiase")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("debora")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deborde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("debruin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("debutante")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("debutantes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("debuted")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("decesare")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("declerque")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("decorative")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("deemphasizing")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("deer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("defense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("defenseless")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("defiore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("defrates")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("degaetano")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("degeorge")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("degiacomo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("degrace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("degrave")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deguire")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("degutare")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dehne")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("deification")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deify")); + $this->assertEquals(9, $this->TextStatistics->syllableCount("deinstitutionalization")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deisher")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deism")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deities")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deity")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("delatte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("delaurentiis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("delbene")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("delcine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("delebarre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("delfine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("delgiorno")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("delia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deline")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("delineate")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("delineated")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("delineates")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("delineating")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("delineation")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deloitte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("delorean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("delores")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("delosreyes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("delphine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("delpriore")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("delre")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("delsignore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deltaic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deluise")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("demagogue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("demagogues")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("demarest")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dementia")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("democratically")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("demographically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("denarii")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("denatale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dengler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("denlinger")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("denouement")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dense")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("densely")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dente")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("denuclearization")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("denuclearized")); + $this->assertEquals(8, $this->TextStatistics->syllableCount("deoxyribonucleic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dep")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("depace")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("depascale")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("depasquale")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("deppe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("depreciable")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("depriest")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dercole")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("derflinger")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("derosia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("derouen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("derouin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("desai")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("desantiago")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("descartes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("deschler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deserved")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("deservedly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deshaies")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("desimone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("desire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("desired")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("desires")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("desiring")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deslatte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("desperate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("desroches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dessauer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("detente")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("determinedly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("detore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dettore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deutschemark")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("deutschemarks")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("devere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("devilish")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("devillier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("devour")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("devoured")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("devouring")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("devours")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dewilde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dewitte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dewolfe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dhlakama")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("diabetes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dialogue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dialogues")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("diamond")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("diamonds")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dianne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("diaper")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("diarrhea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("diastole")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dibiase")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dicesare")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dichroic")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dicke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dickes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dicomed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("didion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("diego")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("diener")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dienst")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dierkes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dierking")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dietary")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dietetic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dieting")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dietitian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dietitians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dietl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("diets")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("Dieu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("diez")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("differentiate")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("differentiated")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("differentiates")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("differentiating")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("differentiation")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("differently")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("difiore")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("digiacomo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("digioia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("digiovanna")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("digiovanni")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("diguglielmo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("diianni")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("diiorio")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dikeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dildine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("diltiazem")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dimare")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dimichele")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dinatale")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dinehart")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dingler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dinmukhamed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dinse")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("dionisio")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("diorio")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dipaola")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dipaolo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dipasquale")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("diplomatically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("directv")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dirkes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dirkse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("discharged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("discotheque")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dIsere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("disgorged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("disgorgement")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("disgruntling")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("disimone")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("disinterested")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dismantling")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("disorient")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("disorientation")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("disoriented")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("disorienting")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dispatched")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dispense")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("disque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dissuade")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dissuaded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("diverged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("divulged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dk")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dlouhy")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dlugos")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dlugosz")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dmitri")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("doable")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dobrzynski")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("doepke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("doer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("doerfler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("doerflinger")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("doering")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dogmatically")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dohme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dohse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("doin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dolores")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("domangue")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("domestically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("domine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("domingue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dominique")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("domke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("donde")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dondlinger")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("donze")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("doonesbury")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("doppler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dorea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dorine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dorion")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dornier")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dorothea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dorthea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dosia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dossier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dossiers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("doubtfire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("doubtfires")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("douglass")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dour")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dovetail")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dovetailed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dovetails")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dower")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dowers")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("downe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("downes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dowse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dramatically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("drastically")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("drawer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("drawers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("drechsler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("dreher")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dressler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("driveway")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("driveways")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("drogue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("drouillard")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("drouin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("druella")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("druid")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("druidism")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("druids")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dsouza")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dualisms")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("duane")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duarte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dubilier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dubreuil")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dubuque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ducharme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duel")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("duelist")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duels")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("duesler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duet")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duets")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duey")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dufresne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duis")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dukedom")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dukeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dulcea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dulciana")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dulcinea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dullea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dumire")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duncombe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dunmire")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("duodenal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duong")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("duopoly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dupler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dupriest")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dupuis")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("duque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duquesne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("duquette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("duramed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("durflinger")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("duvalier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("duvaliers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dwindling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dyches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("dykeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("dyslexia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("dzhirkvelov")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eagleye")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("earle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("earles")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("easudes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eavesdrop")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eavesdropping")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eblen")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("eckes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eckl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eclipse")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ecologically")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("economically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ecstatically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ecuador")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ecuadoran")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ecuadorian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("edgecomb")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("edgecombe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("edgemon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("edgeways")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("edgewood")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("edgeworth")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("edinburgh")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("edizione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("edouard")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("edrea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("edrington")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eduard")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eduardo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("effler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("egoism")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("egregious")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("egregiously")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ehle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ehlke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ehrke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eichler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eiermann")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eifler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eightieth")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eiichi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eiseman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eisemann")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ekkehard")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("elaborate")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("elaborately")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("elapse")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("elbe")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("electricite")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("electrique")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("elementary")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("eleonore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("eletr")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("elinore")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("elkes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ellerbe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ellesmere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ellipse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ellithorpe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("elmes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("else")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("elsea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("elsevier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("elsewhere")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("elysia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("emanuel")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("emanuele")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("embler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("embolisms")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("embryo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("embryonic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("embryos")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("emde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("emerald")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("emeralds")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("emerged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("eminase")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("emmaline")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("emmanuel")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("emotionally")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("emphatically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("emphysema")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("empire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("empires")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("emslie")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("emuil")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("encarnacion")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("encircling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("encroaches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ende")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enea")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("energetically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("engelke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("engeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("engler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("enholme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("enke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("enlarged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enlargement")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enlargements")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ennea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ennui")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enriches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("enslen")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ensminger")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("enthusiasm")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("enthusiasms")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("entire")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("entirely")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("entitling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("entrenches")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("entringer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("entsminger")); + $this->assertEquals(8, $this->TextStatistics->syllableCount("environmentalism")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("epicurean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("epilogue")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("epitome")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("eppes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eppler")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("equiangular")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("equity")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eranthe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("erbe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("erbes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ercole")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("erion")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("eritrea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("eritrean")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("erratically")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("erte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ertl")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("erythropoietin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("esler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("eslinger")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("esme")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("espalier")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("espe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("especially")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("esquer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("est")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("esteves")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("etc")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ethnically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ethyol")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("etiquette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("euan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("euchred")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("euclea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("eudosia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("euphemisms")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("euphemistically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("euphrates")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("euromissiles")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("euromobiliare")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("european")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("europeans")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("europewide")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eveland")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("evening")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("evenings")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("everybody")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("everyday")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("everyman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("everything")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("everytime")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("everywhere")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("evidentiary")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("exchequer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("expanse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("expeditious")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("expeditiously")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("expense")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("experience")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("experienced")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("experiences")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("experiencing")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("expires")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("eyepiece")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("facedown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("facelift")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("facemire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("facetious")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("facetiously")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("faciane")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("facsimile")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("facsimiles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fagundes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fahnestock")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("faiola")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("faist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("falcone")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("falke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("false")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("falsehood")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("falsehoods")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("falsely")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("falzone")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("famiglietti")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("familial")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("familiar")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("familiarity")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("familiarize")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("familiarized")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fansler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fantastically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fanueil")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("farace")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("faraone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("farese")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("farewell")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("farewells")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("farfetched")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("farquhar")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("farruggia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("farrugia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fasone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fassler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fatigue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fatigued")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fatigues")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("faubion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("favale")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fawkes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fayetteville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("FDIC")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fealty")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("feb")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("felde")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("felske")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("feltes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fencl")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fenske")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ferraioli")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ferre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ferriss")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ferrofluidics")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ferrone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fesler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fessler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fiance")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ficke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fickes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fictitious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fidelia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fidler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fieros")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fiers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fiery")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fiesta")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fiftieth")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("figler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("figueira")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("figueiredo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("figurehead")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fildes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("filenet")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fillingame")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("finale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("financier")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("financiera")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("financiero")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("financiers")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("finanziaria")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("finarte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("finches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fincke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("findling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fineberg")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("finefrock")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("finegold")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fineman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("finestone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("finevest")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("finke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("finklea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fiore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("firearm")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("firearms")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("firebaugh")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("firebombed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("firebombs")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fired")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("firefight")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("firefighter")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("firefighting")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fireman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("firemen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("firepower")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fires")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("firestone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("firestorm")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fireworks")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("firstier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fischl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fischler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fisler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fitzhenry")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fitzwilliam")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fivecoat")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fivefold")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("flaharty")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("flaherty")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("flamemaster")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("flavr")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fleer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("flightsafety")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("flirtatious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("florea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("flores")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("florine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("flour")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("flours")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fluid")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fluidity")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fluids")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fluitt")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fluor")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fogler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("foie")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("foiles")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("folkes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("folliard")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("folse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("foncier")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("fondiaria")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fondren")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fonte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("forbes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("forcefulness")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("forde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("forensic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("forensics")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("forest")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("forested")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("forester")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("foresters")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("forestry")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("forests")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("forex")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("forgue")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("formulaic")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("forquer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fortieth")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fortuitous")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fosler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("foulke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("foulkes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("foward")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fowkes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fowlkes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("foxmeyer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fractious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fractiousness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fragale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fraioli")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("framework")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("francese")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("francke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("francoeur")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("franke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("frankincense")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frankl")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("franze")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("franzese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("franzone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frashier")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fratzke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frazier")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("freda")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frederic")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frederick")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fredericks")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fredericksburg")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fredette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("freest")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("freia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fricke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frie")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("friedl")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("friis")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fritze")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fronde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frontier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("frontiers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fruin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fruition")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fruity")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("frunze")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("FSLIC")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fuel")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fueled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fuelled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("fuels")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fuer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fugue")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fugues")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fukui")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fukuoka")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("fullilove")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("funches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("funderburke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("funke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fuoco")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("fuselier")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fyffe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("fyffes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gabbroic")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gabehart")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gabele")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gaboriault")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gabriel")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gabriela")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gabriele")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gabrys")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gaffe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gaffes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gaglione")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gaia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("galatea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("galea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("galentine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("galesburg")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("galiena")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("galilean")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gallentine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("galyon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gambale")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gambler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gamblers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gamesmanship")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gamunde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gangl")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ganske")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gaona")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("garbe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("garde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gardenia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gardenias")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gardiner")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("garoutte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("garske")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gartzke")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("gastrointestinal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gatekeeper")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gatekeepers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gateway")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gateways")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gatewood")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gatx")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gatzke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gauerke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gaulke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gawne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gdansk")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("geagea")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("geerdes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gehres")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gehrke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("geissler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gelasia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gendarme")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("genealogy")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("generales")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("generically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("genetically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gengler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("genial")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("genitalia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("genius")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gensia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("genske")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gensler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gentlest")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("genuine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("genuinely")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("georges")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("georgetown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("georgette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("georgia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("georgian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("georgians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("georgiou")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gerace")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gerdeman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gerdes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gericke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gerke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("germe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gertler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("geschke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gfeller")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ghanaian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ghanaians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("giacco")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giacinta")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giacobbe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("giacomelli")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("giacomini")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giacomo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("giacone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("giaimo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gialanella")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giambalvo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("giambra")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giammarco")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("giammarino")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("giampa")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giampaolo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giampietro")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giancola")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gianelli")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gianfrancesco")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giangrande")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gianino")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("giannattasio")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giannelli")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giannetti")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giannetto")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gianni")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giannini")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giannola")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giannotti")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gianotti")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giaquinto")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giardina")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giardini")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giardino")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("giarratano")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giarrusso")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gier")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gierke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("giesecke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giesler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giggly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giguere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gilberte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gilbertine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gilchrest")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gilcrest")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gilkes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gioia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giordani")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giordano")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("giorgi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("giorgia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("giovanelli")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("giovanetti")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("giovannetti")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("giovannini")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("giovannoni")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("giovenco")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("giovinazzo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("giraffe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("giraffes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("girdler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("girouard")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gisler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gittler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("givebacks")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gjerde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("glacier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("glaciers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("glazebrook")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("glenfed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("glidewell")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("glimpse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gloucester")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("glyndebourne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goates")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gocke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("goecke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("goedde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goedecke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("goemon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("goering")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("goerke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("goette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("goetze")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("goewey")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gohlke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("golde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("goldfinches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goleman")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("golembiewski")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gomes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gondolier")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gonorrhea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gonyer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gonzales")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goosefish")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goosefoot")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("goracke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("Gordievsky")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gottesman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gouin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("govea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("govpx")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("grabbe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("graceland")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("grahams")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("grande")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grapefruit")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grapefruits")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grapeshot")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grapevine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grapevines")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("graphically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("grassia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gratuities")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gratuitous")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("gratuitously")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("graue")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("graunke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("graveline")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("gravitationally")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("greasewood")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("greeniaus")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("greer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("greinke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("greunke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("griesa")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("grinde")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("grismer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grobler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("groene")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("groening")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grolier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grosvenor")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("groveman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gruel")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("grueling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gruet")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("gruhlke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gruis")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("grulke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grunebaum")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("grzelak")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("grzesiak")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("grzeskowiak")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("grzyb")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("grzybowski")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("grzywacz")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("grzywinski")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gschwind")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gsell")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("gtech")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("guadarrama")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gucciardo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guenette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("guerre")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("guglielmetti")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("guglielmi")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("guglielmo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("guiana")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guidebook")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guidebooks")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guideline")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guidelines")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guidepost")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guideposts")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("guidone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("guidry")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guillotte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guinier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guisewite")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gundry")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gunfire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gurgling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gurion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gurtler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guseman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gusler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("gustave")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("guzzler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("gymnasia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("haacke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("habeas")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hacienda")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hacke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hackl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hackler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hades")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hadler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("haering")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("haeussler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hafeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hageman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hagemann")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hagewood")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hague")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hahne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("haist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hajime")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("halcyon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("halcyone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("haldeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hallbauer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("halteman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hamblen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hamler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hampe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hamtramck")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hanemann")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hanke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hankes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hanneman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hannemann")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hanseatic")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hapeman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("happe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("haque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("harangue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("harangued")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("harangues")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("harare")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("harclerode")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hardebeck")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hardeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hardwicke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("harebrained")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("harewood")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("harke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("harmes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("harpe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("harre")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("harte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hartl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("haruo")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("haschke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("haseman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hasler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hass")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hassler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hatheway")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hatler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("haueter")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hausler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("havelock")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("haveman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hawaii")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hawaiian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hawaiians")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hawke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hawkes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hawkiness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("haydn")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("haynesworth")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hbox")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hces")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hebrides")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hedgecock")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hedgehog")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hedgehogs")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hedgepath")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heffler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hegeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hehmeyer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heideman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heidemann")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heidler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heigl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heikes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heileman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heindl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heinecke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heineman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heinemann")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heinicke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("heinke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heinl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heinlen")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("heintze")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("heinze")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heishman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heisler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("helbling")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("helionetics")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("helke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("helme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("helmes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("helmke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hempfling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("henceforth")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hendren")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hendrie")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("henke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("henkes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("henneberger")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("henneman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("henrie")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("henrique")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hensler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("henze")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("heppe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("heppler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("herculean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hercules")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hereby")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("herendeen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heretofore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("herewith")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hernandes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heroic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heroics")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heroin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heroine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heroines")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("heroism")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("heroized")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("herre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hertzler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hesler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hessler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hestia")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("heterogeneity")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hettler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hfdf")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hgh")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hialeah")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hibbler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hideaki")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hidebound")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hideout")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hideouts")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hierarchy")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hiers")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hilde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hildegarde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hildegardes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hileman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hilemon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hilgeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hilliard")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hilmes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hinchcliffe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hinchliffe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hinde")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hindes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hinduism")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hineman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hintze")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hinze")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hippe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hippler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hirai")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hire")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hired")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hires")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hiroaki")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hirose")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hisao")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hitzeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("HIV")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hjelm")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hjort")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hobbyist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hobbyists")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hochstedler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hochstetler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hodde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hodgepodge")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hoefler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hoefling")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hoehne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hoene")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hoeveler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hoey")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hogue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("holcombe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("holde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("holdeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("holdren")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("holeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("holleman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("holme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("holmes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("holste")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("holte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("holyoak")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("holyoke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homebuilder")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homebuilders")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homebuilding")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homebuyers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homecare")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homeclub")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homecoming")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homegrown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homeland")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homelands")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homelessness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homelike")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homemade")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homemaker")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homemakers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homemaking")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homeporting")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homesick")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homesickness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homesley")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homespun")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homestake")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homestate")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homestead")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homesteaded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homestretch")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hometown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homeward")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homewood")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("homework")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("homeworkers")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("homogeneity")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("honea")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("honse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hoobler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hoosier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hoosiers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hopefuls")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hopelessness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hopewell")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hopke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hoppe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hoppes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("horatio")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("horatius")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("horde")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hordes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("horehound")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hornblende")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("horseback")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("horseflesh")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("horsehead")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("horseman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("horsemanship")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("horsemen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("horseplay")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("horsepower")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("horseradish")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("horseshoe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("horseshoes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("horsetails")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hosea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hosler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hosseini")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hostetler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hostutler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hotelier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hoteliers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hottelet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hotwired")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hotze")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hour")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hourglass")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hours")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("houseboat")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("housebroken")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("housecleaning")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("household")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("householder")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("householders")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("households")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("housekeeper")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("housekeepers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("housekeeping")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("houseknecht")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("houseman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("houseware")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("housewares")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("housewife")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("housewives")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("housework")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("houseworth")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("housewright")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("houy")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hovde")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("howse")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("howze")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hrawi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hrdlicka")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hrncir")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hrubik")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hsiao")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hsieh")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("huachuca")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("huallaga")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("huan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("huaneng")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("huang")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("huard")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hucke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hudler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("huetta")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("huette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("huey")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("huffstetler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("huffstutler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hufstedler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hufstetler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("huggler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hui")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("huibregtse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("huish")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hulme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hulse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("humblest")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("humfry")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("huml")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("humphries")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hunches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hunke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("hunte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("huot")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hurdler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hurdling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("huseman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hustler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hustlers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hustling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hyades")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("hydroelectric")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hydropower")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("hygeia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hyperbole")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("hyperborean")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("hypothetically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("hysterically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("hyun")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("iafrate")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("iain")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("iannaccone")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("iannacone")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("iannone")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("iavarone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ibn")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("iceberg")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("icebergs")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("icebox")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("icebreaker")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("icebreakers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("iceland")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("icelandair")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("icelandic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("iceskating")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ickes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("idalia")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("idealistic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("idealized")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ideas")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ideologist")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ideology")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ideonomy")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("idiotically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("idler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("idling")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ierardi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("iezzi")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("iglesia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ignatius")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ihde")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ihrke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("iiams")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("iida")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("iie")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ijames")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ikea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ileana")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("iliescu")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ilse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("imageries")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("imagery")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("imbroglio")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("imm")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("immense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("immensely")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("immunetech")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("impartiality")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("imperiale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("impetuous")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("impoverish")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("impoverished")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("impoverishes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("impoverishment")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("impulse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("imrie")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("inalienable")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("incense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("incestuous")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("inches")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("incipient")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("inconspicuous")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("incoordination")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("incorvaia")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("indianians")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("indifferent")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("indosuez")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("indulged")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("industriale")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("inequity")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ines")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("inexperience")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("inexperienced")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("infectious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ingenious")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ingeniously")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("inglish")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ingratiate")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ingratiating")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("initiate")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("initiated")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("initiates")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("initiating")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("initiation")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("initiator")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("initiators")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("inmobiliaria")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("inouye")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("inquired")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("inquires")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("inquiries")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("inquiring")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("inscore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("inspired")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("institucional")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("intaglio")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("intelligentsia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("intense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("intensely")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("intercollegiate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("interdictes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("interest")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("interested")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("interesting")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("interests")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("intermingling")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("internationale")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("intrigue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("intrigued")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("intrigues")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("intuit")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("intuition")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("intuitive")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("intuitively")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("invaluable")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("iole")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ione")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("iorio")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("iou")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("iovine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ironically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ironton")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("iroquois")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("isadore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("isaiah")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("isautier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("iseman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("isms")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("isoelectronic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("isosceles")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("israel")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("italian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("italianate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("italians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("itll")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ixion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("izquierdo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("izvestia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jacinthe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("jacobean")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jacque")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jacques")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jacquie")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jaenicke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jahnke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jaime")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jaimes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jakeway")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jameson")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jamestown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jamesway")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("janeway")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("janicke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("janke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jaques")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jared")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jayme")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jaymes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jeers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jefferies")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("jeopardizes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("jerboas")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jerde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jere")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("jeroboam")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("jerrome")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jeschke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("jesmer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("jesuit")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("jesuits")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jewkes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jiang")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jiangsu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jiawen")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("jingoism")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("jingoistic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("joachim")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("joachims")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("joann")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("joanna")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jocelin")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("joceline")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jocelyn")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jocelyne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jocylan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("joedicke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("joel")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("joey")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("joffe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("joie")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("jolicoeur")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jolliffe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("jorde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jose")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("joycelyn")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jr")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("jua")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("judishe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("juedes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("juenemann")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("juhnke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("julietta")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("jurgensmeyer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("juul")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kadrmas")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kahane")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kahle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kahre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kalliel")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kalthoff")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kamakau")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kamikaze")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kamler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kampe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("Kampuchea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kanade")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kaniewski")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kanouse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kantian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kaohsiung")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kapler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kappes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kappler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("karaoke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("karate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kardashian")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kartes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kaseman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kasler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kasprzak")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kasprzyk")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kasriel")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kassler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kastenmeier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kastl")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kataoka")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("katharine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("katia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kawai")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kawate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kazuo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("keay")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("keebler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("keeffe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kehne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kehres")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("keiichi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("keio")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("keisler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("keisling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("keister")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("keisuke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("keleman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kelemen")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kempe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kempke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kenealy")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kennebeck")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kennemore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kensler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("keplinger")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("keppler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kerien")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("Kerouac")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kerpedjiev")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kesler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kesling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kessler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kganakga")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kgori")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("Khaled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kibbe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kidde")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kiehne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kiev")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kigale")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kightlinger")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("killian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("killilea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kimbler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kimbriel")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kimler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kindler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kingry")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kinsler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kinzlmaier")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kiplinger")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kippes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kirouac")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kisler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kisling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kissler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kjar")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kjos")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("klabunde")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kleer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kleindienst")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("klenke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kleppe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kliethermes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("klingler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("klinke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("klitzke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("klocke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kmart")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kmetz")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kmiec")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kmiecik")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("knapke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kneer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("knievel")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("knifelike")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("knobbe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("knoedler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("knowledgeware")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("knowles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("Knute")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("koala")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kociemba")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("koegler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("koehne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("koepke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("koeppe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("koestler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("koetje")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kofler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kogler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kohne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kohnke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("koichi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kokate")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kolbe")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("kolodziejski")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kooy")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kooyman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kopke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("koppe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("koppes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("korea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("koreagate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("korean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("koreans")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("koreas")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("korte")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("korzeniewski")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kosanke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kostrzewski")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("koteles")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kotler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kottler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kouri")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kowalke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("krabbe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kracke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kraeutler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("krajina")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("krampe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kratzke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("krauer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kreher")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kreidler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kreisher")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("krenke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kressler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("krienke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kriete")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("krinke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kristoffe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kroening")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kroenke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("krone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kruckeberg")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kruschke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ksiazek")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kuala")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kuan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kuchler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kudrna")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kuechler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kuehne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kugler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kuhne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kuhnke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kumagai")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kunde")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kuntze")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("kunze")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kuo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kusler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kuzniar")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kvale")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kvam")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kvasnicka")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("kvetch")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kveton")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("kvistad")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("kvitsinsky")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("kwh")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("labbe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("labine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("labonte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("laboratories")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("laboratory")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("laborde")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("labossiere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("labouisse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("labrecque")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("labrie")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lacaze")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lacefield")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lacewell")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("lacoursiere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lacquer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("laduke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("laferriere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("laffitte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lafitte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lafler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("laforte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("lafreniere")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lagace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lagrone")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lague")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lahaie")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("laimbeer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("laity")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lajoie")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lakefield")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lakefront")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lakeland")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lakeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lakeshore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lakeview")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lakewood")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lalone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lamaist")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lambe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("lambiase")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lamere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lamonte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lamotte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lampe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lampl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lancelet")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lande")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("landes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("landfried")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lanehart")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lanese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("langelier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("langone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lanier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lanphier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lansdowne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("laos")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("laotian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lapine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lapointe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("laporte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lappe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("laprade")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lapse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("laraia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("lareina")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("larine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("lariviere")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("larke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("larocque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("laroque")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("larose")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("larrea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("larroquette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("laryngeal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lastrapes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("latticework")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("launches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("laureate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("laureates")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("laurentiis")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("laverdiere")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("laverdure")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lavere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lavergne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lavine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lavinia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lavoie")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lawrenceburg")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lawshe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lawyer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lawyerly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lawyers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lazare")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lcs")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ldbrinkman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leaches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("league")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leaguer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leaguers")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("leagues")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leah")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leander")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leandro")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leann")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leapfrogged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leaseback")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leasebacks")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leasehold")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leaseway")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lebegue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leboeuf")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lebouef")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leccese")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lecompte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lecomte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lecrone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leeches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leeuwen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leffler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("legare")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("legrande")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lehne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lehrke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leibfried")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leibler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leicester")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leino")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leist")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("leitzke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lelia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lembcke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lembke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lemcke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lemieux")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lemire")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lempke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lendl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lenient")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lenke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lentine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leonelle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lepere")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lepine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lepore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lequire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lereah")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lesane")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lesesne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("letarte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("letitia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lettiere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("leveque")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("leveraging")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("leverone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("levien")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("levitte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lezotte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lhommedieu")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("liaison")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("liaisons")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lian")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("liang")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("liao")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("liasson")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("liberalization")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("liberatore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("licciardi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("licea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("license")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("licentious")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lichte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("liebler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lieu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lieurance")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("Lieut")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lieutenant")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lieutenants")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifeblood")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifeboat")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifeboats")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifeco")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifeguard")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifelike")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifeline")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifelines")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifelong")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lifesaver")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lifesavers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lifesaving")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifespan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifestyle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifestyles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifetime")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lifetimes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("liffe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("likelier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("likeliest")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("likelihood")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("likewise")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lilienthal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("limehouse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("limelight")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("limestone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("limestones")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("linde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lindeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lineage")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("lineages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lineal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("linear")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("linearly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lineback")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("linebacker")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("linebackers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lineberger")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lineman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("linemen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lineweaver")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("linguistically")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("linke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("linnea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("linneman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("linnemann")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("linoleum")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("linse")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lipke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lippe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("liqueur")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("liqueurs")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("litalien")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("litigious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("littlest")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("liu")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("livelier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("liveliest")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("livelihood")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("liveliness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("liveried")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("livestock")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("livonia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lizotte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("llorens")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("loaiza")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lobbyist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lobbyists")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("locke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lockyer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lodestar")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lodestone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lodgepole")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loeffler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("loella")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loess")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loew")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("loewen")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("loewenstein")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("loewenthal")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("logarithms")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("logically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("logistically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("logiudice")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("logue")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lohnes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lohse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("loiacano")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("loiacono")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lois")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loise")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("loneliness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lonetree")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("longenecker")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("longshoremen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loosestrife")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loosestrifes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lopeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lorean")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lotte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lottes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lotze")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("louanna")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("louart")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("louisette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("louque")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lourdes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("louviere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loveday")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lovegrove")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lovejoy")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loveland")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("loveridge")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lovewell")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lowekamp")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lp")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lpn")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ls")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lsd")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ltd")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lubke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lucchese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("luciani")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lucianna")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lucien")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lucke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("luckiest")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ludeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ludemann")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("luebbe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("luebke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lueck")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("luecke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("luedecke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("luella")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("luera")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("luevano")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lui")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("luigi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("luis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("luisa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lukehart")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lukewarm")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("luncheonette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lunches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lunde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("luoma")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("luong")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("luongo")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("luque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("luquette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lutze")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lutzke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("luu")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lynde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lyon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lyondell")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lyonnais")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lyonnaise")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("lyons")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("lyphomed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("lysne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mabry")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("macaques")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("maccabean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("macdiarmid")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("machete")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("machetes")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("machiavellian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("machinea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("maciag")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maciejewski")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("macke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mackiewicz")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("macmahon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("macqueen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("macrame")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("macwilliams")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("madl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("madlen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("madore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maeda")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("maekawa")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maenza")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maestri")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("maez")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("maglione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("magnolia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("magnolias")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("magnone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("magouirk")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("maher")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mahnke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("maia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mainichi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("maio")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maiolo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("maiorana")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("maiorano")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("maiorino")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("maish")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("majure")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("makegoods")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("makeshift")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("malave")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("malinde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maline")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("malkiel")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("malleability")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("malleable")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mandl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("manfred")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("mangiaracina")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mangine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mangling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mangone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mangope")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("manke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mannerisms")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("manrique")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("manske")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("manthe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mantione")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("manzanares")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("manzione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maoris")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mapplethorpe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("maraline")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("marcelline")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marchese")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("marchione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marcial")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marciante")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marcone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marcotte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("margeotes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("margiotta")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mariel")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("marielitos")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("marijuana")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marineland")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marion")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("marje")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("marke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("markedly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marotte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("marque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marquee")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marquees")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("marques")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("marquette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marriages")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marrone")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("marschke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("marte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("marthe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("martinique")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("martire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("martone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("marui")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("masaaki")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("masai")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("masao")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("maschke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("masciarelli")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mascioli")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("masefield")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maslen")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("massacring")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("massicotte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("massingale")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mastandrea")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("mastrogiovanni")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mastroianni")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("matarese")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("materiel")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mathai")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mathea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mathieu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mathilde")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("matrilineal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("matsui")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("matsuo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("matsuoka")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("matsuura")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("matte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mattes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("matthea")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("matthes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("matzke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maurine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mausoleum")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mawr")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maxion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("maxzide")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("maybe")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("mazowiecki")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mazzei")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mazzone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mbank")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mcalinden")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mcauliffe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mcbrien")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mccaffery")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mccague")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mccahan")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("mccarthyism")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mccaughan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mccluer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mccuin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mcdiarmid")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mcgeough")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mcgoey")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mchargue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mckeague")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mcmillian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mcmurtrie")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mcneer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mcqueary")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mcqueen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mcqueeney")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mctague")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mcteer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mctigue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mcwilliam")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mcwilliams")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("meagher")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meander")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meandered")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("meandering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meanders")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mechanically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mechanisms")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("meckes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("medically")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("mediterranean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("medlen")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("meetze")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("megacarriers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("megace")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("megalomaniacal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("meidl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("meierfeld")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("meincke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("meindl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("meinecke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("meinke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meiosis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meisler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("melamed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("meloche")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("melone")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("memorabilia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("menapace")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("menasion")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mende")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("Mengele")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("menke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("menkes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("menstruation")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mente")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("menze")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mercedes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mercure")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("meridionale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("merion")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("merle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("meschke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("meserole")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mesler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mesozoic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("messagepad")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("messler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("messrs")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("metabolisms")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("metcalfe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("methodisms")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("metier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mettler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("metze")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mfume")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("micale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("micciche")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("michener")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("michl")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("micke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("microcosm")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("micrografx")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("microorganisms")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("microscopically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("midyette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("miert")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("migliore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mignone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mijares")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mildrid")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("milestone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("milestones")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("milieu")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("milke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("milne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("milnes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("minamide")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mincemeat")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("minea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("minebea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("minefield")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("minehart")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("minesweeper")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("minesweepers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mineworkers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mingling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("miniard")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miniaturized")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("minjares")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("minke")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("minneapolis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("minoan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("minogue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("minteer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("minuet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("minuteman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mireles")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("misbehavior")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miscarriages")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mischarged")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mischke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mischler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("miscreant")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("miscreants")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("miscreations")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("misfire")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("misled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mismatched")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("missildine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("missler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mitschke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mitsui")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mittler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("mixte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("miyake")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mkhatshwa")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moab")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("moammar")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moates")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mobiliare")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("modestine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("moening")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("moerbe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("moerke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("moerman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mohamed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mohammed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mojave")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("molehill")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("molelike")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("molesworth")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("moncure")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("monde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("monisms")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("monje")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("monologue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("monologues")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("mononuclear")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("monotheism")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("monsieur")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("monsieurs")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("montagnier")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("montefiore")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("monteleone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("montgomery")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("montiel")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("montien")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("montieth")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("montone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moorehead")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moorehouse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moorestown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moosehead")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("moppes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("morace")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("morea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("morehead")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("morehouse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moreland")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moreman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mores")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("morever")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("morgue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("morine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("morones")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("morriss")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("morrone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mortgagepower")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("morze")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mosaic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mosaical")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mosaics")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moseley")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("moseman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mosier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mosler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mothershed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("motl")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("motorcyclist")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("motorcyclists")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("motte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mousehole")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mousetrap")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mozambique")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mozartean")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mpeg")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mpg")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mph")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mr")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mrs")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("msgr")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mssrs")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mtel")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("muecke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("muehlebach")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("muffler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mufflers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mugabe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("muhamed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("muhammed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mui")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mukai")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mulches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mulqueen")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("multiemployer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mulvehill")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mungia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("munguia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("muraoka")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("muratore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("murguia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("muriel")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("murrelet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("murrieta")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("muscling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("museum")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("museums")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("musically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("mustaches")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("mustachioed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("myhre")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("myocardial")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("myocardium")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("myopia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("myopic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("myosin")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("myotrophin")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("mystique")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("NAACP")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nacional")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nacke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nacogdoches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nadal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nadler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nagai")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nagao")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("naim")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("naish")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("naive")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("naively")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("naivete")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nakai")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nakao")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nakasone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("naked")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nameplate")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nameplates")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("namesake")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nantes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("naoma")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("naomi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("napea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nardone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("narvaez")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nasional")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nasr")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("natale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("natalia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nationale")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nationales")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("natzke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nausea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nauseated")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nauseating")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nauta")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("navellier")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("nazionale")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("neanderthal")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("neanderthals")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("neapolitan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nedlloyd")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("needler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("neer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("negotiate")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("negotiated")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("negotiates")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("negotiating")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("negotiation")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("negotiations")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("negotiator")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("negotiators")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("neidl")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("neidlinger")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("neisler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("neitzke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nemean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("neoax")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("neorx")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nepl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nesler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nessler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nestea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nestler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("neuendorffer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("neuroscience")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("newcombe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("newgateway")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("newtowne")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ngema")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("niagara")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("niaid")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("niall")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nibbe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("niches")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("niclaneshia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nicolai")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nicoline")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nicosia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nienhuis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nieves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("NIH")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("niihau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nike")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ninefold")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nineteen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nineteenth")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nineties")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ninety")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ninneman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("niquette")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("nitrosamines")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nitschke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("njt")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("noah")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nobbe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nobuo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nodine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("noel")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("noffke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nogales")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nogueira")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("noire")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nolde")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nolte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("noncorporate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nondefense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("noninterest")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nonlinear")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nonnuclear")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nonreligious")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nonsense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nordine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nordling")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("noriega")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("noriegas")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("norsemen")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("norte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("norwegian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("norwegians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nosebleed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nosedive")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nosedived")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("noseworthy")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nostalgia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("notebook")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("notebooks")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("noteholders")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("notestine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("noteware")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("noteworthy")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("notte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nov")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("noxema")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("noxious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nuclear")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("nucleation")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nuclei")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nucleic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nucleus")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("numed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("numerically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nunemaker")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("nunsense")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nurre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nusbaum")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nutrient")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nutrients")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nutritious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nvhomes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("nvryan")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("nyers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oad")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oahu")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oases")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oasis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("obermaier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("oblique")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("obliquely")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("oblivion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("obnoxious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oboist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("obrien")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("obscenely")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("observed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ocain")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("occupiers")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("oceanic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oct")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("oddler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("odele")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("odp")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("odysseus")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("oehlke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("oehme")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oeien")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("oelke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("oest")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("oeuvre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ofc")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("offense")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("officeholder")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("officeholders")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("officemax")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oglethorpe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ognibene")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oguin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ohare")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ohlmeyer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("oie")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oishi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ok")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("okabe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("okane")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("okayed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("okeeffe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oken")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("okoniewski")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("olague")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("olde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("olea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("oleander")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("oleaster")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("oligarchs")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("olinde")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("olivares")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("omelet")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("omelets")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oncale")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("oncogenes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("onecomm")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("oneself")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("onetime")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("oooh")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ooohs")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ooten")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("opaque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("opera")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("operas")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ophelia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("oplinger")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("optically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("orangeburg")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("orea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("organically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("organisms")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("orgasms")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("orient")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("oriental")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("orientals")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("orientation")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("oriented")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("orion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oriordan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("orleans")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("orme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ormes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ormonde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("orourke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("orpheum")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("orpheus")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("orthodontia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("osake")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("oshea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("osmer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("osred")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ostentatious")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("ostentatiously")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("osteoarthritis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ostia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ostling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ostriches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("otte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ouimet")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ouimette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("our")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ourada")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ours")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ourself")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("outler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("outstretched")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("overambitious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("Overbye")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("overcharged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("overmatched")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("overreaches")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("overreact")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("overreacted")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("overreacting")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("overreaction")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("oviedo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pacemaker")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pacemakers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pacesetter")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("paceway")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("paez")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pagemaker")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pai")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("painewebber")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("paiute")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("palauans")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("paleozoic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("palese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pallone")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("palme")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("palmieri")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("palmstierna")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("palomares")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("panacea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pancreas")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pancreatic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pannone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("panthea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pantheistic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paolella")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paoletti")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paolillo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paolini")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paolino")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paolucci")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("paone")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paonessa")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("papale")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("papandrea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("papier")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("papke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("paque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("paquette")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("paradoxically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paranoia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paranoiac")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("paraphernalia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paratore")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("parde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("paredes")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("parimutuel")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("parke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("parkes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("parliament")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("parliamentary")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("parliaments")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("parmele")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("paroxysm")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("partecipazioni")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("partiality")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("parziale")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("paschke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pasquale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("passageway")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("passaic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pastiches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("patnaude")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("patrie")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("patrilineal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("patrone")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("patzke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pautler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pavese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("peacefulness")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("peacekeeper")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("peacekeepers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("peacekeeping")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("peacemaker")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("peacemakers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("peacemaking")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peacetime")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peaches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pearle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pecore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("peculiar")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("peculiarly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peddler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peddlers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pedone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peebler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("peer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peerless")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("peers")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("peinado")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pelaez")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pelagia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pele")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pelletier")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("penelope")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pennsylvania")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("penthea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peopled")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pepe")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("pepenadores")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peppler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("peragine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("peraino")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("perales")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("perea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("peres")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pergande")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("perine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("perle")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("permeability")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("permeate")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("permeated")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("permeates")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("perniciaro")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("perricone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("perrine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("perrone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("perseus")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("persuadable")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("persuade")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("persuaded")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("persuades")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("persuading")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("persuasion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("persuasions")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("persuasive")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("persuasively")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("persuasiveness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pescatore")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("peschke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("petrea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("petroleum")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("petrone")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("petrovietnam")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("petteway")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pettine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pevehouse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pfiester")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ph")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pharaonic")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("pharisaism")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("phaseout")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("phebe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("philistia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("phillippe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("phineas")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("phlcorp")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("phoebe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("phonemate")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("phonetically")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("photoelectric")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("photovoltaic")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("photovoltaics")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("phuong")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("physique")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("piccone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pichler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pickler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pickren")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("picotte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("picower")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("picturetel")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("piecemeal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("piecework")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("piedboeuf")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pierette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pierrelouis")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("piers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pieties")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pietro")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pietruski")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pietrzak")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pietrzyk")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("piette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("piety")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pignone")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pigue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pilotte")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pingitore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pipefishes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pipeline")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pipelines")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pipetec")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pique")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("piqued")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("piquette")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pirkl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pirrone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pisces")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pischke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pisciotta")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pitchblende")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pitiable")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("pituitary")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("placeway")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("placke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("plagiarism")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("plague")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("plagued")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("plagues")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("plaia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("plaisted")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("plante")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("plaque")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("plaques")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("plateauing")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("platelets")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("platelike")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("platinum")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("platte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("plebeians")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pleiad")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pleiads")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("plenmeer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("plouffe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("plourde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pm")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pneumonia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("poage")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pocius")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("poel")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("poem")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("poems")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("poeschl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("poet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("poetic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("poetry")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("poets")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("poggioli")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pogue")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("poinsettia")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("poinsettias")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pointe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("poitier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pokeweed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("polecat")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("polecats")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("poleward")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("policeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("policemen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("politte")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("polytheism")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("polytheistic")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("polyurethane")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pomrenze")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ponce")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ponte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pontiac")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pontiacs")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pontikes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pontious")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pooches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("popejoy")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("popieluszko")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("popolare")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("poppe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("poppea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("poquette")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("portales")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("porte")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("possiblity")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("postindustrial")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pottebaum")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pouches")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("poudrier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pourciau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("powercise")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("powerfully")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("powerpc")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("powerpcs")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("powertrain")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ppm")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("practically")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("prague")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("praiseworthy")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pratte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("prayer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("prayers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prechtl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("preciado")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("premier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("premiers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prentnieks")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("preponderance")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prescience")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prescient")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("preserved")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("presler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("presse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pressler")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("prestigiacomo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prestigious")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pretense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("pretentious")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prevatte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pridemore")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("priest")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("priester")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("priestly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prieta")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prieto")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("primebank")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("primeco")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("primenews")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("primestar")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("primetime")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("princeton")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("principally")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("principe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prindl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("priore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pritzl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("privileges")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prizewinner")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prizewinners")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prizewinning")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prizm")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("procreate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("procreates")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("procreation")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prodigious")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("prodigiously")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("proia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("proj")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("prolifically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("prolinea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prologue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("promiscuous")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("propitious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prosaic")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("proskauer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("proske")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("protean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("protease")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("protege")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("protozoan")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("protozoans")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("provincetown")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("provine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("prowse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prudente")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("prudentialbache")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pruitt")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("prunedale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("prurient")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("pryor")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("przybyl")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("przybyla")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("przybylski")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("przybysz")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("przywara")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pseudoscience")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("pseudoscientific")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("psyche")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("psyches")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("psychoanalysis")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("psychoanalyst")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("psychoanalytic")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("psychologically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ptolemaic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pucciarelli")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("puente")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("pugliese")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pulse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("punches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("purebreds")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("puritanisms")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("puzzler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("pylant")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("qiao")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("qiaotou")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("qmax")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("quadrupling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("quagmire")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("quarles")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("quarre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("quassia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("quattrone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("quealy")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("queasiness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("queasy")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("queen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("queena")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("queenan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("queener")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("queenfish")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("queenie")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("queens")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("queensberry")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("queensland")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("queensway")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("queer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("queerer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("queue")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("queues")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("quiett")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("quiles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("quillian")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("quilmes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("quirion")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("quirke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("quixote")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("racamier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("racehorse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("racetrack")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("racetracks")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("raceway")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("racioppi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rackliffe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("radcliffe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("radde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rademaker")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("radiance")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("radically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("radioed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("radler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rafael")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("raffaele")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("raffaelli")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("raffety")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rafuse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ragone")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ragonese")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rai")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("raia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rainier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rakestraw")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rambler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ramblers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rambunctious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ramires")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ranches")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ranieri")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ranke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rapeseed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("raphael")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rappe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("raschke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rasia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ratcliffe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rateliff")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ratepayer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ratepayers")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rathje")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rathke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ratier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ratliffe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ratte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rauls")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rawles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rb")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reaches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reacquire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reacquired")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("react")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reacted")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reacting")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reaction")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reactivate")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reactivated")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reactivating")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reactive")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reactivity")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reactor")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reactors")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reacts")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("readjust")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("readjusted")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("readjusting")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("readjustment")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("readjustments")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("readmitted")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reaffiliation")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reaffirm")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reaffirmation")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reaffirmed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reaffirming")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reaffirms")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reagents")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reappear")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reappearance")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reappeared")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reappears")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reapply")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reappoint")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reappointed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reappointment")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reapportionment")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reappraisal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reappraise")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rearm")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("rearmament")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rearrange")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rearranged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("rearranging")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("rearrested")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reassemble")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reassembled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reassert")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reasserted")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reasserting")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reassertion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reasserts")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reassess")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reassessed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reassessing")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reassessment")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reassign")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reassigned")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reassigning")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reassignment")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reassignments")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reassume")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reassumed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reassurance")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reassurances")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reassure")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reassured")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reassures")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reassuring")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reassuringly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reatta")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reawakened")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reawakening")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rebellious")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("recharged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("recine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("recipe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("recipes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("recipient")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("recipients")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("recompense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("recore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("recreate")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("recreated")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("recreates")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("recreating")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("recreation")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("recreational")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("recycling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("redactes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("rediscovery")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("redlinger")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reelected")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reelection")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reemergence")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reemployment")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reenacted")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reenactment")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reenactments")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reenacts")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reengineering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reenter")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reentering")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reentry")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reestablish")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reestablishing")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reevaluate")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reevaluating")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reevaluation")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reexamination")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reexamine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reexamined")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reexamining")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reexport")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reexports")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("refenes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reflagged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("refuel")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("refueled")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("refueling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("refusenik")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("refuseniks")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("regalia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("reher")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rehired")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reichart")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reichl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reichling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reignite")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reignited")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reigniting")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reimagine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reimburse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reimbursed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reimburses")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reimbursing")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reimpose")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reimposing")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reimposition")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reina")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reincarnated")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reincarnation")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("reincke")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reincorporate")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reincorporating")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reincorporation")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reindeer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reindl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reinecke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reinforce")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reinforced")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinforces")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinforcing")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("reinke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinspection")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reinstate")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinstated")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinstating")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinstitute")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reinstituted")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reinstituting")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinsurance")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reinsure")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reinsured")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinsurer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinsurers")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reintegrated")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinterpret")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reinterpretation")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reinterpreted")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reinterpreting")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reintroduce")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reintroduced")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reintroduces")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reintroducing")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reintroduction")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reinvent")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinvented")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinventing")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reinvest")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinvested")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinvesting")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reinvestment")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reinvests")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reinvigorate")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reinvigorated")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reinvigorating")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reinvigoration")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reischauer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reish")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reissue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reissued")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reissuing")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reister")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reitano")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reiterate")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reiterated")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reiterates")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reiterating")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("reiteration")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("relapse")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("religione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("religious")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("religiously")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("relying")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reminisces")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("remlinger")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rempe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("renate")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rende")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rene")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("renegotiate")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("renegotiated")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("renegotiating")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("renegotiation")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("renegotiations")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("renfred")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("renschler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rensselaer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reorient")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("repetitious")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reponse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("repulse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("require")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("required")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("requires")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("requiring")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("reschke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("researched")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("resendes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reserved")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("resiliency")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("resilient")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("resourcefulness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("response")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("resseguie")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ressler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("restaino")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("retaliatory")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("retemeyer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("retroactive")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("retroactively")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("retroactivity")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reum")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("reunification")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reunified")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reunify")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reunion")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reunions")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reunite")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reunited")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reuniting")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("reusable")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reuse")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("revaluations")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reveles")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("reveres")); + $this->assertEquals(8, $this->TextStatistics->syllableCount("revolucionario")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rewire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rewired")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("rewiring")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("reyes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rhea")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("rhetorically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rhinehardt")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rhinehart")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rhineland")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rhineman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rhinesmith")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rhinestone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rhinestones")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rhodanthe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rhythmically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rhythms")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rials")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ricciardelli")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ricciardi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ricciuti")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("richelieu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("riches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ricke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ricocheted")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("ricostruzione")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rideout")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ridgecrest")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ridgefield")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ridgeway")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("riecke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("riedl")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("riedlinger")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rietveld")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rietz")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("riffe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rigler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rigueur")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rijn")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rinehardt")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rinehart")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rinehimer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ringler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ringuette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rinke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rinse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("riordan")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rioux")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ripke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rippe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rissler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("riviera")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("riviere")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rivieres")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roaches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("roanoke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("roarke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("robare")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("robbe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rocke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rocque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rodarte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roderick")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rodeway")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rodine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rodrigue")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("roebke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roedl")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("roelke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("roepke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("roesler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("roethler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("roever")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("roffe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rogue")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rogues")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rohde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rohweder")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("roleplaying")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rolfe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rolfes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("romesburg")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("romine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("roque")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roquemore")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rorke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roseboom")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("roseboro")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("roseborough")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosebrock")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosebrook")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosebrough")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosebush")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosecrans")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosekrans")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roseland")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roselawn")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roseline")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roseman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rosemarie")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rosemary")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosemead")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rosemeyer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosemond")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosemont")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosenau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosevear")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosewicz")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rosewood")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roshier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rosine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ROTC")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rothmeier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rottler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rouillard")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("roukema")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rourke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rouyn")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("rovaniemi")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rowles")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("rowse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rpm")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rueda")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ruella")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ruhnke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ruin")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ruined")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ruining")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ruinous")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ruins")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ruis")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ruiz")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("rulebook")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rulemaking")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("runde")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("runte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ruocco")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ruoff")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ruotolo")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ruppe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rustlers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rwanda")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rwandan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rwandans")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rwandese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ryobi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ryohei")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ryon")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ryuzo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rzasa")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("rzepka")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sabatine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("saccone")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sachse")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sacrilegious")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("safecard")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("safeco")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("safeguard")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("safeguarding")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("safeguards")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("safekeeping")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("safety")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("safeway")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("safier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sagebrush")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sagraves")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("saia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("saif")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("saitama")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sakai")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sakau")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sakigake")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sakurai")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("salesman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("salesmanship")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("salesmen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("salespeople")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("salesperson")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("salisbury")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("salome")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("salomone")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("salvadore")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("salvatore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("salzhauer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("samuela")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("samuels")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("samuelson")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sanches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sandbagged")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sande")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sandwiches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sansui")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("santacroce")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("santerre")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("santiago")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("santone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("santore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sanzone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("saone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sapiens")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sapone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sapphire")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sarcastically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sarine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sarles")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sassone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("satiny")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("satire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("satires")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("satisfactorily")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("satisfactory")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sattler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("saucepan")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("saute")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sauter")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("savarese")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("savior")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("saviors")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("savoia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("savoie")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("savr")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sawyer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sawyers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sayed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sbf")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("scaglione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("scalese")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scapegoat")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("scapegoating")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scapegoats")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("scarpone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schadler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schaedler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schaefers")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("scharfe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schaufler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schedler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("scheidler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("scheufler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scheunemann")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("schiavone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schickler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schickling")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schielke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schildknecht")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schilke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schimke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schinke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schisler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schisms")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schloesser")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schmidl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schmutzler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schoene")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schoening")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("scholtes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("scholze")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schoneman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schoppe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schouten")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schreder")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schreyer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schroedl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schubring")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schuelke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schuerman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schuermann")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schuessler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schuette")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schuetze")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schulte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schultes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schultze")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schulze")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schuneman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schussler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schutte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schuttler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schwalbe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schwanke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schwantes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schwarze")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schwebke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schweder")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schweer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schweers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schwegler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("schwendeman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schwenke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schweppe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("schweppes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("schwoerer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sciacca")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("scialdone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sciandra")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scianna")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sciara")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sciarrino")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sciclone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("science")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sciences")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("scientific")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("scientifically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("scientifics")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("scientist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("scientists")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("scientology")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("scintilore")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("scipione")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scohier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scoreboard")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scorecard")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("scorekeepers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scour")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scoured")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("scouring")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scours")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("screeches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scribblers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scrimgeour")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("scrivener")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sdn")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("se")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seabed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("searle")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("seattle")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("sebastiana")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sebastiane")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("sebastiani")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sechrest")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sechrist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("secrest")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("secrist")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("securites")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("seditious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sedore")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("seer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("seers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("segraves")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("segrest")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("segue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seidl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("seifried")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("seigler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("Seiichi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sekisui")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("selbe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seles")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("selke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sellier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("semele")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("semireligious")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("semmler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("semones")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("senatore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("senior")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("seniority")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("seniornet")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seniors")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sense")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("senseless")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("senske")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("seoul")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("separate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sequeira")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sequences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sequoia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sequoias")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("serafine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("seraphine")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("serenely")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sergius")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("serpe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("serratore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("serviceman")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("servicemaster")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("servicemen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sesame")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("Sese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sesler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sessler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("settlers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("seve")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("seventieth")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("several")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("severally")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sevier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("seyfried")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sh")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shakedown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shakedowns")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shakeout")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shakespeare")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shampooed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sharecroppers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shareholder")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shareholders")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shareholding")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shareholdings")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shareware")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sharpe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sheer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sheffler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("shenandoah")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sheneman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shidler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shiffler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shiina")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("shiraishi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shiremanstown")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shisler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shissler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("shiu")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shoichi")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("shoichiro")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("shooed")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("shoppe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("shoppes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shor")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shorebird")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shoreham")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shoreward")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shoshone")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("shouldnt")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shoveling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shreffler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shrikelike")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shryock")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("shuddered")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shuey")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("shui")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sichuan")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sicilia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sicotte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sidetracked")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sidler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("siegecraft")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sienko")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sierra")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sierracin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sierras")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("siers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("siewiorek")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sigl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sigler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("signore")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("simione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("simler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("simpler")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("singaporean")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("singaporeans")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("singler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("singling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sinuous")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("siobhan")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sioux")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("siracuse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sirrine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sisemore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sisler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sistare")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sitler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sittler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sitze")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sixtieth")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sizeler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sizelove")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sizemore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sizzler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("skateboard")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("skateboarding")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("skibbe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("skier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("skrzypek")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sledgehammer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("slouches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("smokejumper")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("smokejumpers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("smokescreen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("smokestack")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("smokestacks")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("smtih")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("snakebites")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("snakelike")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sneer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sneers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("soares")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sobieski")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sociable")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("societa")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("societal")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("societe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("societies")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("society")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sociopath")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("socrates")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sofaer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("solares")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("soldier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("soldiers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("soledad")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("solesbee")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("solimine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("soloist")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("soloists")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("soltes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("somebody")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("someday")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("somehow")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("something")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("somethings")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sometime")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sometimes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("somewhat")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("somewhere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sonia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sooy")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sophomore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sophomores")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sosuke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("soulliere")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sour")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sourcebook")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("soured")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("souring")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sourly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sours")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("Sousuke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sovereign")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sovereigns")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sovereignty")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("sovietologists")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("soviets")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sowle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sowles")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spaceballs")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spacebands")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spacecraft")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spacelink")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spacenet")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spacesuit")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spadework")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("spagnuolo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("spangler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spaniard")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spaniards")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spanier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spaniol")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sparkes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spasms")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("speciale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("specialities")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("speciality")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("specifically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("speeches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("speer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("spengler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("speziale")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spieth")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("spilde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("spinale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("spindler")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("spiritualism")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("spitale")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spittler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spokeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spokesman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spokesmen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("spokespeople")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("spokesperson")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sponsler")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("spontaneity")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("spoonemore")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sporadically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sporophyte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sporophytes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("spracklen")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sprague")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("spruiell")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("squeak")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("squeaked")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("squeaker")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("squeakers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("squeaking")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("squeaks")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("squeaky")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("squeal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("squealing")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("squeals")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("squeamish")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("squeamishness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("squeegee")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("squeeze")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("squeezed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("squeezing")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("squiers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("squires")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sr")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stablest")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("staebler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("staehle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stagecoach")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stagecraft")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stagehands")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stahnke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stai")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stakeholder")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stakeholders")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stakeout")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stakeouts")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stalemate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stalemated")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stangl")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stangler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stanke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("stanzione")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stapler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("staplers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stapling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("starace")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("starke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("starkes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("starpointe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("statecraft")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("statehood")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("statehouse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stateroom")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("statesman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("statesmanship")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("statesmen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stateswest")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("statewide")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stechschulte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("steer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("steers")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("steffe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("steffes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("steffler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stefl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stegeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stegemann")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stegemeier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("steidl")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("steinke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stemmler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stepien")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("steppe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("steppes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stettler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("steuart")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stickler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stiegemeier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stiffler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stineman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stiteler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stobbe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stocke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stoeltze")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stoever")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stoia")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stoic")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("stoicism")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stoics")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stokke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stolpe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stolte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stolze")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stoneback")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stoneberg")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stoneberger")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stoneburner")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stonecipher")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stonecutters")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stoneham")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stonehenge")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stonehill")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stonehocker")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stonehouse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stoneking")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stoneman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stoneridge")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stonerock")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stonestreet")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stonewall")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stonewalled")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stonewalling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stoneware")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("storagetek")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("storefront")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("storefronts")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("storehouse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("storekeepers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("storeroom")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stormes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stracke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stragglers")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("strande")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("strangling")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("strategically")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("strehle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("striar")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("stribling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("stricklen")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("strieter")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("strikebreakers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("strikeout")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("strikeouts")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("strubbe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("strzelecki")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stubbe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stucke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("stumpe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("stutesman")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("stylistically")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("styron")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("suarez")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("suasion")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("suave")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("suazo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("submerged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("subnotebook")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("subservience")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("subservient")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("substantiate")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("substantiated")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("substantiates")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("substantiation")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("subterranean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("subtler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("subtly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sudafed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sudler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("suey")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("suez")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("suhre")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sui")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("suicidal")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("suicide")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("suicides")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sumptuous")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sunde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sundial")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("sunobe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("supercharged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("superfamily")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("superfluidity")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("superfluous")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("superstitious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("superx")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("suppes")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("supremely")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("supremes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("surace")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("surreptitious")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("surreptitiously")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("suspense")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("suspenseful")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("sutcliffe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("suttmeier")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("suu")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("svelte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("swanke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("sweers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("swindler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("swinehart")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("swingler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("swoveland")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("synagogue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("synagogues")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("synthetically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("sypniewski")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("systematically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("systemically")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("taaffe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tabares")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tacke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tadeusz")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("taffe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("taflinger")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tagliaferri")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tague")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("taira")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("takao")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("takecare")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("takeout")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("takeuchi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tamales")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tanabe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tangeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tangiers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tania")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tanke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tannehill")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("taormina")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tappe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tarleton")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("tartaglione")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tarte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tassone")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tatiana")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tattler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tattooed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tavares")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("tavoulareas")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tb")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tbilisi")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tcas")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("teaches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("teague")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("teate")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tebbe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tebuthiuron")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("technique")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("techniques")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("teer")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tele")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("teleconference")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("teleconferencing")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("telemecanique")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("telephoniques")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("telesciences")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("temperament")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("temperamental")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("temperamentally")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("temperaments")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("temperate")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("temperature")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("temperatures")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("templer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tendentious")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tenn")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tennessean")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tense")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tensely")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("termeer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("terrien")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("terrifically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tesler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tesmer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tessitore")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tessler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tetsuo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("th")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("thaddeus")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thalia")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tharpe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thatll")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theater")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theaters")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theatre")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theatres")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("theatrical")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("theatricality")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("theatrically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theism")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("thematically")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thenceforth")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thereby")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thered")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("therefore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("theriault")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("thermonuclear")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("therriault")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thielemann")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("thielke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("thirtieth")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("thirtysomething")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("thoene")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("thomasine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("thorpe")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tiananmen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tianjin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tiano")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tiara")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ticklish")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tidewater")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tiedeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tiedemann")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tier")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tiers")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tietje")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tietmeyer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tietze")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tigue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tijuana")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("timeframe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("timeliness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("timeplex")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("timeshare")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("timetable")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("timetables")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("timisoara")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("timothea")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("timpe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("timpone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tingler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tingling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tinkler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tinkling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tipler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tire")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tired")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tireless")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tiremaker")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tires")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tischler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("titania")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tocqueville")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toddler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toddlers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toews")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toffler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tofte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tokuo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tokyo")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tomaino")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tomasine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tongue")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tongued")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tongues")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("toniest")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tonnesen")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("torme")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tornabene")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("tornatore")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("torque")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("torre")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("torturous")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("totzke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("touareg")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("touches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tousled")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("towle")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("towne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("townes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("trachea")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trademark")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trademarked")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trademarks")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tradesmen")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("traditionalists")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("traer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tragically")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("traipse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tramiel")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("trampe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tranches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("transience")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("transients")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("transoceanic")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("transpired")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("transpires")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("trappe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("travelogue")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("trbovich")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("treichler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("treml")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trenches")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trendier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trendiest")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tressler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tribesmen")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("triennial")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("trieu")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("trimedyne")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("trimpe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("triomphe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tripling")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("trippe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("trisler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("troia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("troiani")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tropea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("trousdale")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("truell")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("truest")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("truex")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("truism")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("trulove")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("trusler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tryin")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tryon")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tryout")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tryouts")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("trzaska")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("trzcinski")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("trzeciak")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ts")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tsui")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tufte")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tuinstra")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tuition")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("tuitions")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tumbler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tumblers")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("tunde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tunkelang")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("turbeville")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("turbocharged")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("turcotte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("turquoise")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("turrentine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tvsat")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("twentieth")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("twinkling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("tyo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("typecast")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("typecasting")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("typefaces")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("typeset")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("typesetting")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("typewriter")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("typewriters")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("typewriting")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("typewritten")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("typically")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("uarco")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("uart")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ubiquity")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("uehara")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ueki")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("uemura")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("uhde")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ukulele")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ulfred")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("umpire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("umpires")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("unashamedly")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("uncharacteristically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("uncomfortably")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("uncooperative")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("uncoordinated")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("unctuous")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("underserved")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("undeserved")); + $this->assertEquals(7, $this->TextStatistics->syllableCount("undifferentiated")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("unearthed")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unexpired")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unfamiliar")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("unfamiliarities")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("unfamiliarity")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("uninitiated")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("uninspired")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("uninterested")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("uninteresting")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("unique")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("uniquely")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("uniqueness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("unmatched")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("unnerved")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("unplugged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unpretentious")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unreasonable")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("unreasoning")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("unreimbursed")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("unscientific")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("unsubstantiated")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("untermeyer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("updegrove")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("uplinger")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("urea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("uribe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("urquhart")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("urrea")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("usa")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("usair")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("usameribancs")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("usbancorp")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("usefulness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("usenet")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ustrust")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("uy")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("vague")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vaguely")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vagueness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vaguer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("valade")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("valent")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("valiant")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("valiantly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("valiente")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("valiquette")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("valladares")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("valliere")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vallone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("valonia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("valores")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("valuable")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("valuables")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("vanacore")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("vande")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("vanderleest")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vanderlinde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vandermeer")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("vandersluis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vandervelde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vandevelde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vandevoorde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vandezande")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vanevery")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vanhecke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("vanhouten")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vanleer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vanleeuwen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vanliew")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vanscyoc")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vantine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vardeman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("varietal")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("varnadore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("varrone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vassilios")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vastine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vaudevillian")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("vaughan")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("vecchione")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("veer")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("veers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vegetable")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vegetables")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("velte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("venneman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("venzke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("verdone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("verduin")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("verine")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vermeer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("veronique")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("versluis")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vertically")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("veterinarian")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("veterinarians")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("veterinary")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vexatious")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("viau")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("viceroy")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("victorine")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vidales")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vidalia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("viejo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vienna")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("viennese")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("viers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vietcong")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vieth")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vietnam")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("vietnamese")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vietti")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vieyra")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vigeland")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("viglione")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("vigue")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("villafane")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("villasenor")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("villiers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vineland")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("vinje")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("violations")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("VIP")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("virginia")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("virginian")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("virginians")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("virkler")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("virtuosity")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("virtuoso")); + $this->assertEquals(5, $this->TextStatistics->syllableCount("visualization")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("visualize")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("visualizing")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("visually")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("visuals")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("visx")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vitale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vivien")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("vizcaino")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vlcek")); + $this->assertEquals(6, $this->TextStatistics->syllableCount("vnesheconombank")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("voce")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("vocke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vogl")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("vogue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("voicemail")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("voiceworks")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("volcanically")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("volentine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("volpe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("volunteer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("volunteers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vorhauer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vosler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vrba")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("vrdolyak")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vs")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vsel")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("vuolo")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("vuong")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("w")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("waage")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wageman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wahle")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("waidelich")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wakefield")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wakeham")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wakeland")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wakeley")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wakeman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("walde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("waleson")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("walfred")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("walke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wanke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wannabe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wannabes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("warbling")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("warde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("warehoused")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("warnecke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wass")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wastebasket")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wastebaskets")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wastefulness")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wasteland")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wastepaper")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wastewater")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("watanabe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("waterlogged")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("watershed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("watling")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("watlington")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("watne")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wavelength")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wavelengths")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wavetek")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("waynesboro")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wedgestone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wedgewood")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wedgeworth")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wednesday")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wednesdays")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wegrzyn")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wehde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("weiand")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("weide")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("weideman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("weidemann")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("weidler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("weigl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("weinger")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("weist")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("welke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wellesley")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("welte")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wempe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wenches")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wende")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wengler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wenke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wente")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wenzl")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("weppler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("werdesheim")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("wereldhave")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("werent")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("werewolf")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("werke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wermiel")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wernecke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wernicke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("werre")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("weseman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wesemann")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wesler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wess")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wessler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("westmoreland")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("weyerhaeuser")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("whatsoever")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whereby")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wherehouse")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wherewithal")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitebread")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("whitecotton")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitefield")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitefish")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whiteford")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitehair")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitehall")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitehead")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitehill")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitehorn")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitehorse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitehouse")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitehurst")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitelaw")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whiteley")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitelock")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whiteman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitemont")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitenack")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whiteneir")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitener")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitenight")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("whitescarver")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitesel")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitesell")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitetail")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitewash")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whitewashed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("whitewater")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("whittemore")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("whoever")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wholehearted")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("wholeheartedly")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wholesale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wholesaler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wholesalers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wholesales")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wholesaling")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wholesomeness")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("whosoever")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wicke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wickes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wickliffe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("widebody")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wideman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("widespread")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wiedeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wiedemann")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wienecke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wienke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wier")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wiers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wiesemann")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wiggly")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wiitala")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wilde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wildeman")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wildes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wildfire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wildfires")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wildflowers")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wileman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wilfred")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wilke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wilkes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wilkesboro")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("william")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("williams")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("williamsburg")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("williamsburgh")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("williamsen")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("williamson")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("williamsport")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("williamstown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("williard")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wilmes")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wiltse")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("windes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wineberg")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("winegarden")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wineheim")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wineman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("winemiller")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("winfred")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wingler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("winifred")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wipeout")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wire")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wired")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wireline")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wireman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wires")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wiretaps")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wisecarver")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wisecrack")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wisecracking")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wisecracks")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wisecup")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wiseguy")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wisehart")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wiseman")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wisler")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("wisniewski")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wissler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("witte")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("witteman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wittler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("witzke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("wlodarczyk")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("wlodarski")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wm")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wobbe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wobbly")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wolfe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wolke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wolske")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wolstenholme")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wooed")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("worcester")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wotring")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wouldnt")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("woulfe")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wrangler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wranglers")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wrangling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wrenches")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wrestler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wrinkling")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("writedown")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("writedowns")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("wrzesinski")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("ws")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wuest")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wurdeman")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("wussler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("wylde")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("wyoming")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("xanthe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("xantippe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("xavier")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("xaviera")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("xian")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("xiaoping")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("xiaoyun")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("xscribe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("xtra")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("xuan")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("yaffe")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("yahnke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("yamaichi")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("yamane")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("yamatake")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("yamauchi")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("yanke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("yarbrough")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("yarde")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yarmulkes")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("yasuo")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("yearearlier")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yeates")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("yerke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("yingling")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ynez")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("ynjiun")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("yoichi")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yolande")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("yongue")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("yonke")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yorio")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("yorke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("yosemite")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("yuletide")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zaccone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zaire")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zairean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zaireans")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("zairian")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("zairians")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("zakrzewski")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("zaniewski")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zappone")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zarcone")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zayed")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zeidler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zeigler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zeisler")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zeitler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zemke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zerbe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zeringue")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zettler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zhejiang")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zielke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("ziemke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zier")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zierke")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("ziesmer")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zigler")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zigzagged")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("zimbabwean")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zingale")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zingler")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zinke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zirbes")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zoe")); + $this->assertEquals(2, $this->TextStatistics->syllableCount("zoete")); + $this->assertEquals(3, $this->TextStatistics->syllableCount("zorine")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zuehlke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zuelke")); + $this->assertEquals(1, $this->TextStatistics->syllableCount("zuhlke")); + $this->assertEquals(4, $this->TextStatistics->syllableCount("zuidema")); + } +} diff --git a/vendor/davechild/textstatistics/tests/TextStatisticsKiplingIfTest.php b/vendor/davechild/textstatistics/tests/TextStatisticsKiplingIfTest.php new file mode 100644 index 0000000..c8050d3 --- /dev/null +++ b/vendor/davechild/textstatistics/tests/TextStatisticsKiplingIfTest.php @@ -0,0 +1,468 @@ +TextStatistics = new DaveChild\TextStatistics\TextStatistics(); + $this->TextStatistics->normalise = false; + } + + public function tearDown(): void + { + unset($this->objTextStatistics); + } + + /* Test Syllables + -------------------- */ + public function testKiplingSyllables() + { // The Words from If, in order + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('can'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('keep'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('your'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('head'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('when'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('all'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('about'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('Are'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('losing'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('theirs'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('and'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('blaming'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('it'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('on'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('can'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('trust'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('yourself'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('when'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('all'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('men'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('doubt'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('But'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('make'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('allowance'), 3); + $this->assertEquals($this->TextStatistics->syllableCount('for'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('their'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('doubting'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('too,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('can'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('wait'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('and'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('not'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('be'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('tired'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('by'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('waiting,'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('Or'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('being'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('lied'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('about,'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('don\'t'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('deal'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('in'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('lies,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('Or'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('being'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('hated,'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('don\'t'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('give'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('way'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('to'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('hating,'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('And'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('yet'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('don\'t'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('look'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('too'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('good,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('nor'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('talk'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('too'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('wise:'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('can'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('dream'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('-and'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('not'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('make'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('dreams'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('your'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('master,'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('can'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('think'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('-and'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('not'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('make'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('thoughts'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('your'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('aim;'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('can'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('meet'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('with'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('Triumph'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('and'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('Disaster'), 3); + $this->assertEquals($this->TextStatistics->syllableCount('And'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('treat'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('those'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('two'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('impostors'), 3); + $this->assertEquals($this->TextStatistics->syllableCount('just'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('the'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('same;'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('can'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('bear'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('to'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('hear'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('the'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('truth'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you\'ve'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('spoken'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('Twisted'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('by'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('knaves'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('to'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('make'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('a'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('trap'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('for'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('fools,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('Or'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('watch'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('the'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('things'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('gave'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('your'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('life'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('to,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('broken,'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('And'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('stoop'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('and'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('build'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('\'em'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('up'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('with'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('worn'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('-out'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('tools:'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('can'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('make'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('one'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('heap'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('of'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('all'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('your'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('winnings'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('And'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('risk'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('it'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('all'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('on'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('one'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('turn'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('of'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('pitch'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('-and'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('-toss,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('And'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('lose,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('and'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('start'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('again'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('at'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('your'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('beginnings'), 3); + $this->assertEquals($this->TextStatistics->syllableCount('And'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('never'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('breath'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('a'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('word'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('about'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('your'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('loss;'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('can'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('force'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('your'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('heart'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('and'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('nerve'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('and'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('sinew'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('To'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('serve'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('your'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('turn'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('long'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('after'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('they'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('are'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('gone,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('And'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('so'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('hold'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('on'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('when'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('there'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('is'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('nothing'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('in'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('Except'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('the'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('Will'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('which'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('says'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('to'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('them:'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('"Hold'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('on!"'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('can'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('talk'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('with'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('crowds'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('and'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('keep'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('your'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('virtue,'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('Or'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('walk'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('with'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('kings'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('-nor'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('lose'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('the'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('common'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('touch,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('neither'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('foes'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('nor'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('loving'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('friends'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('can'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('hurt'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you;'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('all'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('men'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('count'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('with'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('but'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('none'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('too'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('much'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('If'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('can'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('fill'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('the'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('unforgiving'), 4); + $this->assertEquals($this->TextStatistics->syllableCount('minute'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('With'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('sixty'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('seconds\''), 2); + $this->assertEquals($this->TextStatistics->syllableCount('worth'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('of'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('distance'), 2); + $this->assertEquals($this->TextStatistics->syllableCount('run,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('Yours'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('is'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('the'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('Earth'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('and'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('everything'), 4); + $this->assertEquals($this->TextStatistics->syllableCount('that\'s'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('in'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('it,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('And'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('which'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('is'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('more'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('you\'ll'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('be'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('a'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('Man,'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('my'), 1); + $this->assertEquals($this->TextStatistics->syllableCount('son!'), 1); + } + + /* Test Total Letters + -------------------- */ + public function testLetterCount() + { + $this->assertEquals(1125, $this->TextStatistics->letterCount($this->strText)); + } + + /* Test Total Syllables + -------------------- */ + public function testSyllableCount() + { + $this->assertEquals(338, $this->TextStatistics->totalSyllables($this->strText)); + } + + /* Test Words + -------------------- */ + public function testWordCount() + { + $this->assertEquals(292, $this->TextStatistics->wordCount($this->strText)); + } + + /* Test Sentences + -------------------- */ + public function testSentenceCount() + { + $this->assertEquals(4, $this->TextStatistics->sentenceCount($this->strText)); + } + + /* Test Letter Count + -------------------- */ + public function testTextLengthCheck() + { + $this->assertEquals(1125, $this->TextStatistics->letterCount($this->strText)); + } + + /* Test Flesch Kincaid Reading Ease + -------------------- */ + public function testFleschKincaidReadingEase() + { + $this->assertEquals(34.8, $this->TextStatistics->flesch_kincaid_reading_ease($this->strText)); + } + + /* Test Flesch Kincaid Grade Level + -------------------- */ + public function testFleschKincaidGradeLevel() + { + $this->assertEquals(26.5, $this->TextStatistics->flesch_kincaid_grade_level($this->strText)); + } + + /* Test Gunning Fog Score + -------------------- */ + public function testGunningFogScore() + { + $this->assertEquals(29.9, $this->TextStatistics->gunning_fog_score($this->strText)); + } + + /* Test Coleman Liau Index + -------------------- */ + public function testColemanLiauIndex() + { + $this->assertEquals(6.9, $this->TextStatistics->coleman_liau_index($this->strText)); + } + + /* Test SMOG Index + -------------------- */ + public function testSMOGIndex() + { + $this->assertEquals(10.3, $this->TextStatistics->smog_index($this->strText)); + } + + /* Test Automated Readability Index + -------------------- */ + public function testAutomatedReadabilityIndex() + { + $this->assertEquals(33.2, $this->TextStatistics->automated_readability_index($this->strText)); + } +} diff --git a/vendor/davechild/textstatistics/tests/TextStatisticsMaths.php b/vendor/davechild/textstatistics/tests/TextStatisticsMaths.php new file mode 100644 index 0000000..2c014b9 --- /dev/null +++ b/vendor/davechild/textstatistics/tests/TextStatisticsMaths.php @@ -0,0 +1,172 @@ +TextStatistics = new DaveChild\TextStatistics\TextStatistics(); + $this->TextStatistics->normalise = false; + } + + public function tearDown(): void + { + unset($this->objTextStatistics); + } + + /* Test Normalisation + -------------------- */ + public function testNormalisation() + { + // Maths::normaliseScore($score, $min, $max, $dps = 1) + $this->assertSame(3.1, DaveChild\TextStatistics\Maths::normaliseScore(3.141592654, 1, 10, 1)); + $this->assertSame(10.0, DaveChild\TextStatistics\Maths::normaliseScore(13.141592654, 1, 10, 1)); + $this->assertSame(1.0, DaveChild\TextStatistics\Maths::normaliseScore(-3.141592654, 1, 10, 1)); + $this->assertSame(3.0, DaveChild\TextStatistics\Maths::normaliseScore(3, 1, 10, 1)); + $this->assertSame(3, DaveChild\TextStatistics\Maths::normaliseScore(3.141592654, 1, 10, 0)); + $this->assertSame(10, DaveChild\TextStatistics\Maths::normaliseScore(13.141592654, 1, 10, 0)); + $this->assertSame(1, DaveChild\TextStatistics\Maths::normaliseScore(-3.141592654, 1, 10, 0)); + $this->assertSame(3, DaveChild\TextStatistics\Maths::normaliseScore(3, 1, 10, 0)); + } + + /* Test Normalisation + -------------------- */ + public function testCalc() + { + $this->assertSame(15.0, DaveChild\TextStatistics\Maths::bcCalc(10, '+', 5, true, 1)); + $this->assertSame(15.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'add', 5, true, 1)); + $this->assertSame(15.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'addition', 5, true, 1)); + $this->assertSame(15.6, DaveChild\TextStatistics\Maths::bcCalc(10, '+', 5.55, true, 1)); + $this->assertSame(15.6, DaveChild\TextStatistics\Maths::bcCalc(10, 'add', 5.55, true, 1)); + $this->assertSame(15.6, DaveChild\TextStatistics\Maths::bcCalc(10, 'addition', 5.55, true, 1)); + $this->assertSame(5.0, DaveChild\TextStatistics\Maths::bcCalc(10, '-', 5, true, 1)); + $this->assertSame(5.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'sub', 5, true, 1)); + $this->assertSame(5.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'subtract', 5, true, 1)); + $this->assertSame(4.5, DaveChild\TextStatistics\Maths::bcCalc(10, '-', 5.55, true, 1)); + $this->assertSame(4.5, DaveChild\TextStatistics\Maths::bcCalc(10, 'sub', 5.55, true, 1)); + $this->assertSame(4.5, DaveChild\TextStatistics\Maths::bcCalc(10, 'subtract', 5.55, true, 1)); + $this->assertSame(4.4, DaveChild\TextStatistics\Maths::bcCalc(10, '-', 5.56, true, 1)); + $this->assertSame(4.4, DaveChild\TextStatistics\Maths::bcCalc(10, 'sub', 5.56, true, 1)); + $this->assertSame(4.4, DaveChild\TextStatistics\Maths::bcCalc(10, 'subtract', 5.56, true, 1)); + $this->assertSame(50.0, DaveChild\TextStatistics\Maths::bcCalc(10, '*', 5, true, 1)); + $this->assertSame(50.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'mul', 5, true, 1)); + $this->assertSame(50.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'multiply', 5, true, 1)); + $this->assertSame(55.6, DaveChild\TextStatistics\Maths::bcCalc(10, '*', 5.555, true, 1)); + $this->assertSame(55.6, DaveChild\TextStatistics\Maths::bcCalc(10, 'mul', 5.555, true, 1)); + $this->assertSame(55.6, DaveChild\TextStatistics\Maths::bcCalc(10, 'multiply', 5.555, true, 1)); + $this->assertSame(2.0, DaveChild\TextStatistics\Maths::bcCalc(10, '/', 5, true, 1)); + $this->assertSame(2.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'div', 5, true, 1)); + $this->assertSame(2.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'divide', 5, true, 1)); + $this->assertSame(1.8, DaveChild\TextStatistics\Maths::bcCalc(10, '/', 5.5, true, 1)); + $this->assertSame(1.8, DaveChild\TextStatistics\Maths::bcCalc(10, 'div', 5.5, true, 1)); + $this->assertSame(1.8, DaveChild\TextStatistics\Maths::bcCalc(10, 'divide', 5.5, true, 1)); + $this->assertSame(0.0, DaveChild\TextStatistics\Maths::bcCalc(0, '/', 10, true, 1)); + $this->assertSame(0.0, DaveChild\TextStatistics\Maths::bcCalc(0, 'div', 10, true, 1)); + $this->assertSame(0.0, DaveChild\TextStatistics\Maths::bcCalc(0, 'divide', 10, true, 1)); + + $this->assertSame(0.0, DaveChild\TextStatistics\Maths::bcCalc(10, '%', 5, true, 1)); + $this->assertSame(0.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'mod', 5, true, 1)); + $this->assertSame(0.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'modulus', 5, true, 1)); + $this->assertSame(3.0, DaveChild\TextStatistics\Maths::bcCalc(10, '%', 7, true, 1)); + $this->assertSame(3.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'mod', 7, true, 1)); + $this->assertSame(3.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'modulus', 7, true, 1)); + // Modulus can only be an integer and is rounded before calculation + $this->assertSame(4.0, DaveChild\TextStatistics\Maths::bcCalc(10, '%', 5.55, true, 1)); + $this->assertSame(4.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'mod', 5.55, true, 1)); + $this->assertSame(4.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'modulus', 5.55, true, 1)); + $this->assertSame(2.0, DaveChild\TextStatistics\Maths::bcCalc(10, '%', 7.55, true, 1)); + $this->assertSame(2.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'mod', 7.55, true, 1)); + $this->assertSame(2.0, DaveChild\TextStatistics\Maths::bcCalc(10, 'modulus', 7.55, true, 1)); + + $this->assertSame(1, DaveChild\TextStatistics\Maths::bcCalc(10, '=', 5, true, 1)); + $this->assertSame(1, DaveChild\TextStatistics\Maths::bcCalc(10, 'comp', 5, true, 1)); + $this->assertSame(1, DaveChild\TextStatistics\Maths::bcCalc(10, 'compare', 5, true, 1)); + $this->assertSame(0, DaveChild\TextStatistics\Maths::bcCalc(10, '=', 10, true, 1)); + $this->assertSame(0, DaveChild\TextStatistics\Maths::bcCalc(10, 'comp', 10, true, 1)); + $this->assertSame(0, DaveChild\TextStatistics\Maths::bcCalc(10, 'compare', 10, true, 1)); + $this->assertSame(-1, DaveChild\TextStatistics\Maths::bcCalc(5, '=', 10, true, 1)); + $this->assertSame(-1, DaveChild\TextStatistics\Maths::bcCalc(5, 'comp', 10, true, 1)); + $this->assertSame(-1, DaveChild\TextStatistics\Maths::bcCalc(5, 'compare', 10, true, 1)); + + $this->assertSame(4.0, DaveChild\TextStatistics\Maths::bcCalc(16, 'sqrt', 5, true, 1)); + $this->assertSame(3.9, DaveChild\TextStatistics\Maths::bcCalc(15, 'sqrt', 5, true, 1)); + + $this->assertSame(15, DaveChild\TextStatistics\Maths::bcCalc(10, '+', 5)); + $this->assertSame(15, DaveChild\TextStatistics\Maths::bcCalc(10, 'add', 5)); + $this->assertSame(15, DaveChild\TextStatistics\Maths::bcCalc(10, 'addition', 5)); + $this->assertSame(15.55, DaveChild\TextStatistics\Maths::bcCalc(10, '+', 5.55)); + $this->assertSame(15.55, DaveChild\TextStatistics\Maths::bcCalc(10, 'add', 5.55)); + $this->assertSame(15.55, DaveChild\TextStatistics\Maths::bcCalc(10, 'addition', 5.55)); + $this->assertSame(5, DaveChild\TextStatistics\Maths::bcCalc(10, '-', 5)); + $this->assertSame(5, DaveChild\TextStatistics\Maths::bcCalc(10, 'sub', 5)); + $this->assertSame(5, DaveChild\TextStatistics\Maths::bcCalc(10, 'subtract', 5)); + $this->assertSame(4.45, DaveChild\TextStatistics\Maths::bcCalc(10, '-', 5.55)); + $this->assertSame(4.45, DaveChild\TextStatistics\Maths::bcCalc(10, 'sub', 5.55)); + $this->assertSame(4.45, DaveChild\TextStatistics\Maths::bcCalc(10, 'subtract', 5.55)); + $this->assertSame(4.44, DaveChild\TextStatistics\Maths::bcCalc(10, '-', 5.56)); + $this->assertSame(4.44, DaveChild\TextStatistics\Maths::bcCalc(10, 'sub', 5.56)); + $this->assertSame(4.44, DaveChild\TextStatistics\Maths::bcCalc(10, 'subtract', 5.56)); + $this->assertSame(50, DaveChild\TextStatistics\Maths::bcCalc(10, '*', 5)); + $this->assertSame(50, DaveChild\TextStatistics\Maths::bcCalc(10, 'mul', 5)); + $this->assertSame(50, DaveChild\TextStatistics\Maths::bcCalc(10, 'multiply', 5)); + $this->assertSame(55.55, DaveChild\TextStatistics\Maths::bcCalc(10, '*', 5.555)); + $this->assertSame(55.55, DaveChild\TextStatistics\Maths::bcCalc(10, 'mul', 5.555)); + $this->assertSame(55.55, DaveChild\TextStatistics\Maths::bcCalc(10, 'multiply', 5.555)); + $this->assertSame(2, DaveChild\TextStatistics\Maths::bcCalc(10, '/', 5)); + $this->assertSame(2, DaveChild\TextStatistics\Maths::bcCalc(10, 'div', 5)); + $this->assertSame(2, DaveChild\TextStatistics\Maths::bcCalc(10, 'divide', 5)); + $this->assertSame(1.81818, DaveChild\TextStatistics\Maths::bcCalc(10, '/', 5.5, true, 5)); + $this->assertSame(1.81818, DaveChild\TextStatistics\Maths::bcCalc(10, 'div', 5.5, true, 5)); + $this->assertSame(1.81818, DaveChild\TextStatistics\Maths::bcCalc(10, 'divide', 5.5, true, 5)); + $this->assertSame(0, DaveChild\TextStatistics\Maths::bcCalc(0, '/', 10)); + $this->assertSame(0, DaveChild\TextStatistics\Maths::bcCalc(0, 'div', 10)); + $this->assertSame(0, DaveChild\TextStatistics\Maths::bcCalc(0, 'divide', 10)); + + $this->assertSame(0, DaveChild\TextStatistics\Maths::bcCalc(10, '%', 5)); + $this->assertSame(0, DaveChild\TextStatistics\Maths::bcCalc(10, 'mod', 5)); + $this->assertSame(0, DaveChild\TextStatistics\Maths::bcCalc(10, 'modulus', 5)); + $this->assertSame(3, DaveChild\TextStatistics\Maths::bcCalc(10, '%', 7)); + $this->assertSame(3, DaveChild\TextStatistics\Maths::bcCalc(10, 'mod', 7)); + $this->assertSame(3, DaveChild\TextStatistics\Maths::bcCalc(10, 'modulus', 7)); + // Modulus can only be an integer and is rounded before calculation + $this->assertSame(4, DaveChild\TextStatistics\Maths::bcCalc(10, '%', 5.55)); + $this->assertSame(4, DaveChild\TextStatistics\Maths::bcCalc(10, 'mod', 5.55)); + $this->assertSame(4, DaveChild\TextStatistics\Maths::bcCalc(10, 'modulus', 5.55)); + $this->assertSame(2, DaveChild\TextStatistics\Maths::bcCalc(10, '%', 7.55)); + $this->assertSame(2, DaveChild\TextStatistics\Maths::bcCalc(10, 'mod', 7.55)); + $this->assertSame(2, DaveChild\TextStatistics\Maths::bcCalc(10, 'modulus', 7.55)); + + $this->assertSame(1, DaveChild\TextStatistics\Maths::bcCalc(10, '=', 5)); + $this->assertSame(1, DaveChild\TextStatistics\Maths::bcCalc(10, 'comp', 5)); + $this->assertSame(1, DaveChild\TextStatistics\Maths::bcCalc(10, 'compare', 5)); + $this->assertSame(0, DaveChild\TextStatistics\Maths::bcCalc(10, '=', 10)); + $this->assertSame(0, DaveChild\TextStatistics\Maths::bcCalc(10, 'comp', 10)); + $this->assertSame(0, DaveChild\TextStatistics\Maths::bcCalc(10, 'compare', 10)); + $this->assertSame(-1, DaveChild\TextStatistics\Maths::bcCalc(5, '=', 10)); + $this->assertSame(-1, DaveChild\TextStatistics\Maths::bcCalc(5, 'comp', 10)); + $this->assertSame(-1, DaveChild\TextStatistics\Maths::bcCalc(5, 'compare', 10)); + + $this->assertSame(4, DaveChild\TextStatistics\Maths::bcCalc(16, 'sqrt', 5)); + $this->assertSame(3.87298, DaveChild\TextStatistics\Maths::bcCalc(15, 'sqrt', 5, true, 5)); + + // Malformed data + $this->assertSame(false, DaveChild\TextStatistics\Maths::bcCalc(array('banana'), '+', 2, true, 1)); + $this->assertSame(false, DaveChild\TextStatistics\Maths::bcCalc(2, '+', array('banana'), true, 1)); + $this->assertSame(false, DaveChild\TextStatistics\Maths::bcCalc('two', '+', 'three', true, 1)); + $this->assertSame(false, DaveChild\TextStatistics\Maths::bcCalc('two', '/', 'three', true, 1)); + $this->assertSame(false, DaveChild\TextStatistics\Maths::bcCalc(array('banana'), '+', 2)); + $this->assertSame(false, DaveChild\TextStatistics\Maths::bcCalc(2, '+', array('banana'))); + $this->assertSame(false, DaveChild\TextStatistics\Maths::bcCalc('two', '+', 'three')); + $this->assertSame(false, DaveChild\TextStatistics\Maths::bcCalc('two', '/', 'three')); + } +} diff --git a/vendor/davechild/textstatistics/tests/TextStatisticsMelvilleMobyDickTest.php b/vendor/davechild/textstatistics/tests/TextStatisticsMelvilleMobyDickTest.php new file mode 100644 index 0000000..ea4d50d --- /dev/null +++ b/vendor/davechild/textstatistics/tests/TextStatisticsMelvilleMobyDickTest.php @@ -0,0 +1,337 @@ +TextStatistics = new DaveChild\TextStatistics\TextStatistics(); + $this->TextStatistics->normalise = false; + } + + public function tearDown(): void + { + unset($this->objTextStatistics); + } + + /* Test Syllables + -------------------- */ + public function testMobyDickSyllables() + { // The Words from Moby Dick, in order + $this->assertEquals(1, $this->TextStatistics->syllableCount('Call')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('me')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('Ishmael')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('Some')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('years')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('ago')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('never')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('mind')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('how')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('long')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('precisely')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('having')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('little')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('or')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('no')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('money')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('in')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('my')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('purse')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('and')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('nothing')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('particular')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('to')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('interest')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('me')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('on')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('shore')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('I')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('thought')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('I')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('would')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('sail')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('about')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('a')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('little')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('and')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('see')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('the')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('watery')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('part')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('of')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('the')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('world')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('It')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('is')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('a')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('way')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('I')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('have')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('of')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('driving')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('off')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('the')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('spleen')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('and')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('regulating')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('the')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('circulation')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('Whenever')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('I')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('find')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('myself')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('growing')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('grim')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('about')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('the')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('mouth')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('whenever')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('it')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('is')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('a')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('damp')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('drizzly')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('November')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('in')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('my')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('soul')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('whenever')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('I')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('find')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('myself')); + $this->assertEquals(6, $this->TextStatistics->syllableCount('involuntarily')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('pausing')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('before')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('coffin')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('warehouses')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('and')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('bringing')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('up')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('the')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('rear')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('of')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('every')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('funeral')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('I')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('meet')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('and')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('especially')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('whenever')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('my')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('hypos')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('get')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('such')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('an')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('upper')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('hand')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('of')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('me')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('that')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('it')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('requires')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('a')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('strong')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('moral')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('principle')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('to')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('prevent')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('me')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('from')); + $this->assertEquals(5, $this->TextStatistics->syllableCount('deliberately')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('stepping')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('into')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('the')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('street')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('and')); + $this->assertEquals(5, $this->TextStatistics->syllableCount('methodically')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('knocking')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('people\'s')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('hats')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('off')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('then')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('I')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('account')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('it')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('high')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('time')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('to')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('get')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('to')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('sea')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('as')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('soon')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('as')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('I')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('can')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('This')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('is')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('my')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('substitute')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('for')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('pistol')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('and')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('ball')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('With')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('a')); + $this->assertEquals(5, $this->TextStatistics->syllableCount('philosophical')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('flourish')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('Cato')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('throws')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('himself')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('upon')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('his')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('sword')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('I')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('quietly')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('take')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('to')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('the')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('ship')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('There')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('is')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('nothing')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('surprising')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('in')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('this')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('If')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('they')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('but')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('knew')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('it')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('almost')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('all')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('men')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('in')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('their')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('degree')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('some')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('time')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('or')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('other')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('cherish')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('very')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('nearly')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('the')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('same')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('feelings')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('towards')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('the')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('ocean')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('with')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('me')); + } + + /* Test Word Count + -------------------- */ + public function testWordCount() + { + $this->assertEquals(201, $this->TextStatistics->wordCount($this->strText)); + } + + /* Test Long Word Count + -------------------- */ + public function testLongWordCount() + { + $this->assertEquals(23, $this->TextStatistics->wordsWithThreeSyllables($this->strText, true)); // Include proper nouns + $this->assertEquals(22, $this->TextStatistics->wordsWithThreeSyllables($this->strText, false)); // Don't include proper nouns + } + + /* Test Sentences + -------------------- */ + public function testSentenceCount() + { + $this->assertEquals(8, $this->TextStatistics->sentenceCount($this->strText)); + } + + /* Test Letter Count + -------------------- */ + public function testTextLengthCheck() + { + $this->assertEquals(884, $this->TextStatistics->letterCount($this->strText)); + } + + /* Test Flesch Kincaid Reading Ease + -------------------- */ + public function testFleschKincaidReadingEase() + { + $this->assertEquals(53.4, $this->TextStatistics->flesch_kincaid_reading_ease($this->strText)); + } + + /* Test Flesch Kincaid Grade Level + -------------------- */ + public function testFleschKincaidGradeLevel() + { + $this->assertEquals(12.1, $this->TextStatistics->flesch_kincaid_grade_level($this->strText)); + } + + /* Test Gunning Fog Score + -------------------- */ + public function testGunningFogScore() + { + $this->assertEquals(14.4, $this->TextStatistics->gunning_fog_score($this->strText)); + } + + /* Test Coleman Liau Index + -------------------- */ + public function testColemanLiauIndex() + { + $this->assertEquals(10.1, $this->TextStatistics->coleman_liau_index($this->strText)); + } + + /* Test SMOG Index + -------------------- */ + public function testSMOGIndex() + { + $this->assertEquals(13.0, $this->TextStatistics->smog_index($this->strText)); + } + + /* Test Automated Readability Index + -------------------- */ + public function testAutomatedReadabilityIndex() + { + $this->assertEquals(11.8, $this->TextStatistics->automated_readability_index($this->strText)); + } +} diff --git a/vendor/davechild/textstatistics/tests/TextStatisticsPluralise.php b/vendor/davechild/textstatistics/tests/TextStatisticsPluralise.php new file mode 100644 index 0000000..d9a8073 --- /dev/null +++ b/vendor/davechild/textstatistics/tests/TextStatisticsPluralise.php @@ -0,0 +1,62 @@ +TextStatistics = new DaveChild\TextStatistics\TextStatistics(); + $this->TextStatistics->normalise = false; + } + + public function tearDown(): void + { + unset($this->objTextStatistics); + } + + /* Test Pluralisation + -------------------- */ + public function testPluralisation() + { + $this->assertEquals('geese', DaveChild\TextStatistics\Pluralise::getPlural('goose')); + $this->assertEquals('mice', DaveChild\TextStatistics\Pluralise::getPlural('mouse')); + $this->assertEquals('houses', DaveChild\TextStatistics\Pluralise::getPlural('house')); + $this->assertEquals('bananas', DaveChild\TextStatistics\Pluralise::getPlural('banana')); + $this->assertEquals('quizzes', DaveChild\TextStatistics\Pluralise::getPlural('quiz')); + $this->assertEquals('geese', DaveChild\TextStatistics\Pluralise::getPlural('geese')); + $this->assertEquals('mice', DaveChild\TextStatistics\Pluralise::getPlural('mice')); + $this->assertEquals('houses', DaveChild\TextStatistics\Pluralise::getPlural('houses')); + $this->assertEquals('bananas', DaveChild\TextStatistics\Pluralise::getPlural('bananas')); + $this->assertEquals('quizzes', DaveChild\TextStatistics\Pluralise::getPlural('quizzes')); + $this->assertEquals('buffalo', DaveChild\TextStatistics\Pluralise::getPlural('buffalo')); + $this->assertEquals('money', DaveChild\TextStatistics\Pluralise::getPlural('money')); + } + + /* Test Singularisations + -------------------- */ + public function testSingularisation() + { + $this->assertEquals('goose', DaveChild\TextStatistics\Pluralise::getSingular('goose')); + $this->assertEquals('mouse', DaveChild\TextStatistics\Pluralise::getSingular('mouse')); + $this->assertEquals('house', DaveChild\TextStatistics\Pluralise::getSingular('house')); + $this->assertEquals('banana', DaveChild\TextStatistics\Pluralise::getSingular('banana')); + $this->assertEquals('quiz', DaveChild\TextStatistics\Pluralise::getSingular('quiz')); + $this->assertEquals('goose', DaveChild\TextStatistics\Pluralise::getSingular('geese')); + $this->assertEquals('mouse', DaveChild\TextStatistics\Pluralise::getSingular('mice')); + $this->assertEquals('house', DaveChild\TextStatistics\Pluralise::getSingular('houses')); + $this->assertEquals('banana', DaveChild\TextStatistics\Pluralise::getSingular('bananas')); + $this->assertEquals('quiz', DaveChild\TextStatistics\Pluralise::getSingular('quizzes')); + $this->assertEquals('buffalo', DaveChild\TextStatistics\Pluralise::getPlural('buffalo')); + $this->assertEquals('money', DaveChild\TextStatistics\Pluralise::getPlural('money')); + } +} diff --git a/vendor/davechild/textstatistics/tests/TextStatisticsTest.php b/vendor/davechild/textstatistics/tests/TextStatisticsTest.php new file mode 100644 index 0000000..45b57dd --- /dev/null +++ b/vendor/davechild/textstatistics/tests/TextStatisticsTest.php @@ -0,0 +1,320 @@ +TextStatistics = new DaveChild\TextStatistics\TextStatistics(); + $this->TextStatistics->normalise = false; + } + + public function tearDown(): void + { + unset($this->objTextStatistics); + } + + /* Test Cleaning of text + -------------------- */ + public function testCleaning() + { + $this->assertSame('', DaveChild\TextStatistics\Text::cleanText(false)); + $this->assertSame('There once was a little sausage named Baldrick. and he lived happily ever after.', DaveChild\TextStatistics\Text::cleanText('There once was a little sausage named Baldrick. . . . And he lived happily ever after.!! !??')); + } + + /* Test Case changes + -------------------- */ + public function testCases() + { + $this->assertSame('banana', DaveChild\TextStatistics\Text::lowerCase('banana')); + $this->assertSame('banana', DaveChild\TextStatistics\Text::lowerCase('Banana')); + $this->assertSame('banana', DaveChild\TextStatistics\Text::lowerCase('BanAna')); + $this->assertSame('banana', DaveChild\TextStatistics\Text::lowerCase('BANANA')); + $this->assertSame('BANANA', DaveChild\TextStatistics\Text::upperCase('banana')); + $this->assertSame('BANANA', DaveChild\TextStatistics\Text::upperCase('Banana')); + $this->assertSame('BANANA', DaveChild\TextStatistics\Text::upperCase('BanAna')); + $this->assertSame('BANANA', DaveChild\TextStatistics\Text::upperCase('BANANA')); + } + + /* Test Counts + -------------------- */ + public function testCounts() + { + $this->assertSame(47, DaveChild\TextStatistics\Text::characterCount('There once was a little sausage named Baldrick.')); + $this->assertSame(47, DaveChild\TextStatistics\Text::textLength('There once was a little sausage named Baldrick.')); + $this->assertSame(39, DaveChild\TextStatistics\Text::letterCount('There once was a little sausage named Baldrick.')); + $this->assertSame(0, DaveChild\TextStatistics\Text::letterCount('')); + $this->assertSame(0, DaveChild\TextStatistics\Text::letterCount(' ')); + $this->assertSame(0, DaveChild\TextStatistics\Text::wordCount('')); + $this->assertSame(0, DaveChild\TextStatistics\Text::wordCount(' ')); + $this->assertSame(0, DaveChild\TextStatistics\Text::sentenceCount('')); + $this->assertSame(0, DaveChild\TextStatistics\Text::sentenceCount(' ')); + $this->assertSame(1, $this->TextStatistics->letterCount('a')); + // Reset text before running second letter count check or it will use preset text of "a" + $this->TextStatistics->setText(''); + $this->assertSame(0, $this->TextStatistics->letterCount('')); + $this->assertSame(46, $this->TextStatistics->letterCount('this sentence has 30 characters, not including the digits')); + } + + /* Test Syllables + -------------------- */ + public function testSyllableCountBasicWords() + { // "Normal" words + $this->assertEquals(0, $this->TextStatistics->syllableCount('.')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('a')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('was')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('the')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('and')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('foobar')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('hello')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('world')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('wonderful')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('simple')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('easy')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('hard')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('quick')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('brown')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('fox')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('jumped')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('over')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('lazy')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('dog')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('camera')); + } + + public function testSyllableCountComplexWords() + { // Odd syllables, long words, difficult sounds + $this->assertEquals(12, $this->TextStatistics->syllableCount('antidisestablishmentarianism')); + $this->assertEquals(14, $this->TextStatistics->syllableCount('supercalifragilisticexpialidocious')); + $this->assertEquals(8, $this->TextStatistics->syllableCount('chlorofluorocarbonation')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('forethoughtfulness')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('phosphorescent')); + $this->assertEquals(5, $this->TextStatistics->syllableCount('theoretician')); + $this->assertEquals(5, $this->TextStatistics->syllableCount('promiscuity')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('unbutlering')); + $this->assertEquals(5, $this->TextStatistics->syllableCount('continuity')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('craunched')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('squelched')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('scrounge')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('coughed')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('smile')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('monopoly')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('doughey')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('doughier')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('leguminous')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('thoroughbreds')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('special')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('delicious')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('spatial')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('pacifism')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('coagulant')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('shouldn\'t')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('mcdonald')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('audience')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('finance')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('prevalence')); + $this->assertEquals(5, $this->TextStatistics->syllableCount('impropriety')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('alien')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('dreadnought')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('verandah')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('similar')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('similarly')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('central')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('cyst')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('term')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('order')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('fur')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('sugar')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('paper')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('make')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('gem')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('program')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('hopeless')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('hopelessly')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('careful')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('carefully')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('stuffy')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('thistle')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('teacher')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('unhappy')); + $this->assertEquals(5, $this->TextStatistics->syllableCount('ambiguity')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('validity')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('ambiguous')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('deserve')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('blooper')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('scooped')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('deserve')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('deal')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('death')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('dearth')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('deign')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('reign')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('bedsore')); + $this->assertEquals(5, $this->TextStatistics->syllableCount('anorexia')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('anymore')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('cored')); + $this->assertEquals(1, $this->TextStatistics->syllableCount('sore')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('foremost')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('restore')); + $this->assertEquals(2, $this->TextStatistics->syllableCount('minute')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('manticores')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('asparagus')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('unexplored')); + $this->assertEquals(4, $this->TextStatistics->syllableCount('unexploded')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('CAPITALS')); + } + + // These are fairly common words that are exceptions to given rules and that can not + // easily be programmed for. I've added them here for documentation purposes as much + // as anything else. If you find a way to program rules for any of these, move them + // into the section above. Many compound words will end up here. + public function testSyllableCountProgrammedExceptions() + { + $this->assertEquals(3, $this->TextStatistics->syllableCount('simile')); + // Compounds that have caused problems so far + // Problem: far too many compound words to list exhaustively. + $this->assertEquals(2, $this->TextStatistics->syllableCount('shoreline')); + $this->assertEquals(3, $this->TextStatistics->syllableCount('forever')); + } + + public function testAverageSyllablesPerWord() + { + $this->assertEquals(1, $this->TextStatistics->averageSyllablesPerWord('and then there was one')); + $this->assertEquals(2, $this->TextStatistics->averageSyllablesPerWord('because special ducklings deserve rainbows')); + $this->assertEquals(1.5, $this->TextStatistics->averageSyllablesPerWord('and then there was one because special ducklings deserve rainbows')); + } + + /* Test Words + -------------------- */ + public function testWordCount() + { + $this->assertEquals(9, $this->TextStatistics->wordCount('The quick brown fox jumps over the lazy dog')); + $this->assertEquals(9, $this->TextStatistics->wordCount('The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(9, $this->TextStatistics->wordCount('The quick brown fox jumps over the lazy dog. ')); + $this->assertEquals(9, $this->TextStatistics->wordCount(' The quick brown fox jumps over the lazy dog. ')); + $this->assertEquals(9, $this->TextStatistics->wordCount(' The quick brown fox jumps over the lazy dog. ')); + $this->assertEquals(2, $this->TextStatistics->wordCount('Yes. No.')); + $this->assertEquals(2, $this->TextStatistics->wordCount('Yes.No.')); + $this->assertEquals(2, $this->TextStatistics->wordCount('Yes.No.')); + $this->assertEquals(2, $this->TextStatistics->wordCount('Yes . No.')); + $this->assertEquals(2, $this->TextStatistics->wordCount('Yes .No.')); + $this->assertEquals(2, $this->TextStatistics->wordCount('Yes - No. ')); + } + + public function testCheckPercentageWordsWithThreeSyllables() + { + $this->assertEquals(9, number_format($this->TextStatistics->percentageWordsWithThreeSyllables('there is just one word with three syllables in this sentence'))); + $this->assertEquals(9, number_format($this->TextStatistics->percentageWordsWithThreeSyllables('there is just one word with three syllables in this sentence', true))); + $this->assertEquals(0, number_format($this->TextStatistics->percentageWordsWithThreeSyllables('there are no valid words with three Syllables in this sentence', false))); + $this->assertEquals(5, number_format($this->TextStatistics->percentageWordsWithThreeSyllables('there is one and only one word with three or more syllables in this long boring sentence of twenty words'))); + $this->assertEquals(10, number_format($this->TextStatistics->percentageWordsWithThreeSyllables('there are two and only two words with three or more syllables in this long sentence of exactly twenty words'))); + $this->assertEquals(5, number_format($this->TextStatistics->percentageWordsWithThreeSyllables('there is Actually only one valid word with three or more syllables in this long sentence of Exactly twenty words', false))); + $this->assertEquals(0, number_format($this->TextStatistics->percentageWordsWithThreeSyllables('no long words in this sentence'))); + $this->assertEquals(0, number_format($this->TextStatistics->percentageWordsWithThreeSyllables('no long valid words in this sentence because the test ignores proper case words like this Behemoth', false))); + } + + /* Test Sentences + -------------------- */ + public function testSentenceCount() + { + $this->assertEquals(1, $this->TextStatistics->sentenceCount('This is a sentence')); + $this->assertEquals(1, $this->TextStatistics->sentenceCount('This is a sentence.')); + $this->assertEquals(1, $this->TextStatistics->sentenceCount('This is a sentence!')); + $this->assertEquals(1, $this->TextStatistics->sentenceCount('This is a sentence?')); + $this->assertEquals(1, $this->TextStatistics->sentenceCount('This is a sentence..')); + $this->assertEquals(2, $this->TextStatistics->sentenceCount('This is a sentence. So is this.')); + $this->assertEquals(2, $this->TextStatistics->sentenceCount("This is a sentence. \n\n So is this, but this is multi-line!")); + $this->assertEquals(2, $this->TextStatistics->sentenceCount('This is a sentence,. So is this.')); + $this->assertEquals(2, $this->TextStatistics->sentenceCount('This is a sentence!? So is this.')); + $this->assertEquals(3, $this->TextStatistics->sentenceCount('This is a sentence. So is this. And this one as well.')); + $this->assertEquals(1, $this->TextStatistics->sentenceCount('This is a sentence - but just one.')); + $this->assertEquals(1, $this->TextStatistics->sentenceCount('This is a sentence (but just one).')); + } + + public function testAverageWordsPerSentence() + { + $this->assertEquals(4, $this->TextStatistics->averageWordsPerSentence('This is a sentence')); + $this->assertEquals(4, $this->TextStatistics->averageWordsPerSentence('This is a sentence.')); + $this->assertEquals(4, $this->TextStatistics->averageWordsPerSentence('This is a sentence. ')); + $this->assertEquals(4, $this->TextStatistics->averageWordsPerSentence('This is a sentence. This is a sentence')); + $this->assertEquals(4, $this->TextStatistics->averageWordsPerSentence('This is a sentence. This is a sentence.')); + $this->assertEquals(4, $this->TextStatistics->averageWordsPerSentence('This, is - a sentence . This is a sentence. ')); + $this->assertEquals(5.5, $this->TextStatistics->averageWordsPerSentence('This is a sentence with extra text. This is a sentence. ')); + $this->assertEquals(6, $this->TextStatistics->averageWordsPerSentence('This is a sentence with some extra text. This is a sentence. ')); + } + + /* Test Scores + -------------------- */ + // Please note that scores for all of these sentences and scoring systems have all been calculated by hand and should therefore be accurate. + // All values have been rounded to a single decimal point. PHP can be temperamental when it comes to floats. + public function testFleschKincaidReadingEase() + { + $this->assertEquals(121.2, $this->TextStatistics->flesch_kincaid_reading_ease('This. Is. A. Nice. Set. Of. Small. Words. Of. One. Part. Each.')); // Best score possible + $this->assertEquals(94.3, $this->TextStatistics->flesch_kincaid_reading_ease('The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(94.3, $this->TextStatistics->flesch_kincaid_reading_ease('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(94.3, $this->TextStatistics->flesch_kincaid_reading_ease('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog')); + $this->assertEquals(94.3, $this->TextStatistics->flesch_kincaid_reading_ease("The quick brown fox jumps over the lazy dog. \n\n The quick brown fox jumps over the lazy dog.")); + $this->assertEquals(50.5, $this->TextStatistics->flesch_kincaid_reading_ease('Now it is time for a more complicated sentence, including several longer words.')); + } + + public function testFleschKincaidGradeLevel() + { + $this->assertEquals(-3.4, $this->TextStatistics->flesch_kincaid_grade_level('This. Is. A. Nice. Set. Of. Small. Words. Of. One. Part. Each.')); // Best score possible + $this->assertEquals(2.3, $this->TextStatistics->flesch_kincaid_grade_level('The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(2.3, $this->TextStatistics->flesch_kincaid_grade_level('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(2.3, $this->TextStatistics->flesch_kincaid_grade_level('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog')); + $this->assertEquals(2.3, $this->TextStatistics->flesch_kincaid_grade_level("The quick brown fox jumps over the lazy dog. \n\n The quick brown fox jumps over the lazy dog.")); + $this->assertEquals(9.4, $this->TextStatistics->flesch_kincaid_grade_level('Now it is time for a more complicated sentence, including several longer words.')); + } + + public function testGunningFogScore() + { + $this->assertEquals(0.4, $this->TextStatistics->gunning_fog_score('This. Is. A. Nice. Set. Of. Small. Words. Of. One. Part. Each.')); // Best possible score + $this->assertEquals(3.6, $this->TextStatistics->gunning_fog_score('The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(3.6, $this->TextStatistics->gunning_fog_score('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(3.6, $this->TextStatistics->gunning_fog_score("The quick brown fox jumps over the lazy dog. \n\n The quick brown fox jumps over the lazy dog.")); + $this->assertEquals(3.6, $this->TextStatistics->gunning_fog_score('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog')); + $this->assertEquals(14.4, $this->TextStatistics->gunning_fog_score('Now it is time for a more complicated sentence, including several longer words.')); + $this->assertEquals(8.3, $this->TextStatistics->gunning_fog_score('Now it is time for a more Complicated sentence, including Several longer words.')); // Two proper nouns, ignored + } + + public function testColemanLiauIndex() + { + $this->assertEquals(3.0, $this->TextStatistics->coleman_liau_index('This. Is. A. Nice. Set. Of. Small. Words. Of. One. Part. Each.')); // Best possible score would be if all words were 1 character + $this->assertEquals(7.1, $this->TextStatistics->coleman_liau_index('The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(7.1, $this->TextStatistics->coleman_liau_index('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(7.1, $this->TextStatistics->coleman_liau_index("The quick brown fox jumps over the lazy dog. \n\n The quick brown fox jumps over the lazy dog.")); + $this->assertEquals(7.1, $this->TextStatistics->coleman_liau_index('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog')); + $this->assertEquals(13.6, $this->TextStatistics->coleman_liau_index('Now it is time for a more complicated sentence, including several longer words.')); + } + + public function testSMOGIndex() + { + $this->assertEquals(3.3, $this->TextStatistics->smog_index('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 + $this->assertEquals(3.3, $this->TextStatistics->smog_index('The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(3.3, $this->TextStatistics->smog_index('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(3.3, $this->TextStatistics->smog_index("The quick brown fox jumps over the lazy dog. \n\n The quick brown fox jumps over the lazy dog.")); + $this->assertEquals(3.3, $this->TextStatistics->smog_index('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog')); + $this->assertEquals(13.2, $this->TextStatistics->smog_index('Now it is time for a more complicated sentence, including several longer words.')); + } + + public function testAutomatedReadabilityIndex() + { + $this->assertEquals(-5.6, $this->TextStatistics->automated_readability_index('This. Is. A. Nice. Set. Of. Small. Words. Of. One. Part. Each.')); + $this->assertEquals(1.4, $this->TextStatistics->automated_readability_index('The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(1.4, $this->TextStatistics->automated_readability_index('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog.')); + $this->assertEquals(1.4, $this->TextStatistics->automated_readability_index("The quick brown fox jumps over the lazy dog. \n\n The quick brown fox jumps over the lazy dog.")); + $this->assertEquals(1.4, $this->TextStatistics->automated_readability_index('The quick brown fox jumps over the lazy dog. The quick brown fox jumps over the lazy dog')); + $this->assertEquals(8.6, $this->TextStatistics->automated_readability_index('Now it is time for a more complicated sentence, including several longer words.')); + } +}