chrislit /
abydos
| Total Complexity | 100 |
| Total Lines | 5002 |
| Duplicated Lines | 1.44 % |
| Changes | 0 | ||
Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
Complex classes like tests.test_phonetic often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
| 1 | # -*- coding: utf-8 -*- |
||
|
coding-style
introduced
by
|
|||
| 2 | |||
| 3 | # Copyright 2014-2018 by Christopher C. Little. |
||
| 4 | # This file is part of Abydos. |
||
| 5 | # |
||
| 6 | # Abydos is free software: you can redistribute it and/or modify |
||
| 7 | # it under the terms of the GNU General Public License as published by |
||
| 8 | # the Free Software Foundation, either version 3 of the License, or |
||
| 9 | # (at your option) any later version. |
||
| 10 | # |
||
| 11 | # Abydos is distributed in the hope that it will be useful, |
||
| 12 | # but WITHOUT ANY WARRANTY; without even the implied warranty of |
||
| 13 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
||
| 14 | # GNU General Public License for more details. |
||
| 15 | # |
||
| 16 | # You should have received a copy of the GNU General Public License |
||
| 17 | # along with Abydos. If not, see <http://www.gnu.org/licenses/>. |
||
| 18 | |||
| 19 | """abydos.tests.test_phonetic. |
||
| 20 | |||
| 21 | This module contains unit tests for abydos.phonetic |
||
| 22 | """ |
||
| 23 | |||
| 24 | from __future__ import unicode_literals |
||
| 25 | |||
| 26 | import codecs |
||
| 27 | import math |
||
| 28 | import os |
||
| 29 | import random |
||
| 30 | import unittest |
||
| 31 | |||
| 32 | from abydos._bm import _bm_apply_rule_if_compat, _bm_expand_alternates, \ |
||
| 33 | _bm_language, _bm_normalize_lang_attrs, _bm_phonetic_number, \ |
||
| 34 | _bm_remove_dupes |
||
| 35 | from abydos._bmdata import L_ANY, L_CYRILLIC, L_CZECH, L_DUTCH, L_ENGLISH, \ |
||
| 36 | L_FRENCH, L_GERMAN, L_GREEK, L_GREEKLATIN, L_HEBREW, L_HUNGARIAN, \ |
||
| 37 | L_ITALIAN, L_LATVIAN, L_POLISH, L_PORTUGUESE, L_ROMANIAN, L_SPANISH, \ |
||
| 38 | L_TURKISH |
||
| 39 | from abydos.phonetic import alpha_sis, bmpm, caverphone, dm_soundex, \ |
||
| 40 | double_metaphone, fuzzy_soundex, koelner_phonetik, \ |
||
| 41 | koelner_phonetik_alpha, koelner_phonetik_num_to_alpha, lein, metaphone, \ |
||
| 42 | mra, nysiis, onca, phonem, phonet, phonex, phonix, refined_soundex, \ |
||
| 43 | roger_root, russell_index, russell_index_alpha, \ |
||
| 44 | russell_index_num_to_alpha, sfinxbis, soundex, spfc, statistics_canada |
||
| 45 | |||
| 46 | from six import text_type |
||
| 47 | |||
| 48 | TESTDIR = os.path.dirname(__file__) |
||
| 49 | |||
| 50 | EXTREME_TEST = False # Set to True to test EVERY single case (NB: takes hours) |
||
| 51 | ALLOW_RANDOM = True # Set to False to skip all random tests |
||
| 52 | |||
| 53 | if not EXTREME_TEST and os.path.isfile(TESTDIR + '/EXTREME_TEST'): |
||
| 54 | # EXTREME_TEST file detected -- switching to EXTREME_TEST mode... |
||
| 55 | EXTREME_TEST = True |
||
| 56 | |||
| 57 | |||
| 58 | def one_in(inverse_probability): |
||
| 59 | """Return whether to run a test. |
||
| 60 | |||
| 61 | Return True if: |
||
| 62 | EXTREME_TEST is True |
||
| 63 | OR |
||
| 64 | (ALLOW_RANDOM is False |
||
| 65 | AND |
||
| 66 | random.random() * inverse_probability < 1 |
||
| 67 | Otherwise return False |
||
| 68 | """ |
||
| 69 | if EXTREME_TEST: |
||
| 70 | return True |
||
| 71 | elif ALLOW_RANDOM and random.random() * inverse_probability < 1: |
||
| 72 | return True |
||
| 73 | else: |
||
| 74 | return False |
||
| 75 | |||
| 76 | |||
| 77 | class RussellIndexTestCases(unittest.TestCase): |
||
| 78 | """Test Russel Index functions. |
||
| 79 | |||
| 80 | test cases for abydos.phonetic.russell_index, |
||
| 81 | .russell_index_num_to_alpha, & .russell_index_alpha |
||
| 82 | """ |
||
| 83 | |||
| 84 | def test_russel_index(self): |
||
| 85 | """Test abydos.phonetic.russell_index.""" |
||
| 86 | self.assertTrue(math.isnan(russell_index(''))) |
||
| 87 | self.assertTrue(math.isnan(russell_index('H'))) |
||
| 88 | self.assertEqual(russell_index('Hoppa'), 12) |
||
| 89 | self.assertEqual(russell_index('Hopley'), 125) |
||
| 90 | self.assertEqual(russell_index('Highfield'), 1254) |
||
| 91 | self.assertEqual(russell_index('Wright'), 814) |
||
| 92 | self.assertEqual(russell_index('Carter'), 31848) |
||
| 93 | self.assertEqual(russell_index('Hopf'), 12) |
||
| 94 | self.assertEqual(russell_index('Hay'), 1) |
||
| 95 | self.assertEqual(russell_index('Haas'), 1) |
||
| 96 | self.assertEqual(russell_index('Meyers'), 618) |
||
| 97 | self.assertEqual(russell_index('Myers'), 618) |
||
| 98 | self.assertEqual(russell_index('Meyer'), 618) |
||
| 99 | self.assertEqual(russell_index('Myer'), 618) |
||
| 100 | self.assertEqual(russell_index('Mack'), 613) |
||
| 101 | self.assertEqual(russell_index('Knack'), 3713) |
||
| 102 | |||
| 103 | def test_russel_index_n2a(self): |
||
| 104 | """Test abydos.phonetic.russell_index_num_to_alpha.""" |
||
| 105 | self.assertEqual(russell_index_num_to_alpha(0), '') |
||
| 106 | self.assertEqual(russell_index_num_to_alpha(''), '') |
||
| 107 | self.assertEqual(russell_index_num_to_alpha(float('NaN')), '') |
||
| 108 | self.assertEqual(russell_index_num_to_alpha(123456789), 'ABCDLMNR') |
||
| 109 | self.assertEqual(russell_index_num_to_alpha('0123456789'), 'ABCDLMNR') |
||
| 110 | |||
| 111 | def test_russel_index_alpha(self): |
||
| 112 | """Test abydos.phonetic.russell_index_alpha.""" |
||
| 113 | self.assertEqual(russell_index_alpha(''), '') |
||
| 114 | self.assertEqual(russell_index_alpha('H'), '') |
||
| 115 | self.assertEqual(russell_index_alpha('Hoppa'), 'AB') |
||
| 116 | self.assertEqual(russell_index_alpha('Hopley'), 'ABL') |
||
| 117 | self.assertEqual(russell_index_alpha('Highfield'), 'ABLD') |
||
| 118 | self.assertEqual(russell_index_alpha('Wright'), 'RAD') |
||
| 119 | self.assertEqual(russell_index_alpha('Carter'), 'CARDR') |
||
| 120 | self.assertEqual(russell_index_alpha('Hopf'), 'AB') |
||
| 121 | self.assertEqual(russell_index_alpha('Hay'), 'A') |
||
| 122 | self.assertEqual(russell_index_alpha('Haas'), 'A') |
||
| 123 | self.assertEqual(russell_index_alpha('Meyers'), 'MAR') |
||
| 124 | self.assertEqual(russell_index_alpha('Myers'), 'MAR') |
||
| 125 | self.assertEqual(russell_index_alpha('Meyer'), 'MAR') |
||
| 126 | self.assertEqual(russell_index_alpha('Myer'), 'MAR') |
||
| 127 | self.assertEqual(russell_index_alpha('Mack'), 'MAC') |
||
| 128 | self.assertEqual(russell_index_alpha('Knack'), 'CNAC') |
||
| 129 | |||
| 130 | |||
| 131 | class SoundexTestCases(unittest.TestCase): |
||
| 132 | """Test Soundex functions. |
||
| 133 | |||
| 134 | test cases for abydos.phonetic.soundex, .refined_soundex, |
||
| 135 | & .dm_soundex |
||
| 136 | """ |
||
| 137 | |||
| 138 | def test_soundex(self): |
||
| 139 | """Test abydos.phonetic.soundex.""" |
||
| 140 | self.assertEqual(soundex(''), '0000') |
||
| 141 | |||
| 142 | # https://archive.org/stream/accessingindivid00moor#page/14/mode/2up |
||
| 143 | self.assertEqual(soundex('Euler'), 'E460') |
||
| 144 | self.assertEqual(soundex('Gauss'), 'G200') |
||
| 145 | self.assertEqual(soundex('Hilbert'), 'H416') |
||
| 146 | self.assertEqual(soundex('Knuth'), 'K530') |
||
| 147 | self.assertEqual(soundex('Lloyd'), 'L300') |
||
| 148 | self.assertEqual(soundex('Lukasieicz'), 'L222') |
||
| 149 | self.assertEqual(soundex('Ellery'), 'E460') |
||
| 150 | self.assertEqual(soundex('Ghosh'), 'G200') |
||
| 151 | self.assertEqual(soundex('Heilbronn'), 'H416') |
||
| 152 | self.assertEqual(soundex('Kant'), 'K530') |
||
| 153 | self.assertEqual(soundex('Ladd'), 'L300') |
||
| 154 | self.assertEqual(soundex('Lissajous'), 'L222') |
||
| 155 | self.assertEqual(soundex('Rogers'), 'R262') |
||
| 156 | self.assertEqual(soundex('Rodgers'), 'R326') |
||
| 157 | self.assertNotEquals(soundex('Rogers'), soundex('Rodgers')) |
||
| 158 | self.assertNotEquals(soundex('Sinclair'), soundex('St. Clair')) |
||
| 159 | self.assertNotEquals(soundex('Tchebysheff'), soundex('Chebyshev')) |
||
| 160 | |||
| 161 | # http://creativyst.com/Doc/Articles/SoundEx1/SoundEx1.htm#Related |
||
| 162 | self.assertEqual(soundex('Htacky'), 'H320') |
||
| 163 | self.assertEqual(soundex('Atacky'), 'A320') |
||
| 164 | self.assertEqual(soundex('Schmit'), 'S530') |
||
| 165 | self.assertEqual(soundex('Schneider'), 'S536') |
||
| 166 | self.assertEqual(soundex('Pfister'), 'P236') |
||
| 167 | self.assertEqual(soundex('Ashcroft'), 'A261') |
||
| 168 | self.assertEqual(soundex('Asicroft'), 'A226') |
||
| 169 | |||
| 170 | # https://en.wikipedia.org/wiki/Soundex |
||
| 171 | self.assertEqual(soundex('Robert'), 'R163') |
||
| 172 | self.assertEqual(soundex('Rupert'), 'R163') |
||
| 173 | self.assertEqual(soundex('Rubin'), 'R150') |
||
| 174 | self.assertEqual(soundex('Tymczak'), 'T522') |
||
| 175 | |||
| 176 | # https://en.wikipedia.org/wiki/Daitch%E2%80%93Mokotoff_Soundex |
||
| 177 | self.assertEqual(soundex('Peters'), 'P362') |
||
| 178 | self.assertEqual(soundex('Peterson'), 'P362') |
||
| 179 | self.assertEqual(soundex('Moskowitz'), 'M232') |
||
| 180 | self.assertEqual(soundex('Moskovitz'), 'M213') |
||
| 181 | self.assertEqual(soundex('Auerbach'), 'A612') |
||
| 182 | self.assertEqual(soundex('Uhrbach'), 'U612') |
||
| 183 | self.assertEqual(soundex('Jackson'), 'J250') |
||
| 184 | self.assertEqual(soundex('Jackson-Jackson'), 'J252') |
||
| 185 | |||
| 186 | # maxlength tests |
||
| 187 | self.assertEqual(soundex('Lincoln', 10), 'L524500000') |
||
| 188 | self.assertEqual(soundex('Lincoln', 5), 'L5245') |
||
| 189 | self.assertEqual(soundex('Christopher', 6), 'C62316') |
||
| 190 | |||
| 191 | # maxlength bounds tests |
||
| 192 | self.assertEqual(soundex('Niall', maxlength=float('inf')), |
||
| 193 | 'N4000000000000000000000000000000000000000000000000' + |
||
| 194 | '00000000000000') |
||
| 195 | self.assertEqual(soundex('Niall', maxlength=None), |
||
| 196 | 'N4000000000000000000000000000000000000000000000000' + |
||
| 197 | '00000000000000') |
||
| 198 | self.assertEqual(soundex('Niall', maxlength=0), 'N400') |
||
| 199 | |||
| 200 | # reverse tests |
||
| 201 | self.assertEqual(soundex('Rubin', reverse=True), 'N160') |
||
| 202 | self.assertEqual(soundex('Llyod', reverse=True), 'D400') |
||
| 203 | self.assertEqual(soundex('Lincoln', reverse=True), 'N425') |
||
| 204 | self.assertEqual(soundex('Knuth', reverse=True), 'H352') |
||
| 205 | |||
| 206 | # zero_pad tests |
||
| 207 | self.assertEqual(soundex('Niall', maxlength=float('inf'), |
||
| 208 | zero_pad=False), 'N4') |
||
| 209 | self.assertEqual(soundex('Niall', maxlength=None, |
||
| 210 | zero_pad=False), 'N4') |
||
| 211 | self.assertEqual(soundex('Niall', maxlength=0, zero_pad=False), 'N4') |
||
| 212 | self.assertEqual(soundex('Niall', maxlength=0, zero_pad=True), 'N400') |
||
| 213 | self.assertEqual(soundex('', maxlength=4, zero_pad=False), '0') |
||
| 214 | self.assertEqual(soundex('', maxlength=4, zero_pad=True), '0000') |
||
| 215 | |||
| 216 | def test_soundex_special(self): |
||
| 217 | """Test abydos.phonetic.soundex (special census variant method).""" |
||
| 218 | self.assertEqual(soundex('Ashcroft', var='special'), 'A226') |
||
| 219 | self.assertEqual(soundex('Asicroft', var='special'), 'A226') |
||
| 220 | self.assertEqual(soundex('AsWcroft', var='special'), 'A226') |
||
| 221 | self.assertEqual(soundex('Rupert', var='special'), 'R163') |
||
| 222 | self.assertEqual(soundex('Rubin', var='special'), 'R150') |
||
| 223 | |||
| 224 | def test_refined_soundex(self): |
||
| 225 | """Test abydos.phonetic.refined_soundex.""" |
||
| 226 | # http://ntz-develop.blogspot.com/2011/03/phonetic-algorithms.html |
||
| 227 | self.assertEqual(refined_soundex('Braz'), 'B1905') |
||
| 228 | self.assertEqual(refined_soundex('Broz'), 'B1905') |
||
| 229 | self.assertEqual(refined_soundex('Caren'), 'C30908') |
||
| 230 | self.assertEqual(refined_soundex('Caron'), 'C30908') |
||
| 231 | self.assertEqual(refined_soundex('Carren'), 'C30908') |
||
| 232 | self.assertEqual(refined_soundex('Charon'), 'C30908') |
||
| 233 | self.assertEqual(refined_soundex('Corain'), 'C30908') |
||
| 234 | self.assertEqual(refined_soundex('Coram'), 'C30908') |
||
| 235 | self.assertEqual(refined_soundex('Corran'), 'C30908') |
||
| 236 | self.assertEqual(refined_soundex('Corrin'), 'C30908') |
||
| 237 | self.assertEqual(refined_soundex('Corwin'), 'C30908') |
||
| 238 | self.assertEqual(refined_soundex('Curran'), 'C30908') |
||
| 239 | self.assertEqual(refined_soundex('Curreen'), 'C30908') |
||
| 240 | self.assertEqual(refined_soundex('Currin'), 'C30908') |
||
| 241 | self.assertEqual(refined_soundex('Currom'), 'C30908') |
||
| 242 | self.assertEqual(refined_soundex('Currum'), 'C30908') |
||
| 243 | self.assertEqual(refined_soundex('Curwen'), 'C30908') |
||
| 244 | self.assertEqual(refined_soundex('Caren'), 'C30908') |
||
| 245 | self.assertEqual(refined_soundex('Caren'), 'C30908') |
||
| 246 | self.assertEqual(refined_soundex('Caren'), 'C30908') |
||
| 247 | self.assertEqual(refined_soundex('Caren'), 'C30908') |
||
| 248 | self.assertEqual(refined_soundex('Caren'), 'C30908') |
||
| 249 | self.assertEqual(refined_soundex('Caren'), 'C30908') |
||
| 250 | self.assertEqual(refined_soundex('Caren'), 'C30908') |
||
| 251 | self.assertEqual(refined_soundex('Hairs'), 'H093') |
||
| 252 | self.assertEqual(refined_soundex('Hark'), 'H093') |
||
| 253 | self.assertEqual(refined_soundex('Hars'), 'H093') |
||
| 254 | self.assertEqual(refined_soundex('Hayers'), 'H093') |
||
| 255 | self.assertEqual(refined_soundex('Heers'), 'H093') |
||
| 256 | self.assertEqual(refined_soundex('Hiers'), 'H093') |
||
| 257 | self.assertEqual(refined_soundex('Lambard'), 'L7081096') |
||
| 258 | self.assertEqual(refined_soundex('Lambart'), 'L7081096') |
||
| 259 | self.assertEqual(refined_soundex('Lambert'), 'L7081096') |
||
| 260 | self.assertEqual(refined_soundex('Lambird'), 'L7081096') |
||
| 261 | self.assertEqual(refined_soundex('Lampaert'), 'L7081096') |
||
| 262 | self.assertEqual(refined_soundex('Lampard'), 'L7081096') |
||
| 263 | self.assertEqual(refined_soundex('Lampart'), 'L7081096') |
||
| 264 | self.assertEqual(refined_soundex('Lamperd'), 'L7081096') |
||
| 265 | self.assertEqual(refined_soundex('Lampert'), 'L7081096') |
||
| 266 | self.assertEqual(refined_soundex('Lamport'), 'L7081096') |
||
| 267 | self.assertEqual(refined_soundex('Limbert'), 'L7081096') |
||
| 268 | self.assertEqual(refined_soundex('Lombard'), 'L7081096') |
||
| 269 | self.assertEqual(refined_soundex('Nolton'), 'N807608') |
||
| 270 | self.assertEqual(refined_soundex('Noulton'), 'N807608') |
||
| 271 | |||
| 272 | # http://trimc-nlp.blogspot.com/2015/03/the-soundex-algorithm.html |
||
| 273 | self.assertEqual(refined_soundex('Craig'), 'C3904') |
||
| 274 | self.assertEqual(refined_soundex('Crag'), 'C3904') |
||
| 275 | self.assertEqual(refined_soundex('Crejg'), 'C3904') |
||
| 276 | self.assertEqual(refined_soundex('Creig'), 'C3904') |
||
| 277 | self.assertEqual(refined_soundex('Craigg'), 'C3904') |
||
| 278 | self.assertEqual(refined_soundex('Craug'), 'C3904') |
||
| 279 | self.assertEqual(refined_soundex('Craiggg'), 'C3904') |
||
| 280 | self.assertEqual(refined_soundex('Creg'), 'C3904') |
||
| 281 | self.assertEqual(refined_soundex('Cregg'), 'C3904') |
||
| 282 | self.assertEqual(refined_soundex('Creag'), 'C3904') |
||
| 283 | self.assertEqual(refined_soundex('Greg'), 'G4904') |
||
| 284 | self.assertEqual(refined_soundex('Gregg'), 'G4904') |
||
| 285 | self.assertEqual(refined_soundex('Graig'), 'G4904') |
||
| 286 | self.assertEqual(refined_soundex('Greig'), 'G4904') |
||
| 287 | self.assertEqual(refined_soundex('Greggg'), 'G4904') |
||
| 288 | self.assertEqual(refined_soundex('Groeg'), 'G4904') |
||
| 289 | self.assertEqual(refined_soundex('Graj'), 'G4904') |
||
| 290 | self.assertEqual(refined_soundex('Grej'), 'G4904') |
||
| 291 | self.assertEqual(refined_soundex('Grreg'), 'G4904') |
||
| 292 | self.assertEqual(refined_soundex('Greag'), 'G4904') |
||
| 293 | self.assertEqual(refined_soundex('Grig'), 'G4904') |
||
| 294 | self.assertEqual(refined_soundex('Kregg'), 'K3904') |
||
| 295 | self.assertEqual(refined_soundex('Kraig'), 'K3904') |
||
| 296 | self.assertEqual(refined_soundex('Krag'), 'K3904') |
||
| 297 | self.assertEqual(refined_soundex('Kreig'), 'K3904') |
||
| 298 | self.assertEqual(refined_soundex('Krug'), 'K3904') |
||
| 299 | self.assertEqual(refined_soundex('Kreg'), 'K3904') |
||
| 300 | self.assertEqual(refined_soundex('Krieg'), 'K3904') |
||
| 301 | self.assertEqual(refined_soundex('Krijg'), 'K3904') |
||
| 302 | |||
| 303 | # Apache Commons test cases |
||
| 304 | # http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/test/java/org/apache/commons/codec/language/RefinedSoundexTest.java?view=markup |
||
| 305 | self.assertEqual(refined_soundex('testing'), 'T6036084') |
||
| 306 | self.assertEqual(refined_soundex('TESTING'), 'T6036084') |
||
| 307 | self.assertEqual(refined_soundex('The'), 'T60') |
||
| 308 | self.assertEqual(refined_soundex('quick'), 'Q503') |
||
| 309 | self.assertEqual(refined_soundex('brown'), 'B1908') |
||
| 310 | self.assertEqual(refined_soundex('fox'), 'F205') |
||
| 311 | self.assertEqual(refined_soundex('jumped'), 'J408106') |
||
| 312 | self.assertEqual(refined_soundex('over'), 'O0209') |
||
| 313 | self.assertEqual(refined_soundex('the'), 'T60') |
||
| 314 | self.assertEqual(refined_soundex('lazy'), 'L7050') |
||
| 315 | self.assertEqual(refined_soundex('dogs'), 'D6043') |
||
| 316 | |||
| 317 | def test_dm_soundex(self): |
||
| 318 | """Test abydos.phonetic.dm_soundex (Daitchh-Mokotoff Soundex).""" |
||
| 319 | # D-M tests |
||
| 320 | self.assertEqual(soundex('', var='dm'), {'000000'}) |
||
| 321 | self.assertEqual(dm_soundex(''), {'000000'}) |
||
| 322 | |||
| 323 | # http://www.avotaynu.com/soundex.htm |
||
| 324 | self.assertEqual(soundex('Augsburg', var='dm'), {'054795'}) |
||
| 325 | self.assertEqual(dm_soundex('Augsburg'), {'054795'}) |
||
| 326 | self.assertEqual(soundex('Breuer', var='dm'), {'791900'}) |
||
| 327 | self.assertEqual(dm_soundex('Breuer'), {'791900'}) |
||
| 328 | self.assertEqual(soundex('Halberstadt', var='dm'), |
||
| 329 | {'587943', '587433'}) |
||
| 330 | self.assertEqual(dm_soundex('Halberstadt'), {'587943', '587433'}) |
||
| 331 | self.assertEqual(soundex('Mannheim', var='dm'), {'665600'}) |
||
| 332 | self.assertEqual(dm_soundex('Mannheim'), {'665600'}) |
||
| 333 | self.assertEqual(soundex('Chernowitz', var='dm'), |
||
| 334 | {'496740', '596740'}) |
||
| 335 | self.assertEqual(dm_soundex('Chernowitz'), {'496740', '596740'}) |
||
| 336 | self.assertEqual(soundex('Cherkassy', var='dm'), |
||
| 337 | {'495400', '595400'}) |
||
| 338 | self.assertEqual(dm_soundex('Cherkassy'), {'495400', '595400'}) |
||
| 339 | self.assertEqual(soundex('Kleinman', var='dm'), {'586660'}) |
||
| 340 | self.assertEqual(dm_soundex('Kleinman'), {'586660'}) |
||
| 341 | self.assertEqual(soundex('Berlin', var='dm'), {'798600'}) |
||
| 342 | self.assertEqual(dm_soundex('Berlin'), {'798600'}) |
||
| 343 | |||
| 344 | self.assertEqual(soundex('Ceniow', var='dm'), |
||
| 345 | {'467000', '567000'}) |
||
| 346 | self.assertEqual(dm_soundex('Ceniow'), {'467000', '567000'}) |
||
| 347 | self.assertEqual(soundex('Tsenyuv', var='dm'), {'467000'}) |
||
| 348 | self.assertEqual(dm_soundex('Tsenyuv'), {'467000'}) |
||
| 349 | self.assertEqual(soundex('Holubica', var='dm'), |
||
| 350 | {'587400', '587500'}) |
||
| 351 | self.assertEqual(dm_soundex('Holubica'), {'587400', '587500'}) |
||
| 352 | self.assertEqual(soundex('Golubitsa', var='dm'), {'587400'}) |
||
| 353 | self.assertEqual(dm_soundex('Golubitsa'), {'587400'}) |
||
| 354 | self.assertEqual(soundex('Przemysl', var='dm'), |
||
| 355 | {'746480', '794648'}) |
||
| 356 | self.assertEqual(dm_soundex('Przemysl'), {'746480', '794648'}) |
||
| 357 | self.assertEqual(soundex('Pshemeshil', var='dm'), {'746480'}) |
||
| 358 | self.assertEqual(dm_soundex('Pshemeshil'), {'746480'}) |
||
| 359 | self.assertEqual(soundex('Rosochowaciec', var='dm'), |
||
| 360 | {'944744', '945744', '944755', '944754', '944745', |
||
| 361 | '945745', '945754', '945755'}) |
||
| 362 | self.assertEqual(dm_soundex('Rosochowaciec'), |
||
| 363 | {'944744', '945744', '944755', '944754', '944745', |
||
| 364 | '945745', '945754', '945755'}) |
||
| 365 | self.assertEqual(soundex('Rosokhovatsets', var='dm'), {'945744'}) |
||
| 366 | self.assertEqual(dm_soundex('Rosokhovatsets'), {'945744'}) |
||
| 367 | |||
| 368 | # https://en.wikipedia.org/wiki/Daitch%E2%80%93Mokotoff_Soundex |
||
| 369 | self.assertEqual(soundex('Peters', var='dm'), |
||
| 370 | {'739400', '734000'}) |
||
| 371 | self.assertEqual(dm_soundex('Peters'), {'739400', '734000'}) |
||
| 372 | self.assertEqual(soundex('Peterson', var='dm'), |
||
| 373 | {'739460', '734600'}) |
||
| 374 | self.assertEqual(dm_soundex('Peterson'), {'739460', '734600'}) |
||
| 375 | self.assertEqual(soundex('Moskowitz', var='dm'), {'645740'}) |
||
| 376 | self.assertEqual(dm_soundex('Moskowitz'), {'645740'}) |
||
| 377 | self.assertEqual(soundex('Moskovitz', var='dm'), {'645740'}) |
||
| 378 | self.assertEqual(dm_soundex('Moskovitz'), {'645740'}) |
||
| 379 | self.assertEqual(soundex('Auerbach', var='dm'), |
||
| 380 | {'097500', '097400'}) |
||
| 381 | self.assertEqual(dm_soundex('Auerbach'), {'097500', '097400'}) |
||
| 382 | self.assertEqual(soundex('Uhrbach', var='dm'), |
||
| 383 | {'097500', '097400'}) |
||
| 384 | self.assertEqual(dm_soundex('Uhrbach'), {'097500', '097400'}) |
||
| 385 | self.assertEqual(soundex('Jackson', var='dm'), |
||
| 386 | {'154600', '454600', '145460', '445460'}) |
||
| 387 | self.assertEqual(dm_soundex('Jackson'), |
||
| 388 | {'154600', '454600', '145460', '445460'}) |
||
| 389 | self.assertEqual(soundex('Jackson-Jackson', var='dm'), |
||
| 390 | {'154654', '454654', '145465', '445465', |
||
| 391 | '154645', '454645', '145464', '445464', |
||
| 392 | '154644', '454644'}) |
||
| 393 | self.assertEqual(dm_soundex('Jackson-Jackson'), |
||
| 394 | {'154654', '454654', '145465', '445465', |
||
| 395 | '154645', '454645', '145464', '445464', |
||
| 396 | '154644', '454644'}) |
||
| 397 | |||
| 398 | # http://www.jewishgen.org/infofiles/soundex.html |
||
| 399 | self.assertEqual(soundex('OHRBACH', var='dm'), |
||
| 400 | {'097500', '097400'}) |
||
| 401 | self.assertEqual(dm_soundex('OHRBACH'), {'097500', '097400'}) |
||
| 402 | self.assertEqual(soundex('LIPSHITZ', var='dm'), {'874400'}) |
||
| 403 | self.assertEqual(dm_soundex('LIPSHITZ'), {'874400'}) |
||
| 404 | self.assertEqual(soundex('LIPPSZYC', var='dm'), |
||
| 405 | {'874400', '874500'}) |
||
| 406 | self.assertEqual(dm_soundex('LIPPSZYC'), {'874400', '874500'}) |
||
| 407 | self.assertEqual(soundex('LEWINSKY', var='dm'), {'876450'}) |
||
| 408 | self.assertEqual(dm_soundex('LEWINSKY'), {'876450'}) |
||
| 409 | self.assertEqual(soundex('LEVINSKI', var='dm'), {'876450'}) |
||
| 410 | self.assertEqual(dm_soundex('LEVINSKI'), {'876450'}) |
||
| 411 | self.assertEqual(soundex('SZLAMAWICZ', var='dm'), {'486740'}) |
||
| 412 | self.assertEqual(dm_soundex('SZLAMAWICZ'), {'486740'}) |
||
| 413 | self.assertEqual(soundex('SHLAMOVITZ', var='dm'), {'486740'}) |
||
| 414 | self.assertEqual(dm_soundex('SHLAMOVITZ'), {'486740'}) |
||
| 415 | |||
| 416 | # http://community.actian.com/wiki/OME_soundex_dm() |
||
| 417 | self.assertEqual(soundex('Schwarzenegger', var='dm'), |
||
| 418 | {'479465', '474659'}) |
||
| 419 | self.assertEqual(dm_soundex('Schwarzenegger'), |
||
| 420 | {'479465', '474659'}) |
||
| 421 | self.assertEqual(soundex('Shwarzenegger', var='dm'), |
||
| 422 | {'479465', '474659'}) |
||
| 423 | self.assertEqual(dm_soundex('Shwarzenegger'), |
||
| 424 | {'479465', '474659'}) |
||
| 425 | self.assertEqual(soundex('Schwartsenegger', var='dm'), |
||
| 426 | {'479465'}) |
||
| 427 | self.assertEqual(dm_soundex('Schwartsenegger'), {'479465'}) |
||
| 428 | |||
| 429 | # reverse DM-Soundex |
||
| 430 | self.assertEqual(soundex('Schwarzenegger', var='dm', reverse=True), |
||
| 431 | {'956497'}) |
||
| 432 | self.assertEqual(dm_soundex('Schwarzenegger', reverse=True), |
||
| 433 | {'956497'}) |
||
| 434 | |||
| 435 | # maxlength bounds tests |
||
| 436 | self.assertEqual(dm_soundex('Niall', maxlength=float('inf')), |
||
| 437 | {'68'+'0'*62}) |
||
| 438 | self.assertEqual(dm_soundex('Niall', maxlength=None), |
||
| 439 | {'68'+'0'*62}) |
||
| 440 | self.assertEqual(dm_soundex('Niall', maxlength=0), {'680000'}) |
||
| 441 | |||
| 442 | # zero_pad tests |
||
| 443 | self.assertEqual(dm_soundex('Niall', maxlength=float('inf'), |
||
| 444 | zero_pad=False), {'68'}) |
||
| 445 | self.assertEqual(dm_soundex('Niall', maxlength=None, zero_pad=False), |
||
| 446 | {'68'}) |
||
| 447 | self.assertEqual(dm_soundex('Niall', maxlength=0, zero_pad=False), |
||
| 448 | {'68'}) |
||
| 449 | self.assertEqual(dm_soundex('Niall', maxlength=0, zero_pad=True), |
||
| 450 | {'680000'}) |
||
| 451 | self.assertEqual(dm_soundex('', maxlength=6, zero_pad=False), |
||
| 452 | {'0'}) |
||
| 453 | self.assertEqual(dm_soundex('', maxlength=6, zero_pad=True), |
||
| 454 | {'000000'}) |
||
| 455 | |||
| 456 | |||
| 457 | class KoelnerPhonetikTestCases(unittest.TestCase): |
||
| 458 | """Test Koelner Phonetic functions. |
||
| 459 | |||
| 460 | test cases for abydos.phonetic.koelner_phonetik, |
||
| 461 | .koelner_phonetik_num_to_alpha, & .koelner_phonetik_alpha |
||
| 462 | """ |
||
| 463 | |||
| 464 | def test_koelner_phonetik(self): |
||
| 465 | """Test abydos.phonetic.koelner_phonetik.""" |
||
| 466 | self.assertEqual(koelner_phonetik(''), '') |
||
| 467 | |||
| 468 | # https://de.wikipedia.org/wiki/K%C3%B6lner_Phonetik |
||
| 469 | self.assertEqual(koelner_phonetik('Müller-Lüdenscheidt'), '65752682') |
||
| 470 | self.assertEqual(koelner_phonetik('Wikipedia'), '3412') |
||
| 471 | self.assertEqual(koelner_phonetik('Breschnew'), '17863') |
||
| 472 | |||
| 473 | # http://search.cpan.org/~maros/Text-Phonetic/lib/Text/Phonetic/Koeln.pm |
||
| 474 | self.assertEqual(koelner_phonetik('Müller'), '657') |
||
| 475 | self.assertEqual(koelner_phonetik('schmidt'), '862') |
||
| 476 | self.assertEqual(koelner_phonetik('schneider'), '8627') |
||
| 477 | self.assertEqual(koelner_phonetik('fischer'), '387') |
||
| 478 | self.assertEqual(koelner_phonetik('weber'), '317') |
||
| 479 | self.assertEqual(koelner_phonetik('meyer'), '67') |
||
| 480 | self.assertEqual(koelner_phonetik('wagner'), '3467') |
||
| 481 | self.assertEqual(koelner_phonetik('schulz'), '858') |
||
| 482 | self.assertEqual(koelner_phonetik('becker'), '147') |
||
| 483 | self.assertEqual(koelner_phonetik('hoffmann'), '0366') |
||
| 484 | self.assertEqual(koelner_phonetik('schäfer'), '837') |
||
| 485 | self.assertEqual(koelner_phonetik('cater'), '427') |
||
| 486 | self.assertEqual(koelner_phonetik('axel'), '0485') |
||
| 487 | |||
| 488 | # etc. (for code coverage) |
||
| 489 | self.assertEqual(koelner_phonetik('Akxel'), '0485') |
||
| 490 | self.assertEqual(koelner_phonetik('Adz'), '08') |
||
| 491 | self.assertEqual(koelner_phonetik('Alpharades'), '053728') |
||
| 492 | self.assertEqual(koelner_phonetik('Cent'), '862') |
||
| 493 | self.assertEqual(koelner_phonetik('Acre'), '087') |
||
| 494 | self.assertEqual(koelner_phonetik('H'), '') |
||
| 495 | |||
| 496 | def test_koelner_phonetik_n2a(self): |
||
| 497 | """Test abydos.phonetic.koelner_phonetik_num_to_alpha.""" |
||
| 498 | self.assertEqual(koelner_phonetik_num_to_alpha('0123456789'), |
||
| 499 | 'APTFKLNRS') |
||
| 500 | |||
| 501 | def test_koelner_phonetik_alpha(self): |
||
| 502 | """Test abydos.phonetic.koelner_phonetik_alpha.""" |
||
| 503 | self.assertEqual(koelner_phonetik_alpha('Müller-Lüdenscheidt'), |
||
| 504 | 'NLRLTNST') |
||
| 505 | self.assertEqual(koelner_phonetik_alpha('Wikipedia'), 'FKPT') |
||
| 506 | self.assertEqual(koelner_phonetik_alpha('Breschnew'), 'PRSNF') |
||
| 507 | self.assertEqual(koelner_phonetik_alpha('Müller'), 'NLR') |
||
| 508 | self.assertEqual(koelner_phonetik_alpha('schmidt'), 'SNT') |
||
| 509 | self.assertEqual(koelner_phonetik_alpha('schneider'), 'SNTR') |
||
| 510 | self.assertEqual(koelner_phonetik_alpha('fischer'), 'FSR') |
||
| 511 | self.assertEqual(koelner_phonetik_alpha('weber'), 'FPR') |
||
| 512 | self.assertEqual(koelner_phonetik_alpha('meyer'), 'NR') |
||
| 513 | self.assertEqual(koelner_phonetik_alpha('wagner'), 'FKNR') |
||
| 514 | self.assertEqual(koelner_phonetik_alpha('schulz'), 'SLS') |
||
| 515 | self.assertEqual(koelner_phonetik_alpha('becker'), 'PKR') |
||
| 516 | self.assertEqual(koelner_phonetik_alpha('hoffmann'), 'AFNN') |
||
| 517 | self.assertEqual(koelner_phonetik_alpha('schäfer'), 'SFR') |
||
| 518 | self.assertEqual(koelner_phonetik_alpha('cater'), 'KTR') |
||
| 519 | self.assertEqual(koelner_phonetik_alpha('axel'), 'AKSL') |
||
| 520 | |||
| 521 | |||
| 522 | class NysiisTestCases(unittest.TestCase): |
||
| 523 | """Test NYSIIS functions. |
||
| 524 | |||
| 525 | test cases for abydos.phonetic.nysiis |
||
| 526 | """ |
||
| 527 | |||
| 528 | def test_nysiis(self): |
||
| 529 | """Test abydos.phonetic.nysiis.""" |
||
| 530 | self.assertEqual(nysiis(''), '') |
||
| 531 | |||
| 532 | # http://coryodaniel.com/index.php/2009/12/30/ruby-nysiis-implementation/ |
||
| 533 | self.assertEqual(nysiis('O\'Daniel'), 'ODANAL') |
||
| 534 | self.assertEqual(nysiis('O\'Donnel'), 'ODANAL') |
||
| 535 | self.assertEqual(nysiis('Cory'), 'CARY') |
||
| 536 | self.assertEqual(nysiis('Corey'), 'CARY') |
||
| 537 | self.assertEqual(nysiis('Kory'), 'CARY') |
||
| 538 | |||
| 539 | # http://ntz-develop.blogspot.com/2011/03/phonetic-algorithms.html |
||
| 540 | self.assertEqual(nysiis('Diggell'), 'DAGAL') |
||
| 541 | self.assertEqual(nysiis('Dougal'), 'DAGAL') |
||
| 542 | self.assertEqual(nysiis('Doughill'), 'DAGAL') |
||
| 543 | self.assertEqual(nysiis('Dougill'), 'DAGAL') |
||
| 544 | self.assertEqual(nysiis('Dowgill'), 'DAGAL') |
||
| 545 | self.assertEqual(nysiis('Dugall'), 'DAGAL') |
||
| 546 | self.assertEqual(nysiis('Dugall'), 'DAGAL') |
||
| 547 | self.assertEqual(nysiis('Glinde'), 'GLAND') |
||
| 548 | self.assertEqual(nysiis('Plumridge', maxlength=20), 'PLANRADG') |
||
| 549 | self.assertEqual(nysiis('Chinnick'), 'CANAC') |
||
| 550 | self.assertEqual(nysiis('Chinnock'), 'CANAC') |
||
| 551 | self.assertEqual(nysiis('Chinnock'), 'CANAC') |
||
| 552 | self.assertEqual(nysiis('Chomicki'), 'CANAC') |
||
| 553 | self.assertEqual(nysiis('Chomicz'), 'CANAC') |
||
| 554 | self.assertEqual(nysiis('Schimek'), 'SANAC') |
||
| 555 | self.assertEqual(nysiis('Shimuk'), 'SANAC') |
||
| 556 | self.assertEqual(nysiis('Simak'), 'SANAC') |
||
| 557 | self.assertEqual(nysiis('Simek'), 'SANAC') |
||
| 558 | self.assertEqual(nysiis('Simic'), 'SANAC') |
||
| 559 | self.assertEqual(nysiis('Sinnock'), 'SANAC') |
||
| 560 | self.assertEqual(nysiis('Sinnocke'), 'SANAC') |
||
| 561 | self.assertEqual(nysiis('Sunnex'), 'SANAX') |
||
| 562 | self.assertEqual(nysiis('Sunnucks'), 'SANAC') |
||
| 563 | self.assertEqual(nysiis('Sunock'), 'SANAC') |
||
| 564 | self.assertEqual(nysiis('Webberley', maxlength=20), 'WABARLY') |
||
| 565 | self.assertEqual(nysiis('Wibberley', maxlength=20), 'WABARLY') |
||
| 566 | |||
| 567 | # etc. (for code coverage) |
||
| 568 | self.assertEqual(nysiis('Alpharades'), 'ALFARA') |
||
| 569 | self.assertEqual(nysiis('Aschenputtel'), 'ASANPA') |
||
| 570 | self.assertEqual(nysiis('Beverly'), 'BAFARL') |
||
| 571 | self.assertEqual(nysiis('Hardt'), 'HARD') |
||
| 572 | self.assertEqual(nysiis('acknowledge'), 'ACNALA') |
||
| 573 | self.assertEqual(nysiis('MacNeill'), 'MCNAL') |
||
| 574 | self.assertEqual(nysiis('MacNeill'), nysiis('McNeill')) |
||
| 575 | self.assertEqual(nysiis('Knight'), 'NAGT') |
||
| 576 | self.assertEqual(nysiis('Knight'), nysiis('Night')) |
||
| 577 | self.assertEqual(nysiis('Pfarr'), 'FAR') |
||
| 578 | self.assertEqual(nysiis('Phair'), 'FAR') |
||
| 579 | self.assertEqual(nysiis('Phair'), nysiis('Pfarr')) |
||
| 580 | self.assertEqual(nysiis('Cherokee'), 'CARACY') |
||
| 581 | self.assertEqual(nysiis('Iraq'), 'IRAG') |
||
| 582 | |||
| 583 | # maxlength bounds tests |
||
| 584 | self.assertEqual(nysiis('Niall', maxlength=float('inf')), 'NAL') |
||
| 585 | self.assertEqual(nysiis('Niall', maxlength=None), 'NAL') |
||
| 586 | self.assertEqual(nysiis('Niall', maxlength=0), 'NAL') |
||
| 587 | |||
| 588 | def test_modified_nysiis(self): |
||
| 589 | """Test abydos.phonetic.nysiis (modified version).""" |
||
| 590 | self.assertEqual(nysiis('', maxlength=float('inf'), modified=True), '') |
||
| 591 | |||
| 592 | # https://naldc.nal.usda.gov/download/27833/PDF |
||
| 593 | # Some of these were... wrong... and have been corrected |
||
| 594 | self.assertEqual(nysiis('Daves', maxlength=8, modified=True), 'DAV') |
||
| 595 | self.assertEqual(nysiis('Davies', maxlength=8, modified=True), 'DAVY') |
||
| 596 | self.assertEqual(nysiis('Devies', maxlength=8, modified=True), 'DAFY') |
||
| 597 | self.assertEqual(nysiis('Divish', maxlength=8, modified=True), 'DAVAS') |
||
| 598 | self.assertEqual(nysiis('Dove', maxlength=8, modified=True), 'DAV') |
||
| 599 | self.assertEqual(nysiis('Devese', maxlength=8, modified=True), 'DAFAS') |
||
| 600 | self.assertEqual(nysiis('Devies', maxlength=8, modified=True), 'DAFY') |
||
| 601 | self.assertEqual(nysiis('Devos', maxlength=8, modified=True), 'DAF') |
||
| 602 | |||
| 603 | self.assertEqual(nysiis('Schmit', maxlength=8, modified=True), 'SNAT') |
||
| 604 | self.assertEqual(nysiis('Schmitt', maxlength=8, modified=True), 'SNAT') |
||
| 605 | self.assertEqual(nysiis('Schmitz', maxlength=8, modified=True), 'SNAT') |
||
| 606 | self.assertEqual(nysiis('Schmoutz', maxlength=8, modified=True), |
||
| 607 | 'SNAT') |
||
| 608 | self.assertEqual(nysiis('Schnitt', maxlength=8, modified=True), 'SNAT') |
||
| 609 | self.assertEqual(nysiis('Smit', maxlength=8, modified=True), 'SNAT') |
||
| 610 | self.assertEqual(nysiis('Smite', maxlength=8, modified=True), 'SNAT') |
||
| 611 | self.assertEqual(nysiis('Smits', maxlength=8, modified=True), 'SNAT') |
||
| 612 | self.assertEqual(nysiis('Smoot', maxlength=8, modified=True), 'SNAT') |
||
| 613 | self.assertEqual(nysiis('Smuts', maxlength=8, modified=True), 'SNAT') |
||
| 614 | self.assertEqual(nysiis('Sneath', maxlength=8, modified=True), 'SNAT') |
||
| 615 | self.assertEqual(nysiis('Smyth', maxlength=8, modified=True), 'SNAT') |
||
| 616 | self.assertEqual(nysiis('Smithy', maxlength=8, modified=True), 'SNATY') |
||
| 617 | self.assertEqual(nysiis('Smithey', maxlength=8, modified=True), |
||
| 618 | 'SNATY') |
||
| 619 | |||
| 620 | # http://www.dropby.com/NYSIISTextStrings.html |
||
| 621 | # Some of these have been altered since the above uses a different set |
||
| 622 | # of modifications. |
||
| 623 | self.assertEqual(nysiis('Edwards', maxlength=8, modified=True), |
||
| 624 | 'EDWAD') |
||
| 625 | self.assertEqual(nysiis('Perez', maxlength=8, modified=True), 'PAR') |
||
| 626 | self.assertEqual(nysiis('Macintosh', maxlength=8, modified=True), |
||
| 627 | 'MCANTAS') |
||
| 628 | self.assertEqual(nysiis('Phillipson', maxlength=8, modified=True), |
||
| 629 | 'FALAPSAN') |
||
| 630 | self.assertEqual(nysiis('Haddix', maxlength=8, modified=True), 'HADAC') |
||
| 631 | self.assertEqual(nysiis('Essex', maxlength=8, modified=True), 'ESAC') |
||
| 632 | self.assertEqual(nysiis('Moye', maxlength=8, modified=True), 'MY') |
||
| 633 | self.assertEqual(nysiis('McKee', maxlength=8, modified=True), 'MCY') |
||
| 634 | self.assertEqual(nysiis('Mackie', maxlength=8, modified=True), 'MCY') |
||
| 635 | self.assertEqual(nysiis('Heitschmidt', maxlength=8, modified=True), |
||
| 636 | 'HATSNAD') |
||
| 637 | self.assertEqual(nysiis('Bart', maxlength=8, modified=True), 'BAD') |
||
| 638 | self.assertEqual(nysiis('Hurd', maxlength=8, modified=True), 'HAD') |
||
| 639 | self.assertEqual(nysiis('Hunt', maxlength=8, modified=True), 'HAN') |
||
| 640 | self.assertEqual(nysiis('Westerlund', maxlength=8, modified=True), |
||
| 641 | 'WASTARLA') |
||
| 642 | self.assertEqual(nysiis('Evers', maxlength=8, modified=True), 'EVAR') |
||
| 643 | self.assertEqual(nysiis('Devito', maxlength=8, modified=True), 'DAFAT') |
||
| 644 | self.assertEqual(nysiis('Rawson', maxlength=8, modified=True), 'RASAN') |
||
| 645 | self.assertEqual(nysiis('Shoulders', maxlength=8, modified=True), |
||
| 646 | 'SALDAR') |
||
| 647 | self.assertEqual(nysiis('Leighton', maxlength=8, modified=True), |
||
| 648 | 'LATAN') |
||
| 649 | self.assertEqual(nysiis('Wooldridge', maxlength=8, modified=True), |
||
| 650 | 'WALDRAG') |
||
| 651 | self.assertEqual(nysiis('Oliphant', maxlength=8, modified=True), |
||
| 652 | 'OLAFAN') |
||
| 653 | self.assertEqual(nysiis('Hatchett', maxlength=8, modified=True), |
||
| 654 | 'HATCAT') |
||
| 655 | self.assertEqual(nysiis('McKnight', maxlength=8, modified=True), |
||
| 656 | 'MCNAT') |
||
| 657 | self.assertEqual(nysiis('Rickert', maxlength=8, modified=True), |
||
| 658 | 'RACAD') |
||
| 659 | self.assertEqual(nysiis('Bowman', maxlength=8, modified=True), 'BANAN') |
||
| 660 | self.assertEqual(nysiis('Vasquez', maxlength=8, modified=True), 'VASG') |
||
| 661 | self.assertEqual(nysiis('Bashaw', maxlength=8, modified=True), 'BAS') |
||
| 662 | self.assertEqual(nysiis('Schoenhoeft', maxlength=8, modified=True), |
||
| 663 | 'SANAFT') |
||
| 664 | self.assertEqual(nysiis('Heywood', maxlength=8, modified=True), 'HAD') |
||
| 665 | self.assertEqual(nysiis('Hayman', maxlength=8, modified=True), 'HANAN') |
||
| 666 | self.assertEqual(nysiis('Seawright', maxlength=8, modified=True), |
||
| 667 | 'SARAT') |
||
| 668 | self.assertEqual(nysiis('Kratzer', maxlength=8, modified=True), |
||
| 669 | 'CRATSAR') |
||
| 670 | self.assertEqual(nysiis('Canaday', maxlength=8, modified=True), |
||
| 671 | 'CANADY') |
||
| 672 | self.assertEqual(nysiis('Crepeau', maxlength=8, modified=True), 'CRAP') |
||
| 673 | |||
| 674 | # Additional tests from @Yomguithereal's talisman |
||
| 675 | # https://github.com/Yomguithereal/talisman/blob/master/test/phonetics/nysiis.js |
||
| 676 | self.assertEqual(nysiis('Andrew', maxlength=8, modified=True), 'ANDR') |
||
| 677 | self.assertEqual(nysiis('Robertson', maxlength=8, modified=True), |
||
| 678 | 'RABARTSA') |
||
| 679 | self.assertEqual(nysiis('Nolan', maxlength=8, modified=True), 'NALAN') |
||
| 680 | self.assertEqual(nysiis('Louis XVI', maxlength=8, modified=True), |
||
| 681 | 'LASXV') |
||
| 682 | self.assertEqual(nysiis('Case', maxlength=8, modified=True), 'CAS') |
||
| 683 | self.assertEqual(nysiis('Mclaughlin', maxlength=8, modified=True), |
||
| 684 | 'MCLAGLAN') |
||
| 685 | self.assertEqual(nysiis('Awale', maxlength=8, modified=True), 'AL') |
||
| 686 | self.assertEqual(nysiis('Aegir', maxlength=8, modified=True), 'AGAR') |
||
| 687 | self.assertEqual(nysiis('Lundgren', maxlength=8, modified=True), |
||
| 688 | 'LANGRAN') |
||
| 689 | self.assertEqual(nysiis('Philbert', maxlength=8, modified=True), |
||
| 690 | 'FALBAD') |
||
| 691 | self.assertEqual(nysiis('Harry', maxlength=8, modified=True), 'HARY') |
||
| 692 | self.assertEqual(nysiis('Mackenzie', maxlength=8, modified=True), |
||
| 693 | 'MCANSY') |
||
| 694 | |||
| 695 | # maxlength bounds tests |
||
| 696 | self.assertEqual(nysiis('Niall', maxlength=float('inf'), |
||
| 697 | modified=True), 'NAL') |
||
| 698 | self.assertEqual(nysiis('Niall', maxlength=None, modified=True), 'NAL') |
||
| 699 | self.assertEqual(nysiis('Niall', maxlength=0, modified=True), 'NAL') |
||
| 700 | |||
| 701 | |||
| 702 | class MraTestCases(unittest.TestCase): |
||
| 703 | """Test MRA functions. |
||
| 704 | |||
| 705 | test cases for abydos.phonetic.mra |
||
| 706 | """ |
||
| 707 | |||
| 708 | def test_mra(self): |
||
| 709 | """Test abydos.phonetic.mra.""" |
||
| 710 | self.assertEqual(mra(''), '') |
||
| 711 | |||
| 712 | # https://en.wikipedia.org/wiki/Match_rating_approach |
||
| 713 | self.assertEqual(mra('Byrne'), 'BYRN') |
||
| 714 | self.assertEqual(mra('Boern'), 'BRN') |
||
| 715 | self.assertEqual(mra('Smith'), 'SMTH') |
||
| 716 | self.assertEqual(mra('Smyth'), 'SMYTH') |
||
| 717 | self.assertEqual(mra('Catherine'), 'CTHRN') |
||
| 718 | self.assertEqual(mra('Kathryn'), 'KTHRYN') |
||
| 719 | |||
| 720 | |||
| 721 | class MetaphoneTestCases(unittest.TestCase): |
||
| 722 | """Test Metaphone functions. |
||
| 723 | |||
| 724 | test cases for abydos.phonetic.metaphone |
||
| 725 | """ |
||
| 726 | |||
| 727 | def test_metaphone(self): |
||
| 728 | """Test abydos.phonetic.metaphone.""" |
||
| 729 | self.assertEqual(metaphone(''), '') |
||
| 730 | self.assertEqual(metaphone('...'), '') |
||
| 731 | |||
| 732 | # http://ntz-develop.blogspot.com/2011/03/phonetic-algorithms.html |
||
| 733 | self.assertEqual(metaphone('Fishpool', 4), 'FXPL') |
||
| 734 | self.assertEqual(metaphone('Fishpoole', 4), 'FXPL') |
||
| 735 | self.assertEqual(metaphone('Gellately', 4), 'JLTL') |
||
| 736 | self.assertEqual(metaphone('Gelletly', 4), 'JLTL') |
||
| 737 | self.assertEqual(metaphone('Lowers', 4), 'LWRS') |
||
| 738 | self.assertEqual(metaphone('Lowerson', 4), 'LWRS') |
||
| 739 | self.assertEqual(metaphone('Mallabar', 4), 'MLBR') |
||
| 740 | self.assertEqual(metaphone('Melbert', 4), 'MLBR') |
||
| 741 | self.assertEqual(metaphone('Melbourn', 4), 'MLBR') |
||
| 742 | self.assertEqual(metaphone('Melbourne', 4), 'MLBR') |
||
| 743 | self.assertEqual(metaphone('Melburg', 4), 'MLBR') |
||
| 744 | self.assertEqual(metaphone('Melbury', 4), 'MLBR') |
||
| 745 | self.assertEqual(metaphone('Milberry', 4), 'MLBR') |
||
| 746 | self.assertEqual(metaphone('Milborn', 4), 'MLBR') |
||
| 747 | self.assertEqual(metaphone('Milbourn', 4), 'MLBR') |
||
| 748 | self.assertEqual(metaphone('Milbourne', 4), 'MLBR') |
||
| 749 | self.assertEqual(metaphone('Milburn', 4), 'MLBR') |
||
| 750 | self.assertEqual(metaphone('Milburne', 4), 'MLBR') |
||
| 751 | self.assertEqual(metaphone('Millberg', 4), 'MLBR') |
||
| 752 | self.assertEqual(metaphone('Mulberry', 4), 'MLBR') |
||
| 753 | self.assertEqual(metaphone('Mulbery', 4), 'MLBR') |
||
| 754 | self.assertEqual(metaphone('Mulbry', 4), 'MLBR') |
||
| 755 | self.assertEqual(metaphone('Saipy', 4), 'SP') |
||
| 756 | self.assertEqual(metaphone('Sapey', 4), 'SP') |
||
| 757 | self.assertEqual(metaphone('Sapp', 4), 'SP') |
||
| 758 | self.assertEqual(metaphone('Sappy', 4), 'SP') |
||
| 759 | self.assertEqual(metaphone('Sepey', 4), 'SP') |
||
| 760 | self.assertEqual(metaphone('Seppey', 4), 'SP') |
||
| 761 | self.assertEqual(metaphone('Sopp', 4), 'SP') |
||
| 762 | self.assertEqual(metaphone('Zoppie', 4), 'SP') |
||
| 763 | self.assertEqual(metaphone('Zoppo', 4), 'SP') |
||
| 764 | self.assertEqual(metaphone('Zupa', 4), 'SP') |
||
| 765 | self.assertEqual(metaphone('Zupo', 4), 'SP') |
||
| 766 | self.assertEqual(metaphone('Zuppa', 4), 'SP') |
||
| 767 | |||
| 768 | # assorted tests to complete code coverage |
||
| 769 | self.assertEqual(metaphone('Xavier'), 'SFR') |
||
| 770 | self.assertEqual(metaphone('Acacia'), 'AKX') |
||
| 771 | self.assertEqual(metaphone('Schuler'), 'SKLR') |
||
| 772 | self.assertEqual(metaphone('Sign'), 'SN') |
||
| 773 | self.assertEqual(metaphone('Signed'), 'SNT') |
||
| 774 | self.assertEqual(metaphone('Horatio'), 'HRX') |
||
| 775 | self.assertEqual(metaphone('Ignatio'), 'IKNX') |
||
| 776 | self.assertEqual(metaphone('Lucretia'), 'LKRX') |
||
| 777 | |||
| 778 | # assorted tests to complete branch coverage |
||
| 779 | self.assertEqual(metaphone('Lamb'), 'LM') |
||
| 780 | self.assertEqual(metaphone('science'), 'SNS') |
||
| 781 | |||
| 782 | # maxlength bounds tests |
||
| 783 | self.assertEqual(metaphone('Niall', maxlength=float('inf')), 'NL') |
||
| 784 | self.assertEqual(metaphone('Niall', maxlength=None), 'NL') |
||
| 785 | self.assertEqual(metaphone('Niall', maxlength=0), 'NL') |
||
| 786 | |||
| 787 | |||
| 788 | class DoubleMetaphoneTestCases(unittest.TestCase): |
||
| 789 | """Test Double Metaphone functions. |
||
| 790 | |||
| 791 | test cases for abydos.phonetic.double_metaphone |
||
| 792 | |||
| 793 | These test cases are copied from two sources: |
||
| 794 | https://github.com/oubiwann/metaphone/blob/master/metaphone/tests/test_metaphone.py |
||
| 795 | and |
||
| 796 | http://swoodbridge.com/DoubleMetaPhone/surnames.txt |
||
| 797 | |||
| 798 | Most test cases other than those in test_surnames and test_surnames4 come |
||
| 799 | from the former and are under the following license: |
||
| 800 | |||
| 801 | Copyright (c) 2007 Andrew Collins, Chris Leong |
||
| 802 | Copyright (c) 2009 Matthew Somerville |
||
| 803 | Copyright (c) 2010 Maximillian Dornseif, Richard Barran |
||
| 804 | Copyright (c) 2012 Duncan McGreggor |
||
| 805 | All rights reserved. |
||
| 806 | |||
| 807 | * Redistribution and use in source and binary forms, with or without |
||
| 808 | modification, are permitted provided that the following conditions |
||
| 809 | are met: |
||
| 810 | |||
| 811 | * Redistributions of source code must retain the above copyright |
||
| 812 | notice, this list of conditions and the following disclaimer. |
||
| 813 | |||
| 814 | * Redistributions in binary form must reproduce the above copyright |
||
| 815 | notice, this list of conditions and the following disclaimer in |
||
| 816 | the documentation and/or other materials provided with the |
||
| 817 | distribution. |
||
| 818 | |||
| 819 | Neither the name "Metaphone" nor the names of its contributors may be |
||
| 820 | used to endorse or promote products derived from this software without |
||
| 821 | specific prior written permission. |
||
| 822 | |||
| 823 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
||
| 824 | "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
||
| 825 | LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
||
| 826 | A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
||
| 827 | HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
||
| 828 | SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
||
| 829 | LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
||
| 830 | DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
||
| 831 | THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
||
| 832 | (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
||
| 833 | OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
||
| 834 | |||
| 835 | test_surname and test_surname4 come from a set of tests for a PHP port |
||
| 836 | of Double Metaphone that is Copyright 2001, Stephen Woodbridge and |
||
| 837 | identified as 'freely distributable' |
||
| 838 | """ |
||
| 839 | |||
| 840 | def test_double_metaphone(self): |
||
| 841 | """Test abydos.phonetic.double_metaphone.""" |
||
| 842 | # base case |
||
| 843 | self.assertEqual(double_metaphone(''), ('', '')) |
||
| 844 | |||
| 845 | # single result |
||
| 846 | self.assertEqual(double_metaphone('aubrey'), ('APR', '')) |
||
| 847 | |||
| 848 | # double result |
||
| 849 | self.assertEqual(double_metaphone('richard'), ('RXRT', 'RKRT')) |
||
| 850 | |||
| 851 | # general word list |
||
| 852 | self.assertEqual(double_metaphone('Jose'), ('HS', '')) |
||
| 853 | self.assertEqual(double_metaphone('cambrillo'), ('KMPRL', 'KMPR')) |
||
| 854 | self.assertEqual(double_metaphone('otto'), ('AT', '')) |
||
| 855 | self.assertEqual(double_metaphone('aubrey'), ('APR', '')) |
||
| 856 | self.assertEqual(double_metaphone('maurice'), ('MRS', '')) |
||
| 857 | self.assertEqual(double_metaphone('auto'), ('AT', '')) |
||
| 858 | self.assertEqual(double_metaphone('maisey'), ('MS', '')) |
||
| 859 | self.assertEqual(double_metaphone('catherine'), ('K0RN', 'KTRN')) |
||
| 860 | self.assertEqual(double_metaphone('geoff'), ('JF', 'KF')) |
||
| 861 | self.assertEqual(double_metaphone('Chile'), ('XL', '')) |
||
| 862 | self.assertEqual(double_metaphone('katherine'), ('K0RN', 'KTRN')) |
||
| 863 | self.assertEqual(double_metaphone('steven'), ('STFN', '')) |
||
| 864 | self.assertEqual(double_metaphone('zhang'), ('JNK', '')) |
||
| 865 | self.assertEqual(double_metaphone('bob'), ('PP', '')) |
||
| 866 | self.assertEqual(double_metaphone('ray'), ('R', '')) |
||
| 867 | self.assertEqual(double_metaphone('Tux'), ('TKS', '')) |
||
| 868 | self.assertEqual(double_metaphone('bryan'), ('PRN', '')) |
||
| 869 | self.assertEqual(double_metaphone('bryce'), ('PRS', '')) |
||
| 870 | self.assertEqual(double_metaphone('Rapelje'), ('RPL', '')) |
||
| 871 | self.assertEqual(double_metaphone('richard'), ('RXRT', 'RKRT')) |
||
| 872 | self.assertEqual(double_metaphone('solilijs'), ('SLLS', '')) |
||
| 873 | self.assertEqual(double_metaphone('Dallas'), ('TLS', '')) |
||
| 874 | self.assertEqual(double_metaphone('Schwein'), ('XN', 'XFN')) |
||
| 875 | self.assertEqual(double_metaphone('dave'), ('TF', '')) |
||
| 876 | self.assertEqual(double_metaphone('eric'), ('ARK', '')) |
||
| 877 | self.assertEqual(double_metaphone('Parachute'), ('PRKT', '')) |
||
| 878 | self.assertEqual(double_metaphone('brian'), ('PRN', '')) |
||
| 879 | self.assertEqual(double_metaphone('randy'), ('RNT', '')) |
||
| 880 | self.assertEqual(double_metaphone('Through'), ('0R', 'TR')) |
||
| 881 | self.assertEqual(double_metaphone('Nowhere'), ('NR', '')) |
||
| 882 | self.assertEqual(double_metaphone('heidi'), ('HT', '')) |
||
| 883 | self.assertEqual(double_metaphone('Arnow'), ('ARN', 'ARNF')) |
||
| 884 | self.assertEqual(double_metaphone('Thumbail'), ('0MPL', 'TMPL')) |
||
| 885 | |||
| 886 | # homophones |
||
| 887 | self.assertEqual(double_metaphone('tolled'), double_metaphone('told')) |
||
| 888 | self.assertEqual(double_metaphone('katherine'), |
||
| 889 | double_metaphone('catherine')) |
||
| 890 | self.assertEqual(double_metaphone('brian'), double_metaphone('bryan')) |
||
| 891 | |||
| 892 | # similar names |
||
| 893 | self.assertEqual(double_metaphone('Bartoš'), ('PRT', '')) |
||
| 894 | self.assertEqual(double_metaphone('Bartosz'), ('PRTS', 'PRTX')) |
||
| 895 | self.assertEqual(double_metaphone('Bartosch'), ('PRTX', '')) |
||
| 896 | self.assertEqual(double_metaphone('Bartos'), ('PRTS', '')) |
||
| 897 | self.assertEqual(list(set(double_metaphone('Jablonski')) |
||
| 898 | .intersection(double_metaphone('Yablonsky'))), |
||
| 899 | ['APLNSK']) |
||
| 900 | self.assertEqual(list(set(double_metaphone('Smith')) |
||
| 901 | .intersection(double_metaphone('Schmidt'))), |
||
| 902 | ['XMT']) |
||
| 903 | |||
| 904 | # non-English Unicode |
||
| 905 | self.assertEqual(double_metaphone('andestādītu'), ('ANTSTTT', '')) |
||
| 906 | |||
| 907 | # c-cedilla |
||
| 908 | self.assertEqual(double_metaphone('français'), ('FRNS', 'FRNSS')) |
||
| 909 | self.assertEqual(double_metaphone('garçon'), ('KRSN', '')) |
||
| 910 | self.assertEqual(double_metaphone('leçon'), ('LSN', '')) |
||
| 911 | |||
| 912 | # German words |
||
| 913 | self.assertEqual(double_metaphone('ach'), ('AK', '')) |
||
| 914 | self.assertEqual(double_metaphone('bacher'), ('PKR', '')) |
||
| 915 | self.assertEqual(double_metaphone('macher'), ('MKR', '')) |
||
| 916 | |||
| 917 | # Italian words |
||
| 918 | self.assertEqual(double_metaphone('bacci'), ('PX', '')) |
||
| 919 | self.assertEqual(double_metaphone('bertucci'), ('PRTX', '')) |
||
| 920 | self.assertEqual(double_metaphone('bellocchio'), ('PLX', '')) |
||
| 921 | self.assertEqual(double_metaphone('bacchus'), ('PKS', '')) |
||
| 922 | self.assertEqual(double_metaphone('focaccia'), ('FKX', '')) |
||
| 923 | self.assertEqual(double_metaphone('chianti'), ('KNT', '')) |
||
| 924 | self.assertEqual(double_metaphone('tagliaro'), ('TKLR', 'TLR')) |
||
| 925 | self.assertEqual(double_metaphone('biaggi'), ('PJ', 'PK')) |
||
| 926 | |||
| 927 | # Spanish words |
||
| 928 | self.assertEqual(double_metaphone('bajador'), ('PJTR', 'PHTR')) |
||
| 929 | self.assertEqual(double_metaphone('cabrillo'), ('KPRL', 'KPR')) |
||
| 930 | self.assertEqual(double_metaphone('gallegos'), ('KLKS', 'KKS')) |
||
| 931 | self.assertEqual(double_metaphone('San Jacinto'), ('SNHSNT', '')) |
||
| 932 | |||
| 933 | # French words |
||
| 934 | self.assertEqual(double_metaphone('rogier'), ('RJ', 'RJR')) |
||
| 935 | self.assertEqual(double_metaphone('breaux'), ('PR', '')) |
||
| 936 | |||
| 937 | # Slavic words |
||
| 938 | self.assertEqual(double_metaphone('Wewski'), ('ASK', 'FFSK')) |
||
| 939 | |||
| 940 | # Chinese words |
||
| 941 | self.assertEqual(double_metaphone('zhao'), ('J', '')) |
||
| 942 | |||
| 943 | # Dutch-origin words |
||
| 944 | self.assertEqual(double_metaphone('school'), ('SKL', '')) |
||
| 945 | self.assertEqual(double_metaphone('schooner'), ('SKNR', '')) |
||
| 946 | self.assertEqual(double_metaphone('schermerhorn'), |
||
| 947 | ('XRMRRN', 'SKRMRRN')) |
||
| 948 | self.assertEqual(double_metaphone('schenker'), ('XNKR', 'SKNKR')) |
||
| 949 | |||
| 950 | # <ch> words |
||
| 951 | self.assertEqual(double_metaphone('Charac'), ('KRK', '')) |
||
| 952 | self.assertEqual(double_metaphone('Charis'), ('KRS', '')) |
||
| 953 | self.assertEqual(double_metaphone('chord'), ('KRT', '')) |
||
| 954 | self.assertEqual(double_metaphone('Chym'), ('KM', '')) |
||
| 955 | self.assertEqual(double_metaphone('Chia'), ('K', '')) |
||
| 956 | self.assertEqual(double_metaphone('chem'), ('KM', '')) |
||
| 957 | self.assertEqual(double_metaphone('chore'), ('XR', '')) |
||
| 958 | self.assertEqual(double_metaphone('orchestra'), ('ARKSTR', '')) |
||
| 959 | self.assertEqual(double_metaphone('architect'), ('ARKTKT', '')) |
||
| 960 | self.assertEqual(double_metaphone('orchid'), ('ARKT', '')) |
||
| 961 | |||
| 962 | # <cc> words |
||
| 963 | self.assertEqual(double_metaphone('accident'), ('AKSTNT', '')) |
||
| 964 | self.assertEqual(double_metaphone('accede'), ('AKST', '')) |
||
| 965 | self.assertEqual(double_metaphone('succeed'), ('SKST', '')) |
||
| 966 | |||
| 967 | # <mc> words |
||
| 968 | self.assertEqual(double_metaphone('mac caffrey'), ('MKFR', '')) |
||
| 969 | self.assertEqual(double_metaphone('mac gregor'), ('MKRKR', '')) |
||
| 970 | self.assertEqual(double_metaphone('mc crae'), ('MKR', '')) |
||
| 971 | self.assertEqual(double_metaphone('mcclain'), ('MKLN', '')) |
||
| 972 | |||
| 973 | # <gh> words |
||
| 974 | self.assertEqual(double_metaphone('laugh'), ('LF', '')) |
||
| 975 | self.assertEqual(double_metaphone('cough'), ('KF', '')) |
||
| 976 | self.assertEqual(double_metaphone('rough'), ('RF', '')) |
||
| 977 | |||
| 978 | # <g__> words |
||
| 979 | self.assertEqual(double_metaphone('gya'), ('K', 'J')) |
||
| 980 | self.assertEqual(double_metaphone('ges'), ('KS', 'JS')) |
||
| 981 | self.assertEqual(double_metaphone('gep'), ('KP', 'JP')) |
||
| 982 | self.assertEqual(double_metaphone('geb'), ('KP', 'JP')) |
||
| 983 | self.assertEqual(double_metaphone('gel'), ('KL', 'JL')) |
||
| 984 | self.assertEqual(double_metaphone('gey'), ('K', 'J')) |
||
| 985 | self.assertEqual(double_metaphone('gib'), ('KP', 'JP')) |
||
| 986 | self.assertEqual(double_metaphone('gil'), ('KL', 'JL')) |
||
| 987 | self.assertEqual(double_metaphone('gin'), ('KN', 'JN')) |
||
| 988 | self.assertEqual(double_metaphone('gie'), ('K', 'J')) |
||
| 989 | self.assertEqual(double_metaphone('gei'), ('K', 'J')) |
||
| 990 | self.assertEqual(double_metaphone('ger'), ('KR', 'JR')) |
||
| 991 | self.assertEqual(double_metaphone('danger'), ('TNJR', 'TNKR')) |
||
| 992 | self.assertEqual(double_metaphone('manager'), ('MNKR', 'MNJR')) |
||
| 993 | self.assertEqual(double_metaphone('dowager'), ('TKR', 'TJR')) |
||
| 994 | |||
| 995 | # <pb> words |
||
| 996 | self.assertEqual(double_metaphone('Campbell'), ('KMPL', '')) |
||
| 997 | self.assertEqual(double_metaphone('raspberry'), ('RSPR', '')) |
||
| 998 | |||
| 999 | # <th> words |
||
| 1000 | self.assertEqual(double_metaphone('Thomas'), ('TMS', '')) |
||
| 1001 | self.assertEqual(double_metaphone('Thames'), ('TMS', '')) |
||
| 1002 | |||
| 1003 | # etc. (for code coverage) |
||
| 1004 | self.assertEqual(double_metaphone('Xavier'), ('SF', 'SFR')) |
||
| 1005 | self.assertEqual(double_metaphone('Michael'), ('MKL', 'MXL')) |
||
| 1006 | self.assertEqual(double_metaphone('Ignacio'), ('AKNS', 'ANX')) |
||
| 1007 | self.assertEqual(double_metaphone('Ajjam'), ('AJM', '')) |
||
| 1008 | self.assertEqual(double_metaphone('Akkad'), ('AKT', '')) |
||
| 1009 | self.assertEqual(double_metaphone('Año'), ('AN', '')) |
||
| 1010 | self.assertEqual(double_metaphone('Año'), double_metaphone('Anno')) |
||
| 1011 | self.assertEqual(double_metaphone('Caucasian'), ('KKSN', 'KKXN')) |
||
| 1012 | self.assertEqual(double_metaphone('Kaukasian'), ('KKSN', '')) |
||
| 1013 | self.assertEqual(double_metaphone('Zaqqum'), ('SKM', '')) |
||
| 1014 | self.assertEqual(double_metaphone('stevven'), ('STFN', '')) |
||
| 1015 | self.assertEqual(double_metaphone('Tuxx'), ('TKS', '')) |
||
| 1016 | self.assertEqual(double_metaphone('Ghiradelli'), ('JRTL', '')) |
||
| 1017 | self.assertEqual(double_metaphone('ghoul'), ('KL', '')) |
||
| 1018 | self.assertEqual(double_metaphone('hej'), ('HJ', 'H')) |
||
| 1019 | |||
| 1020 | # maxlength bounds tests |
||
| 1021 | self.assertEqual(double_metaphone('Niall', maxlength=float('inf')), |
||
| 1022 | ('NL', '')) |
||
| 1023 | self.assertEqual(double_metaphone('Niall', maxlength=None), ('NL', '')) |
||
| 1024 | self.assertEqual(double_metaphone('Niall', maxlength=0), ('NL', '')) |
||
| 1025 | |||
| 1026 | def test_double_metaphone_surnames(self): |
||
| 1027 | """Test abydos.phonetic.double_metaphone (surname data).""" |
||
| 1028 | self.assertEqual(double_metaphone(''), ('', '')) |
||
| 1029 | self.assertEqual(double_metaphone('ALLERTON'), ('ALRTN', '')) |
||
| 1030 | self.assertEqual(double_metaphone('Acton'), ('AKTN', '')) |
||
| 1031 | self.assertEqual(double_metaphone('Adams'), ('ATMS', '')) |
||
| 1032 | self.assertEqual(double_metaphone('Aggar'), ('AKR', '')) |
||
| 1033 | self.assertEqual(double_metaphone('Ahl'), ('AL', '')) |
||
| 1034 | self.assertEqual(double_metaphone('Aiken'), ('AKN', '')) |
||
| 1035 | self.assertEqual(double_metaphone('Alan'), ('ALN', '')) |
||
| 1036 | self.assertEqual(double_metaphone('Alcock'), ('ALKK', '')) |
||
| 1037 | self.assertEqual(double_metaphone('Alden'), ('ALTN', '')) |
||
| 1038 | self.assertEqual(double_metaphone('Aldham'), ('ALTM', '')) |
||
| 1039 | self.assertEqual(double_metaphone('Allen'), ('ALN', '')) |
||
| 1040 | self.assertEqual(double_metaphone('Allerton'), ('ALRTN', '')) |
||
| 1041 | self.assertEqual(double_metaphone('Alsop'), ('ALSP', '')) |
||
| 1042 | self.assertEqual(double_metaphone('Alwein'), ('ALN', '')) |
||
| 1043 | self.assertEqual(double_metaphone('Ambler'), ('AMPLR', '')) |
||
| 1044 | self.assertEqual(double_metaphone('Andevill'), ('ANTFL', '')) |
||
| 1045 | self.assertEqual(double_metaphone('Andrews'), ('ANTRS', '')) |
||
| 1046 | self.assertEqual(double_metaphone('Andreyco'), ('ANTRK', '')) |
||
| 1047 | self.assertEqual(double_metaphone('Andriesse'), ('ANTRS', '')) |
||
| 1048 | self.assertEqual(double_metaphone('Angier'), ('ANJ', 'ANJR')) |
||
| 1049 | self.assertEqual(double_metaphone('Annabel'), ('ANPL', '')) |
||
| 1050 | self.assertEqual(double_metaphone('Anne'), ('AN', '')) |
||
| 1051 | self.assertEqual(double_metaphone('Anstye'), ('ANST', '')) |
||
| 1052 | self.assertEqual(double_metaphone('Appling'), ('APLNK', '')) |
||
| 1053 | self.assertEqual(double_metaphone('Apuke'), ('APK', '')) |
||
| 1054 | self.assertEqual(double_metaphone('Arnold'), ('ARNLT', '')) |
||
| 1055 | self.assertEqual(double_metaphone('Ashby'), ('AXP', '')) |
||
| 1056 | self.assertEqual(double_metaphone('Astwood'), ('ASTT', '')) |
||
| 1057 | self.assertEqual(double_metaphone('Atkinson'), ('ATKNSN', '')) |
||
| 1058 | self.assertEqual(double_metaphone('Audley'), ('ATL', '')) |
||
| 1059 | self.assertEqual(double_metaphone('Austin'), ('ASTN', '')) |
||
| 1060 | self.assertEqual(double_metaphone('Avenal'), ('AFNL', '')) |
||
| 1061 | self.assertEqual(double_metaphone('Ayer'), ('AR', '')) |
||
| 1062 | self.assertEqual(double_metaphone('Ayot'), ('AT', '')) |
||
| 1063 | self.assertEqual(double_metaphone('Babbitt'), ('PPT', '')) |
||
| 1064 | self.assertEqual(double_metaphone('Bachelor'), ('PXLR', 'PKLR')) |
||
| 1065 | self.assertEqual(double_metaphone('Bachelour'), ('PXLR', 'PKLR')) |
||
| 1066 | self.assertEqual(double_metaphone('Bailey'), ('PL', '')) |
||
| 1067 | self.assertEqual(double_metaphone('Baivel'), ('PFL', '')) |
||
| 1068 | self.assertEqual(double_metaphone('Baker'), ('PKR', '')) |
||
| 1069 | self.assertEqual(double_metaphone('Baldwin'), ('PLTN', '')) |
||
| 1070 | self.assertEqual(double_metaphone('Balsley'), ('PLSL', '')) |
||
| 1071 | self.assertEqual(double_metaphone('Barber'), ('PRPR', '')) |
||
| 1072 | self.assertEqual(double_metaphone('Barker'), ('PRKR', '')) |
||
| 1073 | self.assertEqual(double_metaphone('Barlow'), ('PRL', 'PRLF')) |
||
| 1074 | self.assertEqual(double_metaphone('Barnard'), ('PRNRT', '')) |
||
| 1075 | self.assertEqual(double_metaphone('Barnes'), ('PRNS', '')) |
||
| 1076 | self.assertEqual(double_metaphone('Barnsley'), ('PRNSL', '')) |
||
| 1077 | self.assertEqual(double_metaphone('Barouxis'), ('PRKSS', '')) |
||
| 1078 | self.assertEqual(double_metaphone('Bartlet'), ('PRTLT', '')) |
||
| 1079 | self.assertEqual(double_metaphone('Basley'), ('PSL', '')) |
||
| 1080 | self.assertEqual(double_metaphone('Basset'), ('PST', '')) |
||
| 1081 | self.assertEqual(double_metaphone('Bassett'), ('PST', '')) |
||
| 1082 | self.assertEqual(double_metaphone('Batchlor'), ('PXLR', '')) |
||
| 1083 | self.assertEqual(double_metaphone('Bates'), ('PTS', '')) |
||
| 1084 | self.assertEqual(double_metaphone('Batson'), ('PTSN', '')) |
||
| 1085 | self.assertEqual(double_metaphone('Bayes'), ('PS', '')) |
||
| 1086 | self.assertEqual(double_metaphone('Bayley'), ('PL', '')) |
||
| 1087 | self.assertEqual(double_metaphone('Beale'), ('PL', '')) |
||
| 1088 | self.assertEqual(double_metaphone('Beauchamp'), ('PXMP', 'PKMP')) |
||
| 1089 | self.assertEqual(double_metaphone('Beauclerc'), ('PKLRK', '')) |
||
| 1090 | self.assertEqual(double_metaphone('Beech'), ('PK', '')) |
||
| 1091 | self.assertEqual(double_metaphone('Beers'), ('PRS', '')) |
||
| 1092 | self.assertEqual(double_metaphone('Beke'), ('PK', '')) |
||
| 1093 | self.assertEqual(double_metaphone('Belcher'), ('PLXR', 'PLKR')) |
||
| 1094 | self.assertEqual(double_metaphone('Benjamin'), ('PNJMN', '')) |
||
| 1095 | self.assertEqual(double_metaphone('Benningham'), ('PNNKM', '')) |
||
| 1096 | self.assertEqual(double_metaphone('Bereford'), ('PRFRT', '')) |
||
| 1097 | self.assertEqual(double_metaphone('Bergen'), ('PRJN', 'PRKN')) |
||
| 1098 | self.assertEqual(double_metaphone('Berkeley'), ('PRKL', '')) |
||
| 1099 | self.assertEqual(double_metaphone('Berry'), ('PR', '')) |
||
| 1100 | self.assertEqual(double_metaphone('Besse'), ('PS', '')) |
||
| 1101 | self.assertEqual(double_metaphone('Bessey'), ('PS', '')) |
||
| 1102 | self.assertEqual(double_metaphone('Bessiles'), ('PSLS', '')) |
||
| 1103 | self.assertEqual(double_metaphone('Bigelow'), ('PJL', 'PKLF')) |
||
| 1104 | self.assertEqual(double_metaphone('Bigg'), ('PK', '')) |
||
| 1105 | self.assertEqual(double_metaphone('Bigod'), ('PKT', '')) |
||
| 1106 | self.assertEqual(double_metaphone('Billings'), ('PLNKS', '')) |
||
| 1107 | self.assertEqual(double_metaphone('Bimper'), ('PMPR', '')) |
||
| 1108 | self.assertEqual(double_metaphone('Binker'), ('PNKR', '')) |
||
| 1109 | self.assertEqual(double_metaphone('Birdsill'), ('PRTSL', '')) |
||
| 1110 | self.assertEqual(double_metaphone('Bishop'), ('PXP', '')) |
||
| 1111 | self.assertEqual(double_metaphone('Black'), ('PLK', '')) |
||
| 1112 | self.assertEqual(double_metaphone('Blagge'), ('PLK', '')) |
||
| 1113 | self.assertEqual(double_metaphone('Blake'), ('PLK', '')) |
||
| 1114 | self.assertEqual(double_metaphone('Blanck'), ('PLNK', '')) |
||
| 1115 | self.assertEqual(double_metaphone('Bledsoe'), ('PLTS', '')) |
||
| 1116 | self.assertEqual(double_metaphone('Blennerhasset'), ('PLNRST', '')) |
||
| 1117 | self.assertEqual(double_metaphone('Blessing'), ('PLSNK', '')) |
||
| 1118 | self.assertEqual(double_metaphone('Blewett'), ('PLT', '')) |
||
| 1119 | self.assertEqual(double_metaphone('Bloctgoed'), ('PLKTKT', '')) |
||
| 1120 | self.assertEqual(double_metaphone('Bloetgoet'), ('PLTKT', '')) |
||
| 1121 | self.assertEqual(double_metaphone('Bloodgood'), ('PLTKT', '')) |
||
| 1122 | self.assertEqual(double_metaphone('Blossom'), ('PLSM', '')) |
||
| 1123 | self.assertEqual(double_metaphone('Blount'), ('PLNT', '')) |
||
| 1124 | self.assertEqual(double_metaphone('Bodine'), ('PTN', '')) |
||
| 1125 | self.assertEqual(double_metaphone('Bodman'), ('PTMN', '')) |
||
| 1126 | self.assertEqual(double_metaphone('BonCoeur'), ('PNKR', '')) |
||
| 1127 | self.assertEqual(double_metaphone('Bond'), ('PNT', '')) |
||
| 1128 | self.assertEqual(double_metaphone('Boscawen'), ('PSKN', '')) |
||
| 1129 | self.assertEqual(double_metaphone('Bosworth'), ('PSR0', 'PSRT')) |
||
| 1130 | self.assertEqual(double_metaphone('Bouchier'), ('PX', 'PKR')) |
||
| 1131 | self.assertEqual(double_metaphone('Bowne'), ('PN', '')) |
||
| 1132 | self.assertEqual(double_metaphone('Bradbury'), ('PRTPR', '')) |
||
| 1133 | self.assertEqual(double_metaphone('Bradder'), ('PRTR', '')) |
||
| 1134 | self.assertEqual(double_metaphone('Bradford'), ('PRTFRT', '')) |
||
| 1135 | self.assertEqual(double_metaphone('Bradstreet'), ('PRTSTRT', '')) |
||
| 1136 | self.assertEqual(double_metaphone('Braham'), ('PRHM', '')) |
||
| 1137 | self.assertEqual(double_metaphone('Brailsford'), ('PRLSFRT', '')) |
||
| 1138 | self.assertEqual(double_metaphone('Brainard'), ('PRNRT', '')) |
||
| 1139 | self.assertEqual(double_metaphone('Brandish'), ('PRNTX', '')) |
||
| 1140 | self.assertEqual(double_metaphone('Braun'), ('PRN', '')) |
||
| 1141 | self.assertEqual(double_metaphone('Brecc'), ('PRK', '')) |
||
| 1142 | self.assertEqual(double_metaphone('Brent'), ('PRNT', '')) |
||
| 1143 | self.assertEqual(double_metaphone('Brenton'), ('PRNTN', '')) |
||
| 1144 | self.assertEqual(double_metaphone('Briggs'), ('PRKS', '')) |
||
| 1145 | self.assertEqual(double_metaphone('Brigham'), ('PRM', '')) |
||
| 1146 | self.assertEqual(double_metaphone('Brobst'), ('PRPST', '')) |
||
| 1147 | self.assertEqual(double_metaphone('Brome'), ('PRM', '')) |
||
| 1148 | self.assertEqual(double_metaphone('Bronson'), ('PRNSN', '')) |
||
| 1149 | self.assertEqual(double_metaphone('Brooks'), ('PRKS', '')) |
||
| 1150 | self.assertEqual(double_metaphone('Brouillard'), ('PRLRT', '')) |
||
| 1151 | self.assertEqual(double_metaphone('Brown'), ('PRN', '')) |
||
| 1152 | self.assertEqual(double_metaphone('Browne'), ('PRN', '')) |
||
| 1153 | self.assertEqual(double_metaphone('Brownell'), ('PRNL', '')) |
||
| 1154 | self.assertEqual(double_metaphone('Bruley'), ('PRL', '')) |
||
| 1155 | self.assertEqual(double_metaphone('Bryant'), ('PRNT', '')) |
||
| 1156 | self.assertEqual(double_metaphone('Brzozowski'), |
||
| 1157 | ('PRSSSK', 'PRTSTSFSK')) |
||
| 1158 | self.assertEqual(double_metaphone('Buide'), ('PT', '')) |
||
| 1159 | self.assertEqual(double_metaphone('Bulmer'), ('PLMR', '')) |
||
| 1160 | self.assertEqual(double_metaphone('Bunker'), ('PNKR', '')) |
||
| 1161 | self.assertEqual(double_metaphone('Burden'), ('PRTN', '')) |
||
| 1162 | self.assertEqual(double_metaphone('Burge'), ('PRJ', 'PRK')) |
||
| 1163 | self.assertEqual(double_metaphone('Burgoyne'), ('PRKN', '')) |
||
| 1164 | self.assertEqual(double_metaphone('Burke'), ('PRK', '')) |
||
| 1165 | self.assertEqual(double_metaphone('Burnett'), ('PRNT', '')) |
||
| 1166 | self.assertEqual(double_metaphone('Burpee'), ('PRP', '')) |
||
| 1167 | self.assertEqual(double_metaphone('Bursley'), ('PRSL', '')) |
||
| 1168 | self.assertEqual(double_metaphone('Burton'), ('PRTN', '')) |
||
| 1169 | self.assertEqual(double_metaphone('Bushnell'), ('PXNL', '')) |
||
| 1170 | self.assertEqual(double_metaphone('Buss'), ('PS', '')) |
||
| 1171 | self.assertEqual(double_metaphone('Buswell'), ('PSL', '')) |
||
| 1172 | self.assertEqual(double_metaphone('Butler'), ('PTLR', '')) |
||
| 1173 | self.assertEqual(double_metaphone('Calkin'), ('KLKN', '')) |
||
| 1174 | self.assertEqual(double_metaphone('Canada'), ('KNT', '')) |
||
| 1175 | self.assertEqual(double_metaphone('Canmore'), ('KNMR', '')) |
||
| 1176 | self.assertEqual(double_metaphone('Canney'), ('KN', '')) |
||
| 1177 | self.assertEqual(double_metaphone('Capet'), ('KPT', '')) |
||
| 1178 | self.assertEqual(double_metaphone('Card'), ('KRT', '')) |
||
| 1179 | self.assertEqual(double_metaphone('Carman'), ('KRMN', '')) |
||
| 1180 | self.assertEqual(double_metaphone('Carpenter'), ('KRPNTR', '')) |
||
| 1181 | self.assertEqual(double_metaphone('Cartwright'), ('KRTRT', '')) |
||
| 1182 | self.assertEqual(double_metaphone('Casey'), ('KS', '')) |
||
| 1183 | self.assertEqual(double_metaphone('Catterfield'), ('KTRFLT', '')) |
||
| 1184 | self.assertEqual(double_metaphone('Ceeley'), ('SL', '')) |
||
| 1185 | self.assertEqual(double_metaphone('Chambers'), ('XMPRS', '')) |
||
| 1186 | self.assertEqual(double_metaphone('Champion'), ('XMPN', '')) |
||
| 1187 | self.assertEqual(double_metaphone('Chapman'), ('XPMN', '')) |
||
| 1188 | self.assertEqual(double_metaphone('Chase'), ('XS', '')) |
||
| 1189 | self.assertEqual(double_metaphone('Cheney'), ('XN', '')) |
||
| 1190 | self.assertEqual(double_metaphone('Chetwynd'), ('XTNT', '')) |
||
| 1191 | self.assertEqual(double_metaphone('Chevalier'), ('XFL', 'XFLR')) |
||
| 1192 | self.assertEqual(double_metaphone('Chillingsworth'), |
||
| 1193 | ('XLNKSR0', 'XLNKSRT')) |
||
| 1194 | self.assertEqual(double_metaphone('Christie'), ('KRST', '')) |
||
| 1195 | self.assertEqual(double_metaphone('Chubbuck'), ('XPK', '')) |
||
| 1196 | self.assertEqual(double_metaphone('Church'), ('XRX', 'XRK')) |
||
| 1197 | self.assertEqual(double_metaphone('Clark'), ('KLRK', '')) |
||
| 1198 | self.assertEqual(double_metaphone('Clarke'), ('KLRK', '')) |
||
| 1199 | self.assertEqual(double_metaphone('Cleare'), ('KLR', '')) |
||
| 1200 | self.assertEqual(double_metaphone('Clement'), ('KLMNT', '')) |
||
| 1201 | self.assertEqual(double_metaphone('Clerke'), ('KLRK', '')) |
||
| 1202 | self.assertEqual(double_metaphone('Clibben'), ('KLPN', '')) |
||
| 1203 | self.assertEqual(double_metaphone('Clifford'), ('KLFRT', '')) |
||
| 1204 | self.assertEqual(double_metaphone('Clivedon'), ('KLFTN', '')) |
||
| 1205 | self.assertEqual(double_metaphone('Close'), ('KLS', '')) |
||
| 1206 | self.assertEqual(double_metaphone('Clothilde'), ('KL0LT', 'KLTLT')) |
||
| 1207 | self.assertEqual(double_metaphone('Cobb'), ('KP', '')) |
||
| 1208 | self.assertEqual(double_metaphone('Coburn'), ('KPRN', '')) |
||
| 1209 | self.assertEqual(double_metaphone('Coburne'), ('KPRN', '')) |
||
| 1210 | self.assertEqual(double_metaphone('Cocke'), ('KK', '')) |
||
| 1211 | self.assertEqual(double_metaphone('Coffin'), ('KFN', '')) |
||
| 1212 | self.assertEqual(double_metaphone('Coffyn'), ('KFN', '')) |
||
| 1213 | self.assertEqual(double_metaphone('Colborne'), ('KLPRN', '')) |
||
| 1214 | self.assertEqual(double_metaphone('Colby'), ('KLP', '')) |
||
| 1215 | self.assertEqual(double_metaphone('Cole'), ('KL', '')) |
||
| 1216 | self.assertEqual(double_metaphone('Coleman'), ('KLMN', '')) |
||
| 1217 | self.assertEqual(double_metaphone('Collier'), ('KL', 'KLR')) |
||
| 1218 | self.assertEqual(double_metaphone('Compton'), ('KMPTN', '')) |
||
| 1219 | self.assertEqual(double_metaphone('Cone'), ('KN', '')) |
||
| 1220 | self.assertEqual(double_metaphone('Cook'), ('KK', '')) |
||
| 1221 | self.assertEqual(double_metaphone('Cooke'), ('KK', '')) |
||
| 1222 | self.assertEqual(double_metaphone('Cooper'), ('KPR', '')) |
||
| 1223 | self.assertEqual(double_metaphone('Copperthwaite'), ('KPR0T', 'KPRTT')) |
||
| 1224 | self.assertEqual(double_metaphone('Corbet'), ('KRPT', '')) |
||
| 1225 | self.assertEqual(double_metaphone('Corell'), ('KRL', '')) |
||
| 1226 | self.assertEqual(double_metaphone('Corey'), ('KR', '')) |
||
| 1227 | self.assertEqual(double_metaphone('Corlies'), ('KRLS', '')) |
||
| 1228 | self.assertEqual(double_metaphone('Corneliszen'), ('KRNLSN', 'KRNLXN')) |
||
| 1229 | self.assertEqual(double_metaphone('Cornelius'), ('KRNLS', '')) |
||
| 1230 | self.assertEqual(double_metaphone('Cornwallis'), ('KRNLS', '')) |
||
| 1231 | self.assertEqual(double_metaphone('Cosgrove'), ('KSKRF', '')) |
||
| 1232 | self.assertEqual(double_metaphone('Count of Brionne'), ('KNTFPRN', '')) |
||
| 1233 | self.assertEqual(double_metaphone('Covill'), ('KFL', '')) |
||
| 1234 | self.assertEqual(double_metaphone('Cowperthwaite'), ('KPR0T', 'KPRTT')) |
||
| 1235 | self.assertEqual(double_metaphone('Cowperwaite'), ('KPRT', '')) |
||
| 1236 | self.assertEqual(double_metaphone('Crane'), ('KRN', '')) |
||
| 1237 | self.assertEqual(double_metaphone('Creagmile'), ('KRKML', '')) |
||
| 1238 | self.assertEqual(double_metaphone('Crew'), ('KR', 'KRF')) |
||
| 1239 | self.assertEqual(double_metaphone('Crispin'), ('KRSPN', '')) |
||
| 1240 | self.assertEqual(double_metaphone('Crocker'), ('KRKR', '')) |
||
| 1241 | self.assertEqual(double_metaphone('Crockett'), ('KRKT', '')) |
||
| 1242 | self.assertEqual(double_metaphone('Crosby'), ('KRSP', '')) |
||
| 1243 | self.assertEqual(double_metaphone('Crump'), ('KRMP', '')) |
||
| 1244 | self.assertEqual(double_metaphone('Cunningham'), ('KNNKM', '')) |
||
| 1245 | self.assertEqual(double_metaphone('Curtis'), ('KRTS', '')) |
||
| 1246 | self.assertEqual(double_metaphone('Cutha'), ('K0', 'KT')) |
||
| 1247 | self.assertEqual(double_metaphone('Cutter'), ('KTR', '')) |
||
| 1248 | self.assertEqual(double_metaphone('D\'Aubigny'), ('TPN', 'TPKN')) |
||
| 1249 | self.assertEqual(double_metaphone('DAVIS'), ('TFS', '')) |
||
| 1250 | self.assertEqual(double_metaphone('Dabinott'), ('TPNT', '')) |
||
| 1251 | self.assertEqual(double_metaphone('Dacre'), ('TKR', '')) |
||
| 1252 | self.assertEqual(double_metaphone('Daggett'), ('TKT', '')) |
||
| 1253 | self.assertEqual(double_metaphone('Danvers'), ('TNFRS', '')) |
||
| 1254 | self.assertEqual(double_metaphone('Darcy'), ('TRS', '')) |
||
| 1255 | self.assertEqual(double_metaphone('Davis'), ('TFS', '')) |
||
| 1256 | self.assertEqual(double_metaphone('Dawn'), ('TN', '')) |
||
| 1257 | self.assertEqual(double_metaphone('Dawson'), ('TSN', '')) |
||
| 1258 | self.assertEqual(double_metaphone('Day'), ('T', '')) |
||
| 1259 | self.assertEqual(double_metaphone('Daye'), ('T', '')) |
||
| 1260 | self.assertEqual(double_metaphone('DeGrenier'), ('TKRN', 'TKRNR')) |
||
| 1261 | self.assertEqual(double_metaphone('Dean'), ('TN', '')) |
||
| 1262 | self.assertEqual(double_metaphone('Deekindaugh'), ('TKNT', '')) |
||
| 1263 | self.assertEqual(double_metaphone('Dennis'), ('TNS', '')) |
||
| 1264 | self.assertEqual(double_metaphone('Denny'), ('TN', '')) |
||
| 1265 | self.assertEqual(double_metaphone('Denton'), ('TNTN', '')) |
||
| 1266 | self.assertEqual(double_metaphone('Desborough'), ('TSPRF', '')) |
||
| 1267 | self.assertEqual(double_metaphone('Despenser'), ('TSPNSR', '')) |
||
| 1268 | self.assertEqual(double_metaphone('Deverill'), ('TFRL', '')) |
||
| 1269 | self.assertEqual(double_metaphone('Devine'), ('TFN', '')) |
||
| 1270 | self.assertEqual(double_metaphone('Dexter'), ('TKSTR', '')) |
||
| 1271 | self.assertEqual(double_metaphone('Dillaway'), ('TL', '')) |
||
| 1272 | self.assertEqual(double_metaphone('Dimmick'), ('TMK', '')) |
||
| 1273 | self.assertEqual(double_metaphone('Dinan'), ('TNN', '')) |
||
| 1274 | self.assertEqual(double_metaphone('Dix'), ('TKS', '')) |
||
| 1275 | self.assertEqual(double_metaphone('Doggett'), ('TKT', '')) |
||
| 1276 | self.assertEqual(double_metaphone('Donahue'), ('TNH', '')) |
||
| 1277 | self.assertEqual(double_metaphone('Dorfman'), ('TRFMN', '')) |
||
| 1278 | self.assertEqual(double_metaphone('Dorris'), ('TRS', '')) |
||
| 1279 | self.assertEqual(double_metaphone('Dow'), ('T', 'TF')) |
||
| 1280 | self.assertEqual(double_metaphone('Downey'), ('TN', '')) |
||
| 1281 | self.assertEqual(double_metaphone('Downing'), ('TNNK', '')) |
||
| 1282 | self.assertEqual(double_metaphone('Dowsett'), ('TST', '')) |
||
| 1283 | self.assertEqual(double_metaphone('Duck?'), ('TK', '')) |
||
| 1284 | self.assertEqual(double_metaphone('Dudley'), ('TTL', '')) |
||
| 1285 | self.assertEqual(double_metaphone('Duffy'), ('TF', '')) |
||
| 1286 | self.assertEqual(double_metaphone('Dunn'), ('TN', '')) |
||
| 1287 | self.assertEqual(double_metaphone('Dunsterville'), ('TNSTRFL', '')) |
||
| 1288 | self.assertEqual(double_metaphone('Durrant'), ('TRNT', '')) |
||
| 1289 | self.assertEqual(double_metaphone('Durrin'), ('TRN', '')) |
||
| 1290 | self.assertEqual(double_metaphone('Dustin'), ('TSTN', '')) |
||
| 1291 | self.assertEqual(double_metaphone('Duston'), ('TSTN', '')) |
||
| 1292 | self.assertEqual(double_metaphone('Eames'), ('AMS', '')) |
||
| 1293 | self.assertEqual(double_metaphone('Early'), ('ARL', '')) |
||
| 1294 | self.assertEqual(double_metaphone('Easty'), ('AST', '')) |
||
| 1295 | self.assertEqual(double_metaphone('Ebbett'), ('APT', '')) |
||
| 1296 | self.assertEqual(double_metaphone('Eberbach'), ('APRPK', '')) |
||
| 1297 | self.assertEqual(double_metaphone('Eberhard'), ('APRRT', '')) |
||
| 1298 | self.assertEqual(double_metaphone('Eddy'), ('AT', '')) |
||
| 1299 | self.assertEqual(double_metaphone('Edenden'), ('ATNTN', '')) |
||
| 1300 | self.assertEqual(double_metaphone('Edwards'), ('ATRTS', '')) |
||
| 1301 | self.assertEqual(double_metaphone('Eglinton'), ('AKLNTN', 'ALNTN')) |
||
| 1302 | self.assertEqual(double_metaphone('Eliot'), ('ALT', '')) |
||
| 1303 | self.assertEqual(double_metaphone('Elizabeth'), ('ALSP0', 'ALSPT')) |
||
| 1304 | self.assertEqual(double_metaphone('Ellis'), ('ALS', '')) |
||
| 1305 | self.assertEqual(double_metaphone('Ellison'), ('ALSN', '')) |
||
| 1306 | self.assertEqual(double_metaphone('Ellot'), ('ALT', '')) |
||
| 1307 | self.assertEqual(double_metaphone('Elny'), ('ALN', '')) |
||
| 1308 | self.assertEqual(double_metaphone('Elsner'), ('ALSNR', '')) |
||
| 1309 | self.assertEqual(double_metaphone('Emerson'), ('AMRSN', '')) |
||
| 1310 | self.assertEqual(double_metaphone('Empson'), ('AMPSN', '')) |
||
| 1311 | self.assertEqual(double_metaphone('Est'), ('AST', '')) |
||
| 1312 | self.assertEqual(double_metaphone('Estabrook'), ('ASTPRK', '')) |
||
| 1313 | self.assertEqual(double_metaphone('Estes'), ('ASTS', '')) |
||
| 1314 | self.assertEqual(double_metaphone('Estey'), ('AST', '')) |
||
| 1315 | self.assertEqual(double_metaphone('Evans'), ('AFNS', '')) |
||
| 1316 | self.assertEqual(double_metaphone('Fallowell'), ('FLL', '')) |
||
| 1317 | self.assertEqual(double_metaphone('Farnsworth'), ('FRNSR0', 'FRNSRT')) |
||
| 1318 | self.assertEqual(double_metaphone('Feake'), ('FK', '')) |
||
| 1319 | self.assertEqual(double_metaphone('Feke'), ('FK', '')) |
||
| 1320 | self.assertEqual(double_metaphone('Fellows'), ('FLS', '')) |
||
| 1321 | self.assertEqual(double_metaphone('Fettiplace'), ('FTPLS', '')) |
||
| 1322 | self.assertEqual(double_metaphone('Finney'), ('FN', '')) |
||
| 1323 | self.assertEqual(double_metaphone('Fischer'), ('FXR', 'FSKR')) |
||
| 1324 | self.assertEqual(double_metaphone('Fisher'), ('FXR', '')) |
||
| 1325 | self.assertEqual(double_metaphone('Fisk'), ('FSK', '')) |
||
| 1326 | self.assertEqual(double_metaphone('Fiske'), ('FSK', '')) |
||
| 1327 | self.assertEqual(double_metaphone('Fletcher'), ('FLXR', '')) |
||
| 1328 | self.assertEqual(double_metaphone('Folger'), ('FLKR', 'FLJR')) |
||
| 1329 | self.assertEqual(double_metaphone('Foliot'), ('FLT', '')) |
||
| 1330 | self.assertEqual(double_metaphone('Folyot'), ('FLT', '')) |
||
| 1331 | self.assertEqual(double_metaphone('Fones'), ('FNS', '')) |
||
| 1332 | self.assertEqual(double_metaphone('Fordham'), ('FRTM', '')) |
||
| 1333 | self.assertEqual(double_metaphone('Forstner'), ('FRSTNR', '')) |
||
| 1334 | self.assertEqual(double_metaphone('Fosten'), ('FSTN', '')) |
||
| 1335 | self.assertEqual(double_metaphone('Foster'), ('FSTR', '')) |
||
| 1336 | self.assertEqual(double_metaphone('Foulke'), ('FLK', '')) |
||
| 1337 | self.assertEqual(double_metaphone('Fowler'), ('FLR', '')) |
||
| 1338 | self.assertEqual(double_metaphone('Foxwell'), ('FKSL', '')) |
||
| 1339 | self.assertEqual(double_metaphone('Fraley'), ('FRL', '')) |
||
| 1340 | self.assertEqual(double_metaphone('Franceys'), ('FRNSS', '')) |
||
| 1341 | self.assertEqual(double_metaphone('Franke'), ('FRNK', '')) |
||
| 1342 | self.assertEqual(double_metaphone('Frascella'), ('FRSL', '')) |
||
| 1343 | self.assertEqual(double_metaphone('Frazer'), ('FRSR', '')) |
||
| 1344 | self.assertEqual(double_metaphone('Fredd'), ('FRT', '')) |
||
| 1345 | self.assertEqual(double_metaphone('Freeman'), ('FRMN', '')) |
||
| 1346 | self.assertEqual(double_metaphone('French'), ('FRNX', 'FRNK')) |
||
| 1347 | self.assertEqual(double_metaphone('Freville'), ('FRFL', '')) |
||
| 1348 | self.assertEqual(double_metaphone('Frey'), ('FR', '')) |
||
| 1349 | self.assertEqual(double_metaphone('Frick'), ('FRK', '')) |
||
| 1350 | self.assertEqual(double_metaphone('Frier'), ('FR', 'FRR')) |
||
| 1351 | self.assertEqual(double_metaphone('Froe'), ('FR', '')) |
||
| 1352 | self.assertEqual(double_metaphone('Frorer'), ('FRRR', '')) |
||
| 1353 | self.assertEqual(double_metaphone('Frost'), ('FRST', '')) |
||
| 1354 | self.assertEqual(double_metaphone('Frothingham'), ('FR0NKM', 'FRTNKM')) |
||
| 1355 | self.assertEqual(double_metaphone('Fry'), ('FR', '')) |
||
| 1356 | self.assertEqual(double_metaphone('Gaffney'), ('KFN', '')) |
||
| 1357 | self.assertEqual(double_metaphone('Gage'), ('KJ', 'KK')) |
||
| 1358 | self.assertEqual(double_metaphone('Gallion'), ('KLN', '')) |
||
| 1359 | self.assertEqual(double_metaphone('Gallishan'), ('KLXN', '')) |
||
| 1360 | self.assertEqual(double_metaphone('Gamble'), ('KMPL', '')) |
||
| 1361 | self.assertEqual(double_metaphone('Garbrand'), ('KRPRNT', '')) |
||
| 1362 | self.assertEqual(double_metaphone('Gardner'), ('KRTNR', '')) |
||
| 1363 | self.assertEqual(double_metaphone('Garrett'), ('KRT', '')) |
||
| 1364 | self.assertEqual(double_metaphone('Gassner'), ('KSNR', '')) |
||
| 1365 | self.assertEqual(double_metaphone('Gater'), ('KTR', '')) |
||
| 1366 | self.assertEqual(double_metaphone('Gaunt'), ('KNT', '')) |
||
| 1367 | self.assertEqual(double_metaphone('Gayer'), ('KR', '')) |
||
| 1368 | self.assertEqual(double_metaphone('Gerken'), ('KRKN', 'JRKN')) |
||
| 1369 | self.assertEqual(double_metaphone('Gerritsen'), ('KRTSN', 'JRTSN')) |
||
| 1370 | self.assertEqual(double_metaphone('Gibbs'), ('KPS', 'JPS')) |
||
| 1371 | self.assertEqual(double_metaphone('Giffard'), ('JFRT', 'KFRT')) |
||
| 1372 | self.assertEqual(double_metaphone('Gilbert'), ('KLPRT', 'JLPRT')) |
||
| 1373 | self.assertEqual(double_metaphone('Gill'), ('KL', 'JL')) |
||
| 1374 | self.assertEqual(double_metaphone('Gilman'), ('KLMN', 'JLMN')) |
||
| 1375 | self.assertEqual(double_metaphone('Glass'), ('KLS', '')) |
||
| 1376 | self.assertEqual(double_metaphone('GoddardGifford'), ('KTRJFRT', '')) |
||
| 1377 | self.assertEqual(double_metaphone('Godfrey'), ('KTFR', '')) |
||
| 1378 | self.assertEqual(double_metaphone('Godwin'), ('KTN', '')) |
||
| 1379 | self.assertEqual(double_metaphone('Goodale'), ('KTL', '')) |
||
| 1380 | self.assertEqual(double_metaphone('Goodnow'), ('KTN', 'KTNF')) |
||
| 1381 | self.assertEqual(double_metaphone('Gorham'), ('KRM', '')) |
||
| 1382 | self.assertEqual(double_metaphone('Goseline'), ('KSLN', '')) |
||
| 1383 | self.assertEqual(double_metaphone('Gott'), ('KT', '')) |
||
| 1384 | self.assertEqual(double_metaphone('Gould'), ('KLT', '')) |
||
| 1385 | self.assertEqual(double_metaphone('Grafton'), ('KRFTN', '')) |
||
| 1386 | self.assertEqual(double_metaphone('Grant'), ('KRNT', '')) |
||
| 1387 | self.assertEqual(double_metaphone('Gray'), ('KR', '')) |
||
| 1388 | self.assertEqual(double_metaphone('Green'), ('KRN', '')) |
||
| 1389 | self.assertEqual(double_metaphone('Griffin'), ('KRFN', '')) |
||
| 1390 | self.assertEqual(double_metaphone('Grill'), ('KRL', '')) |
||
| 1391 | self.assertEqual(double_metaphone('Grim'), ('KRM', '')) |
||
| 1392 | self.assertEqual(double_metaphone('Grisgonelle'), ('KRSKNL', '')) |
||
| 1393 | self.assertEqual(double_metaphone('Gross'), ('KRS', '')) |
||
| 1394 | self.assertEqual(double_metaphone('Guba'), ('KP', '')) |
||
| 1395 | self.assertEqual(double_metaphone('Gybbes'), ('KPS', 'JPS')) |
||
| 1396 | self.assertEqual(double_metaphone('Haburne'), ('HPRN', '')) |
||
| 1397 | self.assertEqual(double_metaphone('Hackburne'), ('HKPRN', '')) |
||
| 1398 | self.assertEqual(double_metaphone('Haddon?'), ('HTN', '')) |
||
| 1399 | self.assertEqual(double_metaphone('Haines'), ('HNS', '')) |
||
| 1400 | self.assertEqual(double_metaphone('Hale'), ('HL', '')) |
||
| 1401 | self.assertEqual(double_metaphone('Hall'), ('HL', '')) |
||
| 1402 | self.assertEqual(double_metaphone('Hallet'), ('HLT', '')) |
||
| 1403 | self.assertEqual(double_metaphone('Hallock'), ('HLK', '')) |
||
| 1404 | self.assertEqual(double_metaphone('Halstead'), ('HLSTT', '')) |
||
| 1405 | self.assertEqual(double_metaphone('Hammond'), ('HMNT', '')) |
||
| 1406 | self.assertEqual(double_metaphone('Hance'), ('HNS', '')) |
||
| 1407 | self.assertEqual(double_metaphone('Handy'), ('HNT', '')) |
||
| 1408 | self.assertEqual(double_metaphone('Hanson'), ('HNSN', '')) |
||
| 1409 | self.assertEqual(double_metaphone('Harasek'), ('HRSK', '')) |
||
| 1410 | self.assertEqual(double_metaphone('Harcourt'), ('HRKRT', '')) |
||
| 1411 | self.assertEqual(double_metaphone('Hardy'), ('HRT', '')) |
||
| 1412 | self.assertEqual(double_metaphone('Harlock'), ('HRLK', '')) |
||
| 1413 | self.assertEqual(double_metaphone('Harris'), ('HRS', '')) |
||
| 1414 | self.assertEqual(double_metaphone('Hartley'), ('HRTL', '')) |
||
| 1415 | self.assertEqual(double_metaphone('Harvey'), ('HRF', '')) |
||
| 1416 | self.assertEqual(double_metaphone('Harvie'), ('HRF', '')) |
||
| 1417 | self.assertEqual(double_metaphone('Harwood'), ('HRT', '')) |
||
| 1418 | self.assertEqual(double_metaphone('Hathaway'), ('H0', 'HT')) |
||
| 1419 | self.assertEqual(double_metaphone('Haukeness'), ('HKNS', '')) |
||
| 1420 | self.assertEqual(double_metaphone('Hawkes'), ('HKS', '')) |
||
| 1421 | self.assertEqual(double_metaphone('Hawkhurst'), ('HKRST', '')) |
||
| 1422 | self.assertEqual(double_metaphone('Hawkins'), ('HKNS', '')) |
||
| 1423 | self.assertEqual(double_metaphone('Hawley'), ('HL', '')) |
||
| 1424 | self.assertEqual(double_metaphone('Heald'), ('HLT', '')) |
||
| 1425 | self.assertEqual(double_metaphone('Helsdon'), ('HLSTN', '')) |
||
| 1426 | self.assertEqual(double_metaphone('Hemenway'), ('HMN', '')) |
||
| 1427 | self.assertEqual(double_metaphone('Hemmenway'), ('HMN', '')) |
||
| 1428 | self.assertEqual(double_metaphone('Henck'), ('HNK', '')) |
||
| 1429 | self.assertEqual(double_metaphone('Henderson'), ('HNTRSN', '')) |
||
| 1430 | self.assertEqual(double_metaphone('Hendricks'), ('HNTRKS', '')) |
||
| 1431 | self.assertEqual(double_metaphone('Hersey'), ('HRS', '')) |
||
| 1432 | self.assertEqual(double_metaphone('Hewes'), ('HS', '')) |
||
| 1433 | self.assertEqual(double_metaphone('Heyman'), ('HMN', '')) |
||
| 1434 | self.assertEqual(double_metaphone('Hicks'), ('HKS', '')) |
||
| 1435 | self.assertEqual(double_metaphone('Hidden'), ('HTN', '')) |
||
| 1436 | self.assertEqual(double_metaphone('Higgs'), ('HKS', '')) |
||
| 1437 | self.assertEqual(double_metaphone('Hill'), ('HL', '')) |
||
| 1438 | self.assertEqual(double_metaphone('Hills'), ('HLS', '')) |
||
| 1439 | self.assertEqual(double_metaphone('Hinckley'), ('HNKL', '')) |
||
| 1440 | self.assertEqual(double_metaphone('Hipwell'), ('HPL', '')) |
||
| 1441 | self.assertEqual(double_metaphone('Hobart'), ('HPRT', '')) |
||
| 1442 | self.assertEqual(double_metaphone('Hoben'), ('HPN', '')) |
||
| 1443 | self.assertEqual(double_metaphone('Hoffmann'), ('HFMN', '')) |
||
| 1444 | self.assertEqual(double_metaphone('Hogan'), ('HKN', '')) |
||
| 1445 | self.assertEqual(double_metaphone('Holmes'), ('HLMS', '')) |
||
| 1446 | self.assertEqual(double_metaphone('Hoo'), ('H', '')) |
||
| 1447 | self.assertEqual(double_metaphone('Hooker'), ('HKR', '')) |
||
| 1448 | self.assertEqual(double_metaphone('Hopcott'), ('HPKT', '')) |
||
| 1449 | self.assertEqual(double_metaphone('Hopkins'), ('HPKNS', '')) |
||
| 1450 | self.assertEqual(double_metaphone('Hopkinson'), ('HPKNSN', '')) |
||
| 1451 | self.assertEqual(double_metaphone('Hornsey'), ('HRNS', '')) |
||
| 1452 | self.assertEqual(double_metaphone('Houckgeest'), ('HKJST', 'HKKST')) |
||
| 1453 | self.assertEqual(double_metaphone('Hough'), ('H', '')) |
||
| 1454 | self.assertEqual(double_metaphone('Houstin'), ('HSTN', '')) |
||
| 1455 | self.assertEqual(double_metaphone('How'), ('H', 'HF')) |
||
| 1456 | self.assertEqual(double_metaphone('Howe'), ('H', '')) |
||
| 1457 | self.assertEqual(double_metaphone('Howland'), ('HLNT', '')) |
||
| 1458 | self.assertEqual(double_metaphone('Hubner'), ('HPNR', '')) |
||
| 1459 | self.assertEqual(double_metaphone('Hudnut'), ('HTNT', '')) |
||
| 1460 | self.assertEqual(double_metaphone('Hughes'), ('HS', '')) |
||
| 1461 | self.assertEqual(double_metaphone('Hull'), ('HL', '')) |
||
| 1462 | self.assertEqual(double_metaphone('Hulme'), ('HLM', '')) |
||
| 1463 | self.assertEqual(double_metaphone('Hume'), ('HM', '')) |
||
| 1464 | self.assertEqual(double_metaphone('Hundertumark'), ('HNTRTMRK', '')) |
||
| 1465 | self.assertEqual(double_metaphone('Hundley'), ('HNTL', '')) |
||
| 1466 | self.assertEqual(double_metaphone('Hungerford'), |
||
| 1467 | ('HNKRFRT', 'HNJRFRT')) |
||
| 1468 | self.assertEqual(double_metaphone('Hunt'), ('HNT', '')) |
||
| 1469 | self.assertEqual(double_metaphone('Hurst'), ('HRST', '')) |
||
| 1470 | self.assertEqual(double_metaphone('Husbands'), ('HSPNTS', '')) |
||
| 1471 | self.assertEqual(double_metaphone('Hussey'), ('HS', '')) |
||
| 1472 | self.assertEqual(double_metaphone('Husted'), ('HSTT', '')) |
||
| 1473 | self.assertEqual(double_metaphone('Hutchins'), ('HXNS', '')) |
||
| 1474 | self.assertEqual(double_metaphone('Hutchinson'), ('HXNSN', '')) |
||
| 1475 | self.assertEqual(double_metaphone('Huttinger'), ('HTNKR', 'HTNJR')) |
||
| 1476 | self.assertEqual(double_metaphone('Huybertsen'), ('HPRTSN', '')) |
||
| 1477 | self.assertEqual(double_metaphone('Iddenden'), ('ATNTN', '')) |
||
| 1478 | self.assertEqual(double_metaphone('Ingraham'), ('ANKRHM', '')) |
||
| 1479 | self.assertEqual(double_metaphone('Ives'), ('AFS', '')) |
||
| 1480 | self.assertEqual(double_metaphone('Jackson'), ('JKSN', 'AKSN')) |
||
| 1481 | self.assertEqual(double_metaphone('Jacob'), ('JKP', 'AKP')) |
||
| 1482 | self.assertEqual(double_metaphone('Jans'), ('JNS', 'ANS')) |
||
| 1483 | self.assertEqual(double_metaphone('Jenkins'), ('JNKNS', 'ANKNS')) |
||
| 1484 | self.assertEqual(double_metaphone('Jewett'), ('JT', 'AT')) |
||
| 1485 | self.assertEqual(double_metaphone('Jewitt'), ('JT', 'AT')) |
||
| 1486 | self.assertEqual(double_metaphone('Johnson'), ('JNSN', 'ANSN')) |
||
| 1487 | self.assertEqual(double_metaphone('Jones'), ('JNS', 'ANS')) |
||
| 1488 | self.assertEqual(double_metaphone('Josephine'), ('JSFN', 'HSFN')) |
||
| 1489 | self.assertEqual(double_metaphone('Judd'), ('JT', 'AT')) |
||
| 1490 | self.assertEqual(double_metaphone('June'), ('JN', 'AN')) |
||
| 1491 | self.assertEqual(double_metaphone('Kamarowska'), ('KMRSK', '')) |
||
| 1492 | self.assertEqual(double_metaphone('Kay'), ('K', '')) |
||
| 1493 | self.assertEqual(double_metaphone('Kelley'), ('KL', '')) |
||
| 1494 | self.assertEqual(double_metaphone('Kelly'), ('KL', '')) |
||
| 1495 | self.assertEqual(double_metaphone('Keymber'), ('KMPR', '')) |
||
| 1496 | self.assertEqual(double_metaphone('Keynes'), ('KNS', '')) |
||
| 1497 | self.assertEqual(double_metaphone('Kilham'), ('KLM', '')) |
||
| 1498 | self.assertEqual(double_metaphone('Kim'), ('KM', '')) |
||
| 1499 | self.assertEqual(double_metaphone('Kimball'), ('KMPL', '')) |
||
| 1500 | self.assertEqual(double_metaphone('King'), ('KNK', '')) |
||
| 1501 | self.assertEqual(double_metaphone('Kinsey'), ('KNS', '')) |
||
| 1502 | self.assertEqual(double_metaphone('Kirk'), ('KRK', '')) |
||
| 1503 | self.assertEqual(double_metaphone('Kirton'), ('KRTN', '')) |
||
| 1504 | self.assertEqual(double_metaphone('Kistler'), ('KSTLR', '')) |
||
| 1505 | self.assertEqual(double_metaphone('Kitchen'), ('KXN', '')) |
||
| 1506 | self.assertEqual(double_metaphone('Kitson'), ('KTSN', '')) |
||
| 1507 | self.assertEqual(double_metaphone('Klett'), ('KLT', '')) |
||
| 1508 | self.assertEqual(double_metaphone('Kline'), ('KLN', '')) |
||
| 1509 | self.assertEqual(double_metaphone('Knapp'), ('NP', '')) |
||
| 1510 | self.assertEqual(double_metaphone('Knight'), ('NT', '')) |
||
| 1511 | self.assertEqual(double_metaphone('Knote'), ('NT', '')) |
||
| 1512 | self.assertEqual(double_metaphone('Knott'), ('NT', '')) |
||
| 1513 | self.assertEqual(double_metaphone('Knox'), ('NKS', '')) |
||
| 1514 | self.assertEqual(double_metaphone('Koeller'), ('KLR', '')) |
||
| 1515 | self.assertEqual(double_metaphone('La Pointe'), ('LPNT', '')) |
||
| 1516 | self.assertEqual(double_metaphone('LaPlante'), ('LPLNT', '')) |
||
| 1517 | self.assertEqual(double_metaphone('Laimbeer'), ('LMPR', '')) |
||
| 1518 | self.assertEqual(double_metaphone('Lamb'), ('LMP', '')) |
||
| 1519 | self.assertEqual(double_metaphone('Lambertson'), ('LMPRTSN', '')) |
||
| 1520 | self.assertEqual(double_metaphone('Lancto'), ('LNKT', '')) |
||
| 1521 | self.assertEqual(double_metaphone('Landry'), ('LNTR', '')) |
||
| 1522 | self.assertEqual(double_metaphone('Lane'), ('LN', '')) |
||
| 1523 | self.assertEqual(double_metaphone('Langendyck'), ('LNJNTK', 'LNKNTK')) |
||
| 1524 | self.assertEqual(double_metaphone('Langer'), ('LNKR', 'LNJR')) |
||
| 1525 | self.assertEqual(double_metaphone('Langford'), ('LNKFRT', '')) |
||
| 1526 | self.assertEqual(double_metaphone('Lantersee'), ('LNTRS', '')) |
||
| 1527 | self.assertEqual(double_metaphone('Laquer'), ('LKR', '')) |
||
| 1528 | self.assertEqual(double_metaphone('Larkin'), ('LRKN', '')) |
||
| 1529 | self.assertEqual(double_metaphone('Latham'), ('LTM', '')) |
||
| 1530 | self.assertEqual(double_metaphone('Lathrop'), ('L0RP', 'LTRP')) |
||
| 1531 | self.assertEqual(double_metaphone('Lauter'), ('LTR', '')) |
||
| 1532 | self.assertEqual(double_metaphone('Lawrence'), ('LRNS', '')) |
||
| 1533 | self.assertEqual(double_metaphone('Leach'), ('LK', '')) |
||
| 1534 | self.assertEqual(double_metaphone('Leager'), ('LKR', 'LJR')) |
||
| 1535 | self.assertEqual(double_metaphone('Learned'), ('LRNT', '')) |
||
| 1536 | self.assertEqual(double_metaphone('Leavitt'), ('LFT', '')) |
||
| 1537 | self.assertEqual(double_metaphone('Lee'), ('L', '')) |
||
| 1538 | self.assertEqual(double_metaphone('Leete'), ('LT', '')) |
||
| 1539 | self.assertEqual(double_metaphone('Leggett'), ('LKT', '')) |
||
| 1540 | self.assertEqual(double_metaphone('Leland'), ('LLNT', '')) |
||
| 1541 | self.assertEqual(double_metaphone('Leonard'), ('LNRT', '')) |
||
| 1542 | self.assertEqual(double_metaphone('Lester'), ('LSTR', '')) |
||
| 1543 | self.assertEqual(double_metaphone('Lestrange'), ('LSTRNJ', 'LSTRNK')) |
||
| 1544 | self.assertEqual(double_metaphone('Lethem'), ('L0M', 'LTM')) |
||
| 1545 | self.assertEqual(double_metaphone('Levine'), ('LFN', '')) |
||
| 1546 | self.assertEqual(double_metaphone('Lewes'), ('LS', '')) |
||
| 1547 | self.assertEqual(double_metaphone('Lewis'), ('LS', '')) |
||
| 1548 | self.assertEqual(double_metaphone('Lincoln'), ('LNKLN', '')) |
||
| 1549 | self.assertEqual(double_metaphone('Lindsey'), ('LNTS', '')) |
||
| 1550 | self.assertEqual(double_metaphone('Linher'), ('LNR', '')) |
||
| 1551 | self.assertEqual(double_metaphone('Lippet'), ('LPT', '')) |
||
| 1552 | self.assertEqual(double_metaphone('Lippincott'), ('LPNKT', '')) |
||
| 1553 | self.assertEqual(double_metaphone('Lockwood'), ('LKT', '')) |
||
| 1554 | self.assertEqual(double_metaphone('Loines'), ('LNS', '')) |
||
| 1555 | self.assertEqual(double_metaphone('Lombard'), ('LMPRT', '')) |
||
| 1556 | self.assertEqual(double_metaphone('Long'), ('LNK', '')) |
||
| 1557 | self.assertEqual(double_metaphone('Longespee'), ('LNJSP', 'LNKSP')) |
||
| 1558 | self.assertEqual(double_metaphone('Look'), ('LK', '')) |
||
| 1559 | self.assertEqual(double_metaphone('Lounsberry'), ('LNSPR', '')) |
||
| 1560 | self.assertEqual(double_metaphone('Lounsbury'), ('LNSPR', '')) |
||
| 1561 | self.assertEqual(double_metaphone('Louthe'), ('L0', 'LT')) |
||
| 1562 | self.assertEqual(double_metaphone('Loveyne'), ('LFN', '')) |
||
| 1563 | self.assertEqual(double_metaphone('Lowe'), ('L', '')) |
||
| 1564 | self.assertEqual(double_metaphone('Ludlam'), ('LTLM', '')) |
||
| 1565 | self.assertEqual(double_metaphone('Lumbard'), ('LMPRT', '')) |
||
| 1566 | self.assertEqual(double_metaphone('Lund'), ('LNT', '')) |
||
| 1567 | self.assertEqual(double_metaphone('Luno'), ('LN', '')) |
||
| 1568 | self.assertEqual(double_metaphone('Lutz'), ('LTS', '')) |
||
| 1569 | self.assertEqual(double_metaphone('Lydia'), ('LT', '')) |
||
| 1570 | self.assertEqual(double_metaphone('Lynne'), ('LN', '')) |
||
| 1571 | self.assertEqual(double_metaphone('Lyon'), ('LN', '')) |
||
| 1572 | self.assertEqual(double_metaphone('MacAlpin'), ('MKLPN', '')) |
||
| 1573 | self.assertEqual(double_metaphone('MacBricc'), ('MKPRK', '')) |
||
| 1574 | self.assertEqual(double_metaphone('MacCrinan'), ('MKRNN', '')) |
||
| 1575 | self.assertEqual(double_metaphone('MacKenneth'), ('MKN0', 'MKNT')) |
||
| 1576 | self.assertEqual(double_metaphone('MacMael nam Bo'), ('MKMLNMP', '')) |
||
| 1577 | self.assertEqual(double_metaphone('MacMurchada'), ('MKMRXT', 'MKMRKT')) |
||
| 1578 | self.assertEqual(double_metaphone('Macomber'), ('MKMPR', '')) |
||
| 1579 | self.assertEqual(double_metaphone('Macy'), ('MS', '')) |
||
| 1580 | self.assertEqual(double_metaphone('Magnus'), ('MNS', 'MKNS')) |
||
| 1581 | self.assertEqual(double_metaphone('Mahien'), ('MHN', '')) |
||
| 1582 | self.assertEqual(double_metaphone('Malmains'), ('MLMNS', '')) |
||
| 1583 | self.assertEqual(double_metaphone('Malory'), ('MLR', '')) |
||
| 1584 | self.assertEqual(double_metaphone('Mancinelli'), ('MNSNL', '')) |
||
| 1585 | self.assertEqual(double_metaphone('Mancini'), ('MNSN', '')) |
||
| 1586 | self.assertEqual(double_metaphone('Mann'), ('MN', '')) |
||
| 1587 | self.assertEqual(double_metaphone('Manning'), ('MNNK', '')) |
||
| 1588 | self.assertEqual(double_metaphone('Manter'), ('MNTR', '')) |
||
| 1589 | self.assertEqual(double_metaphone('Marion'), ('MRN', '')) |
||
| 1590 | self.assertEqual(double_metaphone('Marley'), ('MRL', '')) |
||
| 1591 | self.assertEqual(double_metaphone('Marmion'), ('MRMN', '')) |
||
| 1592 | self.assertEqual(double_metaphone('Marquart'), ('MRKRT', '')) |
||
| 1593 | self.assertEqual(double_metaphone('Marsh'), ('MRX', '')) |
||
| 1594 | self.assertEqual(double_metaphone('Marshal'), ('MRXL', '')) |
||
| 1595 | self.assertEqual(double_metaphone('Marshall'), ('MRXL', '')) |
||
| 1596 | self.assertEqual(double_metaphone('Martel'), ('MRTL', '')) |
||
| 1597 | self.assertEqual(double_metaphone('Martha'), ('MR0', 'MRT')) |
||
| 1598 | self.assertEqual(double_metaphone('Martin'), ('MRTN', '')) |
||
| 1599 | self.assertEqual(double_metaphone('Marturano'), ('MRTRN', '')) |
||
| 1600 | self.assertEqual(double_metaphone('Marvin'), ('MRFN', '')) |
||
| 1601 | self.assertEqual(double_metaphone('Mary'), ('MR', '')) |
||
| 1602 | self.assertEqual(double_metaphone('Mason'), ('MSN', '')) |
||
| 1603 | self.assertEqual(double_metaphone('Maxwell'), ('MKSL', '')) |
||
| 1604 | self.assertEqual(double_metaphone('Mayhew'), ('MH', 'MHF')) |
||
| 1605 | self.assertEqual(double_metaphone('McAllaster'), ('MKLSTR', '')) |
||
| 1606 | self.assertEqual(double_metaphone('McAllister'), ('MKLSTR', '')) |
||
| 1607 | self.assertEqual(double_metaphone('McConnell'), ('MKNL', '')) |
||
| 1608 | self.assertEqual(double_metaphone('McFarland'), ('MKFRLNT', '')) |
||
| 1609 | self.assertEqual(double_metaphone('McIlroy'), ('MSLR', '')) |
||
| 1610 | self.assertEqual(double_metaphone('McNair'), ('MKNR', '')) |
||
| 1611 | self.assertEqual(double_metaphone('McNair-Landry'), ('MKNRLNTR', '')) |
||
| 1612 | self.assertEqual(double_metaphone('McRaven'), ('MKRFN', '')) |
||
| 1613 | self.assertEqual(double_metaphone('Mead'), ('MT', '')) |
||
| 1614 | self.assertEqual(double_metaphone('Meade'), ('MT', '')) |
||
| 1615 | self.assertEqual(double_metaphone('Meck'), ('MK', '')) |
||
| 1616 | self.assertEqual(double_metaphone('Melton'), ('MLTN', '')) |
||
| 1617 | self.assertEqual(double_metaphone('Mendenhall'), ('MNTNL', '')) |
||
| 1618 | self.assertEqual(double_metaphone('Mering'), ('MRNK', '')) |
||
| 1619 | self.assertEqual(double_metaphone('Merrick'), ('MRK', '')) |
||
| 1620 | self.assertEqual(double_metaphone('Merry'), ('MR', '')) |
||
| 1621 | self.assertEqual(double_metaphone('Mighill'), ('ML', '')) |
||
| 1622 | self.assertEqual(double_metaphone('Miller'), ('MLR', '')) |
||
| 1623 | self.assertEqual(double_metaphone('Milton'), ('MLTN', '')) |
||
| 1624 | self.assertEqual(double_metaphone('Mohun'), ('MHN', '')) |
||
| 1625 | self.assertEqual(double_metaphone('Montague'), ('MNTK', '')) |
||
| 1626 | self.assertEqual(double_metaphone('Montboucher'), ('MNTPXR', 'MNTPKR')) |
||
| 1627 | self.assertEqual(double_metaphone('Moore'), ('MR', '')) |
||
| 1628 | self.assertEqual(double_metaphone('Morrel'), ('MRL', '')) |
||
| 1629 | self.assertEqual(double_metaphone('Morrill'), ('MRL', '')) |
||
| 1630 | self.assertEqual(double_metaphone('Morris'), ('MRS', '')) |
||
| 1631 | self.assertEqual(double_metaphone('Morton'), ('MRTN', '')) |
||
| 1632 | self.assertEqual(double_metaphone('Moton'), ('MTN', '')) |
||
| 1633 | self.assertEqual(double_metaphone('Muir'), ('MR', '')) |
||
| 1634 | self.assertEqual(double_metaphone('Mulferd'), ('MLFRT', '')) |
||
| 1635 | self.assertEqual(double_metaphone('Mullins'), ('MLNS', '')) |
||
| 1636 | self.assertEqual(double_metaphone('Mulso'), ('MLS', '')) |
||
| 1637 | self.assertEqual(double_metaphone('Munger'), ('MNKR', 'MNJR')) |
||
| 1638 | self.assertEqual(double_metaphone('Munt'), ('MNT', '')) |
||
| 1639 | self.assertEqual(double_metaphone('Murchad'), ('MRXT', 'MRKT')) |
||
| 1640 | self.assertEqual(double_metaphone('Murdock'), ('MRTK', '')) |
||
| 1641 | self.assertEqual(double_metaphone('Murray'), ('MR', '')) |
||
| 1642 | self.assertEqual(double_metaphone('Muskett'), ('MSKT', '')) |
||
| 1643 | self.assertEqual(double_metaphone('Myers'), ('MRS', '')) |
||
| 1644 | self.assertEqual(double_metaphone('Myrick'), ('MRK', '')) |
||
| 1645 | self.assertEqual(double_metaphone('NORRIS'), ('NRS', '')) |
||
| 1646 | self.assertEqual(double_metaphone('Nayle'), ('NL', '')) |
||
| 1647 | self.assertEqual(double_metaphone('Newcomb'), ('NKMP', '')) |
||
| 1648 | self.assertEqual(double_metaphone('Newcomb(e)'), ('NKMP', '')) |
||
| 1649 | self.assertEqual(double_metaphone('Newkirk'), ('NKRK', '')) |
||
| 1650 | self.assertEqual(double_metaphone('Newton'), ('NTN', '')) |
||
| 1651 | self.assertEqual(double_metaphone('Niles'), ('NLS', '')) |
||
| 1652 | self.assertEqual(double_metaphone('Noble'), ('NPL', '')) |
||
| 1653 | self.assertEqual(double_metaphone('Noel'), ('NL', '')) |
||
| 1654 | self.assertEqual(double_metaphone('Northend'), ('NR0NT', 'NRTNT')) |
||
| 1655 | self.assertEqual(double_metaphone('Norton'), ('NRTN', '')) |
||
| 1656 | self.assertEqual(double_metaphone('Nutter'), ('NTR', '')) |
||
| 1657 | self.assertEqual(double_metaphone('Odding'), ('ATNK', '')) |
||
| 1658 | self.assertEqual(double_metaphone('Odenbaugh'), ('ATNP', '')) |
||
| 1659 | self.assertEqual(double_metaphone('Ogborn'), ('AKPRN', '')) |
||
| 1660 | self.assertEqual(double_metaphone('Oppenheimer'), ('APNMR', '')) |
||
| 1661 | self.assertEqual(double_metaphone('Otis'), ('ATS', '')) |
||
| 1662 | self.assertEqual(double_metaphone('Oviatt'), ('AFT', '')) |
||
| 1663 | self.assertEqual(double_metaphone('PRUST?'), ('PRST', '')) |
||
| 1664 | self.assertEqual(double_metaphone('Paddock'), ('PTK', '')) |
||
| 1665 | self.assertEqual(double_metaphone('Page'), ('PJ', 'PK')) |
||
| 1666 | self.assertEqual(double_metaphone('Paine'), ('PN', '')) |
||
| 1667 | self.assertEqual(double_metaphone('Paist'), ('PST', '')) |
||
| 1668 | self.assertEqual(double_metaphone('Palmer'), ('PLMR', '')) |
||
| 1669 | self.assertEqual(double_metaphone('Park'), ('PRK', '')) |
||
| 1670 | self.assertEqual(double_metaphone('Parker'), ('PRKR', '')) |
||
| 1671 | self.assertEqual(double_metaphone('Parkhurst'), ('PRKRST', '')) |
||
| 1672 | self.assertEqual(double_metaphone('Parrat'), ('PRT', '')) |
||
| 1673 | self.assertEqual(double_metaphone('Parsons'), ('PRSNS', '')) |
||
| 1674 | self.assertEqual(double_metaphone('Partridge'), ('PRTRJ', '')) |
||
| 1675 | self.assertEqual(double_metaphone('Pashley'), ('PXL', '')) |
||
| 1676 | self.assertEqual(double_metaphone('Pasley'), ('PSL', '')) |
||
| 1677 | self.assertEqual(double_metaphone('Patrick'), ('PTRK', '')) |
||
| 1678 | self.assertEqual(double_metaphone('Pattee'), ('PT', '')) |
||
| 1679 | self.assertEqual(double_metaphone('Patten'), ('PTN', '')) |
||
| 1680 | self.assertEqual(double_metaphone('Pawley'), ('PL', '')) |
||
| 1681 | self.assertEqual(double_metaphone('Payne'), ('PN', '')) |
||
| 1682 | self.assertEqual(double_metaphone('Peabody'), ('PPT', '')) |
||
| 1683 | self.assertEqual(double_metaphone('Peake'), ('PK', '')) |
||
| 1684 | self.assertEqual(double_metaphone('Pearson'), ('PRSN', '')) |
||
| 1685 | self.assertEqual(double_metaphone('Peat'), ('PT', '')) |
||
| 1686 | self.assertEqual(double_metaphone('Pedersen'), ('PTRSN', '')) |
||
| 1687 | self.assertEqual(double_metaphone('Percy'), ('PRS', '')) |
||
| 1688 | self.assertEqual(double_metaphone('Perkins'), ('PRKNS', '')) |
||
| 1689 | self.assertEqual(double_metaphone('Perrine'), ('PRN', '')) |
||
| 1690 | self.assertEqual(double_metaphone('Perry'), ('PR', '')) |
||
| 1691 | self.assertEqual(double_metaphone('Peson'), ('PSN', '')) |
||
| 1692 | self.assertEqual(double_metaphone('Peterson'), ('PTRSN', '')) |
||
| 1693 | self.assertEqual(double_metaphone('Peyton'), ('PTN', '')) |
||
| 1694 | self.assertEqual(double_metaphone('Phinney'), ('FN', '')) |
||
| 1695 | self.assertEqual(double_metaphone('Pickard'), ('PKRT', '')) |
||
| 1696 | self.assertEqual(double_metaphone('Pierce'), ('PRS', '')) |
||
| 1697 | self.assertEqual(double_metaphone('Pierrepont'), ('PRPNT', '')) |
||
| 1698 | self.assertEqual(double_metaphone('Pike'), ('PK', '')) |
||
| 1699 | self.assertEqual(double_metaphone('Pinkham'), ('PNKM', '')) |
||
| 1700 | self.assertEqual(double_metaphone('Pitman'), ('PTMN', '')) |
||
| 1701 | self.assertEqual(double_metaphone('Pitt'), ('PT', '')) |
||
| 1702 | self.assertEqual(double_metaphone('Pitts'), ('PTS', '')) |
||
| 1703 | self.assertEqual(double_metaphone('Plantagenet'), |
||
| 1704 | ('PLNTJNT', 'PLNTKNT')) |
||
| 1705 | self.assertEqual(double_metaphone('Platt'), ('PLT', '')) |
||
| 1706 | self.assertEqual(double_metaphone('Platts'), ('PLTS', '')) |
||
| 1707 | self.assertEqual(double_metaphone('Pleis'), ('PLS', '')) |
||
| 1708 | self.assertEqual(double_metaphone('Pleiss'), ('PLS', '')) |
||
| 1709 | self.assertEqual(double_metaphone('Plisko'), ('PLSK', '')) |
||
| 1710 | self.assertEqual(double_metaphone('Pliskovitch'), ('PLSKFX', '')) |
||
| 1711 | self.assertEqual(double_metaphone('Plum'), ('PLM', '')) |
||
| 1712 | self.assertEqual(double_metaphone('Plume'), ('PLM', '')) |
||
| 1713 | self.assertEqual(double_metaphone('Poitou'), ('PT', '')) |
||
| 1714 | self.assertEqual(double_metaphone('Pomeroy'), ('PMR', '')) |
||
| 1715 | self.assertEqual(double_metaphone('Poretiers'), ('PRTRS', '')) |
||
| 1716 | self.assertEqual(double_metaphone('Pote'), ('PT', '')) |
||
| 1717 | self.assertEqual(double_metaphone('Potter'), ('PTR', '')) |
||
| 1718 | self.assertEqual(double_metaphone('Potts'), ('PTS', '')) |
||
| 1719 | self.assertEqual(double_metaphone('Powell'), ('PL', '')) |
||
| 1720 | self.assertEqual(double_metaphone('Pratt'), ('PRT', '')) |
||
| 1721 | self.assertEqual(double_metaphone('Presbury'), ('PRSPR', '')) |
||
| 1722 | self.assertEqual(double_metaphone('Priest'), ('PRST', '')) |
||
| 1723 | self.assertEqual(double_metaphone('Prindle'), ('PRNTL', '')) |
||
| 1724 | self.assertEqual(double_metaphone('Prior'), ('PRR', '')) |
||
| 1725 | self.assertEqual(double_metaphone('Profumo'), ('PRFM', '')) |
||
| 1726 | self.assertEqual(double_metaphone('Purdy'), ('PRT', '')) |
||
| 1727 | self.assertEqual(double_metaphone('Purefoy'), ('PRF', '')) |
||
| 1728 | self.assertEqual(double_metaphone('Pury'), ('PR', '')) |
||
| 1729 | self.assertEqual(double_metaphone('Quinter'), ('KNTR', '')) |
||
| 1730 | self.assertEqual(double_metaphone('Rachel'), ('RXL', 'RKL')) |
||
| 1731 | self.assertEqual(double_metaphone('Rand'), ('RNT', '')) |
||
| 1732 | self.assertEqual(double_metaphone('Rankin'), ('RNKN', '')) |
||
| 1733 | self.assertEqual(double_metaphone('Ravenscroft'), ('RFNSKFT', '')) |
||
| 1734 | self.assertEqual(double_metaphone('Raynsford'), ('RNSFRT', '')) |
||
| 1735 | self.assertEqual(double_metaphone('Reakirt'), ('RKRT', '')) |
||
| 1736 | self.assertEqual(double_metaphone('Reaves'), ('RFS', '')) |
||
| 1737 | self.assertEqual(double_metaphone('Reeves'), ('RFS', '')) |
||
| 1738 | self.assertEqual(double_metaphone('Reichert'), ('RXRT', 'RKRT')) |
||
| 1739 | self.assertEqual(double_metaphone('Remmele'), ('RML', '')) |
||
| 1740 | self.assertEqual(double_metaphone('Reynolds'), ('RNLTS', '')) |
||
| 1741 | self.assertEqual(double_metaphone('Rhodes'), ('RTS', '')) |
||
| 1742 | self.assertEqual(double_metaphone('Richards'), ('RXRTS', 'RKRTS')) |
||
| 1743 | self.assertEqual(double_metaphone('Richardson'), ('RXRTSN', 'RKRTSN')) |
||
| 1744 | self.assertEqual(double_metaphone('Ring'), ('RNK', '')) |
||
| 1745 | self.assertEqual(double_metaphone('Roberts'), ('RPRTS', '')) |
||
| 1746 | self.assertEqual(double_metaphone('Robertson'), ('RPRTSN', '')) |
||
| 1747 | self.assertEqual(double_metaphone('Robson'), ('RPSN', '')) |
||
| 1748 | self.assertEqual(double_metaphone('Rodie'), ('RT', '')) |
||
| 1749 | self.assertEqual(double_metaphone('Rody'), ('RT', '')) |
||
| 1750 | self.assertEqual(double_metaphone('Rogers'), ('RKRS', 'RJRS')) |
||
| 1751 | self.assertEqual(double_metaphone('Ross'), ('RS', '')) |
||
| 1752 | self.assertEqual(double_metaphone('Rosslevin'), ('RSLFN', '')) |
||
| 1753 | self.assertEqual(double_metaphone('Rowland'), ('RLNT', '')) |
||
| 1754 | self.assertEqual(double_metaphone('Ruehl'), ('RL', '')) |
||
| 1755 | self.assertEqual(double_metaphone('Russell'), ('RSL', '')) |
||
| 1756 | self.assertEqual(double_metaphone('Ruth'), ('R0', 'RT')) |
||
| 1757 | self.assertEqual(double_metaphone('Ryan'), ('RN', '')) |
||
| 1758 | self.assertEqual(double_metaphone('Rysse'), ('RS', '')) |
||
| 1759 | self.assertEqual(double_metaphone('Sadler'), ('STLR', '')) |
||
| 1760 | self.assertEqual(double_metaphone('Salmon'), ('SLMN', '')) |
||
| 1761 | self.assertEqual(double_metaphone('Salter'), ('SLTR', '')) |
||
| 1762 | self.assertEqual(double_metaphone('Salvatore'), ('SLFTR', '')) |
||
| 1763 | self.assertEqual(double_metaphone('Sanders'), ('SNTRS', '')) |
||
| 1764 | self.assertEqual(double_metaphone('Sands'), ('SNTS', '')) |
||
| 1765 | self.assertEqual(double_metaphone('Sanford'), ('SNFRT', '')) |
||
| 1766 | self.assertEqual(double_metaphone('Sanger'), ('SNKR', 'SNJR')) |
||
| 1767 | self.assertEqual(double_metaphone('Sargent'), ('SRJNT', 'SRKNT')) |
||
| 1768 | self.assertEqual(double_metaphone('Saunders'), ('SNTRS', '')) |
||
| 1769 | self.assertEqual(double_metaphone('Schilling'), ('XLNK', '')) |
||
| 1770 | self.assertEqual(double_metaphone('Schlegel'), ('XLKL', 'SLKL')) |
||
| 1771 | self.assertEqual(double_metaphone('Scott'), ('SKT', '')) |
||
| 1772 | self.assertEqual(double_metaphone('Sears'), ('SRS', '')) |
||
| 1773 | self.assertEqual(double_metaphone('Segersall'), ('SJRSL', 'SKRSL')) |
||
| 1774 | self.assertEqual(double_metaphone('Senecal'), ('SNKL', '')) |
||
| 1775 | self.assertEqual(double_metaphone('Sergeaux'), ('SRJ', 'SRK')) |
||
| 1776 | self.assertEqual(double_metaphone('Severance'), ('SFRNS', '')) |
||
| 1777 | self.assertEqual(double_metaphone('Sharp'), ('XRP', '')) |
||
| 1778 | self.assertEqual(double_metaphone('Sharpe'), ('XRP', '')) |
||
| 1779 | self.assertEqual(double_metaphone('Sharply'), ('XRPL', '')) |
||
| 1780 | self.assertEqual(double_metaphone('Shatswell'), ('XTSL', '')) |
||
| 1781 | self.assertEqual(double_metaphone('Shattack'), ('XTK', '')) |
||
| 1782 | self.assertEqual(double_metaphone('Shattock'), ('XTK', '')) |
||
| 1783 | self.assertEqual(double_metaphone('Shattuck'), ('XTK', '')) |
||
| 1784 | self.assertEqual(double_metaphone('Shaw'), ('X', 'XF')) |
||
| 1785 | self.assertEqual(double_metaphone('Sheldon'), ('XLTN', '')) |
||
| 1786 | self.assertEqual(double_metaphone('Sherman'), ('XRMN', '')) |
||
| 1787 | self.assertEqual(double_metaphone('Shinn'), ('XN', '')) |
||
| 1788 | self.assertEqual(double_metaphone('Shirford'), ('XRFRT', '')) |
||
| 1789 | self.assertEqual(double_metaphone('Shirley'), ('XRL', '')) |
||
| 1790 | self.assertEqual(double_metaphone('Shively'), ('XFL', '')) |
||
| 1791 | self.assertEqual(double_metaphone('Shoemaker'), ('XMKR', '')) |
||
| 1792 | self.assertEqual(double_metaphone('Short'), ('XRT', '')) |
||
| 1793 | self.assertEqual(double_metaphone('Shotwell'), ('XTL', '')) |
||
| 1794 | self.assertEqual(double_metaphone('Shute'), ('XT', '')) |
||
| 1795 | self.assertEqual(double_metaphone('Sibley'), ('SPL', '')) |
||
| 1796 | self.assertEqual(double_metaphone('Silver'), ('SLFR', '')) |
||
| 1797 | self.assertEqual(double_metaphone('Simes'), ('SMS', '')) |
||
| 1798 | self.assertEqual(double_metaphone('Sinken'), ('SNKN', '')) |
||
| 1799 | self.assertEqual(double_metaphone('Sinn'), ('SN', '')) |
||
| 1800 | self.assertEqual(double_metaphone('Skelton'), ('SKLTN', '')) |
||
| 1801 | self.assertEqual(double_metaphone('Skiffe'), ('SKF', '')) |
||
| 1802 | self.assertEqual(double_metaphone('Skotkonung'), ('SKTKNNK', '')) |
||
| 1803 | self.assertEqual(double_metaphone('Slade'), ('SLT', 'XLT')) |
||
| 1804 | self.assertEqual(double_metaphone('Slye'), ('SL', 'XL')) |
||
| 1805 | self.assertEqual(double_metaphone('Smedley'), ('SMTL', 'XMTL')) |
||
| 1806 | self.assertEqual(double_metaphone('Smith'), ('SM0', 'XMT')) |
||
| 1807 | self.assertEqual(double_metaphone('Snow'), ('SN', 'XNF')) |
||
| 1808 | self.assertEqual(double_metaphone('Soole'), ('SL', '')) |
||
| 1809 | self.assertEqual(double_metaphone('Soule'), ('SL', '')) |
||
| 1810 | self.assertEqual(double_metaphone('Southworth'), ('S0R0', 'STRT')) |
||
| 1811 | self.assertEqual(double_metaphone('Sowles'), ('SLS', '')) |
||
| 1812 | self.assertEqual(double_metaphone('Spalding'), ('SPLTNK', '')) |
||
| 1813 | self.assertEqual(double_metaphone('Spark'), ('SPRK', '')) |
||
| 1814 | self.assertEqual(double_metaphone('Spencer'), ('SPNSR', '')) |
||
| 1815 | self.assertEqual(double_metaphone('Sperry'), ('SPR', '')) |
||
| 1816 | self.assertEqual(double_metaphone('Spofford'), ('SPFRT', '')) |
||
| 1817 | self.assertEqual(double_metaphone('Spooner'), ('SPNR', '')) |
||
| 1818 | self.assertEqual(double_metaphone('Sprague'), ('SPRK', '')) |
||
| 1819 | self.assertEqual(double_metaphone('Springer'), ('SPRNKR', 'SPRNJR')) |
||
| 1820 | self.assertEqual(double_metaphone('St. Clair'), ('STKLR', '')) |
||
| 1821 | self.assertEqual(double_metaphone('St. Claire'), ('STKLR', '')) |
||
| 1822 | self.assertEqual(double_metaphone('St. Leger'), ('STLJR', 'STLKR')) |
||
| 1823 | self.assertEqual(double_metaphone('St. Omer'), ('STMR', '')) |
||
| 1824 | self.assertEqual(double_metaphone('Stafferton'), ('STFRTN', '')) |
||
| 1825 | self.assertEqual(double_metaphone('Stafford'), ('STFRT', '')) |
||
| 1826 | self.assertEqual(double_metaphone('Stalham'), ('STLM', '')) |
||
| 1827 | self.assertEqual(double_metaphone('Stanford'), ('STNFRT', '')) |
||
| 1828 | self.assertEqual(double_metaphone('Stanton'), ('STNTN', '')) |
||
| 1829 | self.assertEqual(double_metaphone('Star'), ('STR', '')) |
||
| 1830 | self.assertEqual(double_metaphone('Starbuck'), ('STRPK', '')) |
||
| 1831 | self.assertEqual(double_metaphone('Starkey'), ('STRK', '')) |
||
| 1832 | self.assertEqual(double_metaphone('Starkweather'), |
||
| 1833 | ('STRK0R', 'STRKTR')) |
||
| 1834 | self.assertEqual(double_metaphone('Stearns'), ('STRNS', '')) |
||
| 1835 | self.assertEqual(double_metaphone('Stebbins'), ('STPNS', '')) |
||
| 1836 | self.assertEqual(double_metaphone('Steele'), ('STL', '')) |
||
| 1837 | self.assertEqual(double_metaphone('Stephenson'), ('STFNSN', '')) |
||
| 1838 | self.assertEqual(double_metaphone('Stevens'), ('STFNS', '')) |
||
| 1839 | self.assertEqual(double_metaphone('Stoddard'), ('STTRT', '')) |
||
| 1840 | self.assertEqual(double_metaphone('Stodder'), ('STTR', '')) |
||
| 1841 | self.assertEqual(double_metaphone('Stone'), ('STN', '')) |
||
| 1842 | self.assertEqual(double_metaphone('Storey'), ('STR', '')) |
||
| 1843 | self.assertEqual(double_metaphone('Storrada'), ('STRT', '')) |
||
| 1844 | self.assertEqual(double_metaphone('Story'), ('STR', '')) |
||
| 1845 | self.assertEqual(double_metaphone('Stoughton'), ('STFTN', '')) |
||
| 1846 | self.assertEqual(double_metaphone('Stout'), ('STT', '')) |
||
| 1847 | self.assertEqual(double_metaphone('Stow'), ('ST', 'STF')) |
||
| 1848 | self.assertEqual(double_metaphone('Strong'), ('STRNK', '')) |
||
| 1849 | self.assertEqual(double_metaphone('Strutt'), ('STRT', '')) |
||
| 1850 | self.assertEqual(double_metaphone('Stryker'), ('STRKR', '')) |
||
| 1851 | self.assertEqual(double_metaphone('Stuckeley'), ('STKL', '')) |
||
| 1852 | self.assertEqual(double_metaphone('Sturges'), ('STRJS', 'STRKS')) |
||
| 1853 | self.assertEqual(double_metaphone('Sturgess'), ('STRJS', 'STRKS')) |
||
| 1854 | self.assertEqual(double_metaphone('Sturgis'), ('STRJS', 'STRKS')) |
||
| 1855 | self.assertEqual(double_metaphone('Suevain'), ('SFN', '')) |
||
| 1856 | self.assertEqual(double_metaphone('Sulyard'), ('SLRT', '')) |
||
| 1857 | self.assertEqual(double_metaphone('Sutton'), ('STN', '')) |
||
| 1858 | self.assertEqual(double_metaphone('Swain'), ('SN', 'XN')) |
||
| 1859 | self.assertEqual(double_metaphone('Swayne'), ('SN', 'XN')) |
||
| 1860 | self.assertEqual(double_metaphone('Swayze'), ('SS', 'XTS')) |
||
| 1861 | self.assertEqual(double_metaphone('Swift'), ('SFT', 'XFT')) |
||
| 1862 | self.assertEqual(double_metaphone('Taber'), ('TPR', '')) |
||
| 1863 | self.assertEqual(double_metaphone('Talcott'), ('TLKT', '')) |
||
| 1864 | self.assertEqual(double_metaphone('Tarne'), ('TRN', '')) |
||
| 1865 | self.assertEqual(double_metaphone('Tatum'), ('TTM', '')) |
||
| 1866 | self.assertEqual(double_metaphone('Taverner'), ('TFRNR', '')) |
||
| 1867 | self.assertEqual(double_metaphone('Taylor'), ('TLR', '')) |
||
| 1868 | self.assertEqual(double_metaphone('Tenney'), ('TN', '')) |
||
| 1869 | self.assertEqual(double_metaphone('Thayer'), ('0R', 'TR')) |
||
| 1870 | self.assertEqual(double_metaphone('Thember'), ('0MPR', 'TMPR')) |
||
| 1871 | self.assertEqual(double_metaphone('Thomas'), ('TMS', '')) |
||
| 1872 | self.assertEqual(double_metaphone('Thompson'), ('TMPSN', '')) |
||
| 1873 | self.assertEqual(double_metaphone('Thorne'), ('0RN', 'TRN')) |
||
| 1874 | self.assertEqual(double_metaphone('Thornycraft'), |
||
| 1875 | ('0RNKRFT', 'TRNKRFT')) |
||
| 1876 | self.assertEqual(double_metaphone('Threlkeld'), ('0RLKLT', 'TRLKLT')) |
||
| 1877 | self.assertEqual(double_metaphone('Throckmorton'), |
||
| 1878 | ('0RKMRTN', 'TRKMRTN')) |
||
| 1879 | self.assertEqual(double_metaphone('Thwaits'), ('0TS', 'TTS')) |
||
| 1880 | self.assertEqual(double_metaphone('Tibbetts'), ('TPTS', '')) |
||
| 1881 | self.assertEqual(double_metaphone('Tidd'), ('TT', '')) |
||
| 1882 | self.assertEqual(double_metaphone('Tierney'), ('TRN', '')) |
||
| 1883 | self.assertEqual(double_metaphone('Tilley'), ('TL', '')) |
||
| 1884 | self.assertEqual(double_metaphone('Tillieres'), ('TLRS', '')) |
||
| 1885 | self.assertEqual(double_metaphone('Tilly'), ('TL', '')) |
||
| 1886 | self.assertEqual(double_metaphone('Tisdale'), ('TSTL', '')) |
||
| 1887 | self.assertEqual(double_metaphone('Titus'), ('TTS', '')) |
||
| 1888 | self.assertEqual(double_metaphone('Tobey'), ('TP', '')) |
||
| 1889 | self.assertEqual(double_metaphone('Tooker'), ('TKR', '')) |
||
| 1890 | self.assertEqual(double_metaphone('Towle'), ('TL', '')) |
||
| 1891 | self.assertEqual(double_metaphone('Towne'), ('TN', '')) |
||
| 1892 | self.assertEqual(double_metaphone('Townsend'), ('TNSNT', '')) |
||
| 1893 | self.assertEqual(double_metaphone('Treadway'), ('TRT', '')) |
||
| 1894 | self.assertEqual(double_metaphone('Trelawney'), ('TRLN', '')) |
||
| 1895 | self.assertEqual(double_metaphone('Trinder'), ('TRNTR', '')) |
||
| 1896 | self.assertEqual(double_metaphone('Tripp'), ('TRP', '')) |
||
| 1897 | self.assertEqual(double_metaphone('Trippe'), ('TRP', '')) |
||
| 1898 | self.assertEqual(double_metaphone('Trott'), ('TRT', '')) |
||
| 1899 | self.assertEqual(double_metaphone('True'), ('TR', '')) |
||
| 1900 | self.assertEqual(double_metaphone('Trussebut'), ('TRSPT', '')) |
||
| 1901 | self.assertEqual(double_metaphone('Tucker'), ('TKR', '')) |
||
| 1902 | self.assertEqual(double_metaphone('Turgeon'), ('TRJN', 'TRKN')) |
||
| 1903 | self.assertEqual(double_metaphone('Turner'), ('TRNR', '')) |
||
| 1904 | self.assertEqual(double_metaphone('Tuttle'), ('TTL', '')) |
||
| 1905 | self.assertEqual(double_metaphone('Tyler'), ('TLR', '')) |
||
| 1906 | self.assertEqual(double_metaphone('Tylle'), ('TL', '')) |
||
| 1907 | self.assertEqual(double_metaphone('Tyrrel'), ('TRL', '')) |
||
| 1908 | self.assertEqual(double_metaphone('Ua Tuathail'), ('AT0L', 'ATTL')) |
||
| 1909 | self.assertEqual(double_metaphone('Ulrich'), ('ALRX', 'ALRK')) |
||
| 1910 | self.assertEqual(double_metaphone('Underhill'), ('ANTRL', '')) |
||
| 1911 | self.assertEqual(double_metaphone('Underwood'), ('ANTRT', '')) |
||
| 1912 | self.assertEqual(double_metaphone('Unknown'), ('ANKNN', '')) |
||
| 1913 | self.assertEqual(double_metaphone('Valentine'), ('FLNTN', '')) |
||
| 1914 | self.assertEqual(double_metaphone('Van Egmond'), ('FNKMNT', '')) |
||
| 1915 | self.assertEqual(double_metaphone('Van der Beek'), ('FNTRPK', '')) |
||
| 1916 | self.assertEqual(double_metaphone('Vaughan'), ('FKN', '')) |
||
| 1917 | self.assertEqual(double_metaphone('Vermenlen'), ('FRMNLN', '')) |
||
| 1918 | self.assertEqual(double_metaphone('Vincent'), ('FNSNT', '')) |
||
| 1919 | self.assertEqual(double_metaphone('Volentine'), ('FLNTN', '')) |
||
| 1920 | self.assertEqual(double_metaphone('Wagner'), ('AKNR', 'FKNR')) |
||
| 1921 | self.assertEqual(double_metaphone('Waite'), ('AT', 'FT')) |
||
| 1922 | self.assertEqual(double_metaphone('Walker'), ('ALKR', 'FLKR')) |
||
| 1923 | self.assertEqual(double_metaphone('Walter'), ('ALTR', 'FLTR')) |
||
| 1924 | self.assertEqual(double_metaphone('Wandell'), ('ANTL', 'FNTL')) |
||
| 1925 | self.assertEqual(double_metaphone('Wandesford'), |
||
| 1926 | ('ANTSFRT', 'FNTSFRT')) |
||
| 1927 | self.assertEqual(double_metaphone('Warbleton'), ('ARPLTN', 'FRPLTN')) |
||
| 1928 | self.assertEqual(double_metaphone('Ward'), ('ART', 'FRT')) |
||
| 1929 | self.assertEqual(double_metaphone('Warde'), ('ART', 'FRT')) |
||
| 1930 | self.assertEqual(double_metaphone('Ware'), ('AR', 'FR')) |
||
| 1931 | self.assertEqual(double_metaphone('Wareham'), ('ARHM', 'FRHM')) |
||
| 1932 | self.assertEqual(double_metaphone('Warner'), ('ARNR', 'FRNR')) |
||
| 1933 | self.assertEqual(double_metaphone('Warren'), ('ARN', 'FRN')) |
||
| 1934 | self.assertEqual(double_metaphone('Washburne'), ('AXPRN', 'FXPRN')) |
||
| 1935 | self.assertEqual(double_metaphone('Waterbury'), ('ATRPR', 'FTRPR')) |
||
| 1936 | self.assertEqual(double_metaphone('Watson'), ('ATSN', 'FTSN')) |
||
| 1937 | self.assertEqual(double_metaphone('WatsonEllithorpe'), |
||
| 1938 | ('ATSNL0RP', 'FTSNLTRP')) |
||
| 1939 | self.assertEqual(double_metaphone('Watts'), ('ATS', 'FTS')) |
||
| 1940 | self.assertEqual(double_metaphone('Wayne'), ('AN', 'FN')) |
||
| 1941 | self.assertEqual(double_metaphone('Webb'), ('AP', 'FP')) |
||
| 1942 | self.assertEqual(double_metaphone('Weber'), ('APR', 'FPR')) |
||
| 1943 | self.assertEqual(double_metaphone('Webster'), ('APSTR', 'FPSTR')) |
||
| 1944 | self.assertEqual(double_metaphone('Weed'), ('AT', 'FT')) |
||
| 1945 | self.assertEqual(double_metaphone('Weeks'), ('AKS', 'FKS')) |
||
| 1946 | self.assertEqual(double_metaphone('Wells'), ('ALS', 'FLS')) |
||
| 1947 | self.assertEqual(double_metaphone('Wenzell'), ('ANSL', 'FNTSL')) |
||
| 1948 | self.assertEqual(double_metaphone('West'), ('AST', 'FST')) |
||
| 1949 | self.assertEqual(double_metaphone('Westbury'), ('ASTPR', 'FSTPR')) |
||
| 1950 | self.assertEqual(double_metaphone('Whatlocke'), ('ATLK', '')) |
||
| 1951 | self.assertEqual(double_metaphone('Wheeler'), ('ALR', '')) |
||
| 1952 | self.assertEqual(double_metaphone('Whiston'), ('ASTN', '')) |
||
| 1953 | self.assertEqual(double_metaphone('White'), ('AT', '')) |
||
| 1954 | self.assertEqual(double_metaphone('Whitman'), ('ATMN', '')) |
||
| 1955 | self.assertEqual(double_metaphone('Whiton'), ('ATN', '')) |
||
| 1956 | self.assertEqual(double_metaphone('Whitson'), ('ATSN', '')) |
||
| 1957 | self.assertEqual(double_metaphone('Wickes'), ('AKS', 'FKS')) |
||
| 1958 | self.assertEqual(double_metaphone('Wilbur'), ('ALPR', 'FLPR')) |
||
| 1959 | self.assertEqual(double_metaphone('Wilcotes'), ('ALKTS', 'FLKTS')) |
||
| 1960 | self.assertEqual(double_metaphone('Wilkinson'), ('ALKNSN', 'FLKNSN')) |
||
| 1961 | self.assertEqual(double_metaphone('Willets'), ('ALTS', 'FLTS')) |
||
| 1962 | self.assertEqual(double_metaphone('Willett'), ('ALT', 'FLT')) |
||
| 1963 | self.assertEqual(double_metaphone('Willey'), ('AL', 'FL')) |
||
| 1964 | self.assertEqual(double_metaphone('Williams'), ('ALMS', 'FLMS')) |
||
| 1965 | self.assertEqual(double_metaphone('Williston'), ('ALSTN', 'FLSTN')) |
||
| 1966 | self.assertEqual(double_metaphone('Wilson'), ('ALSN', 'FLSN')) |
||
| 1967 | self.assertEqual(double_metaphone('Wimes'), ('AMS', 'FMS')) |
||
| 1968 | self.assertEqual(double_metaphone('Winch'), ('ANX', 'FNK')) |
||
| 1969 | self.assertEqual(double_metaphone('Winegar'), ('ANKR', 'FNKR')) |
||
| 1970 | self.assertEqual(double_metaphone('Wing'), ('ANK', 'FNK')) |
||
| 1971 | self.assertEqual(double_metaphone('Winsley'), ('ANSL', 'FNSL')) |
||
| 1972 | self.assertEqual(double_metaphone('Winslow'), ('ANSL', 'FNSLF')) |
||
| 1973 | self.assertEqual(double_metaphone('Winthrop'), ('AN0RP', 'FNTRP')) |
||
| 1974 | self.assertEqual(double_metaphone('Wise'), ('AS', 'FS')) |
||
| 1975 | self.assertEqual(double_metaphone('Wood'), ('AT', 'FT')) |
||
| 1976 | self.assertEqual(double_metaphone('Woodbridge'), ('ATPRJ', 'FTPRJ')) |
||
| 1977 | self.assertEqual(double_metaphone('Woodward'), ('ATRT', 'FTRT')) |
||
| 1978 | self.assertEqual(double_metaphone('Wooley'), ('AL', 'FL')) |
||
| 1979 | self.assertEqual(double_metaphone('Woolley'), ('AL', 'FL')) |
||
| 1980 | self.assertEqual(double_metaphone('Worth'), ('AR0', 'FRT')) |
||
| 1981 | self.assertEqual(double_metaphone('Worthen'), ('AR0N', 'FRTN')) |
||
| 1982 | self.assertEqual(double_metaphone('Worthley'), ('AR0L', 'FRTL')) |
||
| 1983 | self.assertEqual(double_metaphone('Wright'), ('RT', '')) |
||
| 1984 | self.assertEqual(double_metaphone('Wyer'), ('AR', 'FR')) |
||
| 1985 | self.assertEqual(double_metaphone('Wyere'), ('AR', 'FR')) |
||
| 1986 | self.assertEqual(double_metaphone('Wynkoop'), ('ANKP', 'FNKP')) |
||
| 1987 | self.assertEqual(double_metaphone('Yarnall'), ('ARNL', '')) |
||
| 1988 | self.assertEqual(double_metaphone('Yeoman'), ('AMN', '')) |
||
| 1989 | self.assertEqual(double_metaphone('Yorke'), ('ARK', '')) |
||
| 1990 | self.assertEqual(double_metaphone('Young'), ('ANK', '')) |
||
| 1991 | self.assertEqual(double_metaphone('ab Wennonwen'), ('APNNN', '')) |
||
| 1992 | self.assertEqual(double_metaphone('ap Llewellyn'), ('APLLN', '')) |
||
| 1993 | self.assertEqual(double_metaphone('ap Lorwerth'), ('APLRR0', 'APLRRT')) |
||
| 1994 | self.assertEqual(double_metaphone('d\'Angouleme'), ('TNKLM', '')) |
||
| 1995 | self.assertEqual(double_metaphone('de Audeham'), ('TTHM', '')) |
||
| 1996 | self.assertEqual(double_metaphone('de Bavant'), ('TPFNT', '')) |
||
| 1997 | self.assertEqual(double_metaphone('de Beauchamp'), ('TPXMP', 'TPKMP')) |
||
| 1998 | self.assertEqual(double_metaphone('de Beaumont'), ('TPMNT', '')) |
||
| 1999 | self.assertEqual(double_metaphone('de Bolbec'), ('TPLPK', '')) |
||
| 2000 | self.assertEqual(double_metaphone('de Braiose'), ('TPRS', '')) |
||
| 2001 | self.assertEqual(double_metaphone('de Braose'), ('TPRS', '')) |
||
| 2002 | self.assertEqual(double_metaphone('de Briwere'), ('TPRR', '')) |
||
| 2003 | self.assertEqual(double_metaphone('de Cantelou'), ('TKNTL', '')) |
||
| 2004 | self.assertEqual(double_metaphone('de Cherelton'), |
||
| 2005 | ('TXRLTN', 'TKRLTN')) |
||
| 2006 | self.assertEqual(double_metaphone('de Cherleton'), |
||
| 2007 | ('TXRLTN', 'TKRLTN')) |
||
| 2008 | self.assertEqual(double_metaphone('de Clare'), ('TKLR', '')) |
||
| 2009 | self.assertEqual(double_metaphone('de Claremont'), ('TKLRMNT', '')) |
||
| 2010 | self.assertEqual(double_metaphone('de Clifford'), ('TKLFRT', '')) |
||
| 2011 | self.assertEqual(double_metaphone('de Colville'), ('TKLFL', '')) |
||
| 2012 | self.assertEqual(double_metaphone('de Courtenay'), ('TKRTN', '')) |
||
| 2013 | self.assertEqual(double_metaphone('de Fauconberg'), ('TFKNPRK', '')) |
||
| 2014 | self.assertEqual(double_metaphone('de Forest'), ('TFRST', '')) |
||
| 2015 | self.assertEqual(double_metaphone('de Gai'), ('TK', '')) |
||
| 2016 | self.assertEqual(double_metaphone('de Grey'), ('TKR', '')) |
||
| 2017 | self.assertEqual(double_metaphone('de Guernons'), ('TKRNNS', '')) |
||
| 2018 | self.assertEqual(double_metaphone('de Haia'), ('T', '')) |
||
| 2019 | self.assertEqual(double_metaphone('de Harcourt'), ('TRKRT', '')) |
||
| 2020 | self.assertEqual(double_metaphone('de Hastings'), ('TSTNKS', '')) |
||
| 2021 | self.assertEqual(double_metaphone('de Hoke'), ('TK', '')) |
||
| 2022 | self.assertEqual(double_metaphone('de Hooch'), ('TK', '')) |
||
| 2023 | self.assertEqual(double_metaphone('de Hugelville'), ('TJLFL', 'TKLFL')) |
||
| 2024 | self.assertEqual(double_metaphone('de Huntingdon'), ('TNTNKTN', '')) |
||
| 2025 | self.assertEqual(double_metaphone('de Insula'), ('TNSL', '')) |
||
| 2026 | self.assertEqual(double_metaphone('de Keynes'), ('TKNS', '')) |
||
| 2027 | self.assertEqual(double_metaphone('de Lacy'), ('TLS', '')) |
||
| 2028 | self.assertEqual(double_metaphone('de Lexington'), ('TLKSNKTN', '')) |
||
| 2029 | self.assertEqual(double_metaphone('de Lusignan'), ('TLSNN', 'TLSKNN')) |
||
| 2030 | self.assertEqual(double_metaphone('de Manvers'), ('TMNFRS', '')) |
||
| 2031 | self.assertEqual(double_metaphone('de Montagu'), ('TMNTK', '')) |
||
| 2032 | self.assertEqual(double_metaphone('de Montault'), ('TMNTLT', '')) |
||
| 2033 | self.assertEqual(double_metaphone('de Montfort'), ('TMNTFRT', '')) |
||
| 2034 | self.assertEqual(double_metaphone('de Mortimer'), ('TMRTMR', '')) |
||
| 2035 | self.assertEqual(double_metaphone('de Morville'), ('TMRFL', '')) |
||
| 2036 | self.assertEqual(double_metaphone('de Morvois'), ('TMRF', 'TMRFS')) |
||
| 2037 | self.assertEqual(double_metaphone('de Neufmarche'), |
||
| 2038 | ('TNFMRX', 'TNFMRK')) |
||
| 2039 | self.assertEqual(double_metaphone('de Odingsells'), ('TTNKSLS', '')) |
||
| 2040 | self.assertEqual(double_metaphone('de Odyngsells'), ('TTNKSLS', '')) |
||
| 2041 | self.assertEqual(double_metaphone('de Percy'), ('TPRS', '')) |
||
| 2042 | self.assertEqual(double_metaphone('de Pierrepont'), ('TPRPNT', '')) |
||
| 2043 | self.assertEqual(double_metaphone('de Plessetis'), ('TPLSTS', '')) |
||
| 2044 | self.assertEqual(double_metaphone('de Porhoet'), ('TPRT', '')) |
||
| 2045 | self.assertEqual(double_metaphone('de Prouz'), ('TPRS', '')) |
||
| 2046 | self.assertEqual(double_metaphone('de Quincy'), ('TKNS', '')) |
||
| 2047 | self.assertEqual(double_metaphone('de Ripellis'), ('TRPLS', '')) |
||
| 2048 | self.assertEqual(double_metaphone('de Ros'), ('TRS', '')) |
||
| 2049 | self.assertEqual(double_metaphone('de Salisbury'), ('TSLSPR', '')) |
||
| 2050 | self.assertEqual(double_metaphone('de Sanford'), ('TSNFRT', '')) |
||
| 2051 | self.assertEqual(double_metaphone('de Somery'), ('TSMR', '')) |
||
| 2052 | self.assertEqual(double_metaphone('de St. Hilary'), ('TSTLR', '')) |
||
| 2053 | self.assertEqual(double_metaphone('de St. Liz'), ('TSTLS', '')) |
||
| 2054 | self.assertEqual(double_metaphone('de Sutton'), ('TSTN', '')) |
||
| 2055 | self.assertEqual(double_metaphone('de Toeni'), ('TTN', '')) |
||
| 2056 | self.assertEqual(double_metaphone('de Tony'), ('TTN', '')) |
||
| 2057 | self.assertEqual(double_metaphone('de Umfreville'), ('TMFRFL', '')) |
||
| 2058 | self.assertEqual(double_metaphone('de Valognes'), ('TFLNS', 'TFLKNS')) |
||
| 2059 | self.assertEqual(double_metaphone('de Vaux'), ('TF', '')) |
||
| 2060 | self.assertEqual(double_metaphone('de Vere'), ('TFR', '')) |
||
| 2061 | self.assertEqual(double_metaphone('de Vermandois'), |
||
| 2062 | ('TFRMNT', 'TFRMNTS')) |
||
| 2063 | self.assertEqual(double_metaphone('de Vernon'), ('TFRNN', '')) |
||
| 2064 | self.assertEqual(double_metaphone('de Vexin'), ('TFKSN', '')) |
||
| 2065 | self.assertEqual(double_metaphone('de Vitre'), ('TFTR', '')) |
||
| 2066 | self.assertEqual(double_metaphone('de Wandesford'), ('TNTSFRT', '')) |
||
| 2067 | self.assertEqual(double_metaphone('de Warenne'), ('TRN', '')) |
||
| 2068 | self.assertEqual(double_metaphone('de Westbury'), ('TSTPR', '')) |
||
| 2069 | self.assertEqual(double_metaphone('di Saluzzo'), ('TSLS', 'TSLTS')) |
||
| 2070 | self.assertEqual(double_metaphone('fitz Alan'), ('FTSLN', '')) |
||
| 2071 | self.assertEqual(double_metaphone('fitz Geoffrey'), |
||
| 2072 | ('FTSJFR', 'FTSKFR')) |
||
| 2073 | self.assertEqual(double_metaphone('fitz Herbert'), ('FTSRPRT', '')) |
||
| 2074 | self.assertEqual(double_metaphone('fitz John'), ('FTSJN', '')) |
||
| 2075 | self.assertEqual(double_metaphone('fitz Patrick'), ('FTSPTRK', '')) |
||
| 2076 | self.assertEqual(double_metaphone('fitz Payn'), ('FTSPN', '')) |
||
| 2077 | self.assertEqual(double_metaphone('fitz Piers'), ('FTSPRS', '')) |
||
| 2078 | self.assertEqual(double_metaphone('fitz Randolph'), ('FTSRNTLF', '')) |
||
| 2079 | self.assertEqual(double_metaphone('fitz Richard'), |
||
| 2080 | ('FTSRXRT', 'FTSRKRT')) |
||
| 2081 | self.assertEqual(double_metaphone('fitz Robert'), ('FTSRPRT', '')) |
||
| 2082 | self.assertEqual(double_metaphone('fitz Roy'), ('FTSR', '')) |
||
| 2083 | self.assertEqual(double_metaphone('fitz Scrob'), ('FTSSKP', '')) |
||
| 2084 | self.assertEqual(double_metaphone('fitz Walter'), ('FTSLTR', '')) |
||
| 2085 | self.assertEqual(double_metaphone('fitz Warin'), ('FTSRN', '')) |
||
| 2086 | self.assertEqual(double_metaphone('fitz Williams'), ('FTSLMS', '')) |
||
| 2087 | self.assertEqual(double_metaphone('la Zouche'), ('LSX', 'LSK')) |
||
| 2088 | self.assertEqual(double_metaphone('le Botiller'), ('LPTLR', '')) |
||
| 2089 | self.assertEqual(double_metaphone('le Despenser'), ('LTSPNSR', '')) |
||
| 2090 | self.assertEqual(double_metaphone('le deSpencer'), ('LTSPNSR', '')) |
||
| 2091 | self.assertEqual(double_metaphone('of Allendale'), ('AFLNTL', '')) |
||
| 2092 | self.assertEqual(double_metaphone('of Angouleme'), ('AFNKLM', '')) |
||
| 2093 | self.assertEqual(double_metaphone('of Anjou'), ('AFNJ', '')) |
||
| 2094 | self.assertEqual(double_metaphone('of Aquitaine'), ('AFKTN', '')) |
||
| 2095 | self.assertEqual(double_metaphone('of Aumale'), ('AFML', '')) |
||
| 2096 | self.assertEqual(double_metaphone('of Bavaria'), ('AFPFR', '')) |
||
| 2097 | self.assertEqual(double_metaphone('of Boulogne'), ('AFPLN', 'AFPLKN')) |
||
| 2098 | self.assertEqual(double_metaphone('of Brittany'), ('AFPRTN', '')) |
||
| 2099 | self.assertEqual(double_metaphone('of Brittary'), ('AFPRTR', '')) |
||
| 2100 | self.assertEqual(double_metaphone('of Castile'), ('AFKSTL', '')) |
||
| 2101 | self.assertEqual(double_metaphone('of Chester'), ('AFXSTR', 'AFKSTR')) |
||
| 2102 | self.assertEqual(double_metaphone('of Clermont'), ('AFKLRMNT', '')) |
||
| 2103 | self.assertEqual(double_metaphone('of Cologne'), ('AFKLN', 'AFKLKN')) |
||
| 2104 | self.assertEqual(double_metaphone('of Dinan'), ('AFTNN', '')) |
||
| 2105 | self.assertEqual(double_metaphone('of Dunbar'), ('AFTNPR', '')) |
||
| 2106 | self.assertEqual(double_metaphone('of England'), ('AFNKLNT', '')) |
||
| 2107 | self.assertEqual(double_metaphone('of Essex'), ('AFSKS', '')) |
||
| 2108 | self.assertEqual(double_metaphone('of Falaise'), ('AFFLS', '')) |
||
| 2109 | self.assertEqual(double_metaphone('of Flanders'), ('AFFLNTRS', '')) |
||
| 2110 | self.assertEqual(double_metaphone('of Galloway'), ('AFKL', '')) |
||
| 2111 | self.assertEqual(double_metaphone('of Germany'), ('AFKRMN', 'AFJRMN')) |
||
| 2112 | self.assertEqual(double_metaphone('of Gloucester'), ('AFKLSSTR', '')) |
||
| 2113 | self.assertEqual(double_metaphone('of Heristal'), ('AFRSTL', '')) |
||
| 2114 | self.assertEqual(double_metaphone('of Hungary'), ('AFNKR', '')) |
||
| 2115 | self.assertEqual(double_metaphone('of Huntington'), ('AFNTNKTN', '')) |
||
| 2116 | self.assertEqual(double_metaphone('of Kiev'), ('AFKF', '')) |
||
| 2117 | self.assertEqual(double_metaphone('of Kuno'), ('AFKN', '')) |
||
| 2118 | self.assertEqual(double_metaphone('of Landen'), ('AFLNTN', '')) |
||
| 2119 | self.assertEqual(double_metaphone('of Laon'), ('AFLN', '')) |
||
| 2120 | self.assertEqual(double_metaphone('of Leinster'), ('AFLNSTR', '')) |
||
| 2121 | self.assertEqual(double_metaphone('of Lens'), ('AFLNS', '')) |
||
| 2122 | self.assertEqual(double_metaphone('of Lorraine'), ('AFLRN', '')) |
||
| 2123 | self.assertEqual(double_metaphone('of Louvain'), ('AFLFN', '')) |
||
| 2124 | self.assertEqual(double_metaphone('of Mercia'), ('AFMRS', 'AFMRX')) |
||
| 2125 | self.assertEqual(double_metaphone('of Metz'), ('AFMTS', '')) |
||
| 2126 | self.assertEqual(double_metaphone('of Meulan'), ('AFMLN', '')) |
||
| 2127 | self.assertEqual(double_metaphone('of Nass'), ('AFNS', '')) |
||
| 2128 | self.assertEqual(double_metaphone('of Normandy'), ('AFNRMNT', '')) |
||
| 2129 | self.assertEqual(double_metaphone('of Ohningen'), ('AFNNJN', 'AFNNKN')) |
||
| 2130 | self.assertEqual(double_metaphone('of Orleans'), ('AFRLNS', '')) |
||
| 2131 | self.assertEqual(double_metaphone('of Poitou'), ('AFPT', '')) |
||
| 2132 | self.assertEqual(double_metaphone('of Polotzk'), ('AFPLTSK', '')) |
||
| 2133 | self.assertEqual(double_metaphone('of Provence'), ('AFPRFNS', '')) |
||
| 2134 | self.assertEqual(double_metaphone('of Ringelheim'), |
||
| 2135 | ('AFRNJLM', 'AFRNKLM')) |
||
| 2136 | self.assertEqual(double_metaphone('of Salisbury'), ('AFSLSPR', '')) |
||
| 2137 | self.assertEqual(double_metaphone('of Saxony'), ('AFSKSN', '')) |
||
| 2138 | self.assertEqual(double_metaphone('of Scotland'), ('AFSKTLNT', '')) |
||
| 2139 | self.assertEqual(double_metaphone('of Senlis'), ('AFSNLS', '')) |
||
| 2140 | self.assertEqual(double_metaphone('of Stafford'), ('AFSTFRT', '')) |
||
| 2141 | self.assertEqual(double_metaphone('of Swabia'), ('AFSP', '')) |
||
| 2142 | self.assertEqual(double_metaphone('of Tongres'), ('AFTNKRS', '')) |
||
| 2143 | self.assertEqual(double_metaphone('of the Tributes'), |
||
| 2144 | ('AF0TRPTS', 'AFTTRPTS')) |
||
| 2145 | self.assertEqual(double_metaphone('unknown'), ('ANKNN', '')) |
||
| 2146 | self.assertEqual(double_metaphone('van der Gouda'), ('FNTRKT', '')) |
||
| 2147 | self.assertEqual(double_metaphone('von Adenbaugh'), ('FNTNP', '')) |
||
| 2148 | self.assertEqual(double_metaphone('ARCHITure'), ('ARKTR', '')) |
||
| 2149 | self.assertEqual(double_metaphone('Arnoff'), ('ARNF', '')) |
||
| 2150 | self.assertEqual(double_metaphone('Arnow'), ('ARN', 'ARNF')) |
||
| 2151 | self.assertEqual(double_metaphone('DANGER'), ('TNJR', 'TNKR')) |
||
| 2152 | self.assertEqual(double_metaphone('Jankelowicz'), ('JNKLTS', 'ANKLFX')) |
||
| 2153 | self.assertEqual(double_metaphone('MANGER'), ('MNJR', 'MNKR')) |
||
| 2154 | self.assertEqual(double_metaphone('McClellan'), ('MKLLN', '')) |
||
| 2155 | self.assertEqual(double_metaphone('McHugh'), ('MK', '')) |
||
| 2156 | self.assertEqual(double_metaphone('McLaughlin'), ('MKLFLN', '')) |
||
| 2157 | self.assertEqual(double_metaphone('ORCHEStra'), ('ARKSTR', '')) |
||
| 2158 | self.assertEqual(double_metaphone('ORCHID'), ('ARKT', '')) |
||
| 2159 | self.assertEqual(double_metaphone('Pierce'), ('PRS', '')) |
||
| 2160 | self.assertEqual(double_metaphone('RANGER'), ('RNJR', 'RNKR')) |
||
| 2161 | self.assertEqual(double_metaphone('Schlesinger'), ('XLSNKR', 'SLSNJR')) |
||
| 2162 | self.assertEqual(double_metaphone('Uomo'), ('AM', '')) |
||
| 2163 | self.assertEqual(double_metaphone('Vasserman'), ('FSRMN', '')) |
||
| 2164 | self.assertEqual(double_metaphone('Wasserman'), ('ASRMN', 'FSRMN')) |
||
| 2165 | self.assertEqual(double_metaphone('Womo'), ('AM', 'FM')) |
||
| 2166 | self.assertEqual(double_metaphone('Yankelovich'), ('ANKLFX', 'ANKLFK')) |
||
| 2167 | self.assertEqual(double_metaphone('accede'), ('AKST', '')) |
||
| 2168 | self.assertEqual(double_metaphone('accident'), ('AKSTNT', '')) |
||
| 2169 | self.assertEqual(double_metaphone('adelsheim'), ('ATLSM', '')) |
||
| 2170 | self.assertEqual(double_metaphone('aged'), ('AJT', 'AKT')) |
||
| 2171 | self.assertEqual(double_metaphone('ageless'), ('AJLS', 'AKLS')) |
||
| 2172 | self.assertEqual(double_metaphone('agency'), ('AJNS', 'AKNS')) |
||
| 2173 | self.assertEqual(double_metaphone('aghast'), ('AKST', '')) |
||
| 2174 | self.assertEqual(double_metaphone('agio'), ('AJ', 'AK')) |
||
| 2175 | self.assertEqual(double_metaphone('agrimony'), ('AKRMN', '')) |
||
| 2176 | self.assertEqual(double_metaphone('album'), ('ALPM', '')) |
||
| 2177 | self.assertEqual(double_metaphone('alcmene'), ('ALKMN', '')) |
||
| 2178 | self.assertEqual(double_metaphone('alehouse'), ('ALHS', '')) |
||
| 2179 | self.assertEqual(double_metaphone('antique'), ('ANTK', '')) |
||
| 2180 | self.assertEqual(double_metaphone('artois'), ('ART', 'ARTS')) |
||
| 2181 | self.assertEqual(double_metaphone('automation'), ('ATMXN', '')) |
||
| 2182 | self.assertEqual(double_metaphone('bacchus'), ('PKS', '')) |
||
| 2183 | self.assertEqual(double_metaphone('bacci'), ('PX', '')) |
||
| 2184 | self.assertEqual(double_metaphone('bajador'), ('PJTR', 'PHTR')) |
||
| 2185 | self.assertEqual(double_metaphone('bellocchio'), ('PLX', '')) |
||
| 2186 | self.assertEqual(double_metaphone('bertucci'), ('PRTX', '')) |
||
| 2187 | self.assertEqual(double_metaphone('biaggi'), ('PJ', 'PK')) |
||
| 2188 | self.assertEqual(double_metaphone('bough'), ('P', '')) |
||
| 2189 | self.assertEqual(double_metaphone('breaux'), ('PR', '')) |
||
| 2190 | self.assertEqual(double_metaphone('broughton'), ('PRTN', '')) |
||
| 2191 | self.assertEqual(double_metaphone('cabrillo'), ('KPRL', 'KPR')) |
||
| 2192 | self.assertEqual(double_metaphone('caesar'), ('SSR', '')) |
||
| 2193 | self.assertEqual(double_metaphone('cagney'), ('KKN', '')) |
||
| 2194 | self.assertEqual(double_metaphone('campbell'), ('KMPL', '')) |
||
| 2195 | self.assertEqual(double_metaphone('carlisle'), ('KRLL', '')) |
||
| 2196 | self.assertEqual(double_metaphone('carlysle'), ('KRLL', '')) |
||
| 2197 | self.assertEqual(double_metaphone('chemistry'), ('KMSTR', '')) |
||
| 2198 | self.assertEqual(double_metaphone('chianti'), ('KNT', '')) |
||
| 2199 | self.assertEqual(double_metaphone('chorus'), ('KRS', '')) |
||
| 2200 | self.assertEqual(double_metaphone('cough'), ('KF', '')) |
||
| 2201 | self.assertEqual(double_metaphone('czerny'), ('SRN', 'XRN')) |
||
| 2202 | self.assertEqual(double_metaphone('deffenbacher'), ('TFNPKR', '')) |
||
| 2203 | self.assertEqual(double_metaphone('dumb'), ('TM', '')) |
||
| 2204 | self.assertEqual(double_metaphone('edgar'), ('ATKR', '')) |
||
| 2205 | self.assertEqual(double_metaphone('edge'), ('AJ', '')) |
||
| 2206 | self.assertEqual(double_metaphone('filipowicz'), ('FLPTS', 'FLPFX')) |
||
| 2207 | self.assertEqual(double_metaphone('focaccia'), ('FKX', '')) |
||
| 2208 | self.assertEqual(double_metaphone('gallegos'), ('KLKS', 'KKS')) |
||
| 2209 | self.assertEqual(double_metaphone('gambrelli'), ('KMPRL', '')) |
||
| 2210 | self.assertEqual(double_metaphone('geithain'), ('K0N', 'JTN')) |
||
| 2211 | self.assertEqual(double_metaphone('ghiradelli'), ('JRTL', '')) |
||
| 2212 | self.assertEqual(double_metaphone('ghislane'), ('JLN', '')) |
||
| 2213 | self.assertEqual(double_metaphone('gough'), ('KF', '')) |
||
| 2214 | self.assertEqual(double_metaphone('hartheim'), ('HR0M', 'HRTM')) |
||
| 2215 | self.assertEqual(double_metaphone('heimsheim'), ('HMSM', '')) |
||
| 2216 | self.assertEqual(double_metaphone('hochmeier'), ('HKMR', '')) |
||
| 2217 | self.assertEqual(double_metaphone('hugh'), ('H', '')) |
||
| 2218 | self.assertEqual(double_metaphone('hunger'), ('HNKR', 'HNJR')) |
||
| 2219 | self.assertEqual(double_metaphone('hungry'), ('HNKR', '')) |
||
| 2220 | self.assertEqual(double_metaphone('island'), ('ALNT', '')) |
||
| 2221 | self.assertEqual(double_metaphone('isle'), ('AL', '')) |
||
| 2222 | self.assertEqual(double_metaphone('jose'), ('HS', '')) |
||
| 2223 | self.assertEqual(double_metaphone('laugh'), ('LF', '')) |
||
| 2224 | self.assertEqual(double_metaphone('mac caffrey'), ('MKFR', '')) |
||
| 2225 | self.assertEqual(double_metaphone('mac gregor'), ('MKRKR', '')) |
||
| 2226 | self.assertEqual(double_metaphone('pegnitz'), ('PNTS', 'PKNTS')) |
||
| 2227 | self.assertEqual(double_metaphone('piskowitz'), ('PSKTS', 'PSKFX')) |
||
| 2228 | self.assertEqual(double_metaphone('queen'), ('KN', '')) |
||
| 2229 | self.assertEqual(double_metaphone('raspberry'), ('RSPR', '')) |
||
| 2230 | self.assertEqual(double_metaphone('resnais'), ('RSN', 'RSNS')) |
||
| 2231 | self.assertEqual(double_metaphone('rogier'), ('RJ', 'RJR')) |
||
| 2232 | self.assertEqual(double_metaphone('rough'), ('RF', '')) |
||
| 2233 | self.assertEqual(double_metaphone('san jacinto'), ('SNHSNT', '')) |
||
| 2234 | self.assertEqual(double_metaphone('schenker'), ('XNKR', 'SKNKR')) |
||
| 2235 | self.assertEqual(double_metaphone('schermerhorn'), |
||
| 2236 | ('XRMRRN', 'SKRMRRN')) |
||
| 2237 | self.assertEqual(double_metaphone('schmidt'), ('XMT', 'SMT')) |
||
| 2238 | self.assertEqual(double_metaphone('schneider'), ('XNTR', 'SNTR')) |
||
| 2239 | self.assertEqual(double_metaphone('school'), ('SKL', '')) |
||
| 2240 | self.assertEqual(double_metaphone('schooner'), ('SKNR', '')) |
||
| 2241 | self.assertEqual(double_metaphone('schrozberg'), ('XRSPRK', 'SRSPRK')) |
||
| 2242 | self.assertEqual(double_metaphone('schulman'), ('XLMN', '')) |
||
| 2243 | self.assertEqual(double_metaphone('schwabach'), ('XPK', 'XFPK')) |
||
| 2244 | self.assertEqual(double_metaphone('schwarzach'), ('XRSK', 'XFRTSK')) |
||
| 2245 | self.assertEqual(double_metaphone('smith'), ('SM0', 'XMT')) |
||
| 2246 | self.assertEqual(double_metaphone('snider'), ('SNTR', 'XNTR')) |
||
| 2247 | self.assertEqual(double_metaphone('succeed'), ('SKST', '')) |
||
| 2248 | self.assertEqual(double_metaphone('sugarcane'), ('XKRKN', 'SKRKN')) |
||
| 2249 | self.assertEqual(double_metaphone('svobodka'), ('SFPTK', '')) |
||
| 2250 | self.assertEqual(double_metaphone('tagliaro'), ('TKLR', 'TLR')) |
||
| 2251 | self.assertEqual(double_metaphone('thames'), ('TMS', '')) |
||
| 2252 | self.assertEqual(double_metaphone('theilheim'), ('0LM', 'TLM')) |
||
| 2253 | self.assertEqual(double_metaphone('thomas'), ('TMS', '')) |
||
| 2254 | self.assertEqual(double_metaphone('thumb'), ('0M', 'TM')) |
||
| 2255 | self.assertEqual(double_metaphone('tichner'), ('TXNR', 'TKNR')) |
||
| 2256 | self.assertEqual(double_metaphone('tough'), ('TF', '')) |
||
| 2257 | self.assertEqual(double_metaphone('umbrella'), ('AMPRL', '')) |
||
| 2258 | self.assertEqual(double_metaphone('vilshofen'), ('FLXFN', '')) |
||
| 2259 | self.assertEqual(double_metaphone('von schuller'), ('FNXLR', '')) |
||
| 2260 | self.assertEqual(double_metaphone('wachtler'), ('AKTLR', 'FKTLR')) |
||
| 2261 | self.assertEqual(double_metaphone('wechsler'), ('AKSLR', 'FKSLR')) |
||
| 2262 | self.assertEqual(double_metaphone('weikersheim'), ('AKRSM', 'FKRSM')) |
||
| 2263 | self.assertEqual(double_metaphone('zhao'), ('J', '')) |
||
| 2264 | |||
| 2265 | def test_double_metaphone_surnames4(self): |
||
| 2266 | """Test abydos.phonetic.double_metaphone (surname data, 4-letter).""" |
||
| 2267 | self.assertEqual(double_metaphone('', 4), ('', '')) |
||
| 2268 | self.assertEqual(double_metaphone('ALLERTON', 4), ('ALRT', '')) |
||
| 2269 | self.assertEqual(double_metaphone('Acton', 4), ('AKTN', '')) |
||
| 2270 | self.assertEqual(double_metaphone('Adams', 4), ('ATMS', '')) |
||
| 2271 | self.assertEqual(double_metaphone('Aggar', 4), ('AKR', '')) |
||
| 2272 | self.assertEqual(double_metaphone('Ahl', 4), ('AL', '')) |
||
| 2273 | self.assertEqual(double_metaphone('Aiken', 4), ('AKN', '')) |
||
| 2274 | self.assertEqual(double_metaphone('Alan', 4), ('ALN', '')) |
||
| 2275 | self.assertEqual(double_metaphone('Alcock', 4), ('ALKK', '')) |
||
| 2276 | self.assertEqual(double_metaphone('Alden', 4), ('ALTN', '')) |
||
| 2277 | self.assertEqual(double_metaphone('Aldham', 4), ('ALTM', '')) |
||
| 2278 | self.assertEqual(double_metaphone('Allen', 4), ('ALN', '')) |
||
| 2279 | self.assertEqual(double_metaphone('Allerton', 4), ('ALRT', '')) |
||
| 2280 | self.assertEqual(double_metaphone('Alsop', 4), ('ALSP', '')) |
||
| 2281 | self.assertEqual(double_metaphone('Alwein', 4), ('ALN', '')) |
||
| 2282 | self.assertEqual(double_metaphone('Ambler', 4), ('AMPL', '')) |
||
| 2283 | self.assertEqual(double_metaphone('Andevill', 4), ('ANTF', '')) |
||
| 2284 | self.assertEqual(double_metaphone('Andrews', 4), ('ANTR', '')) |
||
| 2285 | self.assertEqual(double_metaphone('Andreyco', 4), ('ANTR', '')) |
||
| 2286 | self.assertEqual(double_metaphone('Andriesse', 4), ('ANTR', '')) |
||
| 2287 | self.assertEqual(double_metaphone('Angier', 4), ('ANJ', 'ANJR')) |
||
| 2288 | self.assertEqual(double_metaphone('Annabel', 4), ('ANPL', '')) |
||
| 2289 | self.assertEqual(double_metaphone('Anne', 4), ('AN', '')) |
||
| 2290 | self.assertEqual(double_metaphone('Anstye', 4), ('ANST', '')) |
||
| 2291 | self.assertEqual(double_metaphone('Appling', 4), ('APLN', '')) |
||
| 2292 | self.assertEqual(double_metaphone('Apuke', 4), ('APK', '')) |
||
| 2293 | self.assertEqual(double_metaphone('Arnold', 4), ('ARNL', '')) |
||
| 2294 | self.assertEqual(double_metaphone('Ashby', 4), ('AXP', '')) |
||
| 2295 | self.assertEqual(double_metaphone('Astwood', 4), ('ASTT', '')) |
||
| 2296 | self.assertEqual(double_metaphone('Atkinson', 4), ('ATKN', '')) |
||
| 2297 | self.assertEqual(double_metaphone('Audley', 4), ('ATL', '')) |
||
| 2298 | self.assertEqual(double_metaphone('Austin', 4), ('ASTN', '')) |
||
| 2299 | self.assertEqual(double_metaphone('Avenal', 4), ('AFNL', '')) |
||
| 2300 | self.assertEqual(double_metaphone('Ayer', 4), ('AR', '')) |
||
| 2301 | self.assertEqual(double_metaphone('Ayot', 4), ('AT', '')) |
||
| 2302 | self.assertEqual(double_metaphone('Babbitt', 4), ('PPT', '')) |
||
| 2303 | self.assertEqual(double_metaphone('Bachelor', 4), ('PXLR', 'PKLR')) |
||
| 2304 | self.assertEqual(double_metaphone('Bachelour', 4), ('PXLR', 'PKLR')) |
||
| 2305 | self.assertEqual(double_metaphone('Bailey', 4), ('PL', '')) |
||
| 2306 | self.assertEqual(double_metaphone('Baivel', 4), ('PFL', '')) |
||
| 2307 | self.assertEqual(double_metaphone('Baker', 4), ('PKR', '')) |
||
| 2308 | self.assertEqual(double_metaphone('Baldwin', 4), ('PLTN', '')) |
||
| 2309 | self.assertEqual(double_metaphone('Balsley', 4), ('PLSL', '')) |
||
| 2310 | self.assertEqual(double_metaphone('Barber', 4), ('PRPR', '')) |
||
| 2311 | self.assertEqual(double_metaphone('Barker', 4), ('PRKR', '')) |
||
| 2312 | self.assertEqual(double_metaphone('Barlow', 4), ('PRL', 'PRLF')) |
||
| 2313 | self.assertEqual(double_metaphone('Barnard', 4), ('PRNR', '')) |
||
| 2314 | self.assertEqual(double_metaphone('Barnes', 4), ('PRNS', '')) |
||
| 2315 | self.assertEqual(double_metaphone('Barnsley', 4), ('PRNS', '')) |
||
| 2316 | self.assertEqual(double_metaphone('Barouxis', 4), ('PRKS', '')) |
||
| 2317 | self.assertEqual(double_metaphone('Bartlet', 4), ('PRTL', '')) |
||
| 2318 | self.assertEqual(double_metaphone('Basley', 4), ('PSL', '')) |
||
| 2319 | self.assertEqual(double_metaphone('Basset', 4), ('PST', '')) |
||
| 2320 | self.assertEqual(double_metaphone('Bassett', 4), ('PST', '')) |
||
| 2321 | self.assertEqual(double_metaphone('Batchlor', 4), ('PXLR', '')) |
||
| 2322 | self.assertEqual(double_metaphone('Bates', 4), ('PTS', '')) |
||
| 2323 | self.assertEqual(double_metaphone('Batson', 4), ('PTSN', '')) |
||
| 2324 | self.assertEqual(double_metaphone('Bayes', 4), ('PS', '')) |
||
| 2325 | self.assertEqual(double_metaphone('Bayley', 4), ('PL', '')) |
||
| 2326 | self.assertEqual(double_metaphone('Beale', 4), ('PL', '')) |
||
| 2327 | self.assertEqual(double_metaphone('Beauchamp', 4), ('PXMP', 'PKMP')) |
||
| 2328 | self.assertEqual(double_metaphone('Beauclerc', 4), ('PKLR', '')) |
||
| 2329 | self.assertEqual(double_metaphone('Beech', 4), ('PK', '')) |
||
| 2330 | self.assertEqual(double_metaphone('Beers', 4), ('PRS', '')) |
||
| 2331 | self.assertEqual(double_metaphone('Beke', 4), ('PK', '')) |
||
| 2332 | self.assertEqual(double_metaphone('Belcher', 4), ('PLXR', 'PLKR')) |
||
| 2333 | self.assertEqual(double_metaphone('Benjamin', 4), ('PNJM', '')) |
||
| 2334 | self.assertEqual(double_metaphone('Benningham', 4), ('PNNK', '')) |
||
| 2335 | self.assertEqual(double_metaphone('Bereford', 4), ('PRFR', '')) |
||
| 2336 | self.assertEqual(double_metaphone('Bergen', 4), ('PRJN', 'PRKN')) |
||
| 2337 | self.assertEqual(double_metaphone('Berkeley', 4), ('PRKL', '')) |
||
| 2338 | self.assertEqual(double_metaphone('Berry', 4), ('PR', '')) |
||
| 2339 | self.assertEqual(double_metaphone('Besse', 4), ('PS', '')) |
||
| 2340 | self.assertEqual(double_metaphone('Bessey', 4), ('PS', '')) |
||
| 2341 | self.assertEqual(double_metaphone('Bessiles', 4), ('PSLS', '')) |
||
| 2342 | self.assertEqual(double_metaphone('Bigelow', 4), ('PJL', 'PKLF')) |
||
| 2343 | self.assertEqual(double_metaphone('Bigg', 4), ('PK', '')) |
||
| 2344 | self.assertEqual(double_metaphone('Bigod', 4), ('PKT', '')) |
||
| 2345 | self.assertEqual(double_metaphone('Billings', 4), ('PLNK', '')) |
||
| 2346 | self.assertEqual(double_metaphone('Bimper', 4), ('PMPR', '')) |
||
| 2347 | self.assertEqual(double_metaphone('Binker', 4), ('PNKR', '')) |
||
| 2348 | self.assertEqual(double_metaphone('Birdsill', 4), ('PRTS', '')) |
||
| 2349 | self.assertEqual(double_metaphone('Bishop', 4), ('PXP', '')) |
||
| 2350 | self.assertEqual(double_metaphone('Black', 4), ('PLK', '')) |
||
| 2351 | self.assertEqual(double_metaphone('Blagge', 4), ('PLK', '')) |
||
| 2352 | self.assertEqual(double_metaphone('Blake', 4), ('PLK', '')) |
||
| 2353 | self.assertEqual(double_metaphone('Blanck', 4), ('PLNK', '')) |
||
| 2354 | self.assertEqual(double_metaphone('Bledsoe', 4), ('PLTS', '')) |
||
| 2355 | self.assertEqual(double_metaphone('Blennerhasset', 4), ('PLNR', '')) |
||
| 2356 | self.assertEqual(double_metaphone('Blessing', 4), ('PLSN', '')) |
||
| 2357 | self.assertEqual(double_metaphone('Blewett', 4), ('PLT', '')) |
||
| 2358 | self.assertEqual(double_metaphone('Bloctgoed', 4), ('PLKT', '')) |
||
| 2359 | self.assertEqual(double_metaphone('Bloetgoet', 4), ('PLTK', '')) |
||
| 2360 | self.assertEqual(double_metaphone('Bloodgood', 4), ('PLTK', '')) |
||
| 2361 | self.assertEqual(double_metaphone('Blossom', 4), ('PLSM', '')) |
||
| 2362 | self.assertEqual(double_metaphone('Blount', 4), ('PLNT', '')) |
||
| 2363 | self.assertEqual(double_metaphone('Bodine', 4), ('PTN', '')) |
||
| 2364 | self.assertEqual(double_metaphone('Bodman', 4), ('PTMN', '')) |
||
| 2365 | self.assertEqual(double_metaphone('BonCoeur', 4), ('PNKR', '')) |
||
| 2366 | self.assertEqual(double_metaphone('Bond', 4), ('PNT', '')) |
||
| 2367 | self.assertEqual(double_metaphone('Boscawen', 4), ('PSKN', '')) |
||
| 2368 | self.assertEqual(double_metaphone('Bosworth', 4), ('PSR0', 'PSRT')) |
||
| 2369 | self.assertEqual(double_metaphone('Bouchier', 4), ('PX', 'PKR')) |
||
| 2370 | self.assertEqual(double_metaphone('Bowne', 4), ('PN', '')) |
||
| 2371 | self.assertEqual(double_metaphone('Bradbury', 4), ('PRTP', '')) |
||
| 2372 | self.assertEqual(double_metaphone('Bradder', 4), ('PRTR', '')) |
||
| 2373 | self.assertEqual(double_metaphone('Bradford', 4), ('PRTF', '')) |
||
| 2374 | self.assertEqual(double_metaphone('Bradstreet', 4), ('PRTS', '')) |
||
| 2375 | self.assertEqual(double_metaphone('Braham', 4), ('PRHM', '')) |
||
| 2376 | self.assertEqual(double_metaphone('Brailsford', 4), ('PRLS', '')) |
||
| 2377 | self.assertEqual(double_metaphone('Brainard', 4), ('PRNR', '')) |
||
| 2378 | self.assertEqual(double_metaphone('Brandish', 4), ('PRNT', '')) |
||
| 2379 | self.assertEqual(double_metaphone('Braun', 4), ('PRN', '')) |
||
| 2380 | self.assertEqual(double_metaphone('Brecc', 4), ('PRK', '')) |
||
| 2381 | self.assertEqual(double_metaphone('Brent', 4), ('PRNT', '')) |
||
| 2382 | self.assertEqual(double_metaphone('Brenton', 4), ('PRNT', '')) |
||
| 2383 | self.assertEqual(double_metaphone('Briggs', 4), ('PRKS', '')) |
||
| 2384 | self.assertEqual(double_metaphone('Brigham', 4), ('PRM', '')) |
||
| 2385 | self.assertEqual(double_metaphone('Brobst', 4), ('PRPS', '')) |
||
| 2386 | self.assertEqual(double_metaphone('Brome', 4), ('PRM', '')) |
||
| 2387 | self.assertEqual(double_metaphone('Bronson', 4), ('PRNS', '')) |
||
| 2388 | self.assertEqual(double_metaphone('Brooks', 4), ('PRKS', '')) |
||
| 2389 | self.assertEqual(double_metaphone('Brouillard', 4), ('PRLR', '')) |
||
| 2390 | self.assertEqual(double_metaphone('Brown', 4), ('PRN', '')) |
||
| 2391 | self.assertEqual(double_metaphone('Browne', 4), ('PRN', '')) |
||
| 2392 | self.assertEqual(double_metaphone('Brownell', 4), ('PRNL', '')) |
||
| 2393 | self.assertEqual(double_metaphone('Bruley', 4), ('PRL', '')) |
||
| 2394 | self.assertEqual(double_metaphone('Bryant', 4), ('PRNT', '')) |
||
| 2395 | self.assertEqual(double_metaphone('Brzozowski', 4), ('PRSS', 'PRTS')) |
||
| 2396 | self.assertEqual(double_metaphone('Buide', 4), ('PT', '')) |
||
| 2397 | self.assertEqual(double_metaphone('Bulmer', 4), ('PLMR', '')) |
||
| 2398 | self.assertEqual(double_metaphone('Bunker', 4), ('PNKR', '')) |
||
| 2399 | self.assertEqual(double_metaphone('Burden', 4), ('PRTN', '')) |
||
| 2400 | self.assertEqual(double_metaphone('Burge', 4), ('PRJ', 'PRK')) |
||
| 2401 | self.assertEqual(double_metaphone('Burgoyne', 4), ('PRKN', '')) |
||
| 2402 | self.assertEqual(double_metaphone('Burke', 4), ('PRK', '')) |
||
| 2403 | self.assertEqual(double_metaphone('Burnett', 4), ('PRNT', '')) |
||
| 2404 | self.assertEqual(double_metaphone('Burpee', 4), ('PRP', '')) |
||
| 2405 | self.assertEqual(double_metaphone('Bursley', 4), ('PRSL', '')) |
||
| 2406 | self.assertEqual(double_metaphone('Burton', 4), ('PRTN', '')) |
||
| 2407 | self.assertEqual(double_metaphone('Bushnell', 4), ('PXNL', '')) |
||
| 2408 | self.assertEqual(double_metaphone('Buss', 4), ('PS', '')) |
||
| 2409 | self.assertEqual(double_metaphone('Buswell', 4), ('PSL', '')) |
||
| 2410 | self.assertEqual(double_metaphone('Butler', 4), ('PTLR', '')) |
||
| 2411 | self.assertEqual(double_metaphone('Calkin', 4), ('KLKN', '')) |
||
| 2412 | self.assertEqual(double_metaphone('Canada', 4), ('KNT', '')) |
||
| 2413 | self.assertEqual(double_metaphone('Canmore', 4), ('KNMR', '')) |
||
| 2414 | self.assertEqual(double_metaphone('Canney', 4), ('KN', '')) |
||
| 2415 | self.assertEqual(double_metaphone('Capet', 4), ('KPT', '')) |
||
| 2416 | self.assertEqual(double_metaphone('Card', 4), ('KRT', '')) |
||
| 2417 | self.assertEqual(double_metaphone('Carman', 4), ('KRMN', '')) |
||
| 2418 | self.assertEqual(double_metaphone('Carpenter', 4), ('KRPN', '')) |
||
| 2419 | self.assertEqual(double_metaphone('Cartwright', 4), ('KRTR', '')) |
||
| 2420 | self.assertEqual(double_metaphone('Casey', 4), ('KS', '')) |
||
| 2421 | self.assertEqual(double_metaphone('Catterfield', 4), ('KTRF', '')) |
||
| 2422 | self.assertEqual(double_metaphone('Ceeley', 4), ('SL', '')) |
||
| 2423 | self.assertEqual(double_metaphone('Chambers', 4), ('XMPR', '')) |
||
| 2424 | self.assertEqual(double_metaphone('Champion', 4), ('XMPN', '')) |
||
| 2425 | self.assertEqual(double_metaphone('Chapman', 4), ('XPMN', '')) |
||
| 2426 | self.assertEqual(double_metaphone('Chase', 4), ('XS', '')) |
||
| 2427 | self.assertEqual(double_metaphone('Cheney', 4), ('XN', '')) |
||
| 2428 | self.assertEqual(double_metaphone('Chetwynd', 4), ('XTNT', '')) |
||
| 2429 | self.assertEqual(double_metaphone('Chevalier', 4), ('XFL', 'XFLR')) |
||
| 2430 | self.assertEqual(double_metaphone('Chillingsworth', 4), ('XLNK', '')) |
||
| 2431 | self.assertEqual(double_metaphone('Christie', 4), ('KRST', '')) |
||
| 2432 | self.assertEqual(double_metaphone('Chubbuck', 4), ('XPK', '')) |
||
| 2433 | self.assertEqual(double_metaphone('Church', 4), ('XRX', 'XRK')) |
||
| 2434 | self.assertEqual(double_metaphone('Clark', 4), ('KLRK', '')) |
||
| 2435 | self.assertEqual(double_metaphone('Clarke', 4), ('KLRK', '')) |
||
| 2436 | self.assertEqual(double_metaphone('Cleare', 4), ('KLR', '')) |
||
| 2437 | self.assertEqual(double_metaphone('Clement', 4), ('KLMN', '')) |
||
| 2438 | self.assertEqual(double_metaphone('Clerke', 4), ('KLRK', '')) |
||
| 2439 | self.assertEqual(double_metaphone('Clibben', 4), ('KLPN', '')) |
||
| 2440 | self.assertEqual(double_metaphone('Clifford', 4), ('KLFR', '')) |
||
| 2441 | self.assertEqual(double_metaphone('Clivedon', 4), ('KLFT', '')) |
||
| 2442 | self.assertEqual(double_metaphone('Close', 4), ('KLS', '')) |
||
| 2443 | self.assertEqual(double_metaphone('Clothilde', 4), ('KL0L', 'KLTL')) |
||
| 2444 | self.assertEqual(double_metaphone('Cobb', 4), ('KP', '')) |
||
| 2445 | self.assertEqual(double_metaphone('Coburn', 4), ('KPRN', '')) |
||
| 2446 | self.assertEqual(double_metaphone('Coburne', 4), ('KPRN', '')) |
||
| 2447 | self.assertEqual(double_metaphone('Cocke', 4), ('KK', '')) |
||
| 2448 | self.assertEqual(double_metaphone('Coffin', 4), ('KFN', '')) |
||
| 2449 | self.assertEqual(double_metaphone('Coffyn', 4), ('KFN', '')) |
||
| 2450 | self.assertEqual(double_metaphone('Colborne', 4), ('KLPR', '')) |
||
| 2451 | self.assertEqual(double_metaphone('Colby', 4), ('KLP', '')) |
||
| 2452 | self.assertEqual(double_metaphone('Cole', 4), ('KL', '')) |
||
| 2453 | self.assertEqual(double_metaphone('Coleman', 4), ('KLMN', '')) |
||
| 2454 | self.assertEqual(double_metaphone('Collier', 4), ('KL', 'KLR')) |
||
| 2455 | self.assertEqual(double_metaphone('Compton', 4), ('KMPT', '')) |
||
| 2456 | self.assertEqual(double_metaphone('Cone', 4), ('KN', '')) |
||
| 2457 | self.assertEqual(double_metaphone('Cook', 4), ('KK', '')) |
||
| 2458 | self.assertEqual(double_metaphone('Cooke', 4), ('KK', '')) |
||
| 2459 | self.assertEqual(double_metaphone('Cooper', 4), ('KPR', '')) |
||
| 2460 | self.assertEqual(double_metaphone('Copperthwaite', 4), |
||
| 2461 | ('KPR0', 'KPRT')) |
||
| 2462 | self.assertEqual(double_metaphone('Corbet', 4), ('KRPT', '')) |
||
| 2463 | self.assertEqual(double_metaphone('Corell', 4), ('KRL', '')) |
||
| 2464 | self.assertEqual(double_metaphone('Corey', 4), ('KR', '')) |
||
| 2465 | self.assertEqual(double_metaphone('Corlies', 4), ('KRLS', '')) |
||
| 2466 | self.assertEqual(double_metaphone('Corneliszen', 4), ('KRNL', '')) |
||
| 2467 | self.assertEqual(double_metaphone('Cornelius', 4), ('KRNL', '')) |
||
| 2468 | self.assertEqual(double_metaphone('Cornwallis', 4), ('KRNL', '')) |
||
| 2469 | self.assertEqual(double_metaphone('Cosgrove', 4), ('KSKR', '')) |
||
| 2470 | self.assertEqual(double_metaphone('Count of Brionne', 4), ('KNTF', '')) |
||
| 2471 | self.assertEqual(double_metaphone('Covill', 4), ('KFL', '')) |
||
| 2472 | self.assertEqual(double_metaphone('Cowperthwaite', 4), |
||
| 2473 | ('KPR0', 'KPRT')) |
||
| 2474 | self.assertEqual(double_metaphone('Cowperwaite', 4), ('KPRT', '')) |
||
| 2475 | self.assertEqual(double_metaphone('Crane', 4), ('KRN', '')) |
||
| 2476 | self.assertEqual(double_metaphone('Creagmile', 4), ('KRKM', '')) |
||
| 2477 | self.assertEqual(double_metaphone('Crew', 4), ('KR', 'KRF')) |
||
| 2478 | self.assertEqual(double_metaphone('Crispin', 4), ('KRSP', '')) |
||
| 2479 | self.assertEqual(double_metaphone('Crocker', 4), ('KRKR', '')) |
||
| 2480 | self.assertEqual(double_metaphone('Crockett', 4), ('KRKT', '')) |
||
| 2481 | self.assertEqual(double_metaphone('Crosby', 4), ('KRSP', '')) |
||
| 2482 | self.assertEqual(double_metaphone('Crump', 4), ('KRMP', '')) |
||
| 2483 | self.assertEqual(double_metaphone('Cunningham', 4), ('KNNK', '')) |
||
| 2484 | self.assertEqual(double_metaphone('Curtis', 4), ('KRTS', '')) |
||
| 2485 | self.assertEqual(double_metaphone('Cutha', 4), ('K0', 'KT')) |
||
| 2486 | self.assertEqual(double_metaphone('Cutter', 4), ('KTR', '')) |
||
| 2487 | self.assertEqual(double_metaphone('D\'Aubigny', 4), ('TPN', 'TPKN')) |
||
| 2488 | self.assertEqual(double_metaphone('DAVIS', 4), ('TFS', '')) |
||
| 2489 | self.assertEqual(double_metaphone('Dabinott', 4), ('TPNT', '')) |
||
| 2490 | self.assertEqual(double_metaphone('Dacre', 4), ('TKR', '')) |
||
| 2491 | self.assertEqual(double_metaphone('Daggett', 4), ('TKT', '')) |
||
| 2492 | self.assertEqual(double_metaphone('Danvers', 4), ('TNFR', '')) |
||
| 2493 | self.assertEqual(double_metaphone('Darcy', 4), ('TRS', '')) |
||
| 2494 | self.assertEqual(double_metaphone('Davis', 4), ('TFS', '')) |
||
| 2495 | self.assertEqual(double_metaphone('Dawn', 4), ('TN', '')) |
||
| 2496 | self.assertEqual(double_metaphone('Dawson', 4), ('TSN', '')) |
||
| 2497 | self.assertEqual(double_metaphone('Day', 4), ('T', '')) |
||
| 2498 | self.assertEqual(double_metaphone('Daye', 4), ('T', '')) |
||
| 2499 | self.assertEqual(double_metaphone('DeGrenier', 4), ('TKRN', '')) |
||
| 2500 | self.assertEqual(double_metaphone('Dean', 4), ('TN', '')) |
||
| 2501 | self.assertEqual(double_metaphone('Deekindaugh', 4), ('TKNT', '')) |
||
| 2502 | self.assertEqual(double_metaphone('Dennis', 4), ('TNS', '')) |
||
| 2503 | self.assertEqual(double_metaphone('Denny', 4), ('TN', '')) |
||
| 2504 | self.assertEqual(double_metaphone('Denton', 4), ('TNTN', '')) |
||
| 2505 | self.assertEqual(double_metaphone('Desborough', 4), ('TSPR', '')) |
||
| 2506 | self.assertEqual(double_metaphone('Despenser', 4), ('TSPN', '')) |
||
| 2507 | self.assertEqual(double_metaphone('Deverill', 4), ('TFRL', '')) |
||
| 2508 | self.assertEqual(double_metaphone('Devine', 4), ('TFN', '')) |
||
| 2509 | self.assertEqual(double_metaphone('Dexter', 4), ('TKST', '')) |
||
| 2510 | self.assertEqual(double_metaphone('Dillaway', 4), ('TL', '')) |
||
| 2511 | self.assertEqual(double_metaphone('Dimmick', 4), ('TMK', '')) |
||
| 2512 | self.assertEqual(double_metaphone('Dinan', 4), ('TNN', '')) |
||
| 2513 | self.assertEqual(double_metaphone('Dix', 4), ('TKS', '')) |
||
| 2514 | self.assertEqual(double_metaphone('Doggett', 4), ('TKT', '')) |
||
| 2515 | self.assertEqual(double_metaphone('Donahue', 4), ('TNH', '')) |
||
| 2516 | self.assertEqual(double_metaphone('Dorfman', 4), ('TRFM', '')) |
||
| 2517 | self.assertEqual(double_metaphone('Dorris', 4), ('TRS', '')) |
||
| 2518 | self.assertEqual(double_metaphone('Dow', 4), ('T', 'TF')) |
||
| 2519 | self.assertEqual(double_metaphone('Downey', 4), ('TN', '')) |
||
| 2520 | self.assertEqual(double_metaphone('Downing', 4), ('TNNK', '')) |
||
| 2521 | self.assertEqual(double_metaphone('Dowsett', 4), ('TST', '')) |
||
| 2522 | self.assertEqual(double_metaphone('Duck?', 4), ('TK', '')) |
||
| 2523 | self.assertEqual(double_metaphone('Dudley', 4), ('TTL', '')) |
||
| 2524 | self.assertEqual(double_metaphone('Duffy', 4), ('TF', '')) |
||
| 2525 | self.assertEqual(double_metaphone('Dunn', 4), ('TN', '')) |
||
| 2526 | self.assertEqual(double_metaphone('Dunsterville', 4), ('TNST', '')) |
||
| 2527 | self.assertEqual(double_metaphone('Durrant', 4), ('TRNT', '')) |
||
| 2528 | self.assertEqual(double_metaphone('Durrin', 4), ('TRN', '')) |
||
| 2529 | self.assertEqual(double_metaphone('Dustin', 4), ('TSTN', '')) |
||
| 2530 | self.assertEqual(double_metaphone('Duston', 4), ('TSTN', '')) |
||
| 2531 | self.assertEqual(double_metaphone('Eames', 4), ('AMS', '')) |
||
| 2532 | self.assertEqual(double_metaphone('Early', 4), ('ARL', '')) |
||
| 2533 | self.assertEqual(double_metaphone('Easty', 4), ('AST', '')) |
||
| 2534 | self.assertEqual(double_metaphone('Ebbett', 4), ('APT', '')) |
||
| 2535 | self.assertEqual(double_metaphone('Eberbach', 4), ('APRP', '')) |
||
| 2536 | self.assertEqual(double_metaphone('Eberhard', 4), ('APRR', '')) |
||
| 2537 | self.assertEqual(double_metaphone('Eddy', 4), ('AT', '')) |
||
| 2538 | self.assertEqual(double_metaphone('Edenden', 4), ('ATNT', '')) |
||
| 2539 | self.assertEqual(double_metaphone('Edwards', 4), ('ATRT', '')) |
||
| 2540 | self.assertEqual(double_metaphone('Eglinton', 4), ('AKLN', 'ALNT')) |
||
| 2541 | self.assertEqual(double_metaphone('Eliot', 4), ('ALT', '')) |
||
| 2542 | self.assertEqual(double_metaphone('Elizabeth', 4), ('ALSP', '')) |
||
| 2543 | self.assertEqual(double_metaphone('Ellis', 4), ('ALS', '')) |
||
| 2544 | self.assertEqual(double_metaphone('Ellison', 4), ('ALSN', '')) |
||
| 2545 | self.assertEqual(double_metaphone('Ellot', 4), ('ALT', '')) |
||
| 2546 | self.assertEqual(double_metaphone('Elny', 4), ('ALN', '')) |
||
| 2547 | self.assertEqual(double_metaphone('Elsner', 4), ('ALSN', '')) |
||
| 2548 | self.assertEqual(double_metaphone('Emerson', 4), ('AMRS', '')) |
||
| 2549 | self.assertEqual(double_metaphone('Empson', 4), ('AMPS', '')) |
||
| 2550 | self.assertEqual(double_metaphone('Est', 4), ('AST', '')) |
||
| 2551 | self.assertEqual(double_metaphone('Estabrook', 4), ('ASTP', '')) |
||
| 2552 | self.assertEqual(double_metaphone('Estes', 4), ('ASTS', '')) |
||
| 2553 | self.assertEqual(double_metaphone('Estey', 4), ('AST', '')) |
||
| 2554 | self.assertEqual(double_metaphone('Evans', 4), ('AFNS', '')) |
||
| 2555 | self.assertEqual(double_metaphone('Fallowell', 4), ('FLL', '')) |
||
| 2556 | self.assertEqual(double_metaphone('Farnsworth', 4), ('FRNS', '')) |
||
| 2557 | self.assertEqual(double_metaphone('Feake', 4), ('FK', '')) |
||
| 2558 | self.assertEqual(double_metaphone('Feke', 4), ('FK', '')) |
||
| 2559 | self.assertEqual(double_metaphone('Fellows', 4), ('FLS', '')) |
||
| 2560 | self.assertEqual(double_metaphone('Fettiplace', 4), ('FTPL', '')) |
||
| 2561 | self.assertEqual(double_metaphone('Finney', 4), ('FN', '')) |
||
| 2562 | self.assertEqual(double_metaphone('Fischer', 4), ('FXR', 'FSKR')) |
||
| 2563 | self.assertEqual(double_metaphone('Fisher', 4), ('FXR', '')) |
||
| 2564 | self.assertEqual(double_metaphone('Fisk', 4), ('FSK', '')) |
||
| 2565 | self.assertEqual(double_metaphone('Fiske', 4), ('FSK', '')) |
||
| 2566 | self.assertEqual(double_metaphone('Fletcher', 4), ('FLXR', '')) |
||
| 2567 | self.assertEqual(double_metaphone('Folger', 4), ('FLKR', 'FLJR')) |
||
| 2568 | self.assertEqual(double_metaphone('Foliot', 4), ('FLT', '')) |
||
| 2569 | self.assertEqual(double_metaphone('Folyot', 4), ('FLT', '')) |
||
| 2570 | self.assertEqual(double_metaphone('Fones', 4), ('FNS', '')) |
||
| 2571 | self.assertEqual(double_metaphone('Fordham', 4), ('FRTM', '')) |
||
| 2572 | self.assertEqual(double_metaphone('Forstner', 4), ('FRST', '')) |
||
| 2573 | self.assertEqual(double_metaphone('Fosten', 4), ('FSTN', '')) |
||
| 2574 | self.assertEqual(double_metaphone('Foster', 4), ('FSTR', '')) |
||
| 2575 | self.assertEqual(double_metaphone('Foulke', 4), ('FLK', '')) |
||
| 2576 | self.assertEqual(double_metaphone('Fowler', 4), ('FLR', '')) |
||
| 2577 | self.assertEqual(double_metaphone('Foxwell', 4), ('FKSL', '')) |
||
| 2578 | self.assertEqual(double_metaphone('Fraley', 4), ('FRL', '')) |
||
| 2579 | self.assertEqual(double_metaphone('Franceys', 4), ('FRNS', '')) |
||
| 2580 | self.assertEqual(double_metaphone('Franke', 4), ('FRNK', '')) |
||
| 2581 | self.assertEqual(double_metaphone('Frascella', 4), ('FRSL', '')) |
||
| 2582 | self.assertEqual(double_metaphone('Frazer', 4), ('FRSR', '')) |
||
| 2583 | self.assertEqual(double_metaphone('Fredd', 4), ('FRT', '')) |
||
| 2584 | self.assertEqual(double_metaphone('Freeman', 4), ('FRMN', '')) |
||
| 2585 | self.assertEqual(double_metaphone('French', 4), ('FRNX', 'FRNK')) |
||
| 2586 | self.assertEqual(double_metaphone('Freville', 4), ('FRFL', '')) |
||
| 2587 | self.assertEqual(double_metaphone('Frey', 4), ('FR', '')) |
||
| 2588 | self.assertEqual(double_metaphone('Frick', 4), ('FRK', '')) |
||
| 2589 | self.assertEqual(double_metaphone('Frier', 4), ('FR', 'FRR')) |
||
| 2590 | self.assertEqual(double_metaphone('Froe', 4), ('FR', '')) |
||
| 2591 | self.assertEqual(double_metaphone('Frorer', 4), ('FRRR', '')) |
||
| 2592 | self.assertEqual(double_metaphone('Frost', 4), ('FRST', '')) |
||
| 2593 | self.assertEqual(double_metaphone('Frothingham', 4), ('FR0N', 'FRTN')) |
||
| 2594 | self.assertEqual(double_metaphone('Fry', 4), ('FR', '')) |
||
| 2595 | self.assertEqual(double_metaphone('Gaffney', 4), ('KFN', '')) |
||
| 2596 | self.assertEqual(double_metaphone('Gage', 4), ('KJ', 'KK')) |
||
| 2597 | self.assertEqual(double_metaphone('Gallion', 4), ('KLN', '')) |
||
| 2598 | self.assertEqual(double_metaphone('Gallishan', 4), ('KLXN', '')) |
||
| 2599 | self.assertEqual(double_metaphone('Gamble', 4), ('KMPL', '')) |
||
| 2600 | self.assertEqual(double_metaphone('Garbrand', 4), ('KRPR', '')) |
||
| 2601 | self.assertEqual(double_metaphone('Gardner', 4), ('KRTN', '')) |
||
| 2602 | self.assertEqual(double_metaphone('Garrett', 4), ('KRT', '')) |
||
| 2603 | self.assertEqual(double_metaphone('Gassner', 4), ('KSNR', '')) |
||
| 2604 | self.assertEqual(double_metaphone('Gater', 4), ('KTR', '')) |
||
| 2605 | self.assertEqual(double_metaphone('Gaunt', 4), ('KNT', '')) |
||
| 2606 | self.assertEqual(double_metaphone('Gayer', 4), ('KR', '')) |
||
| 2607 | self.assertEqual(double_metaphone('Gerken', 4), ('KRKN', 'JRKN')) |
||
| 2608 | self.assertEqual(double_metaphone('Gerritsen', 4), ('KRTS', 'JRTS')) |
||
| 2609 | self.assertEqual(double_metaphone('Gibbs', 4), ('KPS', 'JPS')) |
||
| 2610 | self.assertEqual(double_metaphone('Giffard', 4), ('JFRT', 'KFRT')) |
||
| 2611 | self.assertEqual(double_metaphone('Gilbert', 4), ('KLPR', 'JLPR')) |
||
| 2612 | self.assertEqual(double_metaphone('Gill', 4), ('KL', 'JL')) |
||
| 2613 | self.assertEqual(double_metaphone('Gilman', 4), ('KLMN', 'JLMN')) |
||
| 2614 | self.assertEqual(double_metaphone('Glass', 4), ('KLS', '')) |
||
| 2615 | self.assertEqual(double_metaphone('GoddardGifford', 4), ('KTRJ', '')) |
||
| 2616 | self.assertEqual(double_metaphone('Godfrey', 4), ('KTFR', '')) |
||
| 2617 | self.assertEqual(double_metaphone('Godwin', 4), ('KTN', '')) |
||
| 2618 | self.assertEqual(double_metaphone('Goodale', 4), ('KTL', '')) |
||
| 2619 | self.assertEqual(double_metaphone('Goodnow', 4), ('KTN', 'KTNF')) |
||
| 2620 | self.assertEqual(double_metaphone('Gorham', 4), ('KRM', '')) |
||
| 2621 | self.assertEqual(double_metaphone('Goseline', 4), ('KSLN', '')) |
||
| 2622 | self.assertEqual(double_metaphone('Gott', 4), ('KT', '')) |
||
| 2623 | self.assertEqual(double_metaphone('Gould', 4), ('KLT', '')) |
||
| 2624 | self.assertEqual(double_metaphone('Grafton', 4), ('KRFT', '')) |
||
| 2625 | self.assertEqual(double_metaphone('Grant', 4), ('KRNT', '')) |
||
| 2626 | self.assertEqual(double_metaphone('Gray', 4), ('KR', '')) |
||
| 2627 | self.assertEqual(double_metaphone('Green', 4), ('KRN', '')) |
||
| 2628 | self.assertEqual(double_metaphone('Griffin', 4), ('KRFN', '')) |
||
| 2629 | self.assertEqual(double_metaphone('Grill', 4), ('KRL', '')) |
||
| 2630 | self.assertEqual(double_metaphone('Grim', 4), ('KRM', '')) |
||
| 2631 | self.assertEqual(double_metaphone('Grisgonelle', 4), ('KRSK', '')) |
||
| 2632 | self.assertEqual(double_metaphone('Gross', 4), ('KRS', '')) |
||
| 2633 | self.assertEqual(double_metaphone('Guba', 4), ('KP', '')) |
||
| 2634 | self.assertEqual(double_metaphone('Gybbes', 4), ('KPS', 'JPS')) |
||
| 2635 | self.assertEqual(double_metaphone('Haburne', 4), ('HPRN', '')) |
||
| 2636 | self.assertEqual(double_metaphone('Hackburne', 4), ('HKPR', '')) |
||
| 2637 | self.assertEqual(double_metaphone('Haddon?', 4), ('HTN', '')) |
||
| 2638 | self.assertEqual(double_metaphone('Haines', 4), ('HNS', '')) |
||
| 2639 | self.assertEqual(double_metaphone('Hale', 4), ('HL', '')) |
||
| 2640 | self.assertEqual(double_metaphone('Hall', 4), ('HL', '')) |
||
| 2641 | self.assertEqual(double_metaphone('Hallet', 4), ('HLT', '')) |
||
| 2642 | self.assertEqual(double_metaphone('Hallock', 4), ('HLK', '')) |
||
| 2643 | self.assertEqual(double_metaphone('Halstead', 4), ('HLST', '')) |
||
| 2644 | self.assertEqual(double_metaphone('Hammond', 4), ('HMNT', '')) |
||
| 2645 | self.assertEqual(double_metaphone('Hance', 4), ('HNS', '')) |
||
| 2646 | self.assertEqual(double_metaphone('Handy', 4), ('HNT', '')) |
||
| 2647 | self.assertEqual(double_metaphone('Hanson', 4), ('HNSN', '')) |
||
| 2648 | self.assertEqual(double_metaphone('Harasek', 4), ('HRSK', '')) |
||
| 2649 | self.assertEqual(double_metaphone('Harcourt', 4), ('HRKR', '')) |
||
| 2650 | self.assertEqual(double_metaphone('Hardy', 4), ('HRT', '')) |
||
| 2651 | self.assertEqual(double_metaphone('Harlock', 4), ('HRLK', '')) |
||
| 2652 | self.assertEqual(double_metaphone('Harris', 4), ('HRS', '')) |
||
| 2653 | self.assertEqual(double_metaphone('Hartley', 4), ('HRTL', '')) |
||
| 2654 | self.assertEqual(double_metaphone('Harvey', 4), ('HRF', '')) |
||
| 2655 | self.assertEqual(double_metaphone('Harvie', 4), ('HRF', '')) |
||
| 2656 | self.assertEqual(double_metaphone('Harwood', 4), ('HRT', '')) |
||
| 2657 | self.assertEqual(double_metaphone('Hathaway', 4), ('H0', 'HT')) |
||
| 2658 | self.assertEqual(double_metaphone('Haukeness', 4), ('HKNS', '')) |
||
| 2659 | self.assertEqual(double_metaphone('Hawkes', 4), ('HKS', '')) |
||
| 2660 | self.assertEqual(double_metaphone('Hawkhurst', 4), ('HKRS', '')) |
||
| 2661 | self.assertEqual(double_metaphone('Hawkins', 4), ('HKNS', '')) |
||
| 2662 | self.assertEqual(double_metaphone('Hawley', 4), ('HL', '')) |
||
| 2663 | self.assertEqual(double_metaphone('Heald', 4), ('HLT', '')) |
||
| 2664 | self.assertEqual(double_metaphone('Helsdon', 4), ('HLST', '')) |
||
| 2665 | self.assertEqual(double_metaphone('Hemenway', 4), ('HMN', '')) |
||
| 2666 | self.assertEqual(double_metaphone('Hemmenway', 4), ('HMN', '')) |
||
| 2667 | self.assertEqual(double_metaphone('Henck', 4), ('HNK', '')) |
||
| 2668 | self.assertEqual(double_metaphone('Henderson', 4), ('HNTR', '')) |
||
| 2669 | self.assertEqual(double_metaphone('Hendricks', 4), ('HNTR', '')) |
||
| 2670 | self.assertEqual(double_metaphone('Hersey', 4), ('HRS', '')) |
||
| 2671 | self.assertEqual(double_metaphone('Hewes', 4), ('HS', '')) |
||
| 2672 | self.assertEqual(double_metaphone('Heyman', 4), ('HMN', '')) |
||
| 2673 | self.assertEqual(double_metaphone('Hicks', 4), ('HKS', '')) |
||
| 2674 | self.assertEqual(double_metaphone('Hidden', 4), ('HTN', '')) |
||
| 2675 | self.assertEqual(double_metaphone('Higgs', 4), ('HKS', '')) |
||
| 2676 | self.assertEqual(double_metaphone('Hill', 4), ('HL', '')) |
||
| 2677 | self.assertEqual(double_metaphone('Hills', 4), ('HLS', '')) |
||
| 2678 | self.assertEqual(double_metaphone('Hinckley', 4), ('HNKL', '')) |
||
| 2679 | self.assertEqual(double_metaphone('Hipwell', 4), ('HPL', '')) |
||
| 2680 | self.assertEqual(double_metaphone('Hobart', 4), ('HPRT', '')) |
||
| 2681 | self.assertEqual(double_metaphone('Hoben', 4), ('HPN', '')) |
||
| 2682 | self.assertEqual(double_metaphone('Hoffmann', 4), ('HFMN', '')) |
||
| 2683 | self.assertEqual(double_metaphone('Hogan', 4), ('HKN', '')) |
||
| 2684 | self.assertEqual(double_metaphone('Holmes', 4), ('HLMS', '')) |
||
| 2685 | self.assertEqual(double_metaphone('Hoo', 4), ('H', '')) |
||
| 2686 | self.assertEqual(double_metaphone('Hooker', 4), ('HKR', '')) |
||
| 2687 | self.assertEqual(double_metaphone('Hopcott', 4), ('HPKT', '')) |
||
| 2688 | self.assertEqual(double_metaphone('Hopkins', 4), ('HPKN', '')) |
||
| 2689 | self.assertEqual(double_metaphone('Hopkinson', 4), ('HPKN', '')) |
||
| 2690 | self.assertEqual(double_metaphone('Hornsey', 4), ('HRNS', '')) |
||
| 2691 | self.assertEqual(double_metaphone('Houckgeest', 4), ('HKJS', 'HKKS')) |
||
| 2692 | self.assertEqual(double_metaphone('Hough', 4), ('H', '')) |
||
| 2693 | self.assertEqual(double_metaphone('Houstin', 4), ('HSTN', '')) |
||
| 2694 | self.assertEqual(double_metaphone('How', 4), ('H', 'HF')) |
||
| 2695 | self.assertEqual(double_metaphone('Howe', 4), ('H', '')) |
||
| 2696 | self.assertEqual(double_metaphone('Howland', 4), ('HLNT', '')) |
||
| 2697 | self.assertEqual(double_metaphone('Hubner', 4), ('HPNR', '')) |
||
| 2698 | self.assertEqual(double_metaphone('Hudnut', 4), ('HTNT', '')) |
||
| 2699 | self.assertEqual(double_metaphone('Hughes', 4), ('HS', '')) |
||
| 2700 | self.assertEqual(double_metaphone('Hull', 4), ('HL', '')) |
||
| 2701 | self.assertEqual(double_metaphone('Hulme', 4), ('HLM', '')) |
||
| 2702 | self.assertEqual(double_metaphone('Hume', 4), ('HM', '')) |
||
| 2703 | self.assertEqual(double_metaphone('Hundertumark', 4), ('HNTR', '')) |
||
| 2704 | self.assertEqual(double_metaphone('Hundley', 4), ('HNTL', '')) |
||
| 2705 | self.assertEqual(double_metaphone('Hungerford', 4), ('HNKR', 'HNJR')) |
||
| 2706 | self.assertEqual(double_metaphone('Hunt', 4), ('HNT', '')) |
||
| 2707 | self.assertEqual(double_metaphone('Hurst', 4), ('HRST', '')) |
||
| 2708 | self.assertEqual(double_metaphone('Husbands', 4), ('HSPN', '')) |
||
| 2709 | self.assertEqual(double_metaphone('Hussey', 4), ('HS', '')) |
||
| 2710 | self.assertEqual(double_metaphone('Husted', 4), ('HSTT', '')) |
||
| 2711 | self.assertEqual(double_metaphone('Hutchins', 4), ('HXNS', '')) |
||
| 2712 | self.assertEqual(double_metaphone('Hutchinson', 4), ('HXNS', '')) |
||
| 2713 | self.assertEqual(double_metaphone('Huttinger', 4), ('HTNK', 'HTNJ')) |
||
| 2714 | self.assertEqual(double_metaphone('Huybertsen', 4), ('HPRT', '')) |
||
| 2715 | self.assertEqual(double_metaphone('Iddenden', 4), ('ATNT', '')) |
||
| 2716 | self.assertEqual(double_metaphone('Ingraham', 4), ('ANKR', '')) |
||
| 2717 | self.assertEqual(double_metaphone('Ives', 4), ('AFS', '')) |
||
| 2718 | self.assertEqual(double_metaphone('Jackson', 4), ('JKSN', 'AKSN')) |
||
| 2719 | self.assertEqual(double_metaphone('Jacob', 4), ('JKP', 'AKP')) |
||
| 2720 | self.assertEqual(double_metaphone('Jans', 4), ('JNS', 'ANS')) |
||
| 2721 | self.assertEqual(double_metaphone('Jenkins', 4), ('JNKN', 'ANKN')) |
||
| 2722 | self.assertEqual(double_metaphone('Jewett', 4), ('JT', 'AT')) |
||
| 2723 | self.assertEqual(double_metaphone('Jewitt', 4), ('JT', 'AT')) |
||
| 2724 | self.assertEqual(double_metaphone('Johnson', 4), ('JNSN', 'ANSN')) |
||
| 2725 | self.assertEqual(double_metaphone('Jones', 4), ('JNS', 'ANS')) |
||
| 2726 | self.assertEqual(double_metaphone('Josephine', 4), ('JSFN', 'HSFN')) |
||
| 2727 | self.assertEqual(double_metaphone('Judd', 4), ('JT', 'AT')) |
||
| 2728 | self.assertEqual(double_metaphone('June', 4), ('JN', 'AN')) |
||
| 2729 | self.assertEqual(double_metaphone('Kamarowska', 4), ('KMRS', '')) |
||
| 2730 | self.assertEqual(double_metaphone('Kay', 4), ('K', '')) |
||
| 2731 | self.assertEqual(double_metaphone('Kelley', 4), ('KL', '')) |
||
| 2732 | self.assertEqual(double_metaphone('Kelly', 4), ('KL', '')) |
||
| 2733 | self.assertEqual(double_metaphone('Keymber', 4), ('KMPR', '')) |
||
| 2734 | self.assertEqual(double_metaphone('Keynes', 4), ('KNS', '')) |
||
| 2735 | self.assertEqual(double_metaphone('Kilham', 4), ('KLM', '')) |
||
| 2736 | self.assertEqual(double_metaphone('Kim', 4), ('KM', '')) |
||
| 2737 | self.assertEqual(double_metaphone('Kimball', 4), ('KMPL', '')) |
||
| 2738 | self.assertEqual(double_metaphone('King', 4), ('KNK', '')) |
||
| 2739 | self.assertEqual(double_metaphone('Kinsey', 4), ('KNS', '')) |
||
| 2740 | self.assertEqual(double_metaphone('Kirk', 4), ('KRK', '')) |
||
| 2741 | self.assertEqual(double_metaphone('Kirton', 4), ('KRTN', '')) |
||
| 2742 | self.assertEqual(double_metaphone('Kistler', 4), ('KSTL', '')) |
||
| 2743 | self.assertEqual(double_metaphone('Kitchen', 4), ('KXN', '')) |
||
| 2744 | self.assertEqual(double_metaphone('Kitson', 4), ('KTSN', '')) |
||
| 2745 | self.assertEqual(double_metaphone('Klett', 4), ('KLT', '')) |
||
| 2746 | self.assertEqual(double_metaphone('Kline', 4), ('KLN', '')) |
||
| 2747 | self.assertEqual(double_metaphone('Knapp', 4), ('NP', '')) |
||
| 2748 | self.assertEqual(double_metaphone('Knight', 4), ('NT', '')) |
||
| 2749 | self.assertEqual(double_metaphone('Knote', 4), ('NT', '')) |
||
| 2750 | self.assertEqual(double_metaphone('Knott', 4), ('NT', '')) |
||
| 2751 | self.assertEqual(double_metaphone('Knox', 4), ('NKS', '')) |
||
| 2752 | self.assertEqual(double_metaphone('Koeller', 4), ('KLR', '')) |
||
| 2753 | self.assertEqual(double_metaphone('La Pointe', 4), ('LPNT', '')) |
||
| 2754 | self.assertEqual(double_metaphone('LaPlante', 4), ('LPLN', '')) |
||
| 2755 | self.assertEqual(double_metaphone('Laimbeer', 4), ('LMPR', '')) |
||
| 2756 | self.assertEqual(double_metaphone('Lamb', 4), ('LMP', '')) |
||
| 2757 | self.assertEqual(double_metaphone('Lambertson', 4), ('LMPR', '')) |
||
| 2758 | self.assertEqual(double_metaphone('Lancto', 4), ('LNKT', '')) |
||
| 2759 | self.assertEqual(double_metaphone('Landry', 4), ('LNTR', '')) |
||
| 2760 | self.assertEqual(double_metaphone('Lane', 4), ('LN', '')) |
||
| 2761 | self.assertEqual(double_metaphone('Langendyck', 4), ('LNJN', 'LNKN')) |
||
| 2762 | self.assertEqual(double_metaphone('Langer', 4), ('LNKR', 'LNJR')) |
||
| 2763 | self.assertEqual(double_metaphone('Langford', 4), ('LNKF', '')) |
||
| 2764 | self.assertEqual(double_metaphone('Lantersee', 4), ('LNTR', '')) |
||
| 2765 | self.assertEqual(double_metaphone('Laquer', 4), ('LKR', '')) |
||
| 2766 | self.assertEqual(double_metaphone('Larkin', 4), ('LRKN', '')) |
||
| 2767 | self.assertEqual(double_metaphone('Latham', 4), ('LTM', '')) |
||
| 2768 | self.assertEqual(double_metaphone('Lathrop', 4), ('L0RP', 'LTRP')) |
||
| 2769 | self.assertEqual(double_metaphone('Lauter', 4), ('LTR', '')) |
||
| 2770 | self.assertEqual(double_metaphone('Lawrence', 4), ('LRNS', '')) |
||
| 2771 | self.assertEqual(double_metaphone('Leach', 4), ('LK', '')) |
||
| 2772 | self.assertEqual(double_metaphone('Leager', 4), ('LKR', 'LJR')) |
||
| 2773 | self.assertEqual(double_metaphone('Learned', 4), ('LRNT', '')) |
||
| 2774 | self.assertEqual(double_metaphone('Leavitt', 4), ('LFT', '')) |
||
| 2775 | self.assertEqual(double_metaphone('Lee', 4), ('L', '')) |
||
| 2776 | self.assertEqual(double_metaphone('Leete', 4), ('LT', '')) |
||
| 2777 | self.assertEqual(double_metaphone('Leggett', 4), ('LKT', '')) |
||
| 2778 | self.assertEqual(double_metaphone('Leland', 4), ('LLNT', '')) |
||
| 2779 | self.assertEqual(double_metaphone('Leonard', 4), ('LNRT', '')) |
||
| 2780 | self.assertEqual(double_metaphone('Lester', 4), ('LSTR', '')) |
||
| 2781 | self.assertEqual(double_metaphone('Lestrange', 4), ('LSTR', '')) |
||
| 2782 | self.assertEqual(double_metaphone('Lethem', 4), ('L0M', 'LTM')) |
||
| 2783 | self.assertEqual(double_metaphone('Levine', 4), ('LFN', '')) |
||
| 2784 | self.assertEqual(double_metaphone('Lewes', 4), ('LS', '')) |
||
| 2785 | self.assertEqual(double_metaphone('Lewis', 4), ('LS', '')) |
||
| 2786 | self.assertEqual(double_metaphone('Lincoln', 4), ('LNKL', '')) |
||
| 2787 | self.assertEqual(double_metaphone('Lindsey', 4), ('LNTS', '')) |
||
| 2788 | self.assertEqual(double_metaphone('Linher', 4), ('LNR', '')) |
||
| 2789 | self.assertEqual(double_metaphone('Lippet', 4), ('LPT', '')) |
||
| 2790 | self.assertEqual(double_metaphone('Lippincott', 4), ('LPNK', '')) |
||
| 2791 | self.assertEqual(double_metaphone('Lockwood', 4), ('LKT', '')) |
||
| 2792 | self.assertEqual(double_metaphone('Loines', 4), ('LNS', '')) |
||
| 2793 | self.assertEqual(double_metaphone('Lombard', 4), ('LMPR', '')) |
||
| 2794 | self.assertEqual(double_metaphone('Long', 4), ('LNK', '')) |
||
| 2795 | self.assertEqual(double_metaphone('Longespee', 4), ('LNJS', 'LNKS')) |
||
| 2796 | self.assertEqual(double_metaphone('Look', 4), ('LK', '')) |
||
| 2797 | self.assertEqual(double_metaphone('Lounsberry', 4), ('LNSP', '')) |
||
| 2798 | self.assertEqual(double_metaphone('Lounsbury', 4), ('LNSP', '')) |
||
| 2799 | self.assertEqual(double_metaphone('Louthe', 4), ('L0', 'LT')) |
||
| 2800 | self.assertEqual(double_metaphone('Loveyne', 4), ('LFN', '')) |
||
| 2801 | self.assertEqual(double_metaphone('Lowe', 4), ('L', '')) |
||
| 2802 | self.assertEqual(double_metaphone('Ludlam', 4), ('LTLM', '')) |
||
| 2803 | self.assertEqual(double_metaphone('Lumbard', 4), ('LMPR', '')) |
||
| 2804 | self.assertEqual(double_metaphone('Lund', 4), ('LNT', '')) |
||
| 2805 | self.assertEqual(double_metaphone('Luno', 4), ('LN', '')) |
||
| 2806 | self.assertEqual(double_metaphone('Lutz', 4), ('LTS', '')) |
||
| 2807 | self.assertEqual(double_metaphone('Lydia', 4), ('LT', '')) |
||
| 2808 | self.assertEqual(double_metaphone('Lynne', 4), ('LN', '')) |
||
| 2809 | self.assertEqual(double_metaphone('Lyon', 4), ('LN', '')) |
||
| 2810 | self.assertEqual(double_metaphone('MacAlpin', 4), ('MKLP', '')) |
||
| 2811 | self.assertEqual(double_metaphone('MacBricc', 4), ('MKPR', '')) |
||
| 2812 | self.assertEqual(double_metaphone('MacCrinan', 4), ('MKRN', '')) |
||
| 2813 | self.assertEqual(double_metaphone('MacKenneth', 4), ('MKN0', 'MKNT')) |
||
| 2814 | self.assertEqual(double_metaphone('MacMael nam Bo', 4), ('MKML', '')) |
||
| 2815 | self.assertEqual(double_metaphone('MacMurchada', 4), ('MKMR', '')) |
||
| 2816 | self.assertEqual(double_metaphone('Macomber', 4), ('MKMP', '')) |
||
| 2817 | self.assertEqual(double_metaphone('Macy', 4), ('MS', '')) |
||
| 2818 | self.assertEqual(double_metaphone('Magnus', 4), ('MNS', 'MKNS')) |
||
| 2819 | self.assertEqual(double_metaphone('Mahien', 4), ('MHN', '')) |
||
| 2820 | self.assertEqual(double_metaphone('Malmains', 4), ('MLMN', '')) |
||
| 2821 | self.assertEqual(double_metaphone('Malory', 4), ('MLR', '')) |
||
| 2822 | self.assertEqual(double_metaphone('Mancinelli', 4), ('MNSN', '')) |
||
| 2823 | self.assertEqual(double_metaphone('Mancini', 4), ('MNSN', '')) |
||
| 2824 | self.assertEqual(double_metaphone('Mann', 4), ('MN', '')) |
||
| 2825 | self.assertEqual(double_metaphone('Manning', 4), ('MNNK', '')) |
||
| 2826 | self.assertEqual(double_metaphone('Manter', 4), ('MNTR', '')) |
||
| 2827 | self.assertEqual(double_metaphone('Marion', 4), ('MRN', '')) |
||
| 2828 | self.assertEqual(double_metaphone('Marley', 4), ('MRL', '')) |
||
| 2829 | self.assertEqual(double_metaphone('Marmion', 4), ('MRMN', '')) |
||
| 2830 | self.assertEqual(double_metaphone('Marquart', 4), ('MRKR', '')) |
||
| 2831 | self.assertEqual(double_metaphone('Marsh', 4), ('MRX', '')) |
||
| 2832 | self.assertEqual(double_metaphone('Marshal', 4), ('MRXL', '')) |
||
| 2833 | self.assertEqual(double_metaphone('Marshall', 4), ('MRXL', '')) |
||
| 2834 | self.assertEqual(double_metaphone('Martel', 4), ('MRTL', '')) |
||
| 2835 | self.assertEqual(double_metaphone('Martha', 4), ('MR0', 'MRT')) |
||
| 2836 | self.assertEqual(double_metaphone('Martin', 4), ('MRTN', '')) |
||
| 2837 | self.assertEqual(double_metaphone('Marturano', 4), ('MRTR', '')) |
||
| 2838 | self.assertEqual(double_metaphone('Marvin', 4), ('MRFN', '')) |
||
| 2839 | self.assertEqual(double_metaphone('Mary', 4), ('MR', '')) |
||
| 2840 | self.assertEqual(double_metaphone('Mason', 4), ('MSN', '')) |
||
| 2841 | self.assertEqual(double_metaphone('Maxwell', 4), ('MKSL', '')) |
||
| 2842 | self.assertEqual(double_metaphone('Mayhew', 4), ('MH', 'MHF')) |
||
| 2843 | self.assertEqual(double_metaphone('McAllaster', 4), ('MKLS', '')) |
||
| 2844 | self.assertEqual(double_metaphone('McAllister', 4), ('MKLS', '')) |
||
| 2845 | self.assertEqual(double_metaphone('McConnell', 4), ('MKNL', '')) |
||
| 2846 | self.assertEqual(double_metaphone('McFarland', 4), ('MKFR', '')) |
||
| 2847 | self.assertEqual(double_metaphone('McIlroy', 4), ('MSLR', '')) |
||
| 2848 | self.assertEqual(double_metaphone('McNair', 4), ('MKNR', '')) |
||
| 2849 | self.assertEqual(double_metaphone('McNair-Landry', 4), ('MKNR', '')) |
||
| 2850 | self.assertEqual(double_metaphone('McRaven', 4), ('MKRF', '')) |
||
| 2851 | self.assertEqual(double_metaphone('Mead', 4), ('MT', '')) |
||
| 2852 | self.assertEqual(double_metaphone('Meade', 4), ('MT', '')) |
||
| 2853 | self.assertEqual(double_metaphone('Meck', 4), ('MK', '')) |
||
| 2854 | self.assertEqual(double_metaphone('Melton', 4), ('MLTN', '')) |
||
| 2855 | self.assertEqual(double_metaphone('Mendenhall', 4), ('MNTN', '')) |
||
| 2856 | self.assertEqual(double_metaphone('Mering', 4), ('MRNK', '')) |
||
| 2857 | self.assertEqual(double_metaphone('Merrick', 4), ('MRK', '')) |
||
| 2858 | self.assertEqual(double_metaphone('Merry', 4), ('MR', '')) |
||
| 2859 | self.assertEqual(double_metaphone('Mighill', 4), ('ML', '')) |
||
| 2860 | self.assertEqual(double_metaphone('Miller', 4), ('MLR', '')) |
||
| 2861 | self.assertEqual(double_metaphone('Milton', 4), ('MLTN', '')) |
||
| 2862 | self.assertEqual(double_metaphone('Mohun', 4), ('MHN', '')) |
||
| 2863 | self.assertEqual(double_metaphone('Montague', 4), ('MNTK', '')) |
||
| 2864 | self.assertEqual(double_metaphone('Montboucher', 4), ('MNTP', '')) |
||
| 2865 | self.assertEqual(double_metaphone('Moore', 4), ('MR', '')) |
||
| 2866 | self.assertEqual(double_metaphone('Morrel', 4), ('MRL', '')) |
||
| 2867 | self.assertEqual(double_metaphone('Morrill', 4), ('MRL', '')) |
||
| 2868 | self.assertEqual(double_metaphone('Morris', 4), ('MRS', '')) |
||
| 2869 | self.assertEqual(double_metaphone('Morton', 4), ('MRTN', '')) |
||
| 2870 | self.assertEqual(double_metaphone('Moton', 4), ('MTN', '')) |
||
| 2871 | self.assertEqual(double_metaphone('Muir', 4), ('MR', '')) |
||
| 2872 | self.assertEqual(double_metaphone('Mulferd', 4), ('MLFR', '')) |
||
| 2873 | self.assertEqual(double_metaphone('Mullins', 4), ('MLNS', '')) |
||
| 2874 | self.assertEqual(double_metaphone('Mulso', 4), ('MLS', '')) |
||
| 2875 | self.assertEqual(double_metaphone('Munger', 4), ('MNKR', 'MNJR')) |
||
| 2876 | self.assertEqual(double_metaphone('Munt', 4), ('MNT', '')) |
||
| 2877 | self.assertEqual(double_metaphone('Murchad', 4), ('MRXT', 'MRKT')) |
||
| 2878 | self.assertEqual(double_metaphone('Murdock', 4), ('MRTK', '')) |
||
| 2879 | self.assertEqual(double_metaphone('Murray', 4), ('MR', '')) |
||
| 2880 | self.assertEqual(double_metaphone('Muskett', 4), ('MSKT', '')) |
||
| 2881 | self.assertEqual(double_metaphone('Myers', 4), ('MRS', '')) |
||
| 2882 | self.assertEqual(double_metaphone('Myrick', 4), ('MRK', '')) |
||
| 2883 | self.assertEqual(double_metaphone('NORRIS', 4), ('NRS', '')) |
||
| 2884 | self.assertEqual(double_metaphone('Nayle', 4), ('NL', '')) |
||
| 2885 | self.assertEqual(double_metaphone('Newcomb', 4), ('NKMP', '')) |
||
| 2886 | self.assertEqual(double_metaphone('Newcomb(e)', 4), ('NKMP', '')) |
||
| 2887 | self.assertEqual(double_metaphone('Newkirk', 4), ('NKRK', '')) |
||
| 2888 | self.assertEqual(double_metaphone('Newton', 4), ('NTN', '')) |
||
| 2889 | self.assertEqual(double_metaphone('Niles', 4), ('NLS', '')) |
||
| 2890 | self.assertEqual(double_metaphone('Noble', 4), ('NPL', '')) |
||
| 2891 | self.assertEqual(double_metaphone('Noel', 4), ('NL', '')) |
||
| 2892 | self.assertEqual(double_metaphone('Northend', 4), ('NR0N', 'NRTN')) |
||
| 2893 | self.assertEqual(double_metaphone('Norton', 4), ('NRTN', '')) |
||
| 2894 | self.assertEqual(double_metaphone('Nutter', 4), ('NTR', '')) |
||
| 2895 | self.assertEqual(double_metaphone('Odding', 4), ('ATNK', '')) |
||
| 2896 | self.assertEqual(double_metaphone('Odenbaugh', 4), ('ATNP', '')) |
||
| 2897 | self.assertEqual(double_metaphone('Ogborn', 4), ('AKPR', '')) |
||
| 2898 | self.assertEqual(double_metaphone('Oppenheimer', 4), ('APNM', '')) |
||
| 2899 | self.assertEqual(double_metaphone('Otis', 4), ('ATS', '')) |
||
| 2900 | self.assertEqual(double_metaphone('Oviatt', 4), ('AFT', '')) |
||
| 2901 | self.assertEqual(double_metaphone('PRUST?', 4), ('PRST', '')) |
||
| 2902 | self.assertEqual(double_metaphone('Paddock', 4), ('PTK', '')) |
||
| 2903 | self.assertEqual(double_metaphone('Page', 4), ('PJ', 'PK')) |
||
| 2904 | self.assertEqual(double_metaphone('Paine', 4), ('PN', '')) |
||
| 2905 | self.assertEqual(double_metaphone('Paist', 4), ('PST', '')) |
||
| 2906 | self.assertEqual(double_metaphone('Palmer', 4), ('PLMR', '')) |
||
| 2907 | self.assertEqual(double_metaphone('Park', 4), ('PRK', '')) |
||
| 2908 | self.assertEqual(double_metaphone('Parker', 4), ('PRKR', '')) |
||
| 2909 | self.assertEqual(double_metaphone('Parkhurst', 4), ('PRKR', '')) |
||
| 2910 | self.assertEqual(double_metaphone('Parrat', 4), ('PRT', '')) |
||
| 2911 | self.assertEqual(double_metaphone('Parsons', 4), ('PRSN', '')) |
||
| 2912 | self.assertEqual(double_metaphone('Partridge', 4), ('PRTR', '')) |
||
| 2913 | self.assertEqual(double_metaphone('Pashley', 4), ('PXL', '')) |
||
| 2914 | self.assertEqual(double_metaphone('Pasley', 4), ('PSL', '')) |
||
| 2915 | self.assertEqual(double_metaphone('Patrick', 4), ('PTRK', '')) |
||
| 2916 | self.assertEqual(double_metaphone('Pattee', 4), ('PT', '')) |
||
| 2917 | self.assertEqual(double_metaphone('Patten', 4), ('PTN', '')) |
||
| 2918 | self.assertEqual(double_metaphone('Pawley', 4), ('PL', '')) |
||
| 2919 | self.assertEqual(double_metaphone('Payne', 4), ('PN', '')) |
||
| 2920 | self.assertEqual(double_metaphone('Peabody', 4), ('PPT', '')) |
||
| 2921 | self.assertEqual(double_metaphone('Peake', 4), ('PK', '')) |
||
| 2922 | self.assertEqual(double_metaphone('Pearson', 4), ('PRSN', '')) |
||
| 2923 | self.assertEqual(double_metaphone('Peat', 4), ('PT', '')) |
||
| 2924 | self.assertEqual(double_metaphone('Pedersen', 4), ('PTRS', '')) |
||
| 2925 | self.assertEqual(double_metaphone('Percy', 4), ('PRS', '')) |
||
| 2926 | self.assertEqual(double_metaphone('Perkins', 4), ('PRKN', '')) |
||
| 2927 | self.assertEqual(double_metaphone('Perrine', 4), ('PRN', '')) |
||
| 2928 | self.assertEqual(double_metaphone('Perry', 4), ('PR', '')) |
||
| 2929 | self.assertEqual(double_metaphone('Peson', 4), ('PSN', '')) |
||
| 2930 | self.assertEqual(double_metaphone('Peterson', 4), ('PTRS', '')) |
||
| 2931 | self.assertEqual(double_metaphone('Peyton', 4), ('PTN', '')) |
||
| 2932 | self.assertEqual(double_metaphone('Phinney', 4), ('FN', '')) |
||
| 2933 | self.assertEqual(double_metaphone('Pickard', 4), ('PKRT', '')) |
||
| 2934 | self.assertEqual(double_metaphone('Pierce', 4), ('PRS', '')) |
||
| 2935 | self.assertEqual(double_metaphone('Pierrepont', 4), ('PRPN', '')) |
||
| 2936 | self.assertEqual(double_metaphone('Pike', 4), ('PK', '')) |
||
| 2937 | self.assertEqual(double_metaphone('Pinkham', 4), ('PNKM', '')) |
||
| 2938 | self.assertEqual(double_metaphone('Pitman', 4), ('PTMN', '')) |
||
| 2939 | self.assertEqual(double_metaphone('Pitt', 4), ('PT', '')) |
||
| 2940 | self.assertEqual(double_metaphone('Pitts', 4), ('PTS', '')) |
||
| 2941 | self.assertEqual(double_metaphone('Plantagenet', 4), ('PLNT', '')) |
||
| 2942 | self.assertEqual(double_metaphone('Platt', 4), ('PLT', '')) |
||
| 2943 | self.assertEqual(double_metaphone('Platts', 4), ('PLTS', '')) |
||
| 2944 | self.assertEqual(double_metaphone('Pleis', 4), ('PLS', '')) |
||
| 2945 | self.assertEqual(double_metaphone('Pleiss', 4), ('PLS', '')) |
||
| 2946 | self.assertEqual(double_metaphone('Plisko', 4), ('PLSK', '')) |
||
| 2947 | self.assertEqual(double_metaphone('Pliskovitch', 4), ('PLSK', '')) |
||
| 2948 | self.assertEqual(double_metaphone('Plum', 4), ('PLM', '')) |
||
| 2949 | self.assertEqual(double_metaphone('Plume', 4), ('PLM', '')) |
||
| 2950 | self.assertEqual(double_metaphone('Poitou', 4), ('PT', '')) |
||
| 2951 | self.assertEqual(double_metaphone('Pomeroy', 4), ('PMR', '')) |
||
| 2952 | self.assertEqual(double_metaphone('Poretiers', 4), ('PRTR', '')) |
||
| 2953 | self.assertEqual(double_metaphone('Pote', 4), ('PT', '')) |
||
| 2954 | self.assertEqual(double_metaphone('Potter', 4), ('PTR', '')) |
||
| 2955 | self.assertEqual(double_metaphone('Potts', 4), ('PTS', '')) |
||
| 2956 | self.assertEqual(double_metaphone('Powell', 4), ('PL', '')) |
||
| 2957 | self.assertEqual(double_metaphone('Pratt', 4), ('PRT', '')) |
||
| 2958 | self.assertEqual(double_metaphone('Presbury', 4), ('PRSP', '')) |
||
| 2959 | self.assertEqual(double_metaphone('Priest', 4), ('PRST', '')) |
||
| 2960 | self.assertEqual(double_metaphone('Prindle', 4), ('PRNT', '')) |
||
| 2961 | self.assertEqual(double_metaphone('Prior', 4), ('PRR', '')) |
||
| 2962 | self.assertEqual(double_metaphone('Profumo', 4), ('PRFM', '')) |
||
| 2963 | self.assertEqual(double_metaphone('Purdy', 4), ('PRT', '')) |
||
| 2964 | self.assertEqual(double_metaphone('Purefoy', 4), ('PRF', '')) |
||
| 2965 | self.assertEqual(double_metaphone('Pury', 4), ('PR', '')) |
||
| 2966 | self.assertEqual(double_metaphone('Quinter', 4), ('KNTR', '')) |
||
| 2967 | self.assertEqual(double_metaphone('Rachel', 4), ('RXL', 'RKL')) |
||
| 2968 | self.assertEqual(double_metaphone('Rand', 4), ('RNT', '')) |
||
| 2969 | self.assertEqual(double_metaphone('Rankin', 4), ('RNKN', '')) |
||
| 2970 | self.assertEqual(double_metaphone('Ravenscroft', 4), ('RFNS', '')) |
||
| 2971 | self.assertEqual(double_metaphone('Raynsford', 4), ('RNSF', '')) |
||
| 2972 | self.assertEqual(double_metaphone('Reakirt', 4), ('RKRT', '')) |
||
| 2973 | self.assertEqual(double_metaphone('Reaves', 4), ('RFS', '')) |
||
| 2974 | self.assertEqual(double_metaphone('Reeves', 4), ('RFS', '')) |
||
| 2975 | self.assertEqual(double_metaphone('Reichert', 4), ('RXRT', 'RKRT')) |
||
| 2976 | self.assertEqual(double_metaphone('Remmele', 4), ('RML', '')) |
||
| 2977 | self.assertEqual(double_metaphone('Reynolds', 4), ('RNLT', '')) |
||
| 2978 | self.assertEqual(double_metaphone('Rhodes', 4), ('RTS', '')) |
||
| 2979 | self.assertEqual(double_metaphone('Richards', 4), ('RXRT', 'RKRT')) |
||
| 2980 | self.assertEqual(double_metaphone('Richardson', 4), ('RXRT', 'RKRT')) |
||
| 2981 | self.assertEqual(double_metaphone('Ring', 4), ('RNK', '')) |
||
| 2982 | self.assertEqual(double_metaphone('Roberts', 4), ('RPRT', '')) |
||
| 2983 | self.assertEqual(double_metaphone('Robertson', 4), ('RPRT', '')) |
||
| 2984 | self.assertEqual(double_metaphone('Robson', 4), ('RPSN', '')) |
||
| 2985 | self.assertEqual(double_metaphone('Rodie', 4), ('RT', '')) |
||
| 2986 | self.assertEqual(double_metaphone('Rody', 4), ('RT', '')) |
||
| 2987 | self.assertEqual(double_metaphone('Rogers', 4), ('RKRS', 'RJRS')) |
||
| 2988 | self.assertEqual(double_metaphone('Ross', 4), ('RS', '')) |
||
| 2989 | self.assertEqual(double_metaphone('Rosslevin', 4), ('RSLF', '')) |
||
| 2990 | self.assertEqual(double_metaphone('Rowland', 4), ('RLNT', '')) |
||
| 2991 | self.assertEqual(double_metaphone('Ruehl', 4), ('RL', '')) |
||
| 2992 | self.assertEqual(double_metaphone('Russell', 4), ('RSL', '')) |
||
| 2993 | self.assertEqual(double_metaphone('Ruth', 4), ('R0', 'RT')) |
||
| 2994 | self.assertEqual(double_metaphone('Ryan', 4), ('RN', '')) |
||
| 2995 | self.assertEqual(double_metaphone('Rysse', 4), ('RS', '')) |
||
| 2996 | self.assertEqual(double_metaphone('Sadler', 4), ('STLR', '')) |
||
| 2997 | self.assertEqual(double_metaphone('Salmon', 4), ('SLMN', '')) |
||
| 2998 | self.assertEqual(double_metaphone('Salter', 4), ('SLTR', '')) |
||
| 2999 | self.assertEqual(double_metaphone('Salvatore', 4), ('SLFT', '')) |
||
| 3000 | self.assertEqual(double_metaphone('Sanders', 4), ('SNTR', '')) |
||
| 3001 | self.assertEqual(double_metaphone('Sands', 4), ('SNTS', '')) |
||
| 3002 | self.assertEqual(double_metaphone('Sanford', 4), ('SNFR', '')) |
||
| 3003 | self.assertEqual(double_metaphone('Sanger', 4), ('SNKR', 'SNJR')) |
||
| 3004 | self.assertEqual(double_metaphone('Sargent', 4), ('SRJN', 'SRKN')) |
||
| 3005 | self.assertEqual(double_metaphone('Saunders', 4), ('SNTR', '')) |
||
| 3006 | self.assertEqual(double_metaphone('Schilling', 4), ('XLNK', '')) |
||
| 3007 | self.assertEqual(double_metaphone('Schlegel', 4), ('XLKL', 'SLKL')) |
||
| 3008 | self.assertEqual(double_metaphone('Scott', 4), ('SKT', '')) |
||
| 3009 | self.assertEqual(double_metaphone('Sears', 4), ('SRS', '')) |
||
| 3010 | self.assertEqual(double_metaphone('Segersall', 4), ('SJRS', 'SKRS')) |
||
| 3011 | self.assertEqual(double_metaphone('Senecal', 4), ('SNKL', '')) |
||
| 3012 | self.assertEqual(double_metaphone('Sergeaux', 4), ('SRJ', 'SRK')) |
||
| 3013 | self.assertEqual(double_metaphone('Severance', 4), ('SFRN', '')) |
||
| 3014 | self.assertEqual(double_metaphone('Sharp', 4), ('XRP', '')) |
||
| 3015 | self.assertEqual(double_metaphone('Sharpe', 4), ('XRP', '')) |
||
| 3016 | self.assertEqual(double_metaphone('Sharply', 4), ('XRPL', '')) |
||
| 3017 | self.assertEqual(double_metaphone('Shatswell', 4), ('XTSL', '')) |
||
| 3018 | self.assertEqual(double_metaphone('Shattack', 4), ('XTK', '')) |
||
| 3019 | self.assertEqual(double_metaphone('Shattock', 4), ('XTK', '')) |
||
| 3020 | self.assertEqual(double_metaphone('Shattuck', 4), ('XTK', '')) |
||
| 3021 | self.assertEqual(double_metaphone('Shaw', 4), ('X', 'XF')) |
||
| 3022 | self.assertEqual(double_metaphone('Sheldon', 4), ('XLTN', '')) |
||
| 3023 | self.assertEqual(double_metaphone('Sherman', 4), ('XRMN', '')) |
||
| 3024 | self.assertEqual(double_metaphone('Shinn', 4), ('XN', '')) |
||
| 3025 | self.assertEqual(double_metaphone('Shirford', 4), ('XRFR', '')) |
||
| 3026 | self.assertEqual(double_metaphone('Shirley', 4), ('XRL', '')) |
||
| 3027 | self.assertEqual(double_metaphone('Shively', 4), ('XFL', '')) |
||
| 3028 | self.assertEqual(double_metaphone('Shoemaker', 4), ('XMKR', '')) |
||
| 3029 | self.assertEqual(double_metaphone('Short', 4), ('XRT', '')) |
||
| 3030 | self.assertEqual(double_metaphone('Shotwell', 4), ('XTL', '')) |
||
| 3031 | self.assertEqual(double_metaphone('Shute', 4), ('XT', '')) |
||
| 3032 | self.assertEqual(double_metaphone('Sibley', 4), ('SPL', '')) |
||
| 3033 | self.assertEqual(double_metaphone('Silver', 4), ('SLFR', '')) |
||
| 3034 | self.assertEqual(double_metaphone('Simes', 4), ('SMS', '')) |
||
| 3035 | self.assertEqual(double_metaphone('Sinken', 4), ('SNKN', '')) |
||
| 3036 | self.assertEqual(double_metaphone('Sinn', 4), ('SN', '')) |
||
| 3037 | self.assertEqual(double_metaphone('Skelton', 4), ('SKLT', '')) |
||
| 3038 | self.assertEqual(double_metaphone('Skiffe', 4), ('SKF', '')) |
||
| 3039 | self.assertEqual(double_metaphone('Skotkonung', 4), ('SKTK', '')) |
||
| 3040 | self.assertEqual(double_metaphone('Slade', 4), ('SLT', 'XLT')) |
||
| 3041 | self.assertEqual(double_metaphone('Slye', 4), ('SL', 'XL')) |
||
| 3042 | self.assertEqual(double_metaphone('Smedley', 4), ('SMTL', 'XMTL')) |
||
| 3043 | self.assertEqual(double_metaphone('Smith', 4), ('SM0', 'XMT')) |
||
| 3044 | self.assertEqual(double_metaphone('Snow', 4), ('SN', 'XNF')) |
||
| 3045 | self.assertEqual(double_metaphone('Soole', 4), ('SL', '')) |
||
| 3046 | self.assertEqual(double_metaphone('Soule', 4), ('SL', '')) |
||
| 3047 | self.assertEqual(double_metaphone('Southworth', 4), ('S0R0', 'STRT')) |
||
| 3048 | self.assertEqual(double_metaphone('Sowles', 4), ('SLS', '')) |
||
| 3049 | self.assertEqual(double_metaphone('Spalding', 4), ('SPLT', '')) |
||
| 3050 | self.assertEqual(double_metaphone('Spark', 4), ('SPRK', '')) |
||
| 3051 | self.assertEqual(double_metaphone('Spencer', 4), ('SPNS', '')) |
||
| 3052 | self.assertEqual(double_metaphone('Sperry', 4), ('SPR', '')) |
||
| 3053 | self.assertEqual(double_metaphone('Spofford', 4), ('SPFR', '')) |
||
| 3054 | self.assertEqual(double_metaphone('Spooner', 4), ('SPNR', '')) |
||
| 3055 | self.assertEqual(double_metaphone('Sprague', 4), ('SPRK', '')) |
||
| 3056 | self.assertEqual(double_metaphone('Springer', 4), ('SPRN', '')) |
||
| 3057 | self.assertEqual(double_metaphone('St. Clair', 4), ('STKL', '')) |
||
| 3058 | self.assertEqual(double_metaphone('St. Claire', 4), ('STKL', '')) |
||
| 3059 | self.assertEqual(double_metaphone('St. Leger', 4), ('STLJ', 'STLK')) |
||
| 3060 | self.assertEqual(double_metaphone('St. Omer', 4), ('STMR', '')) |
||
| 3061 | self.assertEqual(double_metaphone('Stafferton', 4), ('STFR', '')) |
||
| 3062 | self.assertEqual(double_metaphone('Stafford', 4), ('STFR', '')) |
||
| 3063 | self.assertEqual(double_metaphone('Stalham', 4), ('STLM', '')) |
||
| 3064 | self.assertEqual(double_metaphone('Stanford', 4), ('STNF', '')) |
||
| 3065 | self.assertEqual(double_metaphone('Stanton', 4), ('STNT', '')) |
||
| 3066 | self.assertEqual(double_metaphone('Star', 4), ('STR', '')) |
||
| 3067 | self.assertEqual(double_metaphone('Starbuck', 4), ('STRP', '')) |
||
| 3068 | self.assertEqual(double_metaphone('Starkey', 4), ('STRK', '')) |
||
| 3069 | self.assertEqual(double_metaphone('Starkweather', 4), ('STRK', '')) |
||
| 3070 | self.assertEqual(double_metaphone('Stearns', 4), ('STRN', '')) |
||
| 3071 | self.assertEqual(double_metaphone('Stebbins', 4), ('STPN', '')) |
||
| 3072 | self.assertEqual(double_metaphone('Steele', 4), ('STL', '')) |
||
| 3073 | self.assertEqual(double_metaphone('Stephenson', 4), ('STFN', '')) |
||
| 3074 | self.assertEqual(double_metaphone('Stevens', 4), ('STFN', '')) |
||
| 3075 | self.assertEqual(double_metaphone('Stoddard', 4), ('STTR', '')) |
||
| 3076 | self.assertEqual(double_metaphone('Stodder', 4), ('STTR', '')) |
||
| 3077 | self.assertEqual(double_metaphone('Stone', 4), ('STN', '')) |
||
| 3078 | self.assertEqual(double_metaphone('Storey', 4), ('STR', '')) |
||
| 3079 | self.assertEqual(double_metaphone('Storrada', 4), ('STRT', '')) |
||
| 3080 | self.assertEqual(double_metaphone('Story', 4), ('STR', '')) |
||
| 3081 | self.assertEqual(double_metaphone('Stoughton', 4), ('STFT', '')) |
||
| 3082 | self.assertEqual(double_metaphone('Stout', 4), ('STT', '')) |
||
| 3083 | self.assertEqual(double_metaphone('Stow', 4), ('ST', 'STF')) |
||
| 3084 | self.assertEqual(double_metaphone('Strong', 4), ('STRN', '')) |
||
| 3085 | self.assertEqual(double_metaphone('Strutt', 4), ('STRT', '')) |
||
| 3086 | self.assertEqual(double_metaphone('Stryker', 4), ('STRK', '')) |
||
| 3087 | self.assertEqual(double_metaphone('Stuckeley', 4), ('STKL', '')) |
||
| 3088 | self.assertEqual(double_metaphone('Sturges', 4), ('STRJ', 'STRK')) |
||
| 3089 | self.assertEqual(double_metaphone('Sturgess', 4), ('STRJ', 'STRK')) |
||
| 3090 | self.assertEqual(double_metaphone('Sturgis', 4), ('STRJ', 'STRK')) |
||
| 3091 | self.assertEqual(double_metaphone('Suevain', 4), ('SFN', '')) |
||
| 3092 | self.assertEqual(double_metaphone('Sulyard', 4), ('SLRT', '')) |
||
| 3093 | self.assertEqual(double_metaphone('Sutton', 4), ('STN', '')) |
||
| 3094 | self.assertEqual(double_metaphone('Swain', 4), ('SN', 'XN')) |
||
| 3095 | self.assertEqual(double_metaphone('Swayne', 4), ('SN', 'XN')) |
||
| 3096 | self.assertEqual(double_metaphone('Swayze', 4), ('SS', 'XTS')) |
||
| 3097 | self.assertEqual(double_metaphone('Swift', 4), ('SFT', 'XFT')) |
||
| 3098 | self.assertEqual(double_metaphone('Taber', 4), ('TPR', '')) |
||
| 3099 | self.assertEqual(double_metaphone('Talcott', 4), ('TLKT', '')) |
||
| 3100 | self.assertEqual(double_metaphone('Tarne', 4), ('TRN', '')) |
||
| 3101 | self.assertEqual(double_metaphone('Tatum', 4), ('TTM', '')) |
||
| 3102 | self.assertEqual(double_metaphone('Taverner', 4), ('TFRN', '')) |
||
| 3103 | self.assertEqual(double_metaphone('Taylor', 4), ('TLR', '')) |
||
| 3104 | self.assertEqual(double_metaphone('Tenney', 4), ('TN', '')) |
||
| 3105 | self.assertEqual(double_metaphone('Thayer', 4), ('0R', 'TR')) |
||
| 3106 | self.assertEqual(double_metaphone('Thember', 4), ('0MPR', 'TMPR')) |
||
| 3107 | self.assertEqual(double_metaphone('Thomas', 4), ('TMS', '')) |
||
| 3108 | self.assertEqual(double_metaphone('Thompson', 4), ('TMPS', '')) |
||
| 3109 | self.assertEqual(double_metaphone('Thorne', 4), ('0RN', 'TRN')) |
||
| 3110 | self.assertEqual(double_metaphone('Thornycraft', 4), ('0RNK', 'TRNK')) |
||
| 3111 | self.assertEqual(double_metaphone('Threlkeld', 4), ('0RLK', 'TRLK')) |
||
| 3112 | self.assertEqual(double_metaphone('Throckmorton', 4), ('0RKM', 'TRKM')) |
||
| 3113 | self.assertEqual(double_metaphone('Thwaits', 4), ('0TS', 'TTS')) |
||
| 3114 | self.assertEqual(double_metaphone('Tibbetts', 4), ('TPTS', '')) |
||
| 3115 | self.assertEqual(double_metaphone('Tidd', 4), ('TT', '')) |
||
| 3116 | self.assertEqual(double_metaphone('Tierney', 4), ('TRN', '')) |
||
| 3117 | self.assertEqual(double_metaphone('Tilley', 4), ('TL', '')) |
||
| 3118 | self.assertEqual(double_metaphone('Tillieres', 4), ('TLRS', '')) |
||
| 3119 | self.assertEqual(double_metaphone('Tilly', 4), ('TL', '')) |
||
| 3120 | self.assertEqual(double_metaphone('Tisdale', 4), ('TSTL', '')) |
||
| 3121 | self.assertEqual(double_metaphone('Titus', 4), ('TTS', '')) |
||
| 3122 | self.assertEqual(double_metaphone('Tobey', 4), ('TP', '')) |
||
| 3123 | self.assertEqual(double_metaphone('Tooker', 4), ('TKR', '')) |
||
| 3124 | self.assertEqual(double_metaphone('Towle', 4), ('TL', '')) |
||
| 3125 | self.assertEqual(double_metaphone('Towne', 4), ('TN', '')) |
||
| 3126 | self.assertEqual(double_metaphone('Townsend', 4), ('TNSN', '')) |
||
| 3127 | self.assertEqual(double_metaphone('Treadway', 4), ('TRT', '')) |
||
| 3128 | self.assertEqual(double_metaphone('Trelawney', 4), ('TRLN', '')) |
||
| 3129 | self.assertEqual(double_metaphone('Trinder', 4), ('TRNT', '')) |
||
| 3130 | self.assertEqual(double_metaphone('Tripp', 4), ('TRP', '')) |
||
| 3131 | self.assertEqual(double_metaphone('Trippe', 4), ('TRP', '')) |
||
| 3132 | self.assertEqual(double_metaphone('Trott', 4), ('TRT', '')) |
||
| 3133 | self.assertEqual(double_metaphone('True', 4), ('TR', '')) |
||
| 3134 | self.assertEqual(double_metaphone('Trussebut', 4), ('TRSP', '')) |
||
| 3135 | self.assertEqual(double_metaphone('Tucker', 4), ('TKR', '')) |
||
| 3136 | self.assertEqual(double_metaphone('Turgeon', 4), ('TRJN', 'TRKN')) |
||
| 3137 | self.assertEqual(double_metaphone('Turner', 4), ('TRNR', '')) |
||
| 3138 | self.assertEqual(double_metaphone('Tuttle', 4), ('TTL', '')) |
||
| 3139 | self.assertEqual(double_metaphone('Tyler', 4), ('TLR', '')) |
||
| 3140 | self.assertEqual(double_metaphone('Tylle', 4), ('TL', '')) |
||
| 3141 | self.assertEqual(double_metaphone('Tyrrel', 4), ('TRL', '')) |
||
| 3142 | self.assertEqual(double_metaphone('Ua Tuathail', 4), ('AT0L', 'ATTL')) |
||
| 3143 | self.assertEqual(double_metaphone('Ulrich', 4), ('ALRX', 'ALRK')) |
||
| 3144 | self.assertEqual(double_metaphone('Underhill', 4), ('ANTR', '')) |
||
| 3145 | self.assertEqual(double_metaphone('Underwood', 4), ('ANTR', '')) |
||
| 3146 | self.assertEqual(double_metaphone('Unknown', 4), ('ANKN', '')) |
||
| 3147 | self.assertEqual(double_metaphone('Valentine', 4), ('FLNT', '')) |
||
| 3148 | self.assertEqual(double_metaphone('Van Egmond', 4), ('FNKM', '')) |
||
| 3149 | self.assertEqual(double_metaphone('Van der Beek', 4), ('FNTR', '')) |
||
| 3150 | self.assertEqual(double_metaphone('Vaughan', 4), ('FKN', '')) |
||
| 3151 | self.assertEqual(double_metaphone('Vermenlen', 4), ('FRMN', '')) |
||
| 3152 | self.assertEqual(double_metaphone('Vincent', 4), ('FNSN', '')) |
||
| 3153 | self.assertEqual(double_metaphone('Volentine', 4), ('FLNT', '')) |
||
| 3154 | self.assertEqual(double_metaphone('Wagner', 4), ('AKNR', 'FKNR')) |
||
| 3155 | self.assertEqual(double_metaphone('Waite', 4), ('AT', 'FT')) |
||
| 3156 | self.assertEqual(double_metaphone('Walker', 4), ('ALKR', 'FLKR')) |
||
| 3157 | self.assertEqual(double_metaphone('Walter', 4), ('ALTR', 'FLTR')) |
||
| 3158 | self.assertEqual(double_metaphone('Wandell', 4), ('ANTL', 'FNTL')) |
||
| 3159 | self.assertEqual(double_metaphone('Wandesford', 4), ('ANTS', 'FNTS')) |
||
| 3160 | self.assertEqual(double_metaphone('Warbleton', 4), ('ARPL', 'FRPL')) |
||
| 3161 | self.assertEqual(double_metaphone('Ward', 4), ('ART', 'FRT')) |
||
| 3162 | self.assertEqual(double_metaphone('Warde', 4), ('ART', 'FRT')) |
||
| 3163 | self.assertEqual(double_metaphone('Ware', 4), ('AR', 'FR')) |
||
| 3164 | self.assertEqual(double_metaphone('Wareham', 4), ('ARHM', 'FRHM')) |
||
| 3165 | self.assertEqual(double_metaphone('Warner', 4), ('ARNR', 'FRNR')) |
||
| 3166 | self.assertEqual(double_metaphone('Warren', 4), ('ARN', 'FRN')) |
||
| 3167 | self.assertEqual(double_metaphone('Washburne', 4), ('AXPR', 'FXPR')) |
||
| 3168 | self.assertEqual(double_metaphone('Waterbury', 4), ('ATRP', 'FTRP')) |
||
| 3169 | self.assertEqual(double_metaphone('Watson', 4), ('ATSN', 'FTSN')) |
||
| 3170 | self.assertEqual(double_metaphone('WatsonEllithorpe', 4), |
||
| 3171 | ('ATSN', 'FTSN')) |
||
| 3172 | self.assertEqual(double_metaphone('Watts', 4), ('ATS', 'FTS')) |
||
| 3173 | self.assertEqual(double_metaphone('Wayne', 4), ('AN', 'FN')) |
||
| 3174 | self.assertEqual(double_metaphone('Webb', 4), ('AP', 'FP')) |
||
| 3175 | self.assertEqual(double_metaphone('Weber', 4), ('APR', 'FPR')) |
||
| 3176 | self.assertEqual(double_metaphone('Webster', 4), ('APST', 'FPST')) |
||
| 3177 | self.assertEqual(double_metaphone('Weed', 4), ('AT', 'FT')) |
||
| 3178 | self.assertEqual(double_metaphone('Weeks', 4), ('AKS', 'FKS')) |
||
| 3179 | self.assertEqual(double_metaphone('Wells', 4), ('ALS', 'FLS')) |
||
| 3180 | self.assertEqual(double_metaphone('Wenzell', 4), ('ANSL', 'FNTS')) |
||
| 3181 | self.assertEqual(double_metaphone('West', 4), ('AST', 'FST')) |
||
| 3182 | self.assertEqual(double_metaphone('Westbury', 4), ('ASTP', 'FSTP')) |
||
| 3183 | self.assertEqual(double_metaphone('Whatlocke', 4), ('ATLK', '')) |
||
| 3184 | self.assertEqual(double_metaphone('Wheeler', 4), ('ALR', '')) |
||
| 3185 | self.assertEqual(double_metaphone('Whiston', 4), ('ASTN', '')) |
||
| 3186 | self.assertEqual(double_metaphone('White', 4), ('AT', '')) |
||
| 3187 | self.assertEqual(double_metaphone('Whitman', 4), ('ATMN', '')) |
||
| 3188 | self.assertEqual(double_metaphone('Whiton', 4), ('ATN', '')) |
||
| 3189 | self.assertEqual(double_metaphone('Whitson', 4), ('ATSN', '')) |
||
| 3190 | self.assertEqual(double_metaphone('Wickes', 4), ('AKS', 'FKS')) |
||
| 3191 | self.assertEqual(double_metaphone('Wilbur', 4), ('ALPR', 'FLPR')) |
||
| 3192 | self.assertEqual(double_metaphone('Wilcotes', 4), ('ALKT', 'FLKT')) |
||
| 3193 | self.assertEqual(double_metaphone('Wilkinson', 4), ('ALKN', 'FLKN')) |
||
| 3194 | self.assertEqual(double_metaphone('Willets', 4), ('ALTS', 'FLTS')) |
||
| 3195 | self.assertEqual(double_metaphone('Willett', 4), ('ALT', 'FLT')) |
||
| 3196 | self.assertEqual(double_metaphone('Willey', 4), ('AL', 'FL')) |
||
| 3197 | self.assertEqual(double_metaphone('Williams', 4), ('ALMS', 'FLMS')) |
||
| 3198 | self.assertEqual(double_metaphone('Williston', 4), ('ALST', 'FLST')) |
||
| 3199 | self.assertEqual(double_metaphone('Wilson', 4), ('ALSN', 'FLSN')) |
||
| 3200 | self.assertEqual(double_metaphone('Wimes', 4), ('AMS', 'FMS')) |
||
| 3201 | self.assertEqual(double_metaphone('Winch', 4), ('ANX', 'FNK')) |
||
| 3202 | self.assertEqual(double_metaphone('Winegar', 4), ('ANKR', 'FNKR')) |
||
| 3203 | self.assertEqual(double_metaphone('Wing', 4), ('ANK', 'FNK')) |
||
| 3204 | self.assertEqual(double_metaphone('Winsley', 4), ('ANSL', 'FNSL')) |
||
| 3205 | self.assertEqual(double_metaphone('Winslow', 4), ('ANSL', 'FNSL')) |
||
| 3206 | self.assertEqual(double_metaphone('Winthrop', 4), ('AN0R', 'FNTR')) |
||
| 3207 | self.assertEqual(double_metaphone('Wise', 4), ('AS', 'FS')) |
||
| 3208 | self.assertEqual(double_metaphone('Wood', 4), ('AT', 'FT')) |
||
| 3209 | self.assertEqual(double_metaphone('Woodbridge', 4), ('ATPR', 'FTPR')) |
||
| 3210 | self.assertEqual(double_metaphone('Woodward', 4), ('ATRT', 'FTRT')) |
||
| 3211 | self.assertEqual(double_metaphone('Wooley', 4), ('AL', 'FL')) |
||
| 3212 | self.assertEqual(double_metaphone('Woolley', 4), ('AL', 'FL')) |
||
| 3213 | self.assertEqual(double_metaphone('Worth', 4), ('AR0', 'FRT')) |
||
| 3214 | self.assertEqual(double_metaphone('Worthen', 4), ('AR0N', 'FRTN')) |
||
| 3215 | self.assertEqual(double_metaphone('Worthley', 4), ('AR0L', 'FRTL')) |
||
| 3216 | self.assertEqual(double_metaphone('Wright', 4), ('RT', '')) |
||
| 3217 | self.assertEqual(double_metaphone('Wyer', 4), ('AR', 'FR')) |
||
| 3218 | self.assertEqual(double_metaphone('Wyere', 4), ('AR', 'FR')) |
||
| 3219 | self.assertEqual(double_metaphone('Wynkoop', 4), ('ANKP', 'FNKP')) |
||
| 3220 | self.assertEqual(double_metaphone('Yarnall', 4), ('ARNL', '')) |
||
| 3221 | self.assertEqual(double_metaphone('Yeoman', 4), ('AMN', '')) |
||
| 3222 | self.assertEqual(double_metaphone('Yorke', 4), ('ARK', '')) |
||
| 3223 | self.assertEqual(double_metaphone('Young', 4), ('ANK', '')) |
||
| 3224 | self.assertEqual(double_metaphone('ab Wennonwen', 4), ('APNN', '')) |
||
| 3225 | self.assertEqual(double_metaphone('ap Llewellyn', 4), ('APLL', '')) |
||
| 3226 | self.assertEqual(double_metaphone('ap Lorwerth', 4), ('APLR', '')) |
||
| 3227 | self.assertEqual(double_metaphone('d\'Angouleme', 4), ('TNKL', '')) |
||
| 3228 | self.assertEqual(double_metaphone('de Audeham', 4), ('TTHM', '')) |
||
| 3229 | self.assertEqual(double_metaphone('de Bavant', 4), ('TPFN', '')) |
||
| 3230 | self.assertEqual(double_metaphone('de Beauchamp', 4), ('TPXM', 'TPKM')) |
||
| 3231 | self.assertEqual(double_metaphone('de Beaumont', 4), ('TPMN', '')) |
||
| 3232 | self.assertEqual(double_metaphone('de Bolbec', 4), ('TPLP', '')) |
||
| 3233 | self.assertEqual(double_metaphone('de Braiose', 4), ('TPRS', '')) |
||
| 3234 | self.assertEqual(double_metaphone('de Braose', 4), ('TPRS', '')) |
||
| 3235 | self.assertEqual(double_metaphone('de Briwere', 4), ('TPRR', '')) |
||
| 3236 | self.assertEqual(double_metaphone('de Cantelou', 4), ('TKNT', '')) |
||
| 3237 | self.assertEqual(double_metaphone('de Cherelton', 4), ('TXRL', 'TKRL')) |
||
| 3238 | self.assertEqual(double_metaphone('de Cherleton', 4), ('TXRL', 'TKRL')) |
||
| 3239 | self.assertEqual(double_metaphone('de Clare', 4), ('TKLR', '')) |
||
| 3240 | self.assertEqual(double_metaphone('de Claremont', 4), ('TKLR', '')) |
||
| 3241 | self.assertEqual(double_metaphone('de Clifford', 4), ('TKLF', '')) |
||
| 3242 | self.assertEqual(double_metaphone('de Colville', 4), ('TKLF', '')) |
||
| 3243 | self.assertEqual(double_metaphone('de Courtenay', 4), ('TKRT', '')) |
||
| 3244 | self.assertEqual(double_metaphone('de Fauconberg', 4), ('TFKN', '')) |
||
| 3245 | self.assertEqual(double_metaphone('de Forest', 4), ('TFRS', '')) |
||
| 3246 | self.assertEqual(double_metaphone('de Gai', 4), ('TK', '')) |
||
| 3247 | self.assertEqual(double_metaphone('de Grey', 4), ('TKR', '')) |
||
| 3248 | self.assertEqual(double_metaphone('de Guernons', 4), ('TKRN', '')) |
||
| 3249 | self.assertEqual(double_metaphone('de Haia', 4), ('T', '')) |
||
| 3250 | self.assertEqual(double_metaphone('de Harcourt', 4), ('TRKR', '')) |
||
| 3251 | self.assertEqual(double_metaphone('de Hastings', 4), ('TSTN', '')) |
||
| 3252 | self.assertEqual(double_metaphone('de Hoke', 4), ('TK', '')) |
||
| 3253 | self.assertEqual(double_metaphone('de Hooch', 4), ('TK', '')) |
||
| 3254 | self.assertEqual(double_metaphone('de Hugelville', 4), |
||
| 3255 | ('TJLF', 'TKLF')) |
||
| 3256 | self.assertEqual(double_metaphone('de Huntingdon', 4), ('TNTN', '')) |
||
| 3257 | self.assertEqual(double_metaphone('de Insula', 4), ('TNSL', '')) |
||
| 3258 | self.assertEqual(double_metaphone('de Keynes', 4), ('TKNS', '')) |
||
| 3259 | self.assertEqual(double_metaphone('de Lacy', 4), ('TLS', '')) |
||
| 3260 | self.assertEqual(double_metaphone('de Lexington', 4), ('TLKS', '')) |
||
| 3261 | self.assertEqual(double_metaphone('de Lusignan', 4), ('TLSN', 'TLSK')) |
||
| 3262 | self.assertEqual(double_metaphone('de Manvers', 4), ('TMNF', '')) |
||
| 3263 | self.assertEqual(double_metaphone('de Montagu', 4), ('TMNT', '')) |
||
| 3264 | self.assertEqual(double_metaphone('de Montault', 4), ('TMNT', '')) |
||
| 3265 | self.assertEqual(double_metaphone('de Montfort', 4), ('TMNT', '')) |
||
| 3266 | self.assertEqual(double_metaphone('de Mortimer', 4), ('TMRT', '')) |
||
| 3267 | self.assertEqual(double_metaphone('de Morville', 4), ('TMRF', '')) |
||
| 3268 | self.assertEqual(double_metaphone('de Morvois', 4), ('TMRF', '')) |
||
| 3269 | self.assertEqual(double_metaphone('de Neufmarche', 4), ('TNFM', '')) |
||
| 3270 | self.assertEqual(double_metaphone('de Odingsells', 4), ('TTNK', '')) |
||
| 3271 | self.assertEqual(double_metaphone('de Odyngsells', 4), ('TTNK', '')) |
||
| 3272 | self.assertEqual(double_metaphone('de Percy', 4), ('TPRS', '')) |
||
| 3273 | self.assertEqual(double_metaphone('de Pierrepont', 4), ('TPRP', '')) |
||
| 3274 | self.assertEqual(double_metaphone('de Plessetis', 4), ('TPLS', '')) |
||
| 3275 | self.assertEqual(double_metaphone('de Porhoet', 4), ('TPRT', '')) |
||
| 3276 | self.assertEqual(double_metaphone('de Prouz', 4), ('TPRS', '')) |
||
| 3277 | self.assertEqual(double_metaphone('de Quincy', 4), ('TKNS', '')) |
||
| 3278 | self.assertEqual(double_metaphone('de Ripellis', 4), ('TRPL', '')) |
||
| 3279 | self.assertEqual(double_metaphone('de Ros', 4), ('TRS', '')) |
||
| 3280 | self.assertEqual(double_metaphone('de Salisbury', 4), ('TSLS', '')) |
||
| 3281 | self.assertEqual(double_metaphone('de Sanford', 4), ('TSNF', '')) |
||
| 3282 | self.assertEqual(double_metaphone('de Somery', 4), ('TSMR', '')) |
||
| 3283 | self.assertEqual(double_metaphone('de St. Hilary', 4), ('TSTL', '')) |
||
| 3284 | self.assertEqual(double_metaphone('de St. Liz', 4), ('TSTL', '')) |
||
| 3285 | self.assertEqual(double_metaphone('de Sutton', 4), ('TSTN', '')) |
||
| 3286 | self.assertEqual(double_metaphone('de Toeni', 4), ('TTN', '')) |
||
| 3287 | self.assertEqual(double_metaphone('de Tony', 4), ('TTN', '')) |
||
| 3288 | self.assertEqual(double_metaphone('de Umfreville', 4), ('TMFR', '')) |
||
| 3289 | self.assertEqual(double_metaphone('de Valognes', 4), ('TFLN', 'TFLK')) |
||
| 3290 | self.assertEqual(double_metaphone('de Vaux', 4), ('TF', '')) |
||
| 3291 | self.assertEqual(double_metaphone('de Vere', 4), ('TFR', '')) |
||
| 3292 | self.assertEqual(double_metaphone('de Vermandois', 4), ('TFRM', '')) |
||
| 3293 | self.assertEqual(double_metaphone('de Vernon', 4), ('TFRN', '')) |
||
| 3294 | self.assertEqual(double_metaphone('de Vexin', 4), ('TFKS', '')) |
||
| 3295 | self.assertEqual(double_metaphone('de Vitre', 4), ('TFTR', '')) |
||
| 3296 | self.assertEqual(double_metaphone('de Wandesford', 4), ('TNTS', '')) |
||
| 3297 | self.assertEqual(double_metaphone('de Warenne', 4), ('TRN', '')) |
||
| 3298 | self.assertEqual(double_metaphone('de Westbury', 4), ('TSTP', '')) |
||
| 3299 | self.assertEqual(double_metaphone('di Saluzzo', 4), ('TSLS', 'TSLT')) |
||
| 3300 | self.assertEqual(double_metaphone('fitz Alan', 4), ('FTSL', '')) |
||
| 3301 | self.assertEqual(double_metaphone('fitz Geoffrey', 4), |
||
| 3302 | ('FTSJ', 'FTSK')) |
||
| 3303 | self.assertEqual(double_metaphone('fitz Herbert', 4), ('FTSR', '')) |
||
| 3304 | self.assertEqual(double_metaphone('fitz John', 4), ('FTSJ', '')) |
||
| 3305 | self.assertEqual(double_metaphone('fitz Patrick', 4), ('FTSP', '')) |
||
| 3306 | self.assertEqual(double_metaphone('fitz Payn', 4), ('FTSP', '')) |
||
| 3307 | self.assertEqual(double_metaphone('fitz Piers', 4), ('FTSP', '')) |
||
| 3308 | self.assertEqual(double_metaphone('fitz Randolph', 4), ('FTSR', '')) |
||
| 3309 | self.assertEqual(double_metaphone('fitz Richard', 4), ('FTSR', '')) |
||
| 3310 | self.assertEqual(double_metaphone('fitz Robert', 4), ('FTSR', '')) |
||
| 3311 | self.assertEqual(double_metaphone('fitz Roy', 4), ('FTSR', '')) |
||
| 3312 | self.assertEqual(double_metaphone('fitz Scrob', 4), ('FTSS', '')) |
||
| 3313 | self.assertEqual(double_metaphone('fitz Walter', 4), ('FTSL', '')) |
||
| 3314 | self.assertEqual(double_metaphone('fitz Warin', 4), ('FTSR', '')) |
||
| 3315 | self.assertEqual(double_metaphone('fitz Williams', 4), ('FTSL', '')) |
||
| 3316 | self.assertEqual(double_metaphone('la Zouche', 4), ('LSX', 'LSK')) |
||
| 3317 | self.assertEqual(double_metaphone('le Botiller', 4), ('LPTL', '')) |
||
| 3318 | self.assertEqual(double_metaphone('le Despenser', 4), ('LTSP', '')) |
||
| 3319 | self.assertEqual(double_metaphone('le deSpencer', 4), ('LTSP', '')) |
||
| 3320 | self.assertEqual(double_metaphone('of Allendale', 4), ('AFLN', '')) |
||
| 3321 | self.assertEqual(double_metaphone('of Angouleme', 4), ('AFNK', '')) |
||
| 3322 | self.assertEqual(double_metaphone('of Anjou', 4), ('AFNJ', '')) |
||
| 3323 | self.assertEqual(double_metaphone('of Aquitaine', 4), ('AFKT', '')) |
||
| 3324 | self.assertEqual(double_metaphone('of Aumale', 4), ('AFML', '')) |
||
| 3325 | self.assertEqual(double_metaphone('of Bavaria', 4), ('AFPF', '')) |
||
| 3326 | self.assertEqual(double_metaphone('of Boulogne', 4), ('AFPL', '')) |
||
| 3327 | self.assertEqual(double_metaphone('of Brittany', 4), ('AFPR', '')) |
||
| 3328 | self.assertEqual(double_metaphone('of Brittary', 4), ('AFPR', '')) |
||
| 3329 | self.assertEqual(double_metaphone('of Castile', 4), ('AFKS', '')) |
||
| 3330 | self.assertEqual(double_metaphone('of Chester', 4), ('AFXS', 'AFKS')) |
||
| 3331 | self.assertEqual(double_metaphone('of Clermont', 4), ('AFKL', '')) |
||
| 3332 | self.assertEqual(double_metaphone('of Cologne', 4), ('AFKL', '')) |
||
| 3333 | self.assertEqual(double_metaphone('of Dinan', 4), ('AFTN', '')) |
||
| 3334 | self.assertEqual(double_metaphone('of Dunbar', 4), ('AFTN', '')) |
||
| 3335 | self.assertEqual(double_metaphone('of England', 4), ('AFNK', '')) |
||
| 3336 | self.assertEqual(double_metaphone('of Essex', 4), ('AFSK', '')) |
||
| 3337 | self.assertEqual(double_metaphone('of Falaise', 4), ('AFFL', '')) |
||
| 3338 | self.assertEqual(double_metaphone('of Flanders', 4), ('AFFL', '')) |
||
| 3339 | self.assertEqual(double_metaphone('of Galloway', 4), ('AFKL', '')) |
||
| 3340 | self.assertEqual(double_metaphone('of Germany', 4), ('AFKR', 'AFJR')) |
||
| 3341 | self.assertEqual(double_metaphone('of Gloucester', 4), ('AFKL', '')) |
||
| 3342 | self.assertEqual(double_metaphone('of Heristal', 4), ('AFRS', '')) |
||
| 3343 | self.assertEqual(double_metaphone('of Hungary', 4), ('AFNK', '')) |
||
| 3344 | self.assertEqual(double_metaphone('of Huntington', 4), ('AFNT', '')) |
||
| 3345 | self.assertEqual(double_metaphone('of Kiev', 4), ('AFKF', '')) |
||
| 3346 | self.assertEqual(double_metaphone('of Kuno', 4), ('AFKN', '')) |
||
| 3347 | self.assertEqual(double_metaphone('of Landen', 4), ('AFLN', '')) |
||
| 3348 | self.assertEqual(double_metaphone('of Laon', 4), ('AFLN', '')) |
||
| 3349 | self.assertEqual(double_metaphone('of Leinster', 4), ('AFLN', '')) |
||
| 3350 | self.assertEqual(double_metaphone('of Lens', 4), ('AFLN', '')) |
||
| 3351 | self.assertEqual(double_metaphone('of Lorraine', 4), ('AFLR', '')) |
||
| 3352 | self.assertEqual(double_metaphone('of Louvain', 4), ('AFLF', '')) |
||
| 3353 | self.assertEqual(double_metaphone('of Mercia', 4), ('AFMR', '')) |
||
| 3354 | self.assertEqual(double_metaphone('of Metz', 4), ('AFMT', '')) |
||
| 3355 | self.assertEqual(double_metaphone('of Meulan', 4), ('AFML', '')) |
||
| 3356 | self.assertEqual(double_metaphone('of Nass', 4), ('AFNS', '')) |
||
| 3357 | self.assertEqual(double_metaphone('of Normandy', 4), ('AFNR', '')) |
||
| 3358 | self.assertEqual(double_metaphone('of Ohningen', 4), ('AFNN', '')) |
||
| 3359 | self.assertEqual(double_metaphone('of Orleans', 4), ('AFRL', '')) |
||
| 3360 | self.assertEqual(double_metaphone('of Poitou', 4), ('AFPT', '')) |
||
| 3361 | self.assertEqual(double_metaphone('of Polotzk', 4), ('AFPL', '')) |
||
| 3362 | self.assertEqual(double_metaphone('of Provence', 4), ('AFPR', '')) |
||
| 3363 | self.assertEqual(double_metaphone('of Ringelheim', 4), ('AFRN', '')) |
||
| 3364 | self.assertEqual(double_metaphone('of Salisbury', 4), ('AFSL', '')) |
||
| 3365 | self.assertEqual(double_metaphone('of Saxony', 4), ('AFSK', '')) |
||
| 3366 | self.assertEqual(double_metaphone('of Scotland', 4), ('AFSK', '')) |
||
| 3367 | self.assertEqual(double_metaphone('of Senlis', 4), ('AFSN', '')) |
||
| 3368 | self.assertEqual(double_metaphone('of Stafford', 4), ('AFST', '')) |
||
| 3369 | self.assertEqual(double_metaphone('of Swabia', 4), ('AFSP', '')) |
||
| 3370 | self.assertEqual(double_metaphone('of Tongres', 4), ('AFTN', '')) |
||
| 3371 | self.assertEqual(double_metaphone('of the Tributes', 4), |
||
| 3372 | ('AF0T', 'AFTT')) |
||
| 3373 | self.assertEqual(double_metaphone('unknown', 4), ('ANKN', '')) |
||
| 3374 | self.assertEqual(double_metaphone('van der Gouda', 4), ('FNTR', '')) |
||
| 3375 | self.assertEqual(double_metaphone('von Adenbaugh', 4), ('FNTN', '')) |
||
| 3376 | self.assertEqual(double_metaphone('ARCHITure', 4), ('ARKT', '')) |
||
| 3377 | self.assertEqual(double_metaphone('Arnoff', 4), ('ARNF', '')) |
||
| 3378 | self.assertEqual(double_metaphone('Arnow', 4), ('ARN', 'ARNF')) |
||
| 3379 | self.assertEqual(double_metaphone('DANGER', 4), ('TNJR', 'TNKR')) |
||
| 3380 | self.assertEqual(double_metaphone('Jankelowicz', 4), ('JNKL', 'ANKL')) |
||
| 3381 | self.assertEqual(double_metaphone('MANGER', 4), ('MNJR', 'MNKR')) |
||
| 3382 | self.assertEqual(double_metaphone('McClellan', 4), ('MKLL', '')) |
||
| 3383 | self.assertEqual(double_metaphone('McHugh', 4), ('MK', '')) |
||
| 3384 | self.assertEqual(double_metaphone('McLaughlin', 4), ('MKLF', '')) |
||
| 3385 | self.assertEqual(double_metaphone('ORCHEStra', 4), ('ARKS', '')) |
||
| 3386 | self.assertEqual(double_metaphone('ORCHID', 4), ('ARKT', '')) |
||
| 3387 | self.assertEqual(double_metaphone('Pierce', 4), ('PRS', '')) |
||
| 3388 | self.assertEqual(double_metaphone('RANGER', 4), ('RNJR', 'RNKR')) |
||
| 3389 | self.assertEqual(double_metaphone('Schlesinger', 4), ('XLSN', 'SLSN')) |
||
| 3390 | self.assertEqual(double_metaphone('Uomo', 4), ('AM', '')) |
||
| 3391 | self.assertEqual(double_metaphone('Vasserman', 4), ('FSRM', '')) |
||
| 3392 | self.assertEqual(double_metaphone('Wasserman', 4), ('ASRM', 'FSRM')) |
||
| 3393 | self.assertEqual(double_metaphone('Womo', 4), ('AM', 'FM')) |
||
| 3394 | self.assertEqual(double_metaphone('Yankelovich', 4), ('ANKL', '')) |
||
| 3395 | self.assertEqual(double_metaphone('accede', 4), ('AKST', '')) |
||
| 3396 | self.assertEqual(double_metaphone('accident', 4), ('AKST', '')) |
||
| 3397 | self.assertEqual(double_metaphone('adelsheim', 4), ('ATLS', '')) |
||
| 3398 | self.assertEqual(double_metaphone('aged', 4), ('AJT', 'AKT')) |
||
| 3399 | self.assertEqual(double_metaphone('ageless', 4), ('AJLS', 'AKLS')) |
||
| 3400 | self.assertEqual(double_metaphone('agency', 4), ('AJNS', 'AKNS')) |
||
| 3401 | self.assertEqual(double_metaphone('aghast', 4), ('AKST', '')) |
||
| 3402 | self.assertEqual(double_metaphone('agio', 4), ('AJ', 'AK')) |
||
| 3403 | self.assertEqual(double_metaphone('agrimony', 4), ('AKRM', '')) |
||
| 3404 | self.assertEqual(double_metaphone('album', 4), ('ALPM', '')) |
||
| 3405 | self.assertEqual(double_metaphone('alcmene', 4), ('ALKM', '')) |
||
| 3406 | self.assertEqual(double_metaphone('alehouse', 4), ('ALHS', '')) |
||
| 3407 | self.assertEqual(double_metaphone('antique', 4), ('ANTK', '')) |
||
| 3408 | self.assertEqual(double_metaphone('artois', 4), ('ART', 'ARTS')) |
||
| 3409 | self.assertEqual(double_metaphone('automation', 4), ('ATMX', '')) |
||
| 3410 | self.assertEqual(double_metaphone('bacchus', 4), ('PKS', '')) |
||
| 3411 | self.assertEqual(double_metaphone('bacci', 4), ('PX', '')) |
||
| 3412 | self.assertEqual(double_metaphone('bajador', 4), ('PJTR', 'PHTR')) |
||
| 3413 | self.assertEqual(double_metaphone('bellocchio', 4), ('PLX', '')) |
||
| 3414 | self.assertEqual(double_metaphone('bertucci', 4), ('PRTX', '')) |
||
| 3415 | self.assertEqual(double_metaphone('biaggi', 4), ('PJ', 'PK')) |
||
| 3416 | self.assertEqual(double_metaphone('bough', 4), ('P', '')) |
||
| 3417 | self.assertEqual(double_metaphone('breaux', 4), ('PR', '')) |
||
| 3418 | self.assertEqual(double_metaphone('broughton', 4), ('PRTN', '')) |
||
| 3419 | self.assertEqual(double_metaphone('cabrillo', 4), ('KPRL', 'KPR')) |
||
| 3420 | self.assertEqual(double_metaphone('caesar', 4), ('SSR', '')) |
||
| 3421 | self.assertEqual(double_metaphone('cagney', 4), ('KKN', '')) |
||
| 3422 | self.assertEqual(double_metaphone('campbell', 4), ('KMPL', '')) |
||
| 3423 | self.assertEqual(double_metaphone('carlisle', 4), ('KRLL', '')) |
||
| 3424 | self.assertEqual(double_metaphone('carlysle', 4), ('KRLL', '')) |
||
| 3425 | self.assertEqual(double_metaphone('chemistry', 4), ('KMST', '')) |
||
| 3426 | self.assertEqual(double_metaphone('chianti', 4), ('KNT', '')) |
||
| 3427 | self.assertEqual(double_metaphone('chorus', 4), ('KRS', '')) |
||
| 3428 | self.assertEqual(double_metaphone('cough', 4), ('KF', '')) |
||
| 3429 | self.assertEqual(double_metaphone('czerny', 4), ('SRN', 'XRN')) |
||
| 3430 | self.assertEqual(double_metaphone('deffenbacher', 4), ('TFNP', '')) |
||
| 3431 | self.assertEqual(double_metaphone('dumb', 4), ('TM', '')) |
||
| 3432 | self.assertEqual(double_metaphone('edgar', 4), ('ATKR', '')) |
||
| 3433 | self.assertEqual(double_metaphone('edge', 4), ('AJ', '')) |
||
| 3434 | self.assertEqual(double_metaphone('filipowicz', 4), ('FLPT', 'FLPF')) |
||
| 3435 | self.assertEqual(double_metaphone('focaccia', 4), ('FKX', '')) |
||
| 3436 | self.assertEqual(double_metaphone('gallegos', 4), ('KLKS', 'KKS')) |
||
| 3437 | self.assertEqual(double_metaphone('gambrelli', 4), ('KMPR', '')) |
||
| 3438 | self.assertEqual(double_metaphone('geithain', 4), ('K0N', 'JTN')) |
||
| 3439 | self.assertEqual(double_metaphone('ghiradelli', 4), ('JRTL', '')) |
||
| 3440 | self.assertEqual(double_metaphone('ghislane', 4), ('JLN', '')) |
||
| 3441 | self.assertEqual(double_metaphone('gough', 4), ('KF', '')) |
||
| 3442 | self.assertEqual(double_metaphone('hartheim', 4), ('HR0M', 'HRTM')) |
||
| 3443 | self.assertEqual(double_metaphone('heimsheim', 4), ('HMSM', '')) |
||
| 3444 | self.assertEqual(double_metaphone('hochmeier', 4), ('HKMR', '')) |
||
| 3445 | self.assertEqual(double_metaphone('hugh', 4), ('H', '')) |
||
| 3446 | self.assertEqual(double_metaphone('hunger', 4), ('HNKR', 'HNJR')) |
||
| 3447 | self.assertEqual(double_metaphone('hungry', 4), ('HNKR', '')) |
||
| 3448 | self.assertEqual(double_metaphone('island', 4), ('ALNT', '')) |
||
| 3449 | self.assertEqual(double_metaphone('isle', 4), ('AL', '')) |
||
| 3450 | self.assertEqual(double_metaphone('jose', 4), ('HS', '')) |
||
| 3451 | self.assertEqual(double_metaphone('laugh', 4), ('LF', '')) |
||
| 3452 | self.assertEqual(double_metaphone('mac caffrey', 4), ('MKFR', '')) |
||
| 3453 | self.assertEqual(double_metaphone('mac gregor', 4), ('MKRK', '')) |
||
| 3454 | self.assertEqual(double_metaphone('pegnitz', 4), ('PNTS', 'PKNT')) |
||
| 3455 | self.assertEqual(double_metaphone('piskowitz', 4), ('PSKT', 'PSKF')) |
||
| 3456 | self.assertEqual(double_metaphone('queen', 4), ('KN', '')) |
||
| 3457 | self.assertEqual(double_metaphone('raspberry', 4), ('RSPR', '')) |
||
| 3458 | self.assertEqual(double_metaphone('resnais', 4), ('RSN', 'RSNS')) |
||
| 3459 | self.assertEqual(double_metaphone('rogier', 4), ('RJ', 'RJR')) |
||
| 3460 | self.assertEqual(double_metaphone('rough', 4), ('RF', '')) |
||
| 3461 | self.assertEqual(double_metaphone('san jacinto', 4), ('SNHS', '')) |
||
| 3462 | self.assertEqual(double_metaphone('schenker', 4), ('XNKR', 'SKNK')) |
||
| 3463 | self.assertEqual(double_metaphone('schermerhorn', 4), ('XRMR', 'SKRM')) |
||
| 3464 | self.assertEqual(double_metaphone('schmidt', 4), ('XMT', 'SMT')) |
||
| 3465 | self.assertEqual(double_metaphone('schneider', 4), ('XNTR', 'SNTR')) |
||
| 3466 | self.assertEqual(double_metaphone('school', 4), ('SKL', '')) |
||
| 3467 | self.assertEqual(double_metaphone('schooner', 4), ('SKNR', '')) |
||
| 3468 | self.assertEqual(double_metaphone('schrozberg', 4), ('XRSP', 'SRSP')) |
||
| 3469 | self.assertEqual(double_metaphone('schulman', 4), ('XLMN', '')) |
||
| 3470 | self.assertEqual(double_metaphone('schwabach', 4), ('XPK', 'XFPK')) |
||
| 3471 | self.assertEqual(double_metaphone('schwarzach', 4), ('XRSK', 'XFRT')) |
||
| 3472 | self.assertEqual(double_metaphone('smith', 4), ('SM0', 'XMT')) |
||
| 3473 | self.assertEqual(double_metaphone('snider', 4), ('SNTR', 'XNTR')) |
||
| 3474 | self.assertEqual(double_metaphone('succeed', 4), ('SKST', '')) |
||
| 3475 | self.assertEqual(double_metaphone('sugarcane', 4), ('XKRK', 'SKRK')) |
||
| 3476 | self.assertEqual(double_metaphone('svobodka', 4), ('SFPT', '')) |
||
| 3477 | self.assertEqual(double_metaphone('tagliaro', 4), ('TKLR', 'TLR')) |
||
| 3478 | self.assertEqual(double_metaphone('thames', 4), ('TMS', '')) |
||
| 3479 | self.assertEqual(double_metaphone('theilheim', 4), ('0LM', 'TLM')) |
||
| 3480 | self.assertEqual(double_metaphone('thomas', 4), ('TMS', '')) |
||
| 3481 | self.assertEqual(double_metaphone('thumb', 4), ('0M', 'TM')) |
||
| 3482 | self.assertEqual(double_metaphone('tichner', 4), ('TXNR', 'TKNR')) |
||
| 3483 | self.assertEqual(double_metaphone('tough', 4), ('TF', '')) |
||
| 3484 | self.assertEqual(double_metaphone('umbrella', 4), ('AMPR', '')) |
||
| 3485 | self.assertEqual(double_metaphone('vilshofen', 4), ('FLXF', '')) |
||
| 3486 | self.assertEqual(double_metaphone('von schuller', 4), ('FNXL', '')) |
||
| 3487 | self.assertEqual(double_metaphone('wachtler', 4), ('AKTL', 'FKTL')) |
||
| 3488 | self.assertEqual(double_metaphone('wechsler', 4), ('AKSL', 'FKSL')) |
||
| 3489 | self.assertEqual(double_metaphone('weikersheim', 4), ('AKRS', 'FKRS')) |
||
| 3490 | self.assertEqual(double_metaphone('zhao', 4), ('J', '')) |
||
| 3491 | |||
| 3492 | |||
| 3493 | class CaverphoneTestCases(unittest.TestCase): |
||
| 3494 | """Test Caverphone functions. |
||
| 3495 | |||
| 3496 | test cases for abydos.phonetic.caverphone |
||
| 3497 | """ |
||
| 3498 | |||
| 3499 | def test_caverphone2(self): |
||
| 3500 | """Test abydos.phonetic.caverphone (Caverphone 2).""" |
||
| 3501 | self.assertEqual(caverphone(''), '1111111111') |
||
| 3502 | self.assertEqual(caverphone('', 2), '1111111111') |
||
| 3503 | self.assertEqual(caverphone('', version=2), '1111111111') |
||
| 3504 | |||
| 3505 | # http://ntz-develop.blogspot.com/2011/03/phonetic-algorithms.html |
||
| 3506 | self.assertEqual(caverphone('Henrichsen'), 'ANRKSN1111') |
||
| 3507 | self.assertEqual(caverphone('Henricsson'), 'ANRKSN1111') |
||
| 3508 | self.assertEqual(caverphone('Henriksson'), 'ANRKSN1111') |
||
| 3509 | self.assertEqual(caverphone('Hinrichsen'), 'ANRKSN1111') |
||
| 3510 | self.assertEqual(caverphone('Izchaki'), 'ASKKA11111') |
||
| 3511 | self.assertEqual(caverphone('Maclaverty'), 'MKLFTA1111') |
||
| 3512 | self.assertEqual(caverphone('Mccleverty'), 'MKLFTA1111') |
||
| 3513 | self.assertEqual(caverphone('Mcclifferty'), 'MKLFTA1111') |
||
| 3514 | self.assertEqual(caverphone('Mclafferty'), 'MKLFTA1111') |
||
| 3515 | self.assertEqual(caverphone('Mclaverty'), 'MKLFTA1111') |
||
| 3516 | self.assertEqual(caverphone('Slocomb'), 'SLKM111111') |
||
| 3517 | self.assertEqual(caverphone('Slocombe'), 'SLKM111111') |
||
| 3518 | self.assertEqual(caverphone('Slocumb'), 'SLKM111111') |
||
| 3519 | self.assertEqual(caverphone('Whitlam'), 'WTLM111111') |
||
| 3520 | |||
| 3521 | # http://caversham.otago.ac.nz/files/working/ctp150804.pdf |
||
| 3522 | self.assertEqual(caverphone('Stevenson'), 'STFNSN1111') |
||
| 3523 | self.assertEqual(caverphone('Peter'), 'PTA1111111') |
||
| 3524 | for word in ('Darda', 'Datha', 'Dedie', 'Deedee', 'Deerdre', 'Deidre', |
||
| 3525 | 'Deirdre', 'Detta', 'Didi', 'Didier', 'Dido', 'Dierdre', |
||
| 3526 | 'Dieter', 'Dita', 'Ditter', 'Dodi', 'Dodie', 'Dody', |
||
| 3527 | 'Doherty', 'Dorthea', 'Dorthy', 'Doti', 'Dotti', 'Dottie', |
||
| 3528 | 'Dotty', 'Doty', 'Doughty', 'Douty', 'Dowdell', 'Duthie', |
||
| 3529 | 'Tada', 'Taddeo', 'Tadeo', 'Tadio', 'Tati', 'Teador', |
||
| 3530 | 'Tedda', 'Tedder', 'Teddi', 'Teddie', 'Teddy', 'Tedi', |
||
| 3531 | 'Tedie', 'Teeter', 'Teodoor', 'Teodor', 'Terti', 'Theda', |
||
| 3532 | 'Theodor', 'Theodore', 'Theta', 'Thilda', 'Thordia', |
||
| 3533 | 'Tilda', 'Tildi', 'Tildie', 'Tildy', 'Tita', 'Tito', |
||
| 3534 | 'Tjader', 'Toddie', 'Toddy', 'Torto', 'Tuddor', 'Tudor', |
||
| 3535 | 'Turtle', 'Tuttle', 'Tutto'): |
||
| 3536 | self.assertEqual(caverphone(word), 'TTA1111111') |
||
| 3537 | self.assertEqual(caverphone(word, 2), 'TTA1111111') |
||
| 3538 | self.assertEqual(caverphone(word, version=2), 'TTA1111111') |
||
| 3539 | for word in ('Cailean', 'Calan', 'Calen', 'Callahan', 'Callan', |
||
| 3540 | 'Callean', 'Carleen', 'Carlen', 'Carlene', 'Carlin', |
||
| 3541 | 'Carline', 'Carlyn', 'Carlynn', 'Carlynne', 'Charlean', |
||
| 3542 | 'Charleen', 'Charlene', 'Charline', 'Cherlyn', 'Chirlin', |
||
| 3543 | 'Clein', 'Cleon', 'Cline', 'Cohleen', 'Colan', 'Coleen', |
||
| 3544 | 'Colene', 'Colin', 'Colleen', 'Collen', 'Collin', |
||
| 3545 | 'Colline', 'Colon', 'Cullan', 'Cullen', 'Cullin', |
||
| 3546 | 'Gaelan', 'Galan', 'Galen', 'Garlan', 'Garlen', 'Gaulin', |
||
| 3547 | 'Gayleen', 'Gaylene', 'Giliane', 'Gillan', 'Gillian', |
||
| 3548 | 'Glen', 'Glenn', 'Glyn', 'Glynn', 'Gollin', 'Gorlin', |
||
| 3549 | 'Kalin', 'Karlan', 'Karleen', 'Karlen', 'Karlene', |
||
| 3550 | 'Karlin', 'Karlyn', 'Kaylyn', 'Keelin', 'Kellen', |
||
| 3551 | 'Kellene', 'Kellyann', 'Kellyn', 'Khalin', 'Kilan', |
||
| 3552 | 'Kilian', 'Killen', 'Killian', 'Killion', 'Klein', |
||
| 3553 | 'Kleon', 'Kline', 'Koerlin', 'Kylen', 'Kylynn', 'Quillan', |
||
| 3554 | 'Quillon', 'Qulllon', 'Xylon'): |
||
| 3555 | self.assertEqual(caverphone(word), 'KLN1111111') |
||
| 3556 | self.assertEqual(caverphone(word, 2), 'KLN1111111') |
||
| 3557 | self.assertEqual(caverphone(word, version=2), 'KLN1111111') |
||
| 3558 | for word in ('Dan', 'Dane', 'Dann', 'Darn', 'Daune', 'Dawn', 'Ddene', |
||
| 3559 | 'Dean', 'Deane', 'Deanne', 'DeeAnn', 'Deeann', 'Deeanne', |
||
| 3560 | 'Deeyn', 'Den', 'Dene', 'Denn', 'Deonne', 'Diahann', |
||
| 3561 | 'Dian', 'Diane', 'Diann', 'Dianne', 'Diannne', 'Dine', |
||
| 3562 | 'Dion', 'Dione', 'Dionne', 'Doane', 'Doehne', 'Don', |
||
| 3563 | 'Donn', 'Doone', 'Dorn', 'Down', 'Downe', 'Duane', 'Dun', |
||
| 3564 | 'Dunn', 'Duyne', 'Dyan', 'Dyane', 'Dyann', 'Dyanne', |
||
| 3565 | 'Dyun', 'Tan', 'Tann', 'Teahan', 'Ten', 'Tenn', 'Terhune', |
||
| 3566 | 'Thain', 'Thaine', 'Thane', 'Thanh', 'Thayne', 'Theone', |
||
| 3567 | 'Thin', 'Thorn', 'Thorne', 'Thun', 'Thynne', 'Tien', |
||
| 3568 | 'Tine', 'Tjon', 'Town', 'Towne', 'Turne', 'Tyne'): |
||
| 3569 | self.assertEqual(caverphone(word), 'TN11111111') |
||
| 3570 | self.assertEqual(caverphone(word, 2), 'TN11111111') |
||
| 3571 | self.assertEqual(caverphone(word, version=2), 'TN11111111') |
||
| 3572 | |||
| 3573 | # etc. (for code coverage) |
||
| 3574 | self.assertEqual(caverphone('enough'), 'ANF1111111') |
||
| 3575 | self.assertEqual(caverphone('trough'), 'TRF1111111') |
||
| 3576 | self.assertEqual(caverphone('gnu'), 'NA11111111') |
||
| 3577 | |||
| 3578 | def test_caverphone2_php_testset(self): |
||
| 3579 | """Test abydos.phonetic.caverphone (PHP version testset).""" |
||
| 3580 | # https://raw.githubusercontent.com/kiphughes/caverphone/master/unit_tests.php |
||
| 3581 | with open(TESTDIR + '/corpora/php_caverphone.csv') as php_testset: |
||
| 3582 | for php_line in php_testset: |
||
| 3583 | (word, caver) = php_line.strip().split(',') |
||
| 3584 | self.assertEqual(caverphone(word), caver) |
||
| 3585 | |||
| 3586 | def test_caverphone1(self): |
||
| 3587 | """Test abydos.phonetic.caverphone (Caverphone 1).""" |
||
| 3588 | self.assertEqual(caverphone('', 1), '111111') |
||
| 3589 | self.assertEqual(caverphone('', version=1), '111111') |
||
| 3590 | |||
| 3591 | # http://caversham.otago.ac.nz/files/working/ctp060902.pdf |
||
| 3592 | self.assertEqual(caverphone('David', version=1), 'TFT111') |
||
| 3593 | self.assertEqual(caverphone('Whittle', version=1), 'WTL111') |
||
| 3594 | |||
| 3595 | def test_caversham(self): |
||
| 3596 | """Test using Caversham test set (SoundEx, Metaphone, & Caverphone).""" |
||
| 3597 | with open(TESTDIR + '/corpora/variantNames.csv') as cav_testset: |
||
| 3598 | next(cav_testset) |
||
| 3599 | for cav_line in cav_testset: |
||
| 3600 | (name1, soundex1, metaphone1, caverphone1, |
||
| 3601 | name2, soundex2, metaphone2, caverphone2, |
||
| 3602 | soundex_same, metaphone_same, caverphone_same) = \ |
||
| 3603 | cav_line.strip().split(',') |
||
| 3604 | |||
| 3605 | self.assertEqual(soundex(name1), soundex1) |
||
| 3606 | self.assertEqual(soundex(name2), soundex2) |
||
| 3607 | if soundex_same == '1': |
||
| 3608 | self.assertEqual(soundex(name1), soundex(name2)) |
||
| 3609 | else: |
||
| 3610 | self.assertNotEqual(soundex(name1), soundex(name2)) |
||
| 3611 | |||
| 3612 | self.assertEqual(metaphone(name1), metaphone1) |
||
| 3613 | self.assertEqual(metaphone(name2), metaphone2) |
||
| 3614 | if metaphone_same == '1': |
||
| 3615 | self.assertEqual(metaphone(name1), metaphone(name2)) |
||
| 3616 | else: |
||
| 3617 | self.assertNotEqual(metaphone(name1), metaphone(name2)) |
||
| 3618 | |||
| 3619 | self.assertEqual(caverphone(name1), caverphone1) |
||
| 3620 | self.assertEqual(caverphone(name2), caverphone2) |
||
| 3621 | if caverphone_same == '1': |
||
| 3622 | self.assertEqual(caverphone(name1), caverphone(name2)) |
||
| 3623 | else: |
||
| 3624 | self.assertNotEqual(caverphone(name1), caverphone(name2)) |
||
| 3625 | |||
| 3626 | |||
| 3627 | class AlphaSisTestCases(unittest.TestCase): |
||
| 3628 | """Test Alpha-SIS functions. |
||
| 3629 | |||
| 3630 | test cases for abydos.phonetic.alpha_sis |
||
| 3631 | """ |
||
| 3632 | |||
| 3633 | def test_alpha_sis(self): |
||
| 3634 | """Test abydos.phonetic.alpha_sis.""" |
||
| 3635 | self.assertEqual(alpha_sis('')[0], '00000000000000') |
||
| 3636 | |||
| 3637 | self.assertEqual(alpha_sis('Rodgers')[0], '04740000000000') |
||
| 3638 | self.assertEqual(alpha_sis('Rogers')[0], '04740000000000') |
||
| 3639 | self.assertEqual(alpha_sis('Kant')[0], '07210000000000') |
||
| 3640 | self.assertEqual(alpha_sis('Knuth')[0], '02100000000000') |
||
| 3641 | self.assertEqual(alpha_sis('Harper')[0], '24940000000000') |
||
| 3642 | self.assertEqual(alpha_sis('Collier')[0], '07540000000000') |
||
| 3643 | self.assertEqual(alpha_sis('Schultz')[0], '06500000000000') |
||
| 3644 | self.assertEqual(alpha_sis('Livingston')[0], '05827012000000') |
||
| 3645 | |||
| 3646 | # tests of repeated letters |
||
| 3647 | self.assertEqual(alpha_sis('Colllier')[0], '07554000000000') |
||
| 3648 | self.assertEqual(alpha_sis('Collllier')[0], '07554000000000') |
||
| 3649 | self.assertEqual(alpha_sis('Colllllier')[0], '07555400000000') |
||
| 3650 | self.assertEqual(alpha_sis('Collllllier')[0], '07555400000000') |
||
| 3651 | self.assertEqual(alpha_sis('Colalalier')[0], '07555400000000') |
||
| 3652 | |||
| 3653 | # maxlength bounds tests |
||
| 3654 | self.assertEqual(alpha_sis('Niall', maxlength=float('inf'))[0], |
||
| 3655 | '02500000000000000000000000000000000000000000000000' + |
||
| 3656 | '00000000000000') |
||
| 3657 | self.assertEqual(alpha_sis('Niall', maxlength=None)[0], |
||
| 3658 | '02500000000000000000000000000000000000000000000000' + |
||
| 3659 | '00000000000000') |
||
| 3660 | self.assertEqual(alpha_sis('Niall', maxlength=0)[0], '0250') |
||
| 3661 | |||
| 3662 | |||
| 3663 | class FuzzySoundexTestCases(unittest.TestCase): |
||
| 3664 | """Test Fuzzy Soundex functions. |
||
| 3665 | |||
| 3666 | test cases for abydos.phonetic.fuzzy_soundex |
||
| 3667 | """ |
||
| 3668 | |||
| 3669 | def test_fuzzy_soundex(self): |
||
| 3670 | """Test abydos.phonetic.fuzzy_soundex.""" |
||
| 3671 | self.assertEqual(fuzzy_soundex(''), '00000') |
||
| 3672 | # http://wayback.archive.org/web/20100629121128/http://www.ir.iit.edu/publications/downloads/IEEESoundexV5.pdf |
||
| 3673 | self.assertEqual(fuzzy_soundex('Kristen'), 'K6935') |
||
| 3674 | self.assertEqual(fuzzy_soundex('Krissy'), 'K6900') |
||
| 3675 | self.assertEqual(fuzzy_soundex('Christen'), 'K6935') |
||
| 3676 | |||
| 3677 | # http://books.google.com/books?id=LZrT6eWf9NMC&lpg=PA76&ots=Tex3FqNwGP&dq=%22phonix%20algorithm%22&pg=PA75#v=onepage&q=%22phonix%20algorithm%22&f=false |
||
| 3678 | self.assertEqual(fuzzy_soundex('peter', 4), 'P360') |
||
| 3679 | self.assertEqual(fuzzy_soundex('pete', 4), 'P300') |
||
| 3680 | self.assertEqual(fuzzy_soundex('pedro', 4), 'P360') |
||
| 3681 | self.assertEqual(fuzzy_soundex('stephen', 4), 'S315') |
||
| 3682 | self.assertEqual(fuzzy_soundex('steve', 4), 'S310') |
||
| 3683 | self.assertEqual(fuzzy_soundex('smith', 4), 'S530') |
||
| 3684 | self.assertEqual(fuzzy_soundex('smythe', 4), 'S530') |
||
| 3685 | self.assertEqual(fuzzy_soundex('gail', 4), 'G400') |
||
| 3686 | self.assertEqual(fuzzy_soundex('gayle', 4), 'G400') |
||
| 3687 | self.assertEqual(fuzzy_soundex('christine', 4), 'K693') |
||
| 3688 | self.assertEqual(fuzzy_soundex('christina', 4), 'K693') |
||
| 3689 | self.assertEqual(fuzzy_soundex('kristina', 4), 'K693') |
||
| 3690 | |||
| 3691 | # etc. (for code coverage) |
||
| 3692 | self.assertEqual(fuzzy_soundex('Wight'), 'W3000') |
||
| 3693 | self.assertEqual(fuzzy_soundex('Hardt'), 'H6000') |
||
| 3694 | self.assertEqual(fuzzy_soundex('Knight'), 'N3000') |
||
| 3695 | self.assertEqual(fuzzy_soundex('Czech'), 'S7000') |
||
| 3696 | self.assertEqual(fuzzy_soundex('Tsech'), 'S7000') |
||
| 3697 | self.assertEqual(fuzzy_soundex('gnomic'), 'N5900') |
||
| 3698 | self.assertEqual(fuzzy_soundex('Wright'), 'R3000') |
||
| 3699 | self.assertEqual(fuzzy_soundex('Hrothgar'), 'R3760') |
||
| 3700 | self.assertEqual(fuzzy_soundex('Hwaet'), 'W3000') |
||
| 3701 | self.assertEqual(fuzzy_soundex('Grant'), 'G6300') |
||
| 3702 | self.assertEqual(fuzzy_soundex('Hart'), 'H6000') |
||
| 3703 | self.assertEqual(fuzzy_soundex('Hardt'), 'H6000') |
||
| 3704 | |||
| 3705 | # maxlength bounds tests |
||
| 3706 | self.assertEqual(fuzzy_soundex('Niall', maxlength=float('inf')), |
||
| 3707 | 'N4000000000000000000000000000000000000000000000000' + |
||
| 3708 | '00000000000000') |
||
| 3709 | self.assertEqual(fuzzy_soundex('Niall', maxlength=None), |
||
| 3710 | 'N4000000000000000000000000000000000000000000000000' + |
||
| 3711 | '00000000000000') |
||
| 3712 | self.assertEqual(fuzzy_soundex('Niall', maxlength=0), 'N400') |
||
| 3713 | |||
| 3714 | # zero_pad tests |
||
| 3715 | self.assertEqual(fuzzy_soundex('Niall', maxlength=float('inf'), |
||
| 3716 | zero_pad=False), 'N4') |
||
| 3717 | self.assertEqual(fuzzy_soundex('Niall', maxlength=None, |
||
| 3718 | zero_pad=False), 'N4') |
||
| 3719 | self.assertEqual(fuzzy_soundex('Niall', maxlength=0, |
||
| 3720 | zero_pad=False), 'N4') |
||
| 3721 | self.assertEqual(fuzzy_soundex('Niall', maxlength=0, |
||
| 3722 | zero_pad=True), 'N400') |
||
| 3723 | self.assertEqual(fuzzy_soundex('', maxlength=4, zero_pad=False), '0') |
||
| 3724 | self.assertEqual(fuzzy_soundex('', maxlength=4, zero_pad=True), '0000') |
||
| 3725 | |||
| 3726 | |||
| 3727 | class PhonexTestCases(unittest.TestCase): |
||
| 3728 | """Test Phonex functions. |
||
| 3729 | |||
| 3730 | test cases for abydos.phonetic.phonex |
||
| 3731 | """ |
||
| 3732 | |||
| 3733 | def test_phonex(self): |
||
| 3734 | """Test abydos.phonetic.phonex.""" |
||
| 3735 | self.assertEqual(phonex(''), '0000') |
||
| 3736 | |||
| 3737 | # http://homepages.cs.ncl.ac.uk/brian.randell/Genealogy/NameMatching.pdf |
||
| 3738 | self.assertEqual(phonex('Ewell'), 'A400') |
||
| 3739 | self.assertEqual(phonex('Filp'), 'F100') |
||
| 3740 | self.assertEqual(phonex('Heames'), 'A500') |
||
| 3741 | self.assertEqual(phonex('Kneves'), 'N100') |
||
| 3742 | self.assertEqual(phonex('River'), 'R160') |
||
| 3743 | self.assertEqual(phonex('Corley'), 'C400') |
||
| 3744 | self.assertEqual(phonex('Carton'), 'C350') |
||
| 3745 | self.assertEqual(phonex('Cachpole'), 'C214') |
||
| 3746 | |||
| 3747 | self.assertEqual(phonex('Ewell'), phonex('Ule')) |
||
| 3748 | self.assertEqual(phonex('Filp'), phonex('Philp')) |
||
| 3749 | self.assertEqual(phonex('Yule'), phonex('Ewell')) |
||
| 3750 | self.assertEqual(phonex('Heames'), phonex('Eames')) |
||
| 3751 | self.assertEqual(phonex('Kneves'), phonex('Neves')) |
||
| 3752 | self.assertEqual(phonex('River'), phonex('Rivers')) |
||
| 3753 | self.assertEqual(phonex('Corley'), phonex('Coley')) |
||
| 3754 | self.assertEqual(phonex('Carton'), phonex('Carlton')) |
||
| 3755 | self.assertEqual(phonex('Cachpole'), phonex('Catchpole')) |
||
| 3756 | |||
| 3757 | # etc. (for code coverage) |
||
| 3758 | self.assertEqual(phonex('Saxon'), 'S250') |
||
| 3759 | self.assertEqual(phonex('Wright'), 'R230') |
||
| 3760 | self.assertEqual(phonex('Ai'), 'A000') |
||
| 3761 | self.assertEqual(phonex('Barth'), 'B300') |
||
| 3762 | self.assertEqual(phonex('Perry'), 'B600') |
||
| 3763 | self.assertEqual(phonex('Garth'), 'G300') |
||
| 3764 | self.assertEqual(phonex('Jerry'), 'G600') |
||
| 3765 | self.assertEqual(phonex('Gerry'), 'G600') |
||
| 3766 | self.assertEqual(phonex('Camden'), 'C500') |
||
| 3767 | self.assertEqual(phonex('Ganges'), 'G500') |
||
| 3768 | self.assertEqual(phonex('A-1'), 'A000') |
||
| 3769 | |||
| 3770 | # maxlength bounds tests |
||
| 3771 | self.assertEqual(phonex('Niall', maxlength=float('inf')), |
||
| 3772 | 'N4000000000000000000000000000000000000000000000000' + |
||
| 3773 | '00000000000000') |
||
| 3774 | self.assertEqual(phonex('Niall', maxlength=None), |
||
| 3775 | 'N4000000000000000000000000000000000000000000000000' + |
||
| 3776 | '00000000000000') |
||
| 3777 | self.assertEqual(phonex('Niall', maxlength=0), 'N400') |
||
| 3778 | |||
| 3779 | # zero_pad tests |
||
| 3780 | self.assertEqual(phonex('Niall', maxlength=float('inf'), |
||
| 3781 | zero_pad=False), 'N4') |
||
| 3782 | self.assertEqual(phonex('Niall', maxlength=None, zero_pad=False), |
||
| 3783 | 'N4') |
||
| 3784 | self.assertEqual(phonex('Niall', maxlength=0, zero_pad=False), |
||
| 3785 | 'N4') |
||
| 3786 | self.assertEqual(phonex('Niall', maxlength=0, zero_pad=True), |
||
| 3787 | 'N400') |
||
| 3788 | self.assertEqual(phonex('', maxlength=4, zero_pad=False), '0') |
||
| 3789 | self.assertEqual(phonex('', maxlength=4, zero_pad=True), '0000') |
||
| 3790 | |||
| 3791 | |||
| 3792 | class PhonemTestCases(unittest.TestCase): |
||
| 3793 | """Test Phonem functions. |
||
| 3794 | |||
| 3795 | test cases for abydos.phonetic.phonem |
||
| 3796 | """ |
||
| 3797 | |||
| 3798 | def test_phonem(self): |
||
| 3799 | """Test abydos.phonetic.phonem.""" |
||
| 3800 | self.assertEqual(phonem(''), '') |
||
| 3801 | |||
| 3802 | # http://phonetik.phil-fak.uni-koeln.de/fileadmin/home/ritters/Allgemeine_Dateien/Martin_Wilz.pdf |
||
| 3803 | self.assertEqual(phonem('müller'), 'MYLR') |
||
| 3804 | self.assertEqual(phonem('schmidt'), 'CMYD') |
||
| 3805 | self.assertEqual(phonem('schneider'), 'CNAYDR') |
||
| 3806 | self.assertEqual(phonem('fischer'), 'VYCR') |
||
| 3807 | self.assertEqual(phonem('weber'), 'VBR') |
||
| 3808 | self.assertEqual(phonem('meyer'), 'MAYR') |
||
| 3809 | self.assertEqual(phonem('wagner'), 'VACNR') |
||
| 3810 | self.assertEqual(phonem('schulz'), 'CULC') |
||
| 3811 | self.assertEqual(phonem('becker'), 'BCR') |
||
| 3812 | self.assertEqual(phonem('hoffmann'), 'OVMAN') |
||
| 3813 | self.assertEqual(phonem('schäfer'), 'CVR') |
||
| 3814 | |||
| 3815 | # http://cpansearch.perl.org/src/MAROS/Text-Phonetic-2.05/t/008_phonem.t |
||
| 3816 | self.assertEqual(phonem('mair'), 'MAYR') |
||
| 3817 | self.assertEqual(phonem('bäker'), 'BCR') |
||
| 3818 | self.assertEqual(phonem('schaeffer'), 'CVR') |
||
| 3819 | self.assertEqual(phonem('computer'), 'COMBUDR') |
||
| 3820 | self.assertEqual(phonem('pfeifer'), 'VAYVR') |
||
| 3821 | self.assertEqual(phonem('pfeiffer'), 'VAYVR') |
||
| 3822 | |||
| 3823 | |||
| 3824 | class PhonixTestCases(unittest.TestCase): |
||
| 3825 | """Test Phonix functions. |
||
| 3826 | |||
| 3827 | test cases for abydos.phonetic.phonix |
||
| 3828 | """ |
||
| 3829 | |||
| 3830 | def test_phonix(self): |
||
| 3831 | """Test abydos.phonetic.phonix.""" |
||
| 3832 | self.assertEqual(phonix(''), '0000') |
||
| 3833 | |||
| 3834 | # http://cpansearch.perl.org/src/MAROS/Text-Phonetic-2.05/t/007_phonix.t |
||
| 3835 | self.assertEqual(phonix('Müller'), 'M400') |
||
| 3836 | self.assertEqual(phonix('schneider'), 'S530') |
||
| 3837 | self.assertEqual(phonix('fischer'), 'F800') |
||
| 3838 | self.assertEqual(phonix('weber'), 'W100') |
||
| 3839 | self.assertEqual(phonix('meyer'), 'M000') |
||
| 3840 | self.assertEqual(phonix('wagner'), 'W250') |
||
| 3841 | self.assertEqual(phonix('schulz'), 'S480') |
||
| 3842 | self.assertEqual(phonix('becker'), 'B200') |
||
| 3843 | self.assertEqual(phonix('hoffmann'), 'H755') |
||
| 3844 | self.assertEqual(phonix('schäfer'), 'S700') |
||
| 3845 | self.assertEqual(phonix('schmidt'), 'S530') |
||
| 3846 | |||
| 3847 | # http://cpansearch.perl.org/src/MAROS/Text-Phonetic-2.05/t/007_phonix.t: |
||
| 3848 | # testcases from Wais Module |
||
| 3849 | self.assertEqual(phonix('computer'), 'K513') |
||
| 3850 | self.assertEqual(phonix('computers'), 'K513') |
||
| 3851 | self.assertEqual(phonix('computers', 5), 'K5138') |
||
| 3852 | self.assertEqual(phonix('pfeifer'), 'F700') |
||
| 3853 | self.assertEqual(phonix('pfeiffer'), 'F700') |
||
| 3854 | self.assertEqual(phonix('knight'), 'N300') |
||
| 3855 | self.assertEqual(phonix('night'), 'N300') |
||
| 3856 | |||
| 3857 | # http://cpansearch.perl.org/src/MAROS/Text-Phonetic-2.05/t/007_phonix.t: |
||
| 3858 | # testcases from |
||
| 3859 | # http://www.cl.uni-heidelberg.de/~bormann/documents/phono/ |
||
| 3860 | # They use a sliglty different algorithm (first char is not included in |
||
| 3861 | # num code here) |
||
| 3862 | self.assertEqual(phonix('wait'), 'W300') |
||
| 3863 | self.assertEqual(phonix('weight'), 'W300') |
||
| 3864 | self.assertEqual(phonix('gnome'), 'N500') |
||
| 3865 | self.assertEqual(phonix('noam'), 'N500') |
||
| 3866 | self.assertEqual(phonix('rees'), 'R800') |
||
| 3867 | self.assertEqual(phonix('reece'), 'R800') |
||
| 3868 | self.assertEqual(phonix('yaeger'), 'v200') |
||
| 3869 | |||
| 3870 | # http://books.google.com/books?id=xtWPI7Is9wIC&lpg=PA29&ots=DXhaL7ZkvK&dq=phonix%20gadd&pg=PA29#v=onepage&q=phonix%20gadd&f=false |
||
| 3871 | self.assertEqual(phonix('alam'), 'v450') |
||
| 3872 | self.assertEqual(phonix('berkpakaian'), 'B212') |
||
| 3873 | self.assertEqual(phonix('capaian'), 'K150') |
||
| 3874 | |||
| 3875 | # http://books.google.com/books?id=LZrT6eWf9NMC&lpg=PA76&ots=Tex3FqNwGP&dq=%22phonix%20algorithm%22&pg=PA75#v=onepage&q=%22phonix%20algorithm%22&f=false |
||
| 3876 | self.assertEqual(phonix('peter'), 'P300') |
||
| 3877 | self.assertEqual(phonix('pete'), 'P300') |
||
| 3878 | self.assertEqual(phonix('pedro'), 'P360') |
||
| 3879 | self.assertEqual(phonix('stephen'), 'S375') |
||
| 3880 | self.assertEqual(phonix('steve'), 'S370') |
||
| 3881 | self.assertEqual(phonix('smith'), 'S530') |
||
| 3882 | self.assertEqual(phonix('smythe'), 'S530') |
||
| 3883 | self.assertEqual(phonix('gail'), 'G400') |
||
| 3884 | self.assertEqual(phonix('gayle'), 'G400') |
||
| 3885 | self.assertEqual(phonix('christine'), 'K683') |
||
| 3886 | self.assertEqual(phonix('christina'), 'K683') |
||
| 3887 | self.assertEqual(phonix('kristina'), 'K683') |
||
| 3888 | |||
| 3889 | # maxlength bounds tests |
||
| 3890 | self.assertEqual(phonix('Niall', maxlength=float('inf')), 'N4'+'0'*62) |
||
| 3891 | self.assertEqual(phonix('Niall', maxlength=None), 'N4'+'0'*62) |
||
| 3892 | self.assertEqual(phonix('Niall', maxlength=0), 'N400') |
||
| 3893 | |||
| 3894 | # zero_pad tests |
||
| 3895 | self.assertEqual(phonix('Niall', maxlength=float('inf'), |
||
| 3896 | zero_pad=False), 'N4') |
||
| 3897 | self.assertEqual(phonix('Niall', maxlength=None, zero_pad=False), |
||
| 3898 | 'N4') |
||
| 3899 | self.assertEqual(phonix('Niall', maxlength=0, zero_pad=False), |
||
| 3900 | 'N4') |
||
| 3901 | self.assertEqual(phonix('Niall', maxlength=0, zero_pad=True), |
||
| 3902 | 'N400') |
||
| 3903 | self.assertEqual(phonix('', maxlength=4, zero_pad=False), '0') |
||
| 3904 | self.assertEqual(phonix('', maxlength=4, zero_pad=True), '0000') |
||
| 3905 | |||
| 3906 | |||
| 3907 | class SfinxBisTestCases(unittest.TestCase): |
||
| 3908 | """Test SfinxBis functions. |
||
| 3909 | |||
| 3910 | test cases for abydos.phonetic.sfinxbis |
||
| 3911 | """ |
||
| 3912 | |||
| 3913 | def test_sfinxbis(self): |
||
| 3914 | """Test abydos.phonetic.sfinxbis.""" |
||
| 3915 | self.assertEqual(sfinxbis(''), ('',)) |
||
| 3916 | |||
| 3917 | # http://www.swami.se/download/18.248ad5af12aa81365338000106/TestSfinx.txt |
||
| 3918 | # cases where the gold standard gave clearly wrong values have been |
||
| 3919 | # corrected below (marked with '# wrong' |
||
| 3920 | self.assertEqual(sfinxbis('af Sandeberg'), ('S53162',)) |
||
| 3921 | self.assertEqual(sfinxbis('av Ekenstam'), ('$25835',)) |
||
| 3922 | self.assertEqual(sfinxbis('Da Costa'), ('K83',)) |
||
| 3923 | self.assertEqual(sfinxbis('Das Neves'), ('D8', 'N78')) |
||
| 3924 | self.assertEqual(sfinxbis('de Besche'), ('B8',)) |
||
| 3925 | self.assertEqual(sfinxbis('de la Motte'), ('M3',)) |
||
| 3926 | self.assertEqual(sfinxbis('de Las Heras'), ('H68',)) # wrong |
||
| 3927 | self.assertEqual(sfinxbis('de Los Santos'), ('S538',)) |
||
| 3928 | self.assertEqual(sfinxbis('del Rosario'), ('R862',)) |
||
| 3929 | self.assertEqual(sfinxbis('Den Boer'), ('B6',)) |
||
| 3930 | self.assertEqual(sfinxbis('Der de Kazinczy'), |
||
| 3931 | ('D6', 'K8528',)) # wrong |
||
| 3932 | self.assertEqual(sfinxbis('des Rieux'), ('R28',)) |
||
| 3933 | self.assertEqual(sfinxbis('Di Luca'), ('L2',)) |
||
| 3934 | self.assertEqual(sfinxbis('Do Rosario'), ('R862',)) |
||
| 3935 | self.assertEqual(sfinxbis('Don Lind'), ('L53',)) |
||
| 3936 | self.assertEqual(sfinxbis('Dos Santos'), ('S538',)) |
||
| 3937 | self.assertEqual(sfinxbis('du Rietz'), ('R38',)) |
||
| 3938 | self.assertEqual(sfinxbis('in de Betou'), ('B3',)) |
||
| 3939 | self.assertEqual(sfinxbis('La Fleur'), ('F46',)) |
||
| 3940 | self.assertEqual(sfinxbis('Le Grand'), ('G653',)) |
||
| 3941 | self.assertEqual(sfinxbis('li Puma'), ('L', 'P5')) |
||
| 3942 | self.assertEqual(sfinxbis('lo Martire'), ('L', 'M636')) |
||
| 3943 | self.assertEqual(sfinxbis('mac Donald'), ('D543',)) |
||
| 3944 | self.assertEqual(sfinxbis('mc Intosh'), ('$538',)) |
||
| 3945 | self.assertEqual(sfinxbis('S:t Cyr'), ('S6',)) |
||
| 3946 | self.assertEqual(sfinxbis('Van Doom'), ('D5',)) |
||
| 3947 | self.assertEqual(sfinxbis('Van de Peppel'), ('P14',)) |
||
| 3948 | self.assertEqual(sfinxbis('Van den Berg'), ('B62',)) |
||
| 3949 | self.assertEqual(sfinxbis('Van Der Kwast'), ('K783',)) |
||
| 3950 | self.assertEqual(sfinxbis('von Ahn'), ('$5',)) |
||
| 3951 | self.assertEqual(sfinxbis('von Dem Knesebeck'), ('K5812',)) |
||
| 3952 | self.assertEqual(sfinxbis('von Der Burg'), ('B62',)) |
||
| 3953 | self.assertEqual(sfinxbis('D\'Angelo'), ('D524',)) |
||
| 3954 | self.assertEqual(sfinxbis('O\'Conner'), ('$256',)) |
||
| 3955 | self.assertEqual(sfinxbis('Los'), ('L8',)) |
||
| 3956 | self.assertEqual(sfinxbis('Mac'), ('M2',)) |
||
| 3957 | self.assertEqual(sfinxbis('Till'), ('T4',)) |
||
| 3958 | self.assertEqual(sfinxbis('Van'), ('V5',)) |
||
| 3959 | self.assertEqual(sfinxbis('Von'), ('V5',)) |
||
| 3960 | self.assertEqual(sfinxbis('Bernadotte af Wisborg'), ('B6533', 'V8162')) |
||
| 3961 | self.assertEqual(sfinxbis('Hjort af Ornäs'), ('J63', '$658')) |
||
| 3962 | self.assertEqual(sfinxbis('Horn af Åminne'), ('H65', '$55')) |
||
| 3963 | self.assertEqual(sfinxbis('Horn av Åminne'), ('H65', '$55')) |
||
| 3964 | self.assertEqual(sfinxbis('Hård af Segerstad'), ('H63', 'S26833')) |
||
| 3965 | self.assertEqual(sfinxbis('Hård av Segerstad'), ('H63', 'S26833')) |
||
| 3966 | self.assertEqual(sfinxbis('Stael von Holstein'), ('S34', 'H48325')) |
||
| 3967 | self.assertEqual(sfinxbis('de Oliveira e Silva'), ('$4726', 'S47')) |
||
| 3968 | self.assertEqual(sfinxbis('de Alfaro y Gómez'), ('$476', 'G58')) |
||
| 3969 | self.assertEqual(sfinxbis('Arjaliès-de la Lande'), ('$6248', 'L53')) |
||
| 3970 | self.assertEqual(sfinxbis('Dominicus van den Bussche'), |
||
| 3971 | ('D5528', 'B8')) |
||
| 3972 | self.assertEqual(sfinxbis('Edebol Eeg-Olofsson'), |
||
| 3973 | ('$314', '$2', '$4785')) |
||
| 3974 | self.assertEqual(sfinxbis('Jonsson-Blomqvist'), ('J585', 'B452783')) |
||
| 3975 | self.assertEqual(sfinxbis('Kiviniemi Birgersson'), ('#755', 'B62685')) |
||
| 3976 | self.assertEqual(sfinxbis('Massena Serpa dos Santos'), |
||
| 3977 | ('M85', 'S61', 'S538')) |
||
| 3978 | self.assertEqual(sfinxbis('S:t Clair Renard'), ('K426', 'R563')) |
||
| 3979 | self.assertEqual(sfinxbis('Skoog H Andersson'), ('S22', 'H', '$53685')) |
||
| 3980 | self.assertEqual(sfinxbis('von Post-Skagegård'), ('P83', 'S22263')) |
||
| 3981 | self.assertEqual(sfinxbis('von Zur-Mühlen'), ('S6', 'M45')) |
||
| 3982 | self.assertEqual(sfinxbis('Waltå O:son'), ('V43', '$85')) |
||
| 3983 | self.assertEqual(sfinxbis('Zardán Gómez de la Torre'), |
||
| 3984 | ('S635', 'G58', 'T6')) |
||
| 3985 | self.assertEqual(sfinxbis('af Jochnick'), ('J252',)) |
||
| 3986 | self.assertEqual(sfinxbis('af Ioscnick'), ('J8252',)) |
||
| 3987 | self.assertEqual(sfinxbis('Aabakken'), ('$125',)) |
||
| 3988 | self.assertEqual(sfinxbis('Åbacken'), ('$125',)) |
||
| 3989 | self.assertEqual(sfinxbis('Ahlen'), ('$45',)) |
||
| 3990 | self.assertEqual(sfinxbis('Aleen'), ('$45',)) |
||
| 3991 | self.assertEqual(sfinxbis('Braunerhielm'), ('B656245',)) |
||
| 3992 | self.assertEqual(sfinxbis('Branneerhielm'), ('B656245',)) |
||
| 3993 | self.assertEqual(sfinxbis('Carlzon'), ('K6485',)) |
||
| 3994 | self.assertEqual(sfinxbis('Karlsson'), ('K6485',)) |
||
| 3995 | self.assertEqual(sfinxbis('Enochsson'), ('$5285',)) |
||
| 3996 | self.assertEqual(sfinxbis('Ericsson'), ('$6285',)) |
||
| 3997 | self.assertEqual(sfinxbis('Ericksson'), ('$6285',)) |
||
| 3998 | self.assertEqual(sfinxbis('Erixson'), ('$6285',)) |
||
| 3999 | self.assertEqual(sfinxbis('Filipsson'), ('F4185',)) |
||
| 4000 | self.assertEqual(sfinxbis('Philipson'), ('F4185',)) |
||
| 4001 | self.assertEqual(sfinxbis('Flycht'), ('F423',)) |
||
| 4002 | self.assertEqual(sfinxbis('Flygt'), ('F423',)) |
||
| 4003 | self.assertEqual(sfinxbis('Flykt'), ('F423',)) |
||
| 4004 | self.assertEqual(sfinxbis('Fröijer'), ('F626',)) |
||
| 4005 | self.assertEqual(sfinxbis('Fröjer'), ('F626',)) |
||
| 4006 | self.assertEqual(sfinxbis('Gertner'), ('J6356',)) |
||
| 4007 | self.assertEqual(sfinxbis('Hiertner'), ('J6356',)) |
||
| 4008 | self.assertEqual(sfinxbis('Hirch'), ('H62',)) |
||
| 4009 | self.assertEqual(sfinxbis('Hirsch'), ('H68',)) |
||
| 4010 | self.assertEqual(sfinxbis('Haegermarck'), ('H26562',)) |
||
| 4011 | self.assertEqual(sfinxbis('Hägermark'), ('H26562',)) |
||
| 4012 | self.assertEqual(sfinxbis('Isaxon'), ('$8285',)) |
||
| 4013 | self.assertEqual(sfinxbis('Isacsson'), ('$8285',)) |
||
| 4014 | self.assertEqual(sfinxbis('Joachimsson'), ('J2585',)) |
||
| 4015 | self.assertEqual(sfinxbis('Joakimson'), ('J2585',)) |
||
| 4016 | self.assertEqual(sfinxbis('Kjell'), ('#4',)) |
||
| 4017 | self.assertEqual(sfinxbis('Käll'), ('#4',)) |
||
| 4018 | self.assertEqual(sfinxbis('Knapp'), ('K51',)) |
||
| 4019 | self.assertEqual(sfinxbis('Krans'), ('K658',)) |
||
| 4020 | self.assertEqual(sfinxbis('Krantz'), ('K6538',)) |
||
| 4021 | self.assertEqual(sfinxbis('Kvist'), ('K783',)) |
||
| 4022 | self.assertEqual(sfinxbis('Quist'), ('K783',)) |
||
| 4023 | self.assertEqual(sfinxbis('Lidbeck'), ('L312',)) |
||
| 4024 | self.assertEqual(sfinxbis('Lidbäck'), ('L312',)) |
||
| 4025 | self.assertEqual(sfinxbis('Linnér'), ('L56',)) |
||
| 4026 | self.assertEqual(sfinxbis('Linner'), ('L56',)) |
||
| 4027 | self.assertEqual(sfinxbis('Lorenzsonn'), ('L6585',)) |
||
| 4028 | self.assertEqual(sfinxbis('Lorentzon'), ('L65385',)) |
||
| 4029 | self.assertEqual(sfinxbis('Lorenßon'), ('L6585',)) |
||
| 4030 | self.assertEqual(sfinxbis('Lyxell'), ('L284',)) |
||
| 4031 | self.assertEqual(sfinxbis('Lycksell'), ('L284',)) |
||
| 4032 | self.assertEqual(sfinxbis('Marcström'), ('M628365',)) |
||
| 4033 | self.assertEqual(sfinxbis('Markström'), ('M628365',)) |
||
| 4034 | self.assertEqual(sfinxbis('Michaelsson'), ('M2485',)) |
||
| 4035 | self.assertEqual(sfinxbis('Mikaelson'), ('M2485',)) |
||
| 4036 | self.assertEqual(sfinxbis('Mörch'), ('M62',)) |
||
| 4037 | self.assertEqual(sfinxbis('Mörck'), ('M62',)) |
||
| 4038 | self.assertEqual(sfinxbis('Mörk'), ('M62',)) |
||
| 4039 | self.assertEqual(sfinxbis('Mørk'), ('M62',)) |
||
| 4040 | self.assertEqual(sfinxbis('Nääs'), ('N8',)) |
||
| 4041 | self.assertEqual(sfinxbis('Naess'), ('N8',)) |
||
| 4042 | self.assertEqual(sfinxbis('Nordstedt'), ('N63833',)) |
||
| 4043 | self.assertEqual(sfinxbis('Oxenstierna'), ('$28583265',)) |
||
| 4044 | self.assertEqual(sfinxbis('Palmçrañtz'), ('P4526538',)) |
||
| 4045 | self.assertEqual(sfinxbis('Palmcrantz'), ('P4526538',)) |
||
| 4046 | self.assertEqual(sfinxbis('Palmkrantz'), ('P4526538',)) |
||
| 4047 | self.assertEqual(sfinxbis('Preuss'), ('P68',)) |
||
| 4048 | self.assertEqual(sfinxbis('Preutz'), ('P638',)) |
||
| 4049 | self.assertEqual(sfinxbis('Richardson'), ('R26385',)) |
||
| 4050 | self.assertEqual(sfinxbis('Rikardson'), ('R26385',)) |
||
| 4051 | self.assertEqual(sfinxbis('Ruuth'), ('R3',)) |
||
| 4052 | self.assertEqual(sfinxbis('Ruth'), ('R3',)) |
||
| 4053 | self.assertEqual(sfinxbis('Sæter'), ('S36',)) |
||
| 4054 | self.assertEqual(sfinxbis('Zäter'), ('S36',)) |
||
| 4055 | self.assertEqual(sfinxbis('Schedin'), ('#35',)) |
||
| 4056 | self.assertEqual(sfinxbis('Sjödin'), ('#35',)) |
||
| 4057 | self.assertEqual(sfinxbis('Siöö'), ('#',)) |
||
| 4058 | self.assertEqual(sfinxbis('Sjöh'), ('#',)) |
||
| 4059 | self.assertEqual(sfinxbis('Svedberg'), ('S73162',)) |
||
| 4060 | self.assertEqual(sfinxbis('Zwedberg'), ('S73162',)) |
||
| 4061 | self.assertEqual(sfinxbis('Tjäder'), ('#36',)) |
||
| 4062 | self.assertEqual(sfinxbis('þornquist'), ('T652783',)) |
||
| 4063 | self.assertEqual(sfinxbis('Thörnqvist'), ('T652783',)) |
||
| 4064 | self.assertEqual(sfinxbis('Törnkvist'), ('T652783',)) |
||
| 4065 | self.assertEqual(sfinxbis('Wichman'), ('V255',)) |
||
| 4066 | self.assertEqual(sfinxbis('Wickman'), ('V255',)) |
||
| 4067 | self.assertEqual(sfinxbis('Wictorin'), ('V2365',)) |
||
| 4068 | self.assertEqual(sfinxbis('Wictorsson'), ('V23685',)) |
||
| 4069 | self.assertEqual(sfinxbis('Viktorson'), ('V23685',)) |
||
| 4070 | self.assertEqual(sfinxbis('Zachrisson'), ('S2685',)) |
||
| 4071 | self.assertEqual(sfinxbis('Zakrison'), ('S2685',)) |
||
| 4072 | self.assertEqual(sfinxbis('Övragård'), ('$76263',)) |
||
| 4073 | self.assertEqual(sfinxbis('Öfvragårdh'), ('$76263',)) |
||
| 4074 | self.assertEqual(sfinxbis('Bogdanovic'), ('B23572',)) |
||
| 4075 | self.assertEqual(sfinxbis('Bogdanovitch'), ('B235732',)) |
||
| 4076 | self.assertEqual(sfinxbis('Dieterich'), ('D362',)) |
||
| 4077 | self.assertEqual(sfinxbis('Eichorn'), ('$265',)) |
||
| 4078 | self.assertEqual(sfinxbis('Friedrich'), ('F6362',)) |
||
| 4079 | self.assertEqual(sfinxbis('Grantcharova'), ('G653267',)) |
||
| 4080 | self.assertEqual(sfinxbis('Ilichev'), ('$427',)) |
||
| 4081 | self.assertEqual(sfinxbis('Ivankovic'), ('$75272',)) |
||
| 4082 | self.assertEqual(sfinxbis('Ivangurich'), ('$75262',)) |
||
| 4083 | self.assertEqual(sfinxbis('Kinch'), ('#52',)) |
||
| 4084 | self.assertEqual(sfinxbis('Kirchmann'), ('#6255',)) |
||
| 4085 | self.assertEqual(sfinxbis('Machado'), ('M23',)) |
||
| 4086 | self.assertEqual(sfinxbis('Reich'), ('R2',)) |
||
| 4087 | self.assertEqual(sfinxbis('Roche'), ('R2',)) |
||
| 4088 | self.assertEqual(sfinxbis('Rubaszkin'), ('R1825',)) |
||
| 4089 | self.assertEqual(sfinxbis('Rubaschkin'), ('R1825',)) |
||
| 4090 | self.assertEqual(sfinxbis('Sanchez'), ('S528',)) |
||
| 4091 | self.assertEqual(sfinxbis('Walukiewicz'), ('V42728',)) |
||
| 4092 | self.assertEqual(sfinxbis('Valukievitch'), ('V42732',)) |
||
| 4093 | self.assertEqual(sfinxbis('K'), ('K',)) |
||
| 4094 | self.assertEqual(sfinxbis('2010'), ('',)) |
||
| 4095 | self.assertEqual(sfinxbis('cese'), ('S8',)) |
||
| 4096 | |||
| 4097 | # a few maxlength tests |
||
| 4098 | self.assertEqual(sfinxbis('Kiviniemi Birgersson', 3), ('#75', 'B62')) |
||
| 4099 | self.assertEqual(sfinxbis('Eichorn', 4), ('$265',)) |
||
| 4100 | self.assertEqual(sfinxbis('Friedrich', 4), ('F636',)) |
||
| 4101 | self.assertEqual(sfinxbis('Grantcharova', 4), ('G653',)) |
||
| 4102 | self.assertEqual(sfinxbis('Ilichev', 4), ('$427',)) |
||
| 4103 | self.assertEqual(sfinxbis('Ivankovic', 4), ('$752',)) |
||
| 4104 | self.assertEqual(sfinxbis('Ivangurich', 4), ('$752',)) |
||
| 4105 | self.assertEqual(sfinxbis('Kinch', 4), ('#52',)) |
||
| 4106 | self.assertEqual(sfinxbis('Kirchmann', 4), ('#625',)) |
||
| 4107 | self.assertEqual(sfinxbis('Machado', 4), ('M23',)) |
||
| 4108 | self.assertEqual(sfinxbis('Reich', 4), ('R2',)) |
||
| 4109 | self.assertEqual(sfinxbis('Roche', 4), ('R2',)) |
||
| 4110 | self.assertEqual(sfinxbis('Rubaszkin', 4), ('R182',)) |
||
| 4111 | self.assertEqual(sfinxbis('Rubaschkin', 4), ('R182',)) |
||
| 4112 | self.assertEqual(sfinxbis('Sanchez', 4), ('S528',)) |
||
| 4113 | self.assertEqual(sfinxbis('Walukiewicz', 4), ('V427',)) |
||
| 4114 | self.assertEqual(sfinxbis('Valukievitch', 4), ('V427',)) |
||
| 4115 | self.assertEqual(sfinxbis('K', 4), ('K',)) |
||
| 4116 | self.assertEqual(sfinxbis('2010', 4), ('',)) |
||
| 4117 | self.assertEqual(sfinxbis('cese', 4), ('S8',)) |
||
| 4118 | |||
| 4119 | # etc. (for code coverage) |
||
| 4120 | self.assertEqual(sfinxbis('chans'), ('#58',)) |
||
| 4121 | self.assertEqual(sfinxbis('ljud'), ('J3',)) |
||
| 4122 | self.assertEqual(sfinxbis('qi'), ('K',)) |
||
| 4123 | self.assertEqual(sfinxbis('xavier'), ('S76',)) |
||
| 4124 | self.assertEqual(sfinxbis('skjul'), ('#4',)) |
||
| 4125 | self.assertEqual(sfinxbis('schul'), ('#4',)) |
||
| 4126 | self.assertEqual(sfinxbis('skil'), ('#4',)) |
||
| 4127 | |||
| 4128 | # maxlength bounds tests |
||
| 4129 | self.assertEqual(sfinxbis('Niall', maxlength=float('inf')), ('N4',)) |
||
| 4130 | self.assertEqual(sfinxbis('Niall', maxlength=None), ('N4',)) |
||
| 4131 | self.assertEqual(sfinxbis('Niall', maxlength=0), ('N4',)) |
||
| 4132 | |||
| 4133 | |||
| 4134 | class PhonetTestCases(unittest.TestCase): |
||
| 4135 | """Test Phonet functions. |
||
| 4136 | |||
| 4137 | test cases for abydos.phonetic.phonet |
||
| 4138 | """ |
||
| 4139 | |||
| 4140 | def test_phonet_german(self): |
||
| 4141 | """Test abydos.phonetic.phonet (German).""" |
||
| 4142 | self.assertEqual(phonet(''), '') |
||
| 4143 | self.assertEqual(phonet('', trace=True), '') |
||
| 4144 | |||
| 4145 | # https://code.google.com/p/phonet4java/source/browse/trunk/src/test/java/com/googlecode/phonet4java/Phonet1Test.java |
||
| 4146 | self.assertEqual(phonet('', 1), '') |
||
| 4147 | self.assertEqual(phonet('Zedlitz', 1), 'ZETLIZ') |
||
| 4148 | self.assertEqual(phonet('Bremerhaven', 1), 'BREMAHAFN') |
||
| 4149 | self.assertEqual(phonet('Hamburger Hafen', 1), 'HAMBURGA HAFN') |
||
| 4150 | self.assertEqual(phonet('Jesper', 1), 'IESPA') |
||
| 4151 | self.assertEqual(phonet('elisabeth', 1), 'ELISABET') |
||
| 4152 | self.assertEqual(phonet('elisabet', 1), 'ELISABET') |
||
| 4153 | self.assertEqual(phonet('Ziegler', 1), 'ZIKLA') |
||
| 4154 | self.assertEqual(phonet('Scherer', 1), 'SHERA') |
||
| 4155 | self.assertEqual(phonet('Bartels', 1), 'BARTLS') |
||
| 4156 | self.assertEqual(phonet('Jansen', 1), 'IANSN') |
||
| 4157 | self.assertEqual(phonet('Sievers', 1), 'SIWAS') |
||
| 4158 | self.assertEqual(phonet('Michels', 1), 'MICHLS') |
||
| 4159 | self.assertEqual(phonet('Ewers', 1), 'EWERS') |
||
| 4160 | self.assertEqual(phonet('Evers', 1), 'EWERS') |
||
| 4161 | self.assertEqual(phonet('Wessels', 1), 'WESLS') |
||
| 4162 | self.assertEqual(phonet('Gottschalk', 1), 'GOSHALK') |
||
| 4163 | self.assertEqual(phonet('Brückmann', 1), 'BRÜKMAN') |
||
| 4164 | self.assertEqual(phonet('Blechschmidt', 1), 'BLECHSHMIT') |
||
| 4165 | self.assertEqual(phonet('Kolodziej', 1), 'KOLOTZI') |
||
| 4166 | self.assertEqual(phonet('Krauße', 1), 'KRAUSE') |
||
| 4167 | self.assertEqual(phonet('Cachel', 1), 'KESHL') |
||
| 4168 | |||
| 4169 | self.assertEqual(phonet('', 2), '') |
||
| 4170 | self.assertEqual(phonet('Zedlitz', 2), 'ZETLIZ') |
||
| 4171 | self.assertEqual(phonet('Bremerhaven', 2), 'BRENAFN') |
||
| 4172 | self.assertEqual(phonet('Schönberg', 2), 'ZÖNBAK') |
||
| 4173 | self.assertEqual(phonet('Hamburger Hafen', 2), 'ANBURKA AFN') |
||
| 4174 | self.assertEqual(phonet('Ziegler', 2), 'ZIKLA') |
||
| 4175 | self.assertEqual(phonet('Scherer', 2), 'ZERA') |
||
| 4176 | self.assertEqual(phonet('Jansen', 2), 'IANZN') |
||
| 4177 | self.assertEqual(phonet('Eberhardt', 2), 'EBART') |
||
| 4178 | self.assertEqual(phonet('Gottschalk', 2), 'KUZALK') |
||
| 4179 | self.assertEqual(phonet('Brückmann', 2), 'BRIKNAN') |
||
| 4180 | self.assertEqual(phonet('Blechschmidt', 2), 'BLEKZNIT') |
||
| 4181 | self.assertEqual(phonet('Kolodziej', 2), 'KULUTZI') |
||
| 4182 | self.assertEqual(phonet('Krauße', 2), 'KRAUZE') |
||
| 4183 | |||
| 4184 | self.assertEqual(phonet('', 2, trace=True), '') |
||
| 4185 | self.assertEqual(phonet('Zedlitz', 2, trace=True), 'ZETLIZ') |
||
| 4186 | self.assertEqual(phonet('Bremerhaven', 2, trace=True), 'BRENAFN') |
||
| 4187 | self.assertEqual(phonet('Schönberg', 2, trace=True), 'ZÖNBAK') |
||
| 4188 | self.assertEqual(phonet('Hamburger Hafen', 2, trace=True), |
||
| 4189 | 'ANBURKA AFN') |
||
| 4190 | self.assertEqual(phonet('Ziegler', 2, trace=True), 'ZIKLA') |
||
| 4191 | self.assertEqual(phonet('Scherer', 2, trace=True), 'ZERA') |
||
| 4192 | self.assertEqual(phonet('Jansen', 2, trace=True), 'IANZN') |
||
| 4193 | self.assertEqual(phonet('Eberhardt', 2, trace=True), 'EBART') |
||
| 4194 | self.assertEqual(phonet('Gottschalk', 2, trace=True), 'KUZALK') |
||
| 4195 | self.assertEqual(phonet('Brückmann', 2, trace=True), 'BRIKNAN') |
||
| 4196 | self.assertEqual(phonet('Blechschmidt', 2, trace=True), 'BLEKZNIT') |
||
| 4197 | self.assertEqual(phonet('Kolodziej', 2, trace=True), 'KULUTZI') |
||
| 4198 | self.assertEqual(phonet('Krauße', 2, trace=True), 'KRAUZE') |
||
| 4199 | |||
| 4200 | # etc. (for code coverage) |
||
| 4201 | self.assertEqual(phonet('Jesper', 1, trace=True), 'IESPA') |
||
| 4202 | self.assertEqual(phonet('Glacéhandschuh', 1), 'GLAZANSHU') |
||
| 4203 | self.assertEqual(phonet('Blechschmidt', 1, trace=True), 'BLECHSHMIT') |
||
| 4204 | self.assertEqual(phonet('Burgdorf', 1), 'BURKDORF') |
||
| 4205 | self.assertEqual(phonet('Holzschuh', 1), 'HOLSHU') |
||
| 4206 | self.assertEqual(phonet('Aachen', 1, trace=True), 'ACHN') |
||
| 4207 | self.assertEqual(phonet('Abendspaziergang', 1), 'ABENTSPAZIRGANK') |
||
| 4208 | |||
| 4209 | def test_phonet_nolang(self): |
||
| 4210 | """Test abydos.phonetic.phonet (no language).""" |
||
| 4211 | self.assertEqual(phonet('', lang='none'), '') |
||
| 4212 | |||
| 4213 | # https://code.google.com/p/phonet4java/source/browse/trunk/src/test/java/com/googlecode/phonet4java/Phonet1Test.java |
||
| 4214 | self.assertEqual(phonet('', 1, 'none'), '') |
||
| 4215 | self.assertEqual(phonet('Zedlitz', 1, 'none'), 'ZEDLITZ') |
||
| 4216 | self.assertEqual(phonet('Bremerhaven', 1, 'none'), 'BREMERHAVEN') |
||
| 4217 | self.assertEqual(phonet('Schönberg', 2, 'none'), 'SCHOENBERG') |
||
| 4218 | self.assertEqual(phonet('Brückmann', 1, 'none'), 'BRUECKMAN') |
||
| 4219 | self.assertEqual(phonet('Krauße', 1, 'none'), 'KRAUSE') |
||
| 4220 | |||
| 4221 | self.assertEqual(phonet('', 2, 'none'), '') |
||
| 4222 | self.assertEqual(phonet('Zedlitz', 2, 'none'), 'ZEDLITZ') |
||
| 4223 | self.assertEqual(phonet('Bremerhaven', 2, 'none'), 'BREMERHAVEN') |
||
| 4224 | self.assertEqual(phonet('Schönberg', 2, 'none'), 'SCHOENBERG') |
||
| 4225 | self.assertEqual(phonet('Brückmann', 2, 'none'), 'BRUECKMAN') |
||
| 4226 | self.assertEqual(phonet('Krauße', 2, 'none'), 'KRAUSE') |
||
| 4227 | |||
| 4228 | self.assertEqual(phonet('', 2, 'none', True), '') |
||
| 4229 | self.assertEqual(phonet('Zedlitz', 2, 'none', True), 'ZEDLITZ') |
||
| 4230 | self.assertEqual(phonet('Bremerhaven', 2, 'none', True), 'BREMERHAVEN') |
||
| 4231 | self.assertEqual(phonet('Schönberg', 2, 'none', True), 'SCHOENBERG') |
||
| 4232 | self.assertEqual(phonet('Brückmann', 2, 'none', True), 'BRUECKMAN') |
||
| 4233 | self.assertEqual(phonet('Krauße', 2, 'none', True), 'KRAUSE') |
||
| 4234 | |||
| 4235 | def test_phonet_nachnamen(self): |
||
| 4236 | """Test abydos.phonetic.phonet (Nachnamen set).""" |
||
| 4237 | if not ALLOW_RANDOM: |
||
| 4238 | return |
||
| 4239 | with codecs.open(TESTDIR + '/corpora/nachnamen.csv', |
||
| 4240 | encoding='utf-8') as nachnamen_testset: |
||
| 4241 | for nn_line in nachnamen_testset: |
||
| 4242 | if nn_line[0] != '#': |
||
| 4243 | nn_line = nn_line.strip().split(',') |
||
| 4244 | # This test set is very large (~10000 entries) |
||
| 4245 | # so let's just randomly select about 100 for testing |
||
| 4246 | if len(nn_line) >= 3 and one_in(100): |
||
| 4247 | (term, ph1, ph2) = nn_line |
||
| 4248 | self.assertEqual(phonet(term, 1), ph1) |
||
| 4249 | self.assertEqual(phonet(term, 2), ph2) |
||
| 4250 | |||
| 4251 | def test_phonet_ngerman(self): |
||
| 4252 | """Test abydos.phonetic.phonet (ngerman set).""" |
||
| 4253 | if not ALLOW_RANDOM: |
||
| 4254 | return |
||
| 4255 | with codecs.open(TESTDIR + '/corpora/ngerman.csv', |
||
| 4256 | encoding='utf-8') as ngerman_testset: |
||
| 4257 | for ng_line in ngerman_testset: |
||
| 4258 | if ng_line[0] != '#': |
||
| 4259 | ng_line = ng_line.strip().split(',') |
||
| 4260 | # This test set is very large (~3000000 entries) |
||
| 4261 | # so let's just randomly select about 30 for testing |
||
| 4262 | if len(ng_line) >= 3 and one_in(10000): |
||
| 4263 | (term, ph1, ph2) = ng_line |
||
| 4264 | self.assertEqual(phonet(term, 1), ph1) |
||
| 4265 | self.assertEqual(phonet(term, 2), ph2) |
||
| 4266 | |||
| 4267 | |||
| 4268 | class SPFCTestCases(unittest.TestCase): |
||
| 4269 | """Test SPFC functions. |
||
| 4270 | |||
| 4271 | test cases for abydos.phonetic.spfc |
||
| 4272 | """ |
||
| 4273 | |||
| 4274 | def test_spfc(self): |
||
| 4275 | """Test abydos.phonetic.spfc.""" |
||
| 4276 | self.assertEqual(spfc(''), '') |
||
| 4277 | |||
| 4278 | # https://archive.org/stream/accessingindivid00moor#page/19/mode/1up |
||
| 4279 | self.assertEqual(spfc(('J', 'KUHNS')), '16760') |
||
| 4280 | self.assertEqual(spfc(('G', 'ALTSHULER')), '35797') |
||
| 4281 | self.assertEqual(spfc('J KUHNS'), '16760') |
||
| 4282 | self.assertEqual(spfc('G ALTSHULER'), '35797') |
||
| 4283 | self.assertEqual(spfc('J. KUHNS'), '16760') |
||
| 4284 | self.assertEqual(spfc('G. ALTSHULER'), '35797') |
||
| 4285 | self.assertEqual(spfc('J. Kuhns'), '16760') |
||
| 4286 | self.assertEqual(spfc('G. Altshuler'), '35797') |
||
| 4287 | self.assertEqual(spfc('T. Vines'), '16760') |
||
| 4288 | self.assertEqual(spfc('J. Butler'), '35779') |
||
| 4289 | self.assertNotEqual(spfc('J. Kuhns'), spfc('J. Kuntz')) |
||
| 4290 | self.assertEqual(spfc('Jon Kuhns'), '16760') |
||
| 4291 | self.assertEqual(spfc('James Kuhns'), '16760') |
||
| 4292 | |||
| 4293 | self.assertRaises(AttributeError, spfc, ('J', 'A', 'Kuhns')) |
||
| 4294 | self.assertRaises(AttributeError, spfc, 'JKuhns') |
||
| 4295 | self.assertRaises(AttributeError, spfc, 5) |
||
| 4296 | |||
| 4297 | # etc. (for code coverage) |
||
| 4298 | self.assertEqual(spfc('James Goldstein'), '78795') |
||
| 4299 | self.assertEqual(spfc('James Hansen'), '58760') |
||
| 4300 | self.assertEqual(spfc('James Hester'), '59700') |
||
| 4301 | self.assertEqual(spfc('James Bardot'), '31745') |
||
| 4302 | self.assertEqual(spfc('James Windsor'), '29765') |
||
| 4303 | self.assertEqual(spfc('James Wenders'), '27760') |
||
| 4304 | self.assertEqual(spfc('James Ventor'), '17760') |
||
| 4305 | self.assertEqual(spfc('þ þ'), '00') |
||
| 4306 | |||
| 4307 | |||
| 4308 | class StatisticsCanadaTestCases(unittest.TestCase): |
||
| 4309 | """Test Statistics Canada functions. |
||
| 4310 | |||
| 4311 | test cases for abydos.phonetic.statistics_canada |
||
| 4312 | """ |
||
| 4313 | |||
| 4314 | def test_statistics_canada(self): |
||
| 4315 | """Test abydos.phonetic.statistics_canada.""" |
||
| 4316 | self.assertEqual(statistics_canada(''), '') |
||
| 4317 | |||
| 4318 | # https://naldc.nal.usda.gov/download/27833/PDF |
||
| 4319 | self.assertEqual(statistics_canada('Daves'), 'DVS') |
||
| 4320 | self.assertEqual(statistics_canada('Davies'), 'DVS') |
||
| 4321 | self.assertEqual(statistics_canada('Devese'), 'DVS') |
||
| 4322 | self.assertEqual(statistics_canada('Devies'), 'DVS') |
||
| 4323 | self.assertEqual(statistics_canada('Devos'), 'DVS') |
||
| 4324 | |||
| 4325 | self.assertEqual(statistics_canada('Smathers'), 'SMTH') |
||
| 4326 | self.assertEqual(statistics_canada('Smithart'), 'SMTH') |
||
| 4327 | self.assertEqual(statistics_canada('Smithbower'), 'SMTH') |
||
| 4328 | self.assertEqual(statistics_canada('Smitherman'), 'SMTH') |
||
| 4329 | self.assertEqual(statistics_canada('Smithey'), 'SMTH') |
||
| 4330 | self.assertEqual(statistics_canada('Smithgall'), 'SMTH') |
||
| 4331 | self.assertEqual(statistics_canada('Smithingall'), 'SMTH') |
||
| 4332 | self.assertEqual(statistics_canada('Smithmyer'), 'SMTH') |
||
| 4333 | self.assertEqual(statistics_canada('Smithpeter'), 'SMTH') |
||
| 4334 | self.assertEqual(statistics_canada('Smithson'), 'SMTH') |
||
| 4335 | self.assertEqual(statistics_canada('Smithy'), 'SMTH') |
||
| 4336 | self.assertEqual(statistics_canada('Smotherman'), 'SMTH') |
||
| 4337 | self.assertEqual(statistics_canada('Smothers'), 'SMTH') |
||
| 4338 | self.assertEqual(statistics_canada('Smyth'), 'SMTH') |
||
| 4339 | |||
| 4340 | # Additional tests from @Yomguithereal's talisman |
||
| 4341 | # https://github.com/Yomguithereal/talisman/blob/master/test/phonetics/statcan.js |
||
| 4342 | self.assertEqual(statistics_canada('Guillaume'), 'GLM') |
||
| 4343 | self.assertEqual(statistics_canada('Arlène'), 'ARLN') |
||
| 4344 | self.assertEqual(statistics_canada('Lüdenscheidt'), 'LDNS') |
||
| 4345 | |||
| 4346 | |||
| 4347 | class LeinTestCases(unittest.TestCase): |
||
| 4348 | """Test Lein functions. |
||
| 4349 | |||
| 4350 | test cases for abydos.phonetic.lein |
||
| 4351 | """ |
||
| 4352 | |||
| 4353 | def test_lein(self): |
||
| 4354 | """Test abydos.phonetic.lein.""" |
||
| 4355 | self.assertEqual(lein(''), '') |
||
| 4356 | |||
| 4357 | # https://naldc.nal.usda.gov/download/27833/PDF |
||
| 4358 | self.assertEqual(lein('Dubose'), 'D450') |
||
| 4359 | self.assertEqual(lein('Dubs'), 'D450') |
||
| 4360 | self.assertEqual(lein('Dubbs'), 'D450') |
||
| 4361 | self.assertEqual(lein('Doviak'), 'D450') |
||
| 4362 | self.assertEqual(lein('Dubke'), 'D450') |
||
| 4363 | self.assertEqual(lein('Dubus'), 'D450') |
||
| 4364 | self.assertEqual(lein('Dubois'), 'D450') |
||
| 4365 | self.assertEqual(lein('Duboise'), 'D450') |
||
| 4366 | self.assertEqual(lein('Doubek'), 'D450') |
||
| 4367 | self.assertEqual(lein('Defigh'), 'D450') |
||
| 4368 | self.assertEqual(lein('Defazio'), 'D450') |
||
| 4369 | self.assertEqual(lein('Debaca'), 'D450') |
||
| 4370 | self.assertEqual(lein('Dabbs'), 'D450') |
||
| 4371 | self.assertEqual(lein('Davies'), 'D450') |
||
| 4372 | self.assertEqual(lein('Dubukey'), 'D450') |
||
| 4373 | self.assertEqual(lein('Debus'), 'D450') |
||
| 4374 | self.assertEqual(lein('Debose'), 'D450') |
||
| 4375 | self.assertEqual(lein('Daves'), 'D450') |
||
| 4376 | self.assertEqual(lein('Dipiazza'), 'D450') |
||
| 4377 | self.assertEqual(lein('Dobbs'), 'D450') |
||
| 4378 | self.assertEqual(lein('Dobak'), 'D450') |
||
| 4379 | self.assertEqual(lein('Dobis'), 'D450') |
||
| 4380 | self.assertEqual(lein('Dobish'), 'D450') |
||
| 4381 | self.assertEqual(lein('Doepke'), 'D450') |
||
| 4382 | self.assertEqual(lein('Divish'), 'D450') |
||
| 4383 | self.assertEqual(lein('Dobosh'), 'D450') |
||
| 4384 | self.assertEqual(lein('Dupois'), 'D450') |
||
| 4385 | self.assertEqual(lein('Dufek'), 'D450') |
||
| 4386 | self.assertEqual(lein('Duffek'), 'D450') |
||
| 4387 | self.assertEqual(lein('Dupuis'), 'D450') |
||
| 4388 | self.assertEqual(lein('Dupas'), 'D450') |
||
| 4389 | self.assertEqual(lein('Devese'), 'D450') |
||
| 4390 | self.assertEqual(lein('Devos'), 'D450') |
||
| 4391 | self.assertEqual(lein('Deveaux'), 'D450') |
||
| 4392 | self.assertEqual(lein('Devies'), 'D450') |
||
| 4393 | |||
| 4394 | self.assertEqual(lein('Sand'), 'S210') |
||
| 4395 | self.assertEqual(lein('Sandau'), 'S210') |
||
| 4396 | self.assertEqual(lein('Sande'), 'S210') |
||
| 4397 | self.assertEqual(lein('Sandia'), 'S210') |
||
| 4398 | self.assertEqual(lein('Sando'), 'S210') |
||
| 4399 | self.assertEqual(lein('Sandoe'), 'S210') |
||
| 4400 | self.assertEqual(lein('Sandy'), 'S210') |
||
| 4401 | self.assertEqual(lein('Santee'), 'S210') |
||
| 4402 | self.assertEqual(lein('Santi'), 'S210') |
||
| 4403 | self.assertEqual(lein('Santo'), 'S210') |
||
| 4404 | self.assertEqual(lein('Send'), 'S210') |
||
| 4405 | self.assertEqual(lein('Sennet'), 'S210') |
||
| 4406 | self.assertEqual(lein('Shemoit'), 'S210') |
||
| 4407 | self.assertEqual(lein('Shenot'), 'S210') |
||
| 4408 | self.assertEqual(lein('Shumate'), 'S210') |
||
| 4409 | self.assertEqual(lein('Simmet'), 'S210') |
||
| 4410 | self.assertEqual(lein('Simot'), 'S210') |
||
| 4411 | self.assertEqual(lein('Sineath'), 'S210') |
||
| 4412 | self.assertEqual(lein('Sinnott'), 'S210') |
||
| 4413 | self.assertEqual(lein('Sintay'), 'S210') |
||
| 4414 | self.assertEqual(lein('Smead'), 'S210') |
||
| 4415 | self.assertEqual(lein('Smeda'), 'S210') |
||
| 4416 | self.assertEqual(lein('Smit'), 'S210') |
||
| 4417 | |||
| 4418 | # Additional tests from @Yomguithereal's talisman |
||
| 4419 | # https://github.com/Yomguithereal/talisman/blob/master/test/phonetics/lein.js |
||
| 4420 | self.assertEqual(lein('Guillaume'), 'G320') |
||
| 4421 | self.assertEqual(lein('Arlène'), 'A332') |
||
| 4422 | self.assertEqual(lein('Lüdenscheidt'), 'L125') |
||
| 4423 | |||
| 4424 | |||
| 4425 | class RogerRootTestCases(unittest.TestCase): |
||
| 4426 | """Test Roger Root functions. |
||
| 4427 | |||
| 4428 | test cases for abydos.phonetic.roger_root |
||
| 4429 | """ |
||
| 4430 | |||
| 4431 | def test_roger_root(self): |
||
| 4432 | """Test abydos.phonetic.roger_root.""" |
||
| 4433 | self.assertEqual(roger_root(''), '') |
||
| 4434 | |||
| 4435 | # https://naldc.nal.usda.gov/download/27833/PDF |
||
| 4436 | self.assertEqual(roger_root('BROWNER'), '09424') |
||
| 4437 | self.assertEqual(roger_root('STANLEY'), '00125') |
||
| 4438 | self.assertEqual(roger_root('CHALMAN'), '06532') |
||
| 4439 | self.assertEqual(roger_root('CHING'), '06270') |
||
| 4440 | self.assertEqual(roger_root('ANDERSON'), '12140') |
||
| 4441 | self.assertEqual(roger_root('OVERSTREET'), '18401') |
||
| 4442 | self.assertEqual(roger_root('HECKEL'), '27500') |
||
| 4443 | self.assertEqual(roger_root('WYSZYNSKI'), '40207') |
||
| 4444 | self.assertEqual(roger_root('WHITTED'), '41100') |
||
| 4445 | self.assertEqual(roger_root('ONGOQO'), '12770') # PDF had a typo? |
||
| 4446 | self.assertEqual(roger_root('JOHNSON'), '32020') |
||
| 4447 | self.assertEqual(roger_root('WILLIAMS'), '45300') |
||
| 4448 | self.assertEqual(roger_root('SMITH'), '00310') |
||
| 4449 | self.assertEqual(roger_root('JONES'), '32000') |
||
| 4450 | self.assertEqual(roger_root('BROWN'), '09420') |
||
| 4451 | self.assertEqual(roger_root('DAVIS'), '01800') |
||
| 4452 | self.assertEqual(roger_root('JACKSON'), '37020') |
||
| 4453 | self.assertEqual(roger_root('WILSON'), '45020') |
||
| 4454 | self.assertEqual(roger_root('LEE'), '05000') |
||
| 4455 | self.assertEqual(roger_root('THOMAS'), '01300') |
||
| 4456 | |||
| 4457 | self.assertEqual(roger_root('Defouw'), '01800') |
||
| 4458 | self.assertEqual(roger_root('Dauphi'), '01800') |
||
| 4459 | self.assertEqual(roger_root('Defazio'), '01800') |
||
| 4460 | self.assertEqual(roger_root('Defay'), '01800') |
||
| 4461 | self.assertEqual(roger_root('Davy'), '01800') |
||
| 4462 | self.assertEqual(roger_root('Defee'), '01800') |
||
| 4463 | self.assertEqual(roger_root('Dayhoff'), '01800') |
||
| 4464 | self.assertEqual(roger_root('Davie'), '01800') |
||
| 4465 | self.assertEqual(roger_root('Davey'), '01800') |
||
| 4466 | self.assertEqual(roger_root('Davies'), '01800') |
||
| 4467 | self.assertEqual(roger_root('Daves'), '01800') |
||
| 4468 | self.assertEqual(roger_root('Deife'), '01800') |
||
| 4469 | self.assertEqual(roger_root('Dehoff'), '01800') |
||
| 4470 | self.assertEqual(roger_root('Devese'), '01800') |
||
| 4471 | self.assertEqual(roger_root('Devoe'), '01800') |
||
| 4472 | self.assertEqual(roger_root('Devee'), '01800') |
||
| 4473 | self.assertEqual(roger_root('Devies'), '01800') |
||
| 4474 | self.assertEqual(roger_root('Devos'), '01800') |
||
| 4475 | self.assertEqual(roger_root('Dafoe'), '01800') |
||
| 4476 | self.assertEqual(roger_root('Dove'), '01800') |
||
| 4477 | self.assertEqual(roger_root('Duff'), '01800') |
||
| 4478 | self.assertEqual(roger_root('Duffey'), '01800') |
||
| 4479 | self.assertEqual(roger_root('Duffie'), '01800') |
||
| 4480 | self.assertEqual(roger_root('Duffy'), '01800') |
||
| 4481 | self.assertEqual(roger_root('Duyava'), '01800') |
||
| 4482 | self.assertEqual(roger_root('Tafoya'), '01800') |
||
| 4483 | self.assertEqual(roger_root('Tevis'), '01800') |
||
| 4484 | self.assertEqual(roger_root('Tiffee'), '01800') |
||
| 4485 | self.assertEqual(roger_root('Tivis'), '01800') |
||
| 4486 | self.assertEqual(roger_root('Thevis'), '01800') |
||
| 4487 | self.assertEqual(roger_root('Tovey'), '01800') |
||
| 4488 | self.assertEqual(roger_root('Toeves'), '01800') |
||
| 4489 | self.assertEqual(roger_root('Tuffs'), '01800') |
||
| 4490 | |||
| 4491 | self.assertEqual(roger_root('Samotid'), '00311') |
||
| 4492 | self.assertEqual(roger_root('Simmet'), '00310') |
||
| 4493 | self.assertEqual(roger_root('Simot'), '00310') |
||
| 4494 | self.assertEqual(roger_root('Smead'), '00310') |
||
| 4495 | self.assertEqual(roger_root('Smeda'), '00310') |
||
| 4496 | self.assertEqual(roger_root('Smit'), '00310') |
||
| 4497 | self.assertEqual(roger_root('Smite'), '00310') |
||
| 4498 | self.assertEqual(roger_root('Smithe'), '00310') |
||
| 4499 | self.assertEqual(roger_root('Smithey'), '00310') |
||
| 4500 | self.assertEqual(roger_root('Smithson'), '00310') |
||
| 4501 | self.assertEqual(roger_root('Smithy'), '00310') |
||
| 4502 | self.assertEqual(roger_root('Smoot'), '00310') |
||
| 4503 | self.assertEqual(roger_root('Smyth'), '00310') |
||
| 4504 | self.assertEqual(roger_root('Szmodis'), '00310') |
||
| 4505 | self.assertEqual(roger_root('Zemaitis'), '00310') |
||
| 4506 | self.assertEqual(roger_root('Zmuda'), '00310') |
||
| 4507 | |||
| 4508 | # Additional tests from @Yomguithereal's talisman |
||
| 4509 | # https://github.com/Yomguithereal/talisman/blob/master/test/phonetics/roger-root.js |
||
| 4510 | self.assertEqual(roger_root('Guillaume'), '07530') |
||
| 4511 | self.assertEqual(roger_root('Arlène'), '14520') |
||
| 4512 | self.assertEqual(roger_root('Lüdenscheidt'), '05126') |
||
| 4513 | |||
| 4514 | |||
| 4515 | class ONCATestCases(unittest.TestCase): |
||
| 4516 | """Test ONCA functions. |
||
| 4517 | |||
| 4518 | test cases for abydos.phonetic.onca |
||
| 4519 | """ |
||
| 4520 | |||
| 4521 | def test_onca(self): |
||
| 4522 | """Test abydos.phonetic.onca.""" |
||
| 4523 | # https://nces.ed.gov/FCSM/pdf/RLT97.pdf |
||
| 4524 | self.assertEqual(onca('HALL'), 'H400') |
||
| 4525 | self.assertEqual(onca('SMITH'), 'S530') |
||
| 4526 | |||
| 4527 | # http://nchod.uhce.ox.ac.uk/NCHOD%20Oxford%20E5%20Report%201st%20Feb_VerAM2.pdf |
||
| 4528 | self.assertEqual(onca('HAWTON'), 'H350') |
||
| 4529 | self.assertEqual(onca('HORTON'), 'H635') |
||
| 4530 | self.assertEqual(onca('HOUGHTON'), 'H235') |
||
| 4531 | |||
| 4532 | |||
| 4533 | class BeiderMorseTestCases(unittest.TestCase): |
||
| 4534 | """Test BMPM functions. |
||
| 4535 | |||
| 4536 | test cases for abydos.phonetic.bmpm and abydos.bm.* |
||
| 4537 | """ |
||
| 4538 | |||
| 4539 | def test_bmpm(self): |
||
| 4540 | """Test abydos.phonetic.bmpm. |
||
| 4541 | |||
| 4542 | Most test cases from: |
||
| 4543 | http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/test/java/org/apache/commons/codec/language/bm/ |
||
| 4544 | |||
| 4545 | As a rule, the test cases are copied from the above code, but the |
||
| 4546 | resultant values are not. This is largely because this Python port |
||
| 4547 | follows the PHP reference implementation much more closely than the |
||
| 4548 | Java port in Apache Commons Codec does. As a result, these tests have |
||
| 4549 | been conformed to the output produced by the PHP implementation, |
||
| 4550 | particularly in terms of formatting and ordering. |
||
| 4551 | """ |
||
| 4552 | # base cases |
||
| 4553 | self.assertEqual(bmpm(''), '') |
||
| 4554 | |||
| 4555 | for langs in ('', 1, 'spanish', 'english,italian', 3): |
||
| 4556 | for name_mode in ('gen', 'ash', 'sep'): |
||
| 4557 | for match_mode in ('approx', 'exact'): |
||
| 4558 | for concat in (False, True): |
||
| 4559 | if (isinstance(langs, text_type) and |
||
| 4560 | ((name_mode == 'ash' and 'italian' in langs) or |
||
| 4561 | (name_mode == 'sep' and 'english' in langs))): |
||
| 4562 | self.assertRaises(ValueError, bmpm, '', langs, |
||
| 4563 | name_mode, match_mode, concat) |
||
| 4564 | else: |
||
| 4565 | self.assertEqual(bmpm('', langs, name_mode, |
||
| 4566 | match_mode, concat), '') |
||
| 4567 | |||
| 4568 | # testSolrGENERIC |
||
| 4569 | # concat is true, ruleType is EXACT |
||
| 4570 | self.assertEqual(bmpm('Angelo', '', 'gen', 'exact', True), |
||
| 4571 | 'angelo anxelo anhelo anjelo anZelo andZelo') |
||
| 4572 | self.assertEqual(bmpm('D\'Angelo', '', 'gen', 'exact', True), |
||
| 4573 | 'angelo anxelo anhelo anjelo anZelo andZelo dangelo' + |
||
| 4574 | ' danxelo danhelo danjelo danZelo dandZelo') |
||
| 4575 | self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'gen', |
||
| 4576 | 'exact', True), |
||
| 4577 | 'angelo anxelo andZelo') |
||
| 4578 | self.assertEqual(bmpm('1234', '', 'gen', 'exact', True), '') |
||
| 4579 | |||
| 4580 | # concat is false, ruleType is EXACT |
||
| 4581 | self.assertEqual(bmpm('Angelo', '', 'gen', 'exact', False), |
||
| 4582 | 'angelo anxelo anhelo anjelo anZelo andZelo') |
||
| 4583 | self.assertEqual(bmpm('D\'Angelo', '', 'gen', 'exact', False), |
||
| 4584 | 'angelo anxelo anhelo anjelo anZelo andZelo dangelo' + |
||
| 4585 | ' danxelo danhelo danjelo danZelo dandZelo') |
||
| 4586 | self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'gen', |
||
| 4587 | 'exact', False), |
||
| 4588 | 'angelo anxelo andZelo') |
||
| 4589 | self.assertEqual(bmpm('1234', '', 'gen', 'exact', False), '') |
||
| 4590 | |||
| 4591 | # concat is true, ruleType is APPROX |
||
| 4592 | self.assertEqual(bmpm('Angelo', '', 'gen', 'approx', True), |
||
| 4593 | 'angilo angYlo agilo ongilo ongYlo ogilo Yngilo' + |
||
| 4594 | ' YngYlo anxilo onxilo anilo onilo aniilo oniilo' + |
||
| 4595 | ' anzilo onzilo') |
||
| 4596 | self.assertEqual(bmpm('D\'Angelo', '', 'gen', 'approx', True), |
||
| 4597 | 'angilo angYlo agilo ongilo ongYlo ogilo Yngilo' + |
||
| 4598 | ' YngYlo anxilo onxilo anilo onilo aniilo oniilo' + |
||
| 4599 | ' anzilo onzilo dangilo dangYlo dagilo dongilo' + |
||
| 4600 | ' dongYlo dogilo dYngilo dYngYlo danxilo donxilo' + |
||
| 4601 | ' danilo donilo daniilo doniilo danzilo donzilo') |
||
| 4602 | self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'gen', |
||
| 4603 | 'approx', True), |
||
| 4604 | 'angilo ongilo anxilo onxilo anzilo onzilo') |
||
| 4605 | self.assertEqual(bmpm('1234', '', 'gen', 'approx', True), '') |
||
| 4606 | |||
| 4607 | # concat is false, ruleType is APPROX |
||
| 4608 | self.assertEqual(bmpm('Angelo', '', 'gen', 'approx', False), |
||
| 4609 | 'angilo angYlo agilo ongilo ongYlo ogilo Yngilo' + |
||
| 4610 | ' YngYlo anxilo onxilo anilo onilo aniilo oniilo' + |
||
| 4611 | ' anzilo onzilo') |
||
| 4612 | self.assertEqual(bmpm('D\'Angelo', '', 'gen', 'approx', False), |
||
| 4613 | 'angilo angYlo agilo ongilo ongYlo ogilo Yngilo' + |
||
| 4614 | ' YngYlo anxilo onxilo anilo onilo aniilo oniilo' + |
||
| 4615 | ' anzilo onzilo dangilo dangYlo dagilo dongilo' + |
||
| 4616 | ' dongYlo dogilo dYngilo dYngYlo danxilo donxilo' + |
||
| 4617 | ' danilo donilo daniilo doniilo danzilo donzilo') |
||
| 4618 | self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'gen', |
||
| 4619 | 'approx', False), |
||
| 4620 | 'angilo ongilo anxilo onxilo anzilo onzilo') |
||
| 4621 | self.assertEqual(bmpm('1234', '', 'gen', 'approx', False), '') |
||
| 4622 | |||
| 4623 | # testSolrASHKENAZI |
||
| 4624 | # concat is true, ruleType is EXACT |
||
| 4625 | self.assertEqual(bmpm('Angelo', '', 'ash', 'exact', True), |
||
| 4626 | 'angelo andZelo anhelo anxelo') |
||
| 4627 | self.assertEqual(bmpm('D\'Angelo', '', 'ash', 'exact', True), |
||
| 4628 | 'dangelo dandZelo danhelo danxelo') |
||
| 4629 | self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
||
| 4630 | 'ash', 'exact', True) |
||
| 4631 | self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'ash', |
||
| 4632 | 'exact', True, True), 'anxelo angelo') |
||
| 4633 | self.assertEqual(bmpm('1234', '', 'ash', 'exact', True), '') |
||
| 4634 | |||
| 4635 | # concat is false, ruleType is EXACT |
||
| 4636 | self.assertEqual(bmpm('Angelo', '', 'ash', 'exact', False), |
||
| 4637 | 'angelo andZelo anhelo anxelo') |
||
| 4638 | self.assertEqual(bmpm('D\'Angelo', '', 'ash', 'exact', False), |
||
| 4639 | 'dangelo dandZelo danhelo danxelo') |
||
| 4640 | self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
||
| 4641 | 'ash', 'exact', False) |
||
| 4642 | self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'ash', |
||
| 4643 | 'exact', False, True), 'anxelo angelo') |
||
| 4644 | self.assertEqual(bmpm('1234', '', 'ash', 'exact', False), '') |
||
| 4645 | |||
| 4646 | # concat is true, ruleType is APPROX |
||
| 4647 | self.assertEqual(bmpm('Angelo', '', 'ash', 'approx', True), |
||
| 4648 | 'angilo angYlo ongilo ongYlo Yngilo YngYlo anzilo' + |
||
| 4649 | ' onzilo anilo onilo anxilo onxilo') |
||
| 4650 | self.assertEqual(bmpm('D\'Angelo', '', 'ash', 'approx', True), |
||
| 4651 | 'dangilo dangYlo dongilo dongYlo dYngilo dYngYlo' + |
||
| 4652 | ' danzilo donzilo danilo donilo danxilo donxilo') |
||
| 4653 | self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
||
| 4654 | 'ash', 'approx', True) |
||
| 4655 | self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'ash', |
||
| 4656 | 'approx', True, True), |
||
| 4657 | 'anxYlo anxilo onxYlo onxilo angYlo angilo ongYlo' + |
||
| 4658 | ' ongilo') |
||
| 4659 | self.assertEqual(bmpm('1234', '', 'ash', 'approx', True), '') |
||
| 4660 | |||
| 4661 | # concat is false, ruleType is APPROX |
||
| 4662 | self.assertEqual(bmpm('Angelo', '', 'ash', 'approx', False), |
||
| 4663 | 'angilo angYlo ongilo ongYlo Yngilo YngYlo anzilo' + |
||
| 4664 | ' onzilo anilo onilo anxilo onxilo') |
||
| 4665 | self.assertEqual(bmpm('D\'Angelo', '', 'ash', 'approx', False), |
||
| 4666 | 'dangilo dangYlo dongilo dongYlo dYngilo dYngYlo' + |
||
| 4667 | ' danzilo donzilo danilo donilo danxilo donxilo') |
||
| 4668 | self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
||
| 4669 | 'ash', 'approx', False) |
||
| 4670 | self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'ash', |
||
| 4671 | 'approx', False, True), |
||
| 4672 | 'anxYlo anxilo onxYlo onxilo angYlo angilo ongYlo' + |
||
| 4673 | ' ongilo') |
||
| 4674 | self.assertEqual(bmpm('1234', '', 'ash', 'approx', False), '') |
||
| 4675 | |||
| 4676 | # testSolrSEPHARDIC |
||
| 4677 | # concat is true, ruleType is EXACT |
||
| 4678 | self.assertEqual(bmpm('Angelo', '', 'sep', 'exact', True), |
||
| 4679 | 'anZelo andZelo anxelo') |
||
| 4680 | self.assertEqual(bmpm('D\'Angelo', '', 'sep', 'exact', True), |
||
| 4681 | 'anZelo andZelo anxelo') |
||
| 4682 | self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
||
| 4683 | 'sep', 'exact', True) |
||
| 4684 | self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'sep', |
||
| 4685 | 'exact', True, True), |
||
| 4686 | 'andZelo anxelo') |
||
| 4687 | self.assertEqual(bmpm('1234', '', 'sep', 'exact', True), '') |
||
| 4688 | |||
| 4689 | # concat is false, ruleType is EXACT |
||
| 4690 | self.assertEqual(bmpm('Angelo', '', 'sep', 'exact', False), |
||
| 4691 | 'anZelo andZelo anxelo') |
||
| 4692 | self.assertEqual(bmpm('D\'Angelo', '', 'sep', 'exact', False), |
||
| 4693 | 'anZelo andZelo anxelo') |
||
| 4694 | self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
||
| 4695 | 'sep', 'exact', False) |
||
| 4696 | self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'sep', |
||
| 4697 | 'exact', False, True), 'andZelo anxelo') |
||
| 4698 | self.assertEqual(bmpm('1234', '', 'sep', 'exact', False), '') |
||
| 4699 | |||
| 4700 | # concat is true, ruleType is APPROX |
||
| 4701 | self.assertEqual(bmpm('Angelo', '', 'sep', 'approx', True), |
||
| 4702 | 'anzila anzilu nzila nzilu anhila anhilu nhila nhilu') |
||
| 4703 | self.assertEqual(bmpm('D\'Angelo', '', 'sep', 'approx', True), |
||
| 4704 | 'anzila anzilu nzila nzilu anhila anhilu nhila nhilu') |
||
| 4705 | self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
||
| 4706 | 'sep', 'approx', True) |
||
| 4707 | self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'sep', |
||
| 4708 | 'approx', True, True), |
||
| 4709 | 'anzila anzilu nzila nzilu anhila anhilu nhila nhilu') |
||
| 4710 | self.assertEqual(bmpm('1234', '', 'sep', 'approx', True), '') |
||
| 4711 | |||
| 4712 | # concat is false, ruleType is APPROX |
||
| 4713 | self.assertEqual(bmpm('Angelo', '', 'sep', 'approx', False), |
||
| 4714 | 'anzila anzilu nzila nzilu anhila anhilu nhila nhilu') |
||
| 4715 | self.assertEqual(bmpm('D\'Angelo', '', 'sep', 'approx', False), |
||
| 4716 | 'anzila anzilu nzila nzilu anhila anhilu nhila nhilu') |
||
| 4717 | self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
||
| 4718 | 'sep', 'approx', False) |
||
| 4719 | self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'sep', |
||
| 4720 | 'approx', False, True), |
||
| 4721 | 'anzila anzilu nzila nzilu anhila anhilu nhila nhilu') |
||
| 4722 | self.assertEqual(bmpm('1234', '', 'sep', 'approx', False), '') |
||
| 4723 | |||
| 4724 | # testCompatibilityWithOriginalVersion |
||
| 4725 | self.assertEqual(bmpm('abram', '', 'gen', 'approx', False), |
||
| 4726 | 'abram abrom avram avrom obram obrom ovram ovrom' + |
||
| 4727 | ' Ybram Ybrom abran abron obran obron') |
||
| 4728 | self.assertEqual(bmpm('Bendzin', '', 'gen', 'approx', False), |
||
| 4729 | 'binzn bindzn vindzn bintsn vintsn') |
||
| 4730 | self.assertEqual(bmpm('abram', '', 'ash', 'approx', False), |
||
| 4731 | 'abram abrom avram avrom obram obrom ovram ovrom' + |
||
| 4732 | ' Ybram Ybrom ombram ombrom imbram imbrom') |
||
| 4733 | self.assertEqual(bmpm('Halpern', '', 'ash', 'approx', False), |
||
| 4734 | 'alpirn alpYrn olpirn olpYrn Ylpirn YlpYrn xalpirn' + |
||
| 4735 | ' xolpirn') |
||
| 4736 | |||
| 4737 | # PhoneticEngineTest |
||
| 4738 | self.assertEqual(bmpm('Renault', '', 'gen', 'approx', True), |
||
| 4739 | 'rinolt rino rinDlt rinalt rinult rinD rina rinu') |
||
| 4740 | self.assertEqual(bmpm('Renault', '', 'ash', 'approx', True), |
||
| 4741 | 'rinDlt rinalt rinult rYnDlt rYnalt rYnult rinolt') |
||
| 4742 | self.assertEqual(bmpm('Renault', '', 'sep', 'approx', True), |
||
| 4743 | 'rinDlt') |
||
| 4744 | self.assertEqual(bmpm('SntJohn-Smith', '', 'gen', 'exact', True), |
||
| 4745 | 'sntjonsmit') |
||
| 4746 | self.assertEqual(bmpm('d\'ortley', '', 'gen', 'exact', True), |
||
| 4747 | 'ortlaj ortlej dortlaj dortlej') |
||
| 4748 | self.assertEqual(bmpm('van helsing', '', 'gen', 'exact', False), |
||
| 4749 | 'helSink helsink helzink xelsink elSink elsink' + |
||
| 4750 | ' vanhelsink vanhelzink vanjelsink fanhelsink' + |
||
| 4751 | ' fanhelzink banhelsink') |
||
| 4752 | |||
| 4753 | def test_bmpm_misc(self): |
||
| 4754 | """Test abydos.phonetic.bmpm (miscellaneous tests). |
||
| 4755 | |||
| 4756 | The purpose of this test set is to achieve higher code coverage |
||
| 4757 | and to hit some of the test cases noted in the BMPM reference code. |
||
| 4758 | """ |
||
| 4759 | # test of Ashkenazi with discardable prefix |
||
| 4760 | self.assertEqual(bmpm('bar Hayim', name_mode='ash'), 'Dm xDm') |
||
| 4761 | |||
| 4762 | # tests of concat behavior |
||
| 4763 | self.assertEqual(bmpm('Rodham Clinton', concat=False), |
||
| 4764 | 'rodam rodom rYdam rYdom rodan rodon rodxam rodxom' + |
||
| 4765 | ' rodxan rodxon rudam rudom klinton klnton klintun' + |
||
| 4766 | ' klntun tzlinton tzlnton tzlintun tzlntun zlinton' + |
||
| 4767 | ' zlnton') |
||
| 4768 | self.assertEqual(bmpm('Rodham Clinton', concat=True), |
||
| 4769 | 'rodamklinton rodomklinton rodamklnton rodomklnton' + |
||
| 4770 | ' rodamklintun rodomklintun rodamklntun rodomklntun' + |
||
| 4771 | ' rodamtzlinton rodomtzlinton rodamtzlnton' + |
||
| 4772 | ' rodomtzlnton rodamtzlintun rodomtzlintun' + |
||
| 4773 | ' rodamtzlntun rodomtzlntun rodamzlinton' + |
||
| 4774 | ' rodomzlinton rodamzlnton rodomzlnton rodanklinton' + |
||
| 4775 | ' rodonklinton rodanklnton rodonklnton' + |
||
| 4776 | ' rodxamklinton rodxomklinton rodxamklnton' + |
||
| 4777 | ' rodxomklnton rodxanklinton rodxonklinton' + |
||
| 4778 | ' rodxanklnton rodxonklnton rudamklinton' + |
||
| 4779 | ' rudomklinton rudamklnton rudomklnton rudamklintun' + |
||
| 4780 | ' rudomklintun rudamklntun rudomklntun' + |
||
| 4781 | ' rudamtzlinton rudomtzlinton rudamtzlnton' + |
||
| 4782 | ' rudomtzlnton rudamtzlintun rudomtzlintun' + |
||
| 4783 | ' rudamtzlntun rudomtzlntun') |
||
| 4784 | |||
| 4785 | # tests of name_mode values |
||
| 4786 | self.assertEqual(bmpm('bar Hayim', name_mode='ash'), 'Dm xDm') |
||
| 4787 | self.assertEqual(bmpm('bar Hayim', name_mode='ashkenazi'), 'Dm xDm') |
||
| 4788 | self.assertEqual(bmpm('bar Hayim', name_mode='Ashkenazi'), 'Dm xDm') |
||
| 4789 | self.assertEqual(bmpm('bar Hayim', name_mode='gen', concat=True), |
||
| 4790 | 'barDm borDm bYrDm varDm vorDm barDn borDn barxDm' + |
||
| 4791 | ' borxDm varxDm vorxDm barxDn borxDn') |
||
| 4792 | self.assertEqual(bmpm('bar Hayim', name_mode='general', concat=True), |
||
| 4793 | 'barDm borDm bYrDm varDm vorDm barDn borDn barxDm' + |
||
| 4794 | ' borxDm varxDm vorxDm barxDn borxDn') |
||
| 4795 | self.assertEqual(bmpm('bar Hayim', name_mode='Mizrahi', concat=True), |
||
| 4796 | 'barDm borDm bYrDm varDm vorDm barDn borDn barxDm' + |
||
| 4797 | ' borxDm varxDm vorxDm barxDn borxDn') |
||
| 4798 | self.assertEqual(bmpm('bar Hayim', name_mode='mizrahi', concat=True), |
||
| 4799 | 'barDm borDm bYrDm varDm vorDm barDn borDn barxDm' + |
||
| 4800 | ' borxDm varxDm vorxDm barxDn borxDn') |
||
| 4801 | self.assertEqual(bmpm('bar Hayim', name_mode='miz', concat=True), |
||
| 4802 | 'barDm borDm bYrDm varDm vorDm barDn borDn barxDm' + |
||
| 4803 | ' borxDm varxDm vorxDm barxDn borxDn') |
||
| 4804 | |||
| 4805 | # test that out-of-range langauge_arg results in L_ANY |
||
| 4806 | self.assertEqual(bmpm('Rodham Clinton', language_arg=2**32), |
||
| 4807 | 'rodam rodom rYdam rYdom rodan rodon rodxam rodxom' + |
||
| 4808 | ' rodxan rodxon rudam rudom klinton klnton klintun' + |
||
| 4809 | ' klntun tzlinton tzlnton tzlintun tzlntun zlinton' + |
||
| 4810 | ' zlnton') |
||
| 4811 | self.assertEqual(bmpm('Rodham Clinton', language_arg=-4), |
||
| 4812 | 'rodam rodom rYdam rYdom rodan rodon rodxam rodxom' + |
||
| 4813 | ' rodxan rodxon rudam rudom klinton klnton klintun' + |
||
| 4814 | ' klntun tzlinton tzlnton tzlintun tzlntun zlinton' + |
||
| 4815 | ' zlnton') |
||
| 4816 | |||
| 4817 | # etc. (for code coverage) |
||
| 4818 | self.assertEqual(bmpm('van Damme', name_mode='sep'), 'dami mi dam m') |
||
| 4819 | |||
| 4820 | View Code Duplication | def test_bmpm_nachnamen(self): |
|
| 4821 | """Test abydos.phonetic.bmpm (Nachnamen set).""" |
||
| 4822 | if not ALLOW_RANDOM: |
||
| 4823 | return |
||
| 4824 | with codecs.open(TESTDIR + '/corpora/nachnamen.bm.csv', |
||
| 4825 | encoding='utf-8') as nachnamen_testset: |
||
| 4826 | next(nachnamen_testset) |
||
| 4827 | for nn_line in nachnamen_testset: |
||
| 4828 | nn_line = nn_line.strip().split(',') |
||
| 4829 | # This test set is very large (~10000 entries) |
||
| 4830 | # so let's just randomly select about 20 for testing |
||
| 4831 | if nn_line[0] != '#' and one_in(500): |
||
| 4832 | self.assertEqual(bmpm(nn_line[0], language_arg='german'), |
||
| 4833 | nn_line[1]) |
||
| 4834 | self.assertEqual(bmpm(nn_line[0]), nn_line[2]) |
||
| 4835 | |||
| 4836 | View Code Duplication | def test_bmpm_nachnamen_cc(self): |
|
| 4837 | """Test abydos.phonetic.bmpm (Nachnamen set, corner cases).""" |
||
| 4838 | with codecs.open(TESTDIR + '/corpora/nachnamen.bm.cc.csv', |
||
| 4839 | encoding='utf-8') as nachnamen_testset: |
||
| 4840 | next(nachnamen_testset) |
||
| 4841 | for nn_line in nachnamen_testset: |
||
| 4842 | nn_line = nn_line.strip().split(',') |
||
| 4843 | # This test set is very large (~10000 entries) |
||
| 4844 | # so let's just randomly select about 20 for testing |
||
| 4845 | if nn_line[0] != '#': |
||
| 4846 | self.assertEqual(bmpm(nn_line[0], language_arg='german'), |
||
| 4847 | nn_line[1]) |
||
| 4848 | self.assertEqual(bmpm(nn_line[0]), nn_line[2]) |
||
| 4849 | |||
| 4850 | View Code Duplication | def test_bmpm_uscensus2000(self): |
|
| 4851 | """Test abydos.phonetic.bmpm (US Census 2000 set).""" |
||
| 4852 | if not ALLOW_RANDOM: |
||
| 4853 | return |
||
| 4854 | with open(TESTDIR + '/corpora/uscensus2000.bm.csv') as uscensus_ts: |
||
| 4855 | next(uscensus_ts) |
||
| 4856 | for cen_line in uscensus_ts: |
||
| 4857 | cen_line = cen_line.strip().split(',') |
||
| 4858 | # This test set is very large (~150000 entries) |
||
| 4859 | # so let's just randomly select about 20 for testing |
||
| 4860 | if cen_line[0] != '#' and one_in(7500): |
||
| 4861 | self.assertEqual(bmpm(cen_line[0], match_mode='approx', |
||
| 4862 | name_mode='gen'), cen_line[1]) |
||
| 4863 | self.assertEqual(bmpm(cen_line[0], match_mode='approx', |
||
| 4864 | name_mode='ash'), cen_line[2]) |
||
| 4865 | self.assertEqual(bmpm(cen_line[0], match_mode='approx', |
||
| 4866 | name_mode='sep'), cen_line[3]) |
||
| 4867 | self.assertEqual(bmpm(cen_line[0], match_mode='exact', |
||
| 4868 | name_mode='gen'), cen_line[4]) |
||
| 4869 | self.assertEqual(bmpm(cen_line[0], match_mode='exact', |
||
| 4870 | name_mode='ash'), cen_line[5]) |
||
| 4871 | self.assertEqual(bmpm(cen_line[0], match_mode='exact', |
||
| 4872 | name_mode='sep'), cen_line[6]) |
||
| 4873 | |||
| 4874 | View Code Duplication | def test_bmpm_uscensus2000_cc(self): |
|
| 4875 | """Test abydos.phonetic.bmpm (US Census 2000 set, corner cases).""" |
||
| 4876 | with open(TESTDIR + '/corpora/uscensus2000.bm.cc.csv') as uscensus_ts: |
||
| 4877 | next(uscensus_ts) |
||
| 4878 | for cen_line in uscensus_ts: |
||
| 4879 | cen_line = cen_line.strip().split(',') |
||
| 4880 | # This test set is very large (~150000 entries) |
||
| 4881 | # so let's just randomly select about 20 for testing |
||
| 4882 | if cen_line[0] != '#' and one_in(10): |
||
| 4883 | self.assertEqual(bmpm(cen_line[0], match_mode='approx', |
||
| 4884 | name_mode='gen'), cen_line[1]) |
||
| 4885 | self.assertEqual(bmpm(cen_line[0], match_mode='approx', |
||
| 4886 | name_mode='ash'), cen_line[2]) |
||
| 4887 | self.assertEqual(bmpm(cen_line[0], match_mode='approx', |
||
| 4888 | name_mode='sep'), cen_line[3]) |
||
| 4889 | self.assertEqual(bmpm(cen_line[0], match_mode='exact', |
||
| 4890 | name_mode='gen'), cen_line[4]) |
||
| 4891 | self.assertEqual(bmpm(cen_line[0], match_mode='exact', |
||
| 4892 | name_mode='ash'), cen_line[5]) |
||
| 4893 | self.assertEqual(bmpm(cen_line[0], match_mode='exact', |
||
| 4894 | name_mode='sep'), cen_line[6]) |
||
| 4895 | |||
| 4896 | def test_bm_phonetic_number(self): |
||
| 4897 | """Test abydos.bm._bm_phonetic_number.""" |
||
| 4898 | self.assertEqual(_bm_phonetic_number(''), '') |
||
| 4899 | self.assertEqual(_bm_phonetic_number('abcd'), 'abcd') |
||
| 4900 | self.assertEqual(_bm_phonetic_number('abcd[123]'), 'abcd') |
||
| 4901 | self.assertEqual(_bm_phonetic_number('abcd[123'), 'abcd') |
||
| 4902 | self.assertEqual(_bm_phonetic_number('abcd['), 'abcd') |
||
| 4903 | self.assertEqual(_bm_phonetic_number('abcd[[[123]]]'), 'abcd') |
||
| 4904 | |||
| 4905 | def test_bm_apply_rule_if_compat(self): |
||
| 4906 | """Test abydos.bm._bm_apply_rule_if_compat.""" |
||
| 4907 | self.assertEqual(_bm_apply_rule_if_compat('abc', 'def', 4), 'abcdef') |
||
| 4908 | self.assertEqual(_bm_apply_rule_if_compat('abc', 'def[6]', 4), |
||
| 4909 | 'abcdef[4]') |
||
| 4910 | self.assertEqual(_bm_apply_rule_if_compat('abc', 'def[4]', 4), |
||
| 4911 | 'abcdef[4]') |
||
| 4912 | self.assertEqual(_bm_apply_rule_if_compat('abc', 'def[0]', 4), None) |
||
| 4913 | self.assertEqual(_bm_apply_rule_if_compat('abc', 'def[8]', 4), None) |
||
| 4914 | self.assertEqual(_bm_apply_rule_if_compat('abc', 'def', 1), 'abcdef') |
||
| 4915 | self.assertEqual(_bm_apply_rule_if_compat('abc', 'def[4]', 1), |
||
| 4916 | 'abcdef[4]') |
||
| 4917 | |||
| 4918 | def test_bm_language(self): |
||
| 4919 | """Test abydos.bm._bm_language. |
||
| 4920 | |||
| 4921 | Most test cases from: |
||
| 4922 | http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/test/java/org/apache/commons/codec/language/bm/LanguageGuessingTest.java?view=markup |
||
| 4923 | """ |
||
| 4924 | self.assertEqual(_bm_language('Renault', 'gen'), L_FRENCH) |
||
| 4925 | self.assertEqual(_bm_language('Mickiewicz', 'gen'), L_POLISH) |
||
| 4926 | self.assertEqual(_bm_language('Thompson', 'gen') & L_ENGLISH, |
||
| 4927 | L_ENGLISH) |
||
| 4928 | self.assertEqual(_bm_language('Nuñez', 'gen'), L_SPANISH) |
||
| 4929 | self.assertEqual(_bm_language('Carvalho', 'gen'), L_PORTUGUESE) |
||
| 4930 | self.assertEqual(_bm_language('Čapek', 'gen'), L_CZECH | L_LATVIAN) |
||
| 4931 | self.assertEqual(_bm_language('Sjneijder', 'gen'), L_DUTCH) |
||
| 4932 | self.assertEqual(_bm_language('Klausewitz', 'gen'), L_GERMAN) |
||
| 4933 | self.assertEqual(_bm_language('Küçük', 'gen'), L_TURKISH) |
||
| 4934 | self.assertEqual(_bm_language('Giacometti', 'gen'), L_ITALIAN) |
||
| 4935 | self.assertEqual(_bm_language('Nagy', 'gen'), L_HUNGARIAN) |
||
| 4936 | self.assertEqual(_bm_language('Ceauşescu', 'gen'), L_ROMANIAN) |
||
| 4937 | self.assertEqual(_bm_language('Angelopoulos', 'gen'), L_GREEKLATIN) |
||
| 4938 | self.assertEqual(_bm_language('Αγγελόπουλος', 'gen'), L_GREEK) |
||
| 4939 | self.assertEqual(_bm_language('Пушкин', 'gen'), L_CYRILLIC) |
||
| 4940 | self.assertEqual(_bm_language('כהן', 'gen'), L_HEBREW) |
||
| 4941 | self.assertEqual(_bm_language('ácz', 'gen'), L_ANY) |
||
| 4942 | self.assertEqual(_bm_language('átz', 'gen'), L_ANY) |
||
| 4943 | |||
| 4944 | def test_bm_expand_alternates(self): |
||
| 4945 | """Test abydos.bm._bm_expand_alternates.""" |
||
| 4946 | self.assertEqual(_bm_expand_alternates(''), '') |
||
| 4947 | self.assertEqual(_bm_expand_alternates('aa'), 'aa') |
||
| 4948 | self.assertEqual(_bm_expand_alternates('aa|bb'), 'aa|bb') |
||
| 4949 | self.assertEqual(_bm_expand_alternates('aa|aa'), 'aa|aa') |
||
| 4950 | |||
| 4951 | self.assertEqual(_bm_expand_alternates('(aa)(bb)'), 'aabb') |
||
| 4952 | self.assertEqual(_bm_expand_alternates('(aa)(bb[0])'), '') |
||
| 4953 | self.assertEqual(_bm_expand_alternates('(aa)(bb[4])'), 'aabb[4]') |
||
| 4954 | self.assertEqual(_bm_expand_alternates('(aa[0])(bb)'), '') |
||
| 4955 | self.assertEqual(_bm_expand_alternates('(aa[4])(bb)'), 'aabb[4]') |
||
| 4956 | |||
| 4957 | self.assertEqual(_bm_expand_alternates('(a|b|c)(a|b|c)'), |
||
| 4958 | 'aa|ab|ac|ba|bb|bc|ca|cb|cc') |
||
| 4959 | self.assertEqual(_bm_expand_alternates('(a[1]|b[2])(c|d)'), |
||
| 4960 | 'ac[1]|ad[1]|bc[2]|bd[2]') |
||
| 4961 | self.assertEqual(_bm_expand_alternates('(a[1]|b[2])(c[4]|d)'), |
||
| 4962 | 'ad[1]|bd[2]') |
||
| 4963 | |||
| 4964 | def test_bm_remove_dupes(self): |
||
| 4965 | """Test abydos.bm._bm_remove_dupes.""" |
||
| 4966 | self.assertEqual(_bm_remove_dupes(''), '') |
||
| 4967 | self.assertEqual(_bm_remove_dupes('aa'), 'aa') |
||
| 4968 | self.assertEqual(_bm_remove_dupes('aa|bb'), 'aa|bb') |
||
| 4969 | self.assertEqual(_bm_remove_dupes('aa|aa'), 'aa') |
||
| 4970 | self.assertEqual(_bm_remove_dupes('aa|aa|aa|bb|aa'), 'aa|bb') |
||
| 4971 | self.assertEqual(_bm_remove_dupes('bb|aa|bb|aa|bb'), 'bb|aa') |
||
| 4972 | |||
| 4973 | def test_bm_normalize_lang_attrs(self): |
||
| 4974 | """Test abydos.bm._bm_normalize_language_attributes.""" |
||
| 4975 | self.assertEqual(_bm_normalize_lang_attrs('', False), '') |
||
| 4976 | self.assertEqual(_bm_normalize_lang_attrs('', True), '') |
||
| 4977 | |||
| 4978 | self.assertRaises(ValueError, _bm_normalize_lang_attrs, 'a[1', False) |
||
| 4979 | self.assertRaises(ValueError, _bm_normalize_lang_attrs, 'a[1', True) |
||
| 4980 | |||
| 4981 | self.assertEqual(_bm_normalize_lang_attrs('abc', False), 'abc') |
||
| 4982 | self.assertEqual(_bm_normalize_lang_attrs('abc[0]', False), '[0]') |
||
| 4983 | self.assertEqual(_bm_normalize_lang_attrs('abc[2]', False), 'abc[2]') |
||
| 4984 | self.assertEqual(_bm_normalize_lang_attrs('abc[2][4]', False), '[0]') |
||
| 4985 | self.assertEqual(_bm_normalize_lang_attrs('abc[2][6]', False), |
||
| 4986 | 'abc[2]') |
||
| 4987 | self.assertEqual(_bm_normalize_lang_attrs('ab[2]c[4]', False), '[0]') |
||
| 4988 | self.assertEqual(_bm_normalize_lang_attrs('ab[2]c[6]', False), |
||
| 4989 | 'abc[2]') |
||
| 4990 | |||
| 4991 | self.assertEqual(_bm_normalize_lang_attrs('abc', True), 'abc') |
||
| 4992 | self.assertEqual(_bm_normalize_lang_attrs('abc[0]', True), 'abc') |
||
| 4993 | self.assertEqual(_bm_normalize_lang_attrs('abc[2]', True), 'abc') |
||
| 4994 | self.assertEqual(_bm_normalize_lang_attrs('abc[2][4]', True), 'abc') |
||
| 4995 | self.assertEqual(_bm_normalize_lang_attrs('abc[2][6]', True), 'abc') |
||
| 4996 | self.assertEqual(_bm_normalize_lang_attrs('ab[2]c[4]', True), 'abc') |
||
| 4997 | self.assertEqual(_bm_normalize_lang_attrs('ab[2]c[6]', True), 'abc') |
||
| 4998 | |||
| 4999 | |||
| 5000 | if __name__ == '__main__': |
||
| 5001 | unittest.main() |
||
| 5002 |
Loading history...