|
1
|
|
|
# -*- coding: utf-8 -*- |
|
|
|
|
|
|
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, eudex, 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 EudexTestCases(unittest.TestCase): |
|
4534
|
|
|
"""Test eudex functions. |
|
4535
|
|
|
|
|
4536
|
|
|
test cases for abydos.phonetic.eudex |
|
4537
|
|
|
""" |
|
4538
|
|
|
def test_eudex(self): |
|
4539
|
|
|
"""Test abydos.phonetic.eudex.""" |
|
4540
|
|
|
# exact & mismatch cases from https://github.com/ticki/eudex/blob/master/src/tests.rs |
|
4541
|
|
|
self.assertEqual(eudex("JAva"), eudex("jAva")) |
|
4542
|
|
|
self.assertEqual(eudex("co!mputer"), eudex("computer")) |
|
4543
|
|
|
self.assertEqual(eudex("comp-uter"), eudex("computer")) |
|
4544
|
|
|
self.assertEqual(eudex("comp@u#te?r"), eudex("computer")) |
|
4545
|
|
|
self.assertEqual(eudex("lal"), eudex("lel")) |
|
4546
|
|
|
self.assertEqual(eudex("rindom"), eudex("ryndom")) |
|
4547
|
|
|
self.assertEqual(eudex("riiiindom"), eudex("ryyyyyndom")) |
|
4548
|
|
|
self.assertEqual(eudex("riyiyiiindom"), eudex("ryyyyyndom")) |
|
4549
|
|
|
self.assertEqual(eudex("triggered"), eudex("TRIGGERED")) |
|
4550
|
|
|
self.assertEqual(eudex("repert"), eudex("ropert")) |
|
4551
|
|
|
|
|
4552
|
|
|
self.assertNotEqual(eudex("reddit"), eudex("eddit")) |
|
4553
|
|
|
self.assertNotEqual(eudex("lol"), eudex("lulz")) |
|
4554
|
|
|
self.assertNotEqual(eudex("ijava"), eudex("java")) |
|
4555
|
|
|
self.assertNotEqual(eudex("jiva"), eudex("java")) |
|
4556
|
|
|
self.assertNotEqual(eudex("jesus"), eudex("iesus")) |
|
4557
|
|
|
self.assertNotEqual(eudex("aesus"), eudex("iesus")) |
|
4558
|
|
|
self.assertNotEqual(eudex("iesus"), eudex("yesus")) |
|
4559
|
|
|
self.assertNotEqual(eudex("rupirt"), eudex("ropert")) |
|
4560
|
|
|
self.assertNotEqual(eudex("ripert"), eudex("ropyrt")) |
|
4561
|
|
|
self.assertNotEqual(eudex("rrr"), eudex("rraaaa")) |
|
4562
|
|
|
self.assertNotEqual(eudex("randomal"), eudex("randomai")) |
|
4563
|
|
|
|
|
4564
|
|
|
|
|
4565
|
|
|
class BeiderMorseTestCases(unittest.TestCase): |
|
4566
|
|
|
"""Test BMPM functions. |
|
4567
|
|
|
|
|
4568
|
|
|
test cases for abydos.phonetic.bmpm and abydos.bm.* |
|
4569
|
|
|
""" |
|
4570
|
|
|
|
|
4571
|
|
|
def test_bmpm(self): |
|
4572
|
|
|
"""Test abydos.phonetic.bmpm. |
|
4573
|
|
|
|
|
4574
|
|
|
Most test cases from: |
|
4575
|
|
|
http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/test/java/org/apache/commons/codec/language/bm/ |
|
4576
|
|
|
|
|
4577
|
|
|
As a rule, the test cases are copied from the above code, but the |
|
4578
|
|
|
resultant values are not. This is largely because this Python port |
|
4579
|
|
|
follows the PHP reference implementation much more closely than the |
|
4580
|
|
|
Java port in Apache Commons Codec does. As a result, these tests have |
|
4581
|
|
|
been conformed to the output produced by the PHP implementation, |
|
4582
|
|
|
particularly in terms of formatting and ordering. |
|
4583
|
|
|
""" |
|
4584
|
|
|
# base cases |
|
4585
|
|
|
self.assertEqual(bmpm(''), '') |
|
4586
|
|
|
|
|
4587
|
|
|
for langs in ('', 1, 'spanish', 'english,italian', 3): |
|
4588
|
|
|
for name_mode in ('gen', 'ash', 'sep'): |
|
4589
|
|
|
for match_mode in ('approx', 'exact'): |
|
4590
|
|
|
for concat in (False, True): |
|
4591
|
|
|
if (isinstance(langs, text_type) and |
|
4592
|
|
|
((name_mode == 'ash' and 'italian' in langs) or |
|
|
|
|
|
|
4593
|
|
|
(name_mode == 'sep' and 'english' in langs))): |
|
4594
|
|
|
self.assertRaises(ValueError, bmpm, '', langs, |
|
4595
|
|
|
name_mode, match_mode, concat) |
|
4596
|
|
|
else: |
|
4597
|
|
|
self.assertEqual(bmpm('', langs, name_mode, |
|
4598
|
|
|
match_mode, concat), '') |
|
4599
|
|
|
|
|
4600
|
|
|
# testSolrGENERIC |
|
4601
|
|
|
# concat is true, ruleType is EXACT |
|
4602
|
|
|
self.assertEqual(bmpm('Angelo', '', 'gen', 'exact', True), |
|
4603
|
|
|
'angelo anxelo anhelo anjelo anZelo andZelo') |
|
4604
|
|
|
self.assertEqual(bmpm('D\'Angelo', '', 'gen', 'exact', True), |
|
4605
|
|
|
'angelo anxelo anhelo anjelo anZelo andZelo dangelo' + |
|
4606
|
|
|
' danxelo danhelo danjelo danZelo dandZelo') |
|
4607
|
|
|
self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'gen', |
|
4608
|
|
|
'exact', True), |
|
4609
|
|
|
'angelo anxelo andZelo') |
|
4610
|
|
|
self.assertEqual(bmpm('1234', '', 'gen', 'exact', True), '') |
|
4611
|
|
|
|
|
4612
|
|
|
# concat is false, ruleType is EXACT |
|
4613
|
|
|
self.assertEqual(bmpm('Angelo', '', 'gen', 'exact', False), |
|
4614
|
|
|
'angelo anxelo anhelo anjelo anZelo andZelo') |
|
4615
|
|
|
self.assertEqual(bmpm('D\'Angelo', '', 'gen', 'exact', False), |
|
4616
|
|
|
'angelo anxelo anhelo anjelo anZelo andZelo dangelo' + |
|
4617
|
|
|
' danxelo danhelo danjelo danZelo dandZelo') |
|
4618
|
|
|
self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'gen', |
|
4619
|
|
|
'exact', False), |
|
4620
|
|
|
'angelo anxelo andZelo') |
|
4621
|
|
|
self.assertEqual(bmpm('1234', '', 'gen', 'exact', False), '') |
|
4622
|
|
|
|
|
4623
|
|
|
# concat is true, ruleType is APPROX |
|
4624
|
|
|
self.assertEqual(bmpm('Angelo', '', 'gen', 'approx', True), |
|
4625
|
|
|
'angilo angYlo agilo ongilo ongYlo ogilo Yngilo' + |
|
4626
|
|
|
' YngYlo anxilo onxilo anilo onilo aniilo oniilo' + |
|
4627
|
|
|
' anzilo onzilo') |
|
4628
|
|
|
self.assertEqual(bmpm('D\'Angelo', '', 'gen', 'approx', True), |
|
4629
|
|
|
'angilo angYlo agilo ongilo ongYlo ogilo Yngilo' + |
|
4630
|
|
|
' YngYlo anxilo onxilo anilo onilo aniilo oniilo' + |
|
4631
|
|
|
' anzilo onzilo dangilo dangYlo dagilo dongilo' + |
|
4632
|
|
|
' dongYlo dogilo dYngilo dYngYlo danxilo donxilo' + |
|
4633
|
|
|
' danilo donilo daniilo doniilo danzilo donzilo') |
|
4634
|
|
|
self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'gen', |
|
4635
|
|
|
'approx', True), |
|
4636
|
|
|
'angilo ongilo anxilo onxilo anzilo onzilo') |
|
4637
|
|
|
self.assertEqual(bmpm('1234', '', 'gen', 'approx', True), '') |
|
4638
|
|
|
|
|
4639
|
|
|
# concat is false, ruleType is APPROX |
|
4640
|
|
|
self.assertEqual(bmpm('Angelo', '', 'gen', 'approx', False), |
|
4641
|
|
|
'angilo angYlo agilo ongilo ongYlo ogilo Yngilo' + |
|
4642
|
|
|
' YngYlo anxilo onxilo anilo onilo aniilo oniilo' + |
|
4643
|
|
|
' anzilo onzilo') |
|
4644
|
|
|
self.assertEqual(bmpm('D\'Angelo', '', 'gen', 'approx', False), |
|
4645
|
|
|
'angilo angYlo agilo ongilo ongYlo ogilo Yngilo' + |
|
4646
|
|
|
' YngYlo anxilo onxilo anilo onilo aniilo oniilo' + |
|
4647
|
|
|
' anzilo onzilo dangilo dangYlo dagilo dongilo' + |
|
4648
|
|
|
' dongYlo dogilo dYngilo dYngYlo danxilo donxilo' + |
|
4649
|
|
|
' danilo donilo daniilo doniilo danzilo donzilo') |
|
4650
|
|
|
self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'gen', |
|
4651
|
|
|
'approx', False), |
|
4652
|
|
|
'angilo ongilo anxilo onxilo anzilo onzilo') |
|
4653
|
|
|
self.assertEqual(bmpm('1234', '', 'gen', 'approx', False), '') |
|
4654
|
|
|
|
|
4655
|
|
|
# testSolrASHKENAZI |
|
4656
|
|
|
# concat is true, ruleType is EXACT |
|
4657
|
|
|
self.assertEqual(bmpm('Angelo', '', 'ash', 'exact', True), |
|
4658
|
|
|
'angelo andZelo anhelo anxelo') |
|
4659
|
|
|
self.assertEqual(bmpm('D\'Angelo', '', 'ash', 'exact', True), |
|
4660
|
|
|
'dangelo dandZelo danhelo danxelo') |
|
4661
|
|
|
self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
|
4662
|
|
|
'ash', 'exact', True) |
|
4663
|
|
|
self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'ash', |
|
4664
|
|
|
'exact', True, True), 'anxelo angelo') |
|
4665
|
|
|
self.assertEqual(bmpm('1234', '', 'ash', 'exact', True), '') |
|
4666
|
|
|
|
|
4667
|
|
|
# concat is false, ruleType is EXACT |
|
4668
|
|
|
self.assertEqual(bmpm('Angelo', '', 'ash', 'exact', False), |
|
4669
|
|
|
'angelo andZelo anhelo anxelo') |
|
4670
|
|
|
self.assertEqual(bmpm('D\'Angelo', '', 'ash', 'exact', False), |
|
4671
|
|
|
'dangelo dandZelo danhelo danxelo') |
|
4672
|
|
|
self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
|
4673
|
|
|
'ash', 'exact', False) |
|
4674
|
|
|
self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'ash', |
|
4675
|
|
|
'exact', False, True), 'anxelo angelo') |
|
4676
|
|
|
self.assertEqual(bmpm('1234', '', 'ash', 'exact', False), '') |
|
4677
|
|
|
|
|
4678
|
|
|
# concat is true, ruleType is APPROX |
|
4679
|
|
|
self.assertEqual(bmpm('Angelo', '', 'ash', 'approx', True), |
|
4680
|
|
|
'angilo angYlo ongilo ongYlo Yngilo YngYlo anzilo' + |
|
4681
|
|
|
' onzilo anilo onilo anxilo onxilo') |
|
4682
|
|
|
self.assertEqual(bmpm('D\'Angelo', '', 'ash', 'approx', True), |
|
4683
|
|
|
'dangilo dangYlo dongilo dongYlo dYngilo dYngYlo' + |
|
4684
|
|
|
' danzilo donzilo danilo donilo danxilo donxilo') |
|
4685
|
|
|
self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
|
4686
|
|
|
'ash', 'approx', True) |
|
4687
|
|
|
self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'ash', |
|
4688
|
|
|
'approx', True, True), |
|
4689
|
|
|
'anxYlo anxilo onxYlo onxilo angYlo angilo ongYlo' + |
|
4690
|
|
|
' ongilo') |
|
4691
|
|
|
self.assertEqual(bmpm('1234', '', 'ash', 'approx', True), '') |
|
4692
|
|
|
|
|
4693
|
|
|
# concat is false, ruleType is APPROX |
|
4694
|
|
|
self.assertEqual(bmpm('Angelo', '', 'ash', 'approx', False), |
|
4695
|
|
|
'angilo angYlo ongilo ongYlo Yngilo YngYlo anzilo' + |
|
4696
|
|
|
' onzilo anilo onilo anxilo onxilo') |
|
4697
|
|
|
self.assertEqual(bmpm('D\'Angelo', '', 'ash', 'approx', False), |
|
4698
|
|
|
'dangilo dangYlo dongilo dongYlo dYngilo dYngYlo' + |
|
4699
|
|
|
' danzilo donzilo danilo donilo danxilo donxilo') |
|
4700
|
|
|
self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
|
4701
|
|
|
'ash', 'approx', False) |
|
4702
|
|
|
self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'ash', |
|
4703
|
|
|
'approx', False, True), |
|
4704
|
|
|
'anxYlo anxilo onxYlo onxilo angYlo angilo ongYlo' + |
|
4705
|
|
|
' ongilo') |
|
4706
|
|
|
self.assertEqual(bmpm('1234', '', 'ash', 'approx', False), '') |
|
4707
|
|
|
|
|
4708
|
|
|
# testSolrSEPHARDIC |
|
4709
|
|
|
# concat is true, ruleType is EXACT |
|
4710
|
|
|
self.assertEqual(bmpm('Angelo', '', 'sep', 'exact', True), |
|
4711
|
|
|
'anZelo andZelo anxelo') |
|
4712
|
|
|
self.assertEqual(bmpm('D\'Angelo', '', 'sep', 'exact', True), |
|
4713
|
|
|
'anZelo andZelo anxelo') |
|
4714
|
|
|
self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
|
4715
|
|
|
'sep', 'exact', True) |
|
4716
|
|
|
self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'sep', |
|
4717
|
|
|
'exact', True, True), |
|
4718
|
|
|
'andZelo anxelo') |
|
4719
|
|
|
self.assertEqual(bmpm('1234', '', 'sep', 'exact', True), '') |
|
4720
|
|
|
|
|
4721
|
|
|
# concat is false, ruleType is EXACT |
|
4722
|
|
|
self.assertEqual(bmpm('Angelo', '', 'sep', 'exact', False), |
|
4723
|
|
|
'anZelo andZelo anxelo') |
|
4724
|
|
|
self.assertEqual(bmpm('D\'Angelo', '', 'sep', 'exact', False), |
|
4725
|
|
|
'anZelo andZelo anxelo') |
|
4726
|
|
|
self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
|
4727
|
|
|
'sep', 'exact', False) |
|
4728
|
|
|
self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'sep', |
|
4729
|
|
|
'exact', False, True), 'andZelo anxelo') |
|
4730
|
|
|
self.assertEqual(bmpm('1234', '', 'sep', 'exact', False), '') |
|
4731
|
|
|
|
|
4732
|
|
|
# concat is true, ruleType is APPROX |
|
4733
|
|
|
self.assertEqual(bmpm('Angelo', '', 'sep', 'approx', True), |
|
4734
|
|
|
'anzila anzilu nzila nzilu anhila anhilu nhila nhilu') |
|
4735
|
|
|
self.assertEqual(bmpm('D\'Angelo', '', 'sep', 'approx', True), |
|
4736
|
|
|
'anzila anzilu nzila nzilu anhila anhilu nhila nhilu') |
|
4737
|
|
|
self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
|
4738
|
|
|
'sep', 'approx', True) |
|
4739
|
|
|
self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'sep', |
|
4740
|
|
|
'approx', True, True), |
|
4741
|
|
|
'anzila anzilu nzila nzilu anhila anhilu nhila nhilu') |
|
4742
|
|
|
self.assertEqual(bmpm('1234', '', 'sep', 'approx', True), '') |
|
4743
|
|
|
|
|
4744
|
|
|
# concat is false, ruleType is APPROX |
|
4745
|
|
|
self.assertEqual(bmpm('Angelo', '', 'sep', 'approx', False), |
|
4746
|
|
|
'anzila anzilu nzila nzilu anhila anhilu nhila nhilu') |
|
4747
|
|
|
self.assertEqual(bmpm('D\'Angelo', '', 'sep', 'approx', False), |
|
4748
|
|
|
'anzila anzilu nzila nzilu anhila anhilu nhila nhilu') |
|
4749
|
|
|
self.assertRaises(ValueError, bmpm, 'Angelo', 'italian,greek,spanish', |
|
4750
|
|
|
'sep', 'approx', False) |
|
4751
|
|
|
self.assertEqual(bmpm('Angelo', 'italian,greek,spanish', 'sep', |
|
4752
|
|
|
'approx', False, True), |
|
4753
|
|
|
'anzila anzilu nzila nzilu anhila anhilu nhila nhilu') |
|
4754
|
|
|
self.assertEqual(bmpm('1234', '', 'sep', 'approx', False), '') |
|
4755
|
|
|
|
|
4756
|
|
|
# testCompatibilityWithOriginalVersion |
|
4757
|
|
|
self.assertEqual(bmpm('abram', '', 'gen', 'approx', False), |
|
4758
|
|
|
'abram abrom avram avrom obram obrom ovram ovrom' + |
|
4759
|
|
|
' Ybram Ybrom abran abron obran obron') |
|
4760
|
|
|
self.assertEqual(bmpm('Bendzin', '', 'gen', 'approx', False), |
|
4761
|
|
|
'binzn bindzn vindzn bintsn vintsn') |
|
4762
|
|
|
self.assertEqual(bmpm('abram', '', 'ash', 'approx', False), |
|
4763
|
|
|
'abram abrom avram avrom obram obrom ovram ovrom' + |
|
4764
|
|
|
' Ybram Ybrom ombram ombrom imbram imbrom') |
|
4765
|
|
|
self.assertEqual(bmpm('Halpern', '', 'ash', 'approx', False), |
|
4766
|
|
|
'alpirn alpYrn olpirn olpYrn Ylpirn YlpYrn xalpirn' + |
|
4767
|
|
|
' xolpirn') |
|
4768
|
|
|
|
|
4769
|
|
|
# PhoneticEngineTest |
|
4770
|
|
|
self.assertEqual(bmpm('Renault', '', 'gen', 'approx', True), |
|
4771
|
|
|
'rinolt rino rinDlt rinalt rinult rinD rina rinu') |
|
4772
|
|
|
self.assertEqual(bmpm('Renault', '', 'ash', 'approx', True), |
|
4773
|
|
|
'rinDlt rinalt rinult rYnDlt rYnalt rYnult rinolt') |
|
4774
|
|
|
self.assertEqual(bmpm('Renault', '', 'sep', 'approx', True), |
|
4775
|
|
|
'rinDlt') |
|
4776
|
|
|
self.assertEqual(bmpm('SntJohn-Smith', '', 'gen', 'exact', True), |
|
4777
|
|
|
'sntjonsmit') |
|
4778
|
|
|
self.assertEqual(bmpm('d\'ortley', '', 'gen', 'exact', True), |
|
4779
|
|
|
'ortlaj ortlej dortlaj dortlej') |
|
4780
|
|
|
self.assertEqual(bmpm('van helsing', '', 'gen', 'exact', False), |
|
4781
|
|
|
'helSink helsink helzink xelsink elSink elsink' + |
|
4782
|
|
|
' vanhelsink vanhelzink vanjelsink fanhelsink' + |
|
4783
|
|
|
' fanhelzink banhelsink') |
|
4784
|
|
|
|
|
4785
|
|
|
def test_bmpm_misc(self): |
|
4786
|
|
|
"""Test abydos.phonetic.bmpm (miscellaneous tests). |
|
4787
|
|
|
|
|
4788
|
|
|
The purpose of this test set is to achieve higher code coverage |
|
4789
|
|
|
and to hit some of the test cases noted in the BMPM reference code. |
|
4790
|
|
|
""" |
|
4791
|
|
|
# test of Ashkenazi with discardable prefix |
|
4792
|
|
|
self.assertEqual(bmpm('bar Hayim', name_mode='ash'), 'Dm xDm') |
|
4793
|
|
|
|
|
4794
|
|
|
# tests of concat behavior |
|
4795
|
|
|
self.assertEqual(bmpm('Rodham Clinton', concat=False), |
|
4796
|
|
|
'rodam rodom rYdam rYdom rodan rodon rodxam rodxom' + |
|
4797
|
|
|
' rodxan rodxon rudam rudom klinton klnton klintun' + |
|
4798
|
|
|
' klntun tzlinton tzlnton tzlintun tzlntun zlinton' + |
|
4799
|
|
|
' zlnton') |
|
4800
|
|
|
self.assertEqual(bmpm('Rodham Clinton', concat=True), |
|
4801
|
|
|
'rodamklinton rodomklinton rodamklnton rodomklnton' + |
|
4802
|
|
|
' rodamklintun rodomklintun rodamklntun rodomklntun' + |
|
4803
|
|
|
' rodamtzlinton rodomtzlinton rodamtzlnton' + |
|
4804
|
|
|
' rodomtzlnton rodamtzlintun rodomtzlintun' + |
|
4805
|
|
|
' rodamtzlntun rodomtzlntun rodamzlinton' + |
|
4806
|
|
|
' rodomzlinton rodamzlnton rodomzlnton rodanklinton' + |
|
4807
|
|
|
' rodonklinton rodanklnton rodonklnton' + |
|
4808
|
|
|
' rodxamklinton rodxomklinton rodxamklnton' + |
|
4809
|
|
|
' rodxomklnton rodxanklinton rodxonklinton' + |
|
4810
|
|
|
' rodxanklnton rodxonklnton rudamklinton' + |
|
4811
|
|
|
' rudomklinton rudamklnton rudomklnton rudamklintun' + |
|
4812
|
|
|
' rudomklintun rudamklntun rudomklntun' + |
|
4813
|
|
|
' rudamtzlinton rudomtzlinton rudamtzlnton' + |
|
4814
|
|
|
' rudomtzlnton rudamtzlintun rudomtzlintun' + |
|
4815
|
|
|
' rudamtzlntun rudomtzlntun') |
|
4816
|
|
|
|
|
4817
|
|
|
# tests of name_mode values |
|
4818
|
|
|
self.assertEqual(bmpm('bar Hayim', name_mode='ash'), 'Dm xDm') |
|
4819
|
|
|
self.assertEqual(bmpm('bar Hayim', name_mode='ashkenazi'), 'Dm xDm') |
|
4820
|
|
|
self.assertEqual(bmpm('bar Hayim', name_mode='Ashkenazi'), 'Dm xDm') |
|
4821
|
|
|
self.assertEqual(bmpm('bar Hayim', name_mode='gen', concat=True), |
|
4822
|
|
|
'barDm borDm bYrDm varDm vorDm barDn borDn barxDm' + |
|
4823
|
|
|
' borxDm varxDm vorxDm barxDn borxDn') |
|
4824
|
|
|
self.assertEqual(bmpm('bar Hayim', name_mode='general', concat=True), |
|
4825
|
|
|
'barDm borDm bYrDm varDm vorDm barDn borDn barxDm' + |
|
4826
|
|
|
' borxDm varxDm vorxDm barxDn borxDn') |
|
4827
|
|
|
self.assertEqual(bmpm('bar Hayim', name_mode='Mizrahi', concat=True), |
|
4828
|
|
|
'barDm borDm bYrDm varDm vorDm barDn borDn barxDm' + |
|
4829
|
|
|
' borxDm varxDm vorxDm barxDn borxDn') |
|
4830
|
|
|
self.assertEqual(bmpm('bar Hayim', name_mode='mizrahi', concat=True), |
|
4831
|
|
|
'barDm borDm bYrDm varDm vorDm barDn borDn barxDm' + |
|
4832
|
|
|
' borxDm varxDm vorxDm barxDn borxDn') |
|
4833
|
|
|
self.assertEqual(bmpm('bar Hayim', name_mode='miz', concat=True), |
|
4834
|
|
|
'barDm borDm bYrDm varDm vorDm barDn borDn barxDm' + |
|
4835
|
|
|
' borxDm varxDm vorxDm barxDn borxDn') |
|
4836
|
|
|
|
|
4837
|
|
|
# test that out-of-range langauge_arg results in L_ANY |
|
4838
|
|
|
self.assertEqual(bmpm('Rodham Clinton', language_arg=2**32), |
|
4839
|
|
|
'rodam rodom rYdam rYdom rodan rodon rodxam rodxom' + |
|
4840
|
|
|
' rodxan rodxon rudam rudom klinton klnton klintun' + |
|
4841
|
|
|
' klntun tzlinton tzlnton tzlintun tzlntun zlinton' + |
|
4842
|
|
|
' zlnton') |
|
4843
|
|
|
self.assertEqual(bmpm('Rodham Clinton', language_arg=-4), |
|
4844
|
|
|
'rodam rodom rYdam rYdom rodan rodon rodxam rodxom' + |
|
4845
|
|
|
' rodxan rodxon rudam rudom klinton klnton klintun' + |
|
4846
|
|
|
' klntun tzlinton tzlnton tzlintun tzlntun zlinton' + |
|
4847
|
|
|
' zlnton') |
|
4848
|
|
|
|
|
4849
|
|
|
# etc. (for code coverage) |
|
4850
|
|
|
self.assertEqual(bmpm('van Damme', name_mode='sep'), 'dami mi dam m') |
|
4851
|
|
|
|
|
4852
|
|
View Code Duplication |
def test_bmpm_nachnamen(self): |
|
|
|
|
|
|
4853
|
|
|
"""Test abydos.phonetic.bmpm (Nachnamen set).""" |
|
4854
|
|
|
if not ALLOW_RANDOM: |
|
4855
|
|
|
return |
|
4856
|
|
|
with codecs.open(TESTDIR + '/corpora/nachnamen.bm.csv', |
|
4857
|
|
|
encoding='utf-8') as nachnamen_testset: |
|
4858
|
|
|
next(nachnamen_testset) |
|
4859
|
|
|
for nn_line in nachnamen_testset: |
|
4860
|
|
|
nn_line = nn_line.strip().split(',') |
|
4861
|
|
|
# This test set is very large (~10000 entries) |
|
4862
|
|
|
# so let's just randomly select about 20 for testing |
|
4863
|
|
|
if nn_line[0] != '#' and one_in(500): |
|
4864
|
|
|
self.assertEqual(bmpm(nn_line[0], language_arg='german'), |
|
4865
|
|
|
nn_line[1]) |
|
4866
|
|
|
self.assertEqual(bmpm(nn_line[0]), nn_line[2]) |
|
4867
|
|
|
|
|
4868
|
|
View Code Duplication |
def test_bmpm_nachnamen_cc(self): |
|
|
|
|
|
|
4869
|
|
|
"""Test abydos.phonetic.bmpm (Nachnamen set, corner cases).""" |
|
4870
|
|
|
with codecs.open(TESTDIR + '/corpora/nachnamen.bm.cc.csv', |
|
4871
|
|
|
encoding='utf-8') as nachnamen_testset: |
|
4872
|
|
|
next(nachnamen_testset) |
|
4873
|
|
|
for nn_line in nachnamen_testset: |
|
4874
|
|
|
nn_line = nn_line.strip().split(',') |
|
4875
|
|
|
# This test set is very large (~10000 entries) |
|
4876
|
|
|
# so let's just randomly select about 20 for testing |
|
4877
|
|
|
if nn_line[0] != '#': |
|
4878
|
|
|
self.assertEqual(bmpm(nn_line[0], language_arg='german'), |
|
4879
|
|
|
nn_line[1]) |
|
4880
|
|
|
self.assertEqual(bmpm(nn_line[0]), nn_line[2]) |
|
4881
|
|
|
|
|
4882
|
|
View Code Duplication |
def test_bmpm_uscensus2000(self): |
|
|
|
|
|
|
4883
|
|
|
"""Test abydos.phonetic.bmpm (US Census 2000 set).""" |
|
4884
|
|
|
if not ALLOW_RANDOM: |
|
4885
|
|
|
return |
|
4886
|
|
|
with open(TESTDIR + '/corpora/uscensus2000.bm.csv') as uscensus_ts: |
|
4887
|
|
|
next(uscensus_ts) |
|
4888
|
|
|
for cen_line in uscensus_ts: |
|
4889
|
|
|
cen_line = cen_line.strip().split(',') |
|
4890
|
|
|
# This test set is very large (~150000 entries) |
|
4891
|
|
|
# so let's just randomly select about 20 for testing |
|
4892
|
|
|
if cen_line[0] != '#' and one_in(7500): |
|
4893
|
|
|
self.assertEqual(bmpm(cen_line[0], match_mode='approx', |
|
4894
|
|
|
name_mode='gen'), cen_line[1]) |
|
4895
|
|
|
self.assertEqual(bmpm(cen_line[0], match_mode='approx', |
|
4896
|
|
|
name_mode='ash'), cen_line[2]) |
|
4897
|
|
|
self.assertEqual(bmpm(cen_line[0], match_mode='approx', |
|
4898
|
|
|
name_mode='sep'), cen_line[3]) |
|
4899
|
|
|
self.assertEqual(bmpm(cen_line[0], match_mode='exact', |
|
4900
|
|
|
name_mode='gen'), cen_line[4]) |
|
4901
|
|
|
self.assertEqual(bmpm(cen_line[0], match_mode='exact', |
|
4902
|
|
|
name_mode='ash'), cen_line[5]) |
|
4903
|
|
|
self.assertEqual(bmpm(cen_line[0], match_mode='exact', |
|
4904
|
|
|
name_mode='sep'), cen_line[6]) |
|
4905
|
|
|
|
|
4906
|
|
View Code Duplication |
def test_bmpm_uscensus2000_cc(self): |
|
|
|
|
|
|
4907
|
|
|
"""Test abydos.phonetic.bmpm (US Census 2000 set, corner cases).""" |
|
4908
|
|
|
with open(TESTDIR + '/corpora/uscensus2000.bm.cc.csv') as uscensus_ts: |
|
4909
|
|
|
next(uscensus_ts) |
|
4910
|
|
|
for cen_line in uscensus_ts: |
|
4911
|
|
|
cen_line = cen_line.strip().split(',') |
|
4912
|
|
|
# This test set is very large (~150000 entries) |
|
4913
|
|
|
# so let's just randomly select about 20 for testing |
|
4914
|
|
|
if cen_line[0] != '#' and one_in(10): |
|
4915
|
|
|
self.assertEqual(bmpm(cen_line[0], match_mode='approx', |
|
4916
|
|
|
name_mode='gen'), cen_line[1]) |
|
4917
|
|
|
self.assertEqual(bmpm(cen_line[0], match_mode='approx', |
|
4918
|
|
|
name_mode='ash'), cen_line[2]) |
|
4919
|
|
|
self.assertEqual(bmpm(cen_line[0], match_mode='approx', |
|
4920
|
|
|
name_mode='sep'), cen_line[3]) |
|
4921
|
|
|
self.assertEqual(bmpm(cen_line[0], match_mode='exact', |
|
4922
|
|
|
name_mode='gen'), cen_line[4]) |
|
4923
|
|
|
self.assertEqual(bmpm(cen_line[0], match_mode='exact', |
|
4924
|
|
|
name_mode='ash'), cen_line[5]) |
|
4925
|
|
|
self.assertEqual(bmpm(cen_line[0], match_mode='exact', |
|
4926
|
|
|
name_mode='sep'), cen_line[6]) |
|
4927
|
|
|
|
|
4928
|
|
|
def test_bm_phonetic_number(self): |
|
4929
|
|
|
"""Test abydos.bm._bm_phonetic_number.""" |
|
4930
|
|
|
self.assertEqual(_bm_phonetic_number(''), '') |
|
4931
|
|
|
self.assertEqual(_bm_phonetic_number('abcd'), 'abcd') |
|
4932
|
|
|
self.assertEqual(_bm_phonetic_number('abcd[123]'), 'abcd') |
|
4933
|
|
|
self.assertEqual(_bm_phonetic_number('abcd[123'), 'abcd') |
|
4934
|
|
|
self.assertEqual(_bm_phonetic_number('abcd['), 'abcd') |
|
4935
|
|
|
self.assertEqual(_bm_phonetic_number('abcd[[[123]]]'), 'abcd') |
|
4936
|
|
|
|
|
4937
|
|
|
def test_bm_apply_rule_if_compat(self): |
|
4938
|
|
|
"""Test abydos.bm._bm_apply_rule_if_compat.""" |
|
4939
|
|
|
self.assertEqual(_bm_apply_rule_if_compat('abc', 'def', 4), 'abcdef') |
|
4940
|
|
|
self.assertEqual(_bm_apply_rule_if_compat('abc', 'def[6]', 4), |
|
4941
|
|
|
'abcdef[4]') |
|
4942
|
|
|
self.assertEqual(_bm_apply_rule_if_compat('abc', 'def[4]', 4), |
|
4943
|
|
|
'abcdef[4]') |
|
4944
|
|
|
self.assertEqual(_bm_apply_rule_if_compat('abc', 'def[0]', 4), None) |
|
4945
|
|
|
self.assertEqual(_bm_apply_rule_if_compat('abc', 'def[8]', 4), None) |
|
4946
|
|
|
self.assertEqual(_bm_apply_rule_if_compat('abc', 'def', 1), 'abcdef') |
|
4947
|
|
|
self.assertEqual(_bm_apply_rule_if_compat('abc', 'def[4]', 1), |
|
4948
|
|
|
'abcdef[4]') |
|
4949
|
|
|
|
|
4950
|
|
|
def test_bm_language(self): |
|
4951
|
|
|
"""Test abydos.bm._bm_language. |
|
4952
|
|
|
|
|
4953
|
|
|
Most test cases from: |
|
4954
|
|
|
http://svn.apache.org/viewvc/commons/proper/codec/trunk/src/test/java/org/apache/commons/codec/language/bm/LanguageGuessingTest.java?view=markup |
|
4955
|
|
|
""" |
|
4956
|
|
|
self.assertEqual(_bm_language('Renault', 'gen'), L_FRENCH) |
|
4957
|
|
|
self.assertEqual(_bm_language('Mickiewicz', 'gen'), L_POLISH) |
|
4958
|
|
|
self.assertEqual(_bm_language('Thompson', 'gen') & L_ENGLISH, |
|
4959
|
|
|
L_ENGLISH) |
|
4960
|
|
|
self.assertEqual(_bm_language('Nuñez', 'gen'), L_SPANISH) |
|
4961
|
|
|
self.assertEqual(_bm_language('Carvalho', 'gen'), L_PORTUGUESE) |
|
4962
|
|
|
self.assertEqual(_bm_language('Čapek', 'gen'), L_CZECH | L_LATVIAN) |
|
4963
|
|
|
self.assertEqual(_bm_language('Sjneijder', 'gen'), L_DUTCH) |
|
4964
|
|
|
self.assertEqual(_bm_language('Klausewitz', 'gen'), L_GERMAN) |
|
4965
|
|
|
self.assertEqual(_bm_language('Küçük', 'gen'), L_TURKISH) |
|
4966
|
|
|
self.assertEqual(_bm_language('Giacometti', 'gen'), L_ITALIAN) |
|
4967
|
|
|
self.assertEqual(_bm_language('Nagy', 'gen'), L_HUNGARIAN) |
|
4968
|
|
|
self.assertEqual(_bm_language('Ceauşescu', 'gen'), L_ROMANIAN) |
|
4969
|
|
|
self.assertEqual(_bm_language('Angelopoulos', 'gen'), L_GREEKLATIN) |
|
4970
|
|
|
self.assertEqual(_bm_language('Αγγελόπουλος', 'gen'), L_GREEK) |
|
4971
|
|
|
self.assertEqual(_bm_language('Пушкин', 'gen'), L_CYRILLIC) |
|
4972
|
|
|
self.assertEqual(_bm_language('כהן', 'gen'), L_HEBREW) |
|
4973
|
|
|
self.assertEqual(_bm_language('ácz', 'gen'), L_ANY) |
|
4974
|
|
|
self.assertEqual(_bm_language('átz', 'gen'), L_ANY) |
|
4975
|
|
|
|
|
4976
|
|
|
def test_bm_expand_alternates(self): |
|
4977
|
|
|
"""Test abydos.bm._bm_expand_alternates.""" |
|
4978
|
|
|
self.assertEqual(_bm_expand_alternates(''), '') |
|
4979
|
|
|
self.assertEqual(_bm_expand_alternates('aa'), 'aa') |
|
4980
|
|
|
self.assertEqual(_bm_expand_alternates('aa|bb'), 'aa|bb') |
|
4981
|
|
|
self.assertEqual(_bm_expand_alternates('aa|aa'), 'aa|aa') |
|
4982
|
|
|
|
|
4983
|
|
|
self.assertEqual(_bm_expand_alternates('(aa)(bb)'), 'aabb') |
|
4984
|
|
|
self.assertEqual(_bm_expand_alternates('(aa)(bb[0])'), '') |
|
4985
|
|
|
self.assertEqual(_bm_expand_alternates('(aa)(bb[4])'), 'aabb[4]') |
|
4986
|
|
|
self.assertEqual(_bm_expand_alternates('(aa[0])(bb)'), '') |
|
4987
|
|
|
self.assertEqual(_bm_expand_alternates('(aa[4])(bb)'), 'aabb[4]') |
|
4988
|
|
|
|
|
4989
|
|
|
self.assertEqual(_bm_expand_alternates('(a|b|c)(a|b|c)'), |
|
4990
|
|
|
'aa|ab|ac|ba|bb|bc|ca|cb|cc') |
|
4991
|
|
|
self.assertEqual(_bm_expand_alternates('(a[1]|b[2])(c|d)'), |
|
4992
|
|
|
'ac[1]|ad[1]|bc[2]|bd[2]') |
|
4993
|
|
|
self.assertEqual(_bm_expand_alternates('(a[1]|b[2])(c[4]|d)'), |
|
4994
|
|
|
'ad[1]|bd[2]') |
|
4995
|
|
|
|
|
4996
|
|
|
def test_bm_remove_dupes(self): |
|
4997
|
|
|
"""Test abydos.bm._bm_remove_dupes.""" |
|
4998
|
|
|
self.assertEqual(_bm_remove_dupes(''), '') |
|
4999
|
|
|
self.assertEqual(_bm_remove_dupes('aa'), 'aa') |
|
5000
|
|
|
self.assertEqual(_bm_remove_dupes('aa|bb'), 'aa|bb') |
|
5001
|
|
|
self.assertEqual(_bm_remove_dupes('aa|aa'), 'aa') |
|
5002
|
|
|
self.assertEqual(_bm_remove_dupes('aa|aa|aa|bb|aa'), 'aa|bb') |
|
5003
|
|
|
self.assertEqual(_bm_remove_dupes('bb|aa|bb|aa|bb'), 'bb|aa') |
|
5004
|
|
|
|
|
5005
|
|
|
def test_bm_normalize_lang_attrs(self): |
|
5006
|
|
|
"""Test abydos.bm._bm_normalize_language_attributes.""" |
|
5007
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('', False), '') |
|
5008
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('', True), '') |
|
5009
|
|
|
|
|
5010
|
|
|
self.assertRaises(ValueError, _bm_normalize_lang_attrs, 'a[1', False) |
|
5011
|
|
|
self.assertRaises(ValueError, _bm_normalize_lang_attrs, 'a[1', True) |
|
5012
|
|
|
|
|
5013
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('abc', False), 'abc') |
|
5014
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('abc[0]', False), '[0]') |
|
5015
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('abc[2]', False), 'abc[2]') |
|
5016
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('abc[2][4]', False), '[0]') |
|
5017
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('abc[2][6]', False), |
|
5018
|
|
|
'abc[2]') |
|
5019
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('ab[2]c[4]', False), '[0]') |
|
5020
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('ab[2]c[6]', False), |
|
5021
|
|
|
'abc[2]') |
|
5022
|
|
|
|
|
5023
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('abc', True), 'abc') |
|
5024
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('abc[0]', True), 'abc') |
|
5025
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('abc[2]', True), 'abc') |
|
5026
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('abc[2][4]', True), 'abc') |
|
5027
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('abc[2][6]', True), 'abc') |
|
5028
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('ab[2]c[4]', True), 'abc') |
|
5029
|
|
|
self.assertEqual(_bm_normalize_lang_attrs('ab[2]c[6]', True), 'abc') |
|
5030
|
|
|
|
|
5031
|
|
|
|
|
5032
|
|
|
if __name__ == '__main__': |
|
5033
|
|
|
unittest.main() |
|
5034
|
|
|
|
chrislit /
abydos
Loading history...