| 
                    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_sv.  | 
            
            
                                                        
            
                                    
            
            
                | 
                    20
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    21
                 | 
                                    
                                                     | 
                
                 | 
                This module contains unit tests for abydos.phonetic.sv  | 
            
            
                                                        
            
                                    
            
            
                | 
                    22
                 | 
                                    
                                                     | 
                
                 | 
                """  | 
            
            
                                                        
            
                                    
            
            
                | 
                    23
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    24
                 | 
                                    
                                                     | 
                
                 | 
                from __future__ import unicode_literals  | 
            
            
                                                        
            
                                    
            
            
                | 
                    25
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    26
                 | 
                                    
                                                     | 
                
                 | 
                import unittest  | 
            
            
                                                        
            
                                    
            
            
                | 
                    27
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    28
                 | 
                                    
                                                     | 
                
                 | 
                from abydos.phonetic.sv import norphone, sfinxbis  | 
            
            
                                                        
            
                                    
            
            
                | 
                    29
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    30
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    31
                 | 
                                    
                                                     | 
                
                 | 
                class SfinxBisTestCases(unittest.TestCase):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    32
                 | 
                                    
                                                     | 
                
                 | 
                    """Test SfinxBis functions.  | 
            
            
                                                        
            
                                    
            
            
                | 
                    33
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    34
                 | 
                                    
                                                     | 
                
                 | 
                    test cases for abydos.phonetic.sfinxbis  | 
            
            
                                                        
            
                                    
            
            
                | 
                    35
                 | 
                                    
                                                     | 
                
                 | 
                    """  | 
            
            
                                                        
            
                                    
            
            
                | 
                    36
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    37
                 | 
                                    
                                                     | 
                
                 | 
                    def test_sfinxbis(self):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    38
                 | 
                                    
                                                     | 
                
                 | 
                        """Test abydos.phonetic.sfinxbis."""  | 
            
            
                                                        
            
                                    
            
            
                | 
                    39
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis(''), ('',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    40
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    41
                 | 
                                    
                                                     | 
                
                 | 
                        # http://www.swami.se/download/18.248ad5af12aa81365338000106/TestSfinx.txt  | 
            
            
                                                        
            
                                    
            
            
                | 
                    42
                 | 
                                    
                                                     | 
                
                 | 
                        # cases where the gold standard gave clearly wrong values have been  | 
            
            
                                                        
            
                                    
            
            
                | 
                    43
                 | 
                                    
                                                     | 
                
                 | 
                        # corrected below (marked with '# wrong'  | 
            
            
                                                        
            
                                    
            
            
                | 
                    44
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('af Sandeberg'), ('S53162',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    45
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('av Ekenstam'), ('$25835',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    46
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Da Costa'), ('K83',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    47
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Das Neves'), ('D8', 'N78')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    48
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('de Besche'), ('B8',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    49
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('de la Motte'), ('M3',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    50
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('de Las Heras'), ('H68',))  # wrong | 
            
            
                                                        
            
                                    
            
            
                | 
                    51
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('de Los Santos'), ('S538',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    52
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('del Rosario'), ('R862',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    53
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Den Boer'), ('B6',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    54
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Der de Kazinczy'), | 
            
            
                                                        
            
                                    
            
            
                | 
                    55
                 | 
                                    
                                                     | 
                
                 | 
                                         ('D6', 'K8528',))  # wrong | 
            
            
                                                        
            
                                    
            
            
                | 
                    56
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('des Rieux'), ('R28',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    57
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Di Luca'), ('L2',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    58
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Do Rosario'), ('R862',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    59
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Don Lind'), ('L53',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    60
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Dos Santos'), ('S538',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    61
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('du Rietz'), ('R38',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    62
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('in de Betou'), ('B3',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    63
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('La Fleur'), ('F46',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    64
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Le Grand'), ('G653',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    65
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('li Puma'), ('L', 'P5')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    66
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('lo Martire'), ('L', 'M636')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    67
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('mac Donald'), ('D543',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    68
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('mc Intosh'), ('$538',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    69
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('S:t Cyr'), ('S6',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    70
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Van Doom'), ('D5',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    71
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Van de Peppel'), ('P14',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    72
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Van den Berg'), ('B62',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    73
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Van Der Kwast'), ('K783',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    74
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('von Ahn'), ('$5',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    75
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('von Dem Knesebeck'), ('K5812',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    76
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('von Der Burg'), ('B62',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    77
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('D\'Angelo'), ('D524',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    78
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('O\'Conner'), ('$256',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    79
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Los'), ('L8',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    80
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Mac'), ('M2',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    81
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Till'), ('T4',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    82
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Van'), ('V5',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    83
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Von'), ('V5',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    84
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Bernadotte af Wisborg'), ('B6533', 'V8162')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    85
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Hjort af Ornäs'), ('J63', '$658')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    86
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Horn af Åminne'), ('H65', '$55')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    87
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Horn av Åminne'), ('H65', '$55')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    88
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Hård af Segerstad'), ('H63', 'S26833')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    89
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Hård av Segerstad'), ('H63', 'S26833')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    90
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Stael von Holstein'), ('S34', 'H48325')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    91
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('de Oliveira e Silva'), ('$4726', 'S47')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    92
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('de Alfaro y Gómez'), ('$476', 'G58')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    93
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Arjaliès-de la Lande'), ('$6248', 'L53')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    94
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Dominicus van den Bussche'), | 
            
            
                                                        
            
                                    
            
            
                | 
                    95
                 | 
                                    
                                                     | 
                
                 | 
                                         ('D5528', 'B8')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    96
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Edebol Eeg-Olofsson'), | 
            
            
                                                        
            
                                    
            
            
                | 
                    97
                 | 
                                    
                                                     | 
                
                 | 
                                         ('$314', '$2', '$4785')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    98
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Jonsson-Blomqvist'), ('J585', 'B452783')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    99
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Kiviniemi Birgersson'), ('#755', 'B62685')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    100
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Massena Serpa dos Santos'), | 
            
            
                                                        
            
                                    
            
            
                | 
                    101
                 | 
                                    
                                                     | 
                
                 | 
                                         ('M85', 'S61', 'S538')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    102
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('S:t Clair Renard'), ('K426', 'R563')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    103
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Skoog H Andersson'), ('S22', 'H', '$53685')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    104
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('von Post-Skagegård'), ('P83', 'S22263')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    105
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('von Zur-Mühlen'), ('S6', 'M45')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    106
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Waltå O:son'), ('V43', '$85')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    107
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Zardán Gómez de la Torre'), | 
            
            
                                                        
            
                                    
            
            
                | 
                    108
                 | 
                                    
                                                     | 
                
                 | 
                                         ('S635', 'G58', 'T6')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    109
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('af Jochnick'), ('J252',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    110
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('af Ioscnick'), ('J8252',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    111
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Aabakken'), ('$125',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    112
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Åbacken'), ('$125',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    113
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Ahlen'), ('$45',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    114
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Aleen'), ('$45',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    115
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Braunerhielm'), ('B656245',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    116
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Branneerhielm'), ('B656245',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    117
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Carlzon'), ('K6485',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    118
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Karlsson'), ('K6485',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    119
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Enochsson'), ('$5285',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    120
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Ericsson'), ('$6285',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    121
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Ericksson'), ('$6285',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    122
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Erixson'), ('$6285',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    123
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Filipsson'), ('F4185',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    124
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Philipson'), ('F4185',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    125
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Flycht'), ('F423',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    126
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Flygt'), ('F423',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    127
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Flykt'), ('F423',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    128
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Fröijer'), ('F626',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    129
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Fröjer'), ('F626',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    130
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Gertner'), ('J6356',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    131
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Hiertner'), ('J6356',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    132
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Hirch'), ('H62',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    133
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Hirsch'), ('H68',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    134
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Haegermarck'), ('H26562',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    135
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Hägermark'), ('H26562',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    136
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Isaxon'), ('$8285',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    137
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Isacsson'), ('$8285',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    138
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Joachimsson'), ('J2585',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    139
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Joakimson'), ('J2585',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    140
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Kjell'), ('#4',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    141
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Käll'), ('#4',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    142
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Knapp'), ('K51',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    143
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Krans'), ('K658',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    144
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Krantz'), ('K6538',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    145
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Kvist'), ('K783',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    146
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Quist'), ('K783',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    147
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Lidbeck'), ('L312',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    148
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Lidbäck'), ('L312',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    149
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Linnér'), ('L56',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    150
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Linner'), ('L56',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    151
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Lorenzsonn'), ('L6585',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    152
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Lorentzon'), ('L65385',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    153
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Lorenßon'), ('L6585',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    154
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Lyxell'), ('L284',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    155
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Lycksell'), ('L284',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    156
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Marcström'), ('M628365',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    157
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Markström'), ('M628365',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    158
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Michaelsson'), ('M2485',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    159
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Mikaelson'), ('M2485',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    160
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Mörch'), ('M62',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    161
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Mörck'), ('M62',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    162
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Mörk'), ('M62',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    163
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Mørk'), ('M62',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    164
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Nääs'), ('N8',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    165
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Naess'), ('N8',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    166
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Nordstedt'), ('N63833',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    167
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Oxenstierna'), ('$28583265',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    168
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Palmçrañtz'), ('P4526538',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    169
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Palmcrantz'), ('P4526538',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    170
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Palmkrantz'), ('P4526538',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    171
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Preuss'), ('P68',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    172
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Preutz'), ('P638',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    173
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Richardson'), ('R26385',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    174
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Rikardson'), ('R26385',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    175
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Ruuth'), ('R3',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    176
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Ruth'), ('R3',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    177
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Sæter'), ('S36',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    178
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Zäter'), ('S36',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    179
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Schedin'), ('#35',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    180
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Sjödin'), ('#35',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    181
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Siöö'), ('#',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    182
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Sjöh'), ('#',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    183
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Svedberg'), ('S73162',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    184
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Zwedberg'), ('S73162',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    185
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Tjäder'), ('#36',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    186
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('þornquist'), ('T652783',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    187
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Thörnqvist'), ('T652783',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    188
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Törnkvist'), ('T652783',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    189
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Wichman'), ('V255',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    190
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Wickman'), ('V255',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    191
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Wictorin'), ('V2365',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    192
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Wictorsson'), ('V23685',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    193
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Viktorson'), ('V23685',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    194
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Zachrisson'), ('S2685',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    195
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Zakrison'), ('S2685',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    196
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Övragård'), ('$76263',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    197
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Öfvragårdh'), ('$76263',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    198
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Bogdanovic'), ('B23572',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    199
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Bogdanovitch'), ('B235732',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    200
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Dieterich'), ('D362',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    201
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Eichorn'), ('$265',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    202
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Friedrich'), ('F6362',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    203
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Grantcharova'), ('G653267',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    204
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Ilichev'), ('$427',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    205
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Ivankovic'), ('$75272',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    206
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Ivangurich'), ('$75262',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    207
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Kinch'), ('#52',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    208
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Kirchmann'), ('#6255',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    209
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Machado'), ('M23',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    210
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Reich'), ('R2',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    211
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Roche'), ('R2',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    212
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Rubaszkin'), ('R1825',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    213
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Rubaschkin'), ('R1825',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    214
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Sanchez'), ('S528',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    215
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Walukiewicz'), ('V42728',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    216
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Valukievitch'), ('V42732',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    217
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('K'), ('K',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    218
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('2010'), ('',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    219
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('cese'), ('S8',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    220
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    221
                 | 
                                    
                                                     | 
                
                 | 
                        # a few max_length tests  | 
            
            
                                                        
            
                                    
            
            
                | 
                    222
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Kiviniemi Birgersson', 3), ('#75', 'B62')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    223
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Eichorn', 4), ('$265',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    224
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Friedrich', 4), ('F636',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    225
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Grantcharova', 4), ('G653',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    226
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Ilichev', 4), ('$427',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    227
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Ivankovic', 4), ('$752',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    228
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Ivangurich', 4), ('$752',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    229
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Kinch', 4), ('#52',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    230
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Kirchmann', 4), ('#625',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    231
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Machado', 4), ('M23',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    232
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Reich', 4), ('R2',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    233
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Roche', 4), ('R2',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    234
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Rubaszkin', 4), ('R182',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    235
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Rubaschkin', 4), ('R182',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    236
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Sanchez', 4), ('S528',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    237
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Walukiewicz', 4), ('V427',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    238
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Valukievitch', 4), ('V427',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    239
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('K', 4), ('K',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    240
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('2010', 4), ('',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    241
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('cese', 4), ('S8',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    242
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    243
                 | 
                                    
                                                     | 
                
                 | 
                        # etc. (for code coverage)  | 
            
            
                                                        
            
                                    
            
            
                | 
                    244
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('chans'), ('#58',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    245
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('ljud'), ('J3',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    246
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('qi'), ('K',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    247
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('xavier'), ('S76',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    248
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('skjul'), ('#4',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    249
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('schul'), ('#4',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    250
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('skil'), ('#4',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    251
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    252
                 | 
                                    
                                                     | 
                
                 | 
                        # max_length bounds tests  | 
            
            
                                                        
            
                                    
            
            
                | 
                    253
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Niall', max_length=-1), ('N4',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    254
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(sfinxbis('Niall', max_length=0), ('N4',)) | 
            
            
                                                        
            
                                    
            
            
                | 
                    255
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    256
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    257
                 | 
                                    
                                                     | 
                
                 | 
                class NorphoneTestCases(unittest.TestCase):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    258
                 | 
                                    
                                                     | 
                
                 | 
                    """Test Norphone functions.  | 
            
            
                                                        
            
                                    
            
            
                | 
                    259
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    260
                 | 
                                    
                                                     | 
                
                 | 
                    test cases for abydos.phonetic.norphone  | 
            
            
                                                        
            
                                    
            
            
                | 
                    261
                 | 
                                    
                                                     | 
                
                 | 
                    """  | 
            
            
                                                        
            
                                    
            
            
                | 
                    262
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    263
                 | 
                                    
                                                     | 
                
                 | 
                    def test_norphone(self):  | 
            
            
                                                        
            
                                    
            
            
                | 
                    264
                 | 
                                    
                                                     | 
                
                 | 
                        """Test abydos.phonetic.norphone."""  | 
            
            
                                                        
            
                                    
            
            
                | 
                    265
                 | 
                                    
                                                     | 
                
                 | 
                        # Base case  | 
            
            
                                                        
            
                                    
            
            
                | 
                    266
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone(''), '') | 
            
            
                                                        
            
                                    
            
            
                | 
                    267
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    268
                 | 
                                    
                                                     | 
                
                 | 
                        # Examples given at  | 
            
            
                                                        
            
                                    
            
            
                | 
                    269
                 | 
                                    
                                                     | 
                
                 | 
                        # https://github.com/larsga/Duke/blob/master/duke-core/src/test/java/no/priv/garshol/duke/comparators/NorphoneComparatorTest.java  | 
            
            
                                                        
            
                                    
            
            
                | 
                    270
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Aarestad'), norphone('\u00C5rrestad')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    271
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Andreasen'), norphone('Andreassen')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    272
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Arntsen'), norphone('Arntzen')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    273
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Bache'), norphone('Bakke')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    274
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Frank'), norphone('Franck')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    275
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Christian'), norphone('Kristian')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    276
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Kielland'), norphone('Kjelland')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    277
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Krogh'), norphone('Krog')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    278
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Krog'), norphone('Krohg')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    279
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Jendal'), norphone('Jendahl')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    280
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Jendal'), norphone('Hjendal')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    281
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Jendal'), norphone('Gjendal')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    282
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Vold'), norphone('Wold')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    283
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Thomas'), norphone('Tomas')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    284
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Aamodt'), norphone('Aamot')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    285
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Aksel'), norphone('Axel')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    286
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Kristoffersen'), norphone('Christophersen')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    287
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Voll'), norphone('Vold')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    288
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Granli'), norphone('Granlid')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    289
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Gjever'), norphone('Giever')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    290
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Sannerhaugen'), norphone('Sanderhaugen')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    291
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Jahren'), norphone('Jaren')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    292
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Amundsrud'), norphone('Amundsr\u00F8d')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    293
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Karlson'), norphone('Carlson')) | 
            
            
                                                        
            
                                    
            
            
                | 
                    294
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    295
                 | 
                                    
                                                     | 
                
                 | 
                        # Additional tests to increase coverage  | 
            
            
                                                        
            
                                    
            
            
                | 
                    296
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Århus'), 'ÅRHS') | 
            
            
                                                        
            
                                    
            
            
                | 
                    297
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Skyrim'), 'XRM') | 
            
            
                                                        
            
                                    
            
            
                | 
                    298
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('kyss'), 'XS') | 
            
            
                                                        
            
                                    
            
            
                | 
                    299
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Äthelwulf'), 'ÆTLVLF') | 
            
            
                                                        
            
                                    
            
            
                | 
                    300
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('eit'), 'ÆT') | 
            
            
                                                        
            
                                    
            
            
                | 
                    301
                 | 
                                    
                                                     | 
                
                 | 
                        self.assertEqual(norphone('Öl'), 'ØL') | 
            
            
                                                        
            
                                    
            
            
                | 
                    302
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    303
                 | 
                                    
                                                     | 
                
                 | 
                        # test cases by larsga (the algorithm's author) posted to Reddit  | 
            
            
                                                        
            
                                    
            
            
                | 
                    304
                 | 
                                    
                                                     | 
                
                 | 
                        # https://www.reddit.com/r/norge/comments/vksb5/norphone_mitt_forslag_til_en_norsk_soundex_vel/  | 
            
            
                                                        
            
                                    
            
            
                | 
                    305
                 | 
                                    
                                                     | 
                
                 | 
                        # modified, where necessary to match the "not implemented" rules  | 
            
            
                                                        
            
                                    
            
            
                | 
                    306
                 | 
                                    
                                                     | 
                
                 | 
                        # and rule added after the Reddit post  | 
            
            
                                                        
            
                                    
            
            
                | 
                    307
                 | 
                                    
                                                     | 
                
                 | 
                        reddit_tests = (('MKLSN', ('MICHALSEN', 'MIKKELSEN', 'MIKALSEN', | 
            
            
                                                        
            
                                    
            
            
                | 
                    308
                 | 
                                    
                                                     | 
                
                 | 
                                                   'MICHAELSEN', 'MIKAELSEN', 'MICKAELSEN',  | 
            
            
                                                        
            
                                    
            
            
                | 
                    309
                 | 
                                    
                                                     | 
                
                 | 
                                                   'MICHELSEN', 'MIKELSEN')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    310
                 | 
                                    
                                                     | 
                
                 | 
                                        ('BRKR', ('BERGER', 'BORGERUD', 'BURGER', 'BORGER', | 
            
            
                                                        
            
                                    
            
            
                | 
                    311
                 | 
                                    
                                                     | 
                
                 | 
                                                  'BORGAR', 'BIRGER', 'BRAGER', 'BERGERUD')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    312
                 | 
                                    
                                                     | 
                
                 | 
                                        ('TMS', ('TOMMAS', 'THOMAS', 'THAMS', 'TOUMAS', | 
            
            
                                                        
            
                                    
            
            
                | 
                    313
                 | 
                                    
                                                     | 
                
                 | 
                                                 'THOMMAS', 'TIMMS', 'TOMAS', 'TUOMAS')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    314
                 | 
                                    
                                                     | 
                
                 | 
                                        ('HLR', ('HOLER', 'HELLERUD', 'HALLRE', 'HOLLERUD', | 
            
            
                                                        
            
                                    
            
            
                | 
                    315
                 | 
                                    
                                                     | 
                
                 | 
                                                 'HILLER', 'HALLERUD', 'HOLLER', 'HALLER')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    316
                 | 
                                    
                                                     | 
                
                 | 
                                        ('MS', ('MASS', 'MMS', 'MSS', 'MOES', 'MEZZO', 'MESA', | 
            
            
                                                        
            
                                    
            
            
                | 
                    317
                 | 
                                    
                                                     | 
                
                 | 
                                                'MESSE', 'MOSS')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    318
                 | 
                                    
                                                     | 
                
                 | 
                                        ('HRST', ('HIRSTI', 'HAARSETH', 'HAARSTAD', 'HARSTAD', | 
            
            
                                                        
            
                                    
            
            
                | 
                    319
                 | 
                                    
                                                     | 
                
                 | 
                                                  'HARESTUA', 'HERSETH', 'HERSTAD',  | 
            
            
                                                        
            
                                    
            
            
                | 
                    320
                 | 
                                    
                                                     | 
                
                 | 
                                                  'HERSTUA')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    321
                 | 
                                    
                                                     | 
                
                 | 
                                        ('SVN', ('SWANN', 'SVENI', 'SWAN', 'SVEN', 'SVEIN', | 
            
            
                                                        
            
                                    
            
            
                | 
                    322
                 | 
                                    
                                                     | 
                
                 | 
                                                 'SVEEN', 'SVENN', 'SVANE')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    323
                 | 
                                    
                                                     | 
                
                 | 
                                        ('SLT', ('SELTE', 'SALT', 'SALTE', 'SLOTT', 'SLAATTO', | 
            
            
                                                        
            
                                    
            
            
                | 
                    324
                 | 
                                    
                                                     | 
                
                 | 
                                                 'SLETT', 'SLETTA', 'SLETTE')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    325
                 | 
                                    
                                                     | 
                
                 | 
                                        ('JNSN', ('JANSSEN', 'JANSEN', 'JENSEN', 'JONASSEN', | 
            
            
                                                        
            
                                    
            
            
                | 
                    326
                 | 
                                    
                                                     | 
                
                 | 
                                                  'JANSON', 'JONSON', 'JENSSEN', 'JONSSON')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    327
                 | 
                                    
                                                     | 
                
                 | 
                                        ('ANRSN', ('ANDRESSEN', 'ANDERSSON', 'ANDRESEN', | 
            
            
                                                        
            
                                    
            
            
                | 
                    328
                 | 
                                    
                                                     | 
                
                 | 
                                                   'ANDREASSEN', 'ANDERSEN', 'ANDERSON',  | 
            
            
                                                        
            
                                    
            
            
                | 
                    329
                 | 
                                    
                                                     | 
                
                 | 
                                                   'ANDORSEN', 'ANDERSSEN')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    330
                 | 
                                    
                                                     | 
                
                 | 
                                        ('BRK', ('BREKKE', 'BORCH', 'BRAKKE', 'BORK', 'BRECKE', | 
            
            
                                                        
            
                                    
            
            
                | 
                    331
                 | 
                                    
                                                     | 
                
                 | 
                                                 'BROCH', 'BRICK', 'BRUK')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    332
                 | 
                                    
                                                     | 
                
                 | 
                                        ('LN', ('LINDE', 'LENDE', 'LUND', 'LAND', 'LINDA', | 
            
            
                                                        
            
                                    
            
            
                | 
                    333
                 | 
                                    
                                                     | 
                
                 | 
                                                'LANDE', 'LIND', 'LUNDE')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    334
                 | 
                                    
                                                     | 
                
                 | 
                                        ('SF', ('SOPHIE', 'SFE', 'SEFF', 'SEAFOOD', 'SOFIE', | 
            
            
                                                        
            
                                    
            
            
                | 
                    335
                 | 
                                    
                                                     | 
                
                 | 
                                                'SAFE', 'SOFI', 'SOPHIA')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    336
                 | 
                                    
                                                     | 
                
                 | 
                                        ('BRST', ('BRUASET', 'BUERSTAD', 'BARSTAD', 'BAARSTAD', | 
            
            
                                                        
            
                                    
            
            
                | 
                    337
                 | 
                                    
                                                     | 
                
                 | 
                                                  'BRUSETH', 'BERSTAD', 'BORSTAD', 'BRUSTAD')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    338
                 | 
                                    
                                                     | 
                
                 | 
                                        ('OLSN', ('OHLSSON', 'OLESEN', 'OLSSON', 'OLAUSSON', | 
            
            
                                                        
            
                                    
            
            
                | 
                    339
                 | 
                                    
                                                     | 
                
                 | 
                                                  'OLAUSEN', 'OLAUSSEN', 'OLSEN', 'OLSON')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    340
                 | 
                                    
                                                     | 
                
                 | 
                                        ('MKL', ('MIKAEL', 'MICHELA', 'MEIKLE', 'MIKAL', | 
            
            
                                                        
            
                                    
            
            
                | 
                    341
                 | 
                                    
                                                     | 
                
                 | 
                                                 'MIKKEL', 'MICHEL', 'MICHAL', 'MICHAEL')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    342
                 | 
                                    
                                                     | 
                
                 | 
                                        ('HR', ('HEIER', 'HAR', 'HEER', 'HARRY', 'HEIR', | 
            
            
                                                        
            
                                    
            
            
                | 
                    343
                 | 
                                    
                                                     | 
                
                 | 
                                                'HURRE', 'HERO', 'HUURRE')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    344
                 | 
                                    
                                                     | 
                
                 | 
                                        ('VLM', ('VILLUM', 'WOLLUM', 'WILLIAM', 'WILLAM', | 
            
            
                                                        
            
                                    
            
            
                | 
                    345
                 | 
                                    
                                                     | 
                
                 | 
                                                 'WALLEM', 'WILLUM', 'VALUM', 'WILMO')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    346
                 | 
                                    
                                                     | 
                
                 | 
                                        ('SNS', ('SYNNES', 'SINUS', 'SNUS', 'SNEIS', 'SANNES', | 
            
            
                                                        
            
                                    
            
            
                | 
                    347
                 | 
                                    
                                                     | 
                
                 | 
                                                 'SUNAAS', 'SUNNAAS', 'SAINES')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    348
                 | 
                                    
                                                     | 
                
                 | 
                                        ('SNL', ('SANDAL', 'SANDAHL', 'SUNDEL', 'SANDLI', | 
            
            
                                                        
            
                                    
            
            
                | 
                    349
                 | 
                                    
                                                     | 
                
                 | 
                                                 'SUNNDAL', 'SANDELL', 'SANDLIE', 'SUNDAL')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    350
                 | 
                                    
                                                     | 
                
                 | 
                                        ('VK', ('VEKA', 'VIKA', 'WIIK', 'WOK', 'WIKE', 'WEEK', | 
            
            
                                                        
            
                                    
            
            
                | 
                    351
                 | 
                                    
                                                     | 
                
                 | 
                                                'VIK', 'VIAK')),  | 
            
            
                                                        
            
                                    
            
            
                | 
                    352
                 | 
                                    
                                                     | 
                
                 | 
                                        ('MTS', ('METSO', 'MOTHES', 'MATHIAS', 'MATHIS', | 
            
            
                                                        
            
                                    
            
            
                | 
                    353
                 | 
                                    
                                                     | 
                
                 | 
                                                 'MATTIS', 'MYTHES', 'METOS', 'MATS')))  | 
            
            
                                                        
            
                                    
            
            
                | 
                    354
                 | 
                                    
                                                     | 
                
                 | 
                        for encoded, names in reddit_tests:  | 
            
            
                                                        
            
                                    
            
            
                | 
                    355
                 | 
                                    
                                                     | 
                
                 | 
                            for name in names:  | 
            
            
                                                        
            
                                    
            
            
                | 
                    356
                 | 
                                    
                                                     | 
                
                 | 
                                self.assertEqual(encoded, norphone(name))  | 
            
            
                                                        
            
                                    
            
            
                | 
                    357
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    358
                 | 
                                    
                                                     | 
                
                 | 
                 | 
            
            
                                                        
            
                                    
            
            
                | 
                    359
                 | 
                                    
                                                     | 
                
                 | 
                if __name__ == '__main__':  | 
            
            
                                                        
            
                                    
            
            
                | 
                    360
                 | 
                                    
                                                     | 
                
                 | 
                    unittest.main()  | 
            
            
                                                        
            
                                    
            
            
                | 
                    361
                 | 
                                    
                                                     | 
                
                 | 
                 |