def load_settings(self, defaults=False):
        if defaults:
            settings = copy.deepcopy(self.main.settings_default)
        else:
            settings = copy.deepcopy(self.main.settings_custom)

        for lang in settings['lemmatization']['lemmatizers']:
            self.__dict__[f'combo_box_lemmatizer_{lang}'].blockSignals(True)

            self.__dict__[f'combo_box_lemmatizer_{lang}'].setCurrentText(
                settings['lemmatization']['lemmatizers'][lang])

            self.__dict__[f'combo_box_lemmatizer_{lang}'].blockSignals(False)

        if not defaults:
            self.combo_box_lemmatization_preview_lang.blockSignals(True)
            self.text_edit_lemmatization_preview_samples.blockSignals(True)

            self.combo_box_lemmatization_preview_lang.setCurrentText(
                wl_conversion.to_lang_text(
                    self.main, settings['lemmatization']['preview_lang']))
            self.text_edit_lemmatization_preview_samples.setText(
                settings['lemmatization']['preview_samples'])
            self.text_edit_lemmatization_preview_results.setText(
                settings['lemmatization']['preview_results'])

            self.combo_box_lemmatization_preview_lang.blockSignals(False)
            self.text_edit_lemmatization_preview_samples.blockSignals(False)
Example #2
0
def test_word_detokenize(lang):
    lang_text = wl_conversion.to_lang_text(main, lang)

    print(f'{lang_text} ({lang}):')

    tokens = wl_word_tokenization.wl_word_tokenize_flat(
        main,
        text = getattr(wl_test_lang_examples, f"SENTENCE_{lang.upper() if lang != 'other' else 'ENG_GB'}"),
        lang = lang
    )
    text = wl_word_detokenization.wl_word_detokenize(
        main,
        tokens = tokens,
        lang = lang
    )

    print(text)

    if lang == 'zho_cn':
        assert text == '汉语,又称汉文、中文、中国话、中国语、华语、华文、唐话[2] ,或被视为一个语族,或被视为隶属于汉藏语系汉语族之一种语言。'
    elif lang == 'zho_tw':
        assert text == '漢語,又稱漢文、中文、中國話、中國語、華語、華文、唐話[2] ,或被視為一個語族,或被視為隸屬於漢藏語系漢語族之一種語言。'
    elif lang == 'eng_gb':
        assert text == 'English is a West Germanic language of the Indo - European language family, originally spoken by the inhabitants of early medieval England.[3][4][5]'
    elif lang == 'jpn':
        assert text == '日本語(にほんご、にっぽんご[注2]、英: Japanese )は、日本国内や、かつての日本領だった国、そして日本人同士の間で使用されている言語。'
    elif lang == 'tha':
        assert text == 'ภาษาไทยหรือภาษาไทยกลางเป็นภาษาราชการและภาษาประจำชาติของประเทศไทย'
    elif lang == 'bod':
        assert text == 'བོད་ཀྱི་སྐད་ཡིག་ནི་བོད་ཡུལ་དང་དེའི་ཉེ་འཁོར་གྱི་ས་ཁུལ་ཏེ།'
    elif lang == 'other':
        assert text == 'English is a West Germanic language of the Indo - European language family, originally spoken by the inhabitants of early medieval England.[3][4][5]'
    else:
        raise Exception(f'Error: Tests for language "{lang}" is skipped!')
Example #3
0
    def load_settings(self, defaults=False):
        if defaults:
            settings = copy.deepcopy(self.settings_default)
        else:
            settings = copy.deepcopy(self.settings_custom)

        # Default Settings
        self.combo_box_files_encoding.setCurrentText(
            wl_conversion.to_encoding_text(
                self.main, settings['default_settings']['encoding']))
        self.combo_box_files_lang.setCurrentText(
            wl_conversion.to_lang_text(self.main,
                                       settings['default_settings']['lang']))

        if settings['default_settings']['tokenized']:
            self.combo_box_files_tokenized.setCurrentText(self.tr('Yes'))
        else:
            self.combo_box_files_tokenized.setCurrentText(self.tr('No'))
        if settings['default_settings']['tagged']:
            self.combo_box_files_tagged.setCurrentText(self.tr('Yes'))
        else:
            self.combo_box_files_tagged.setCurrentText(self.tr('No'))

        # Auto-detection Settings
        self.spin_box_files_number_lines.setValue(
            settings['auto_detection_settings']['number_lines'])
        self.checkbox_files_number_lines_no_limit.setChecked(
            settings['auto_detection_settings']['number_lines_no_limit'])

        # Miscellaneous
        self.spin_box_read_files_in_chunks.setValue(
            settings['misc']['read_files_in_chunks'])
Example #4
0
    def load_settings(self, defaults=False):
        if defaults:
            settings = copy.deepcopy(self.settings_default)
        else:
            settings = copy.deepcopy(self.settings_custom)

        self.table_stop_word_lists.disable_updates()

        for i, lang in enumerate(settings['stop_word_lists']):
            self.table_stop_word_lists.model().item(i, 1).setText(
                wl_nlp_utils.to_lang_util_text(
                    self.main,
                    util_type='stop_word_lists',
                    util_code=settings['stop_word_lists'][lang]))

        self.table_stop_word_lists.enable_updates(emit_signals=False)

        if not defaults:
            self.combo_box_stop_word_list_preview_lang.setCurrentText(
                wl_conversion.to_lang_text(self.main,
                                           settings['preview_lang']))

        if defaults:
            self.settings_custom['custom_lists'] = copy.deepcopy(
                self.settings_default['custom_lists'])

        self.combo_box_stop_word_list_preview_lang.currentTextChanged.emit(
            self.combo_box_stop_word_list_preview_lang.currentText())
    def load_settings(self, defaults=False):
        if defaults:
            settings = copy.deepcopy(self.settings_default)
        else:
            settings = copy.deepcopy(self.settings_custom)

        self.table_syl_tokenizers.disable_updates()

        for i, lang in enumerate(settings['syl_tokenizers']):
            self.table_syl_tokenizers.model().item(i, 1).setText(
                wl_nlp_utils.to_lang_util_text(
                    self.main,
                    util_type='syl_tokenizers',
                    util_code=settings['syl_tokenizers'][lang]))

        self.table_syl_tokenizers.enable_updates()

        if not defaults:
            self.combo_box_syl_tokenization_preview_lang.blockSignals(True)
            self.text_edit_syl_tokenization_preview_samples.blockSignals(True)

            self.combo_box_syl_tokenization_preview_lang.setCurrentText(
                wl_conversion.to_lang_text(self.main,
                                           settings['preview_lang']))
            self.text_edit_syl_tokenization_preview_samples.setText(
                settings['preview_samples'])
            self.text_edit_syl_tokenization_preview_results.setText(
                settings['preview_results'])

            self.combo_box_syl_tokenization_preview_lang.blockSignals(False)
            self.text_edit_syl_tokenization_preview_samples.blockSignals(False)
Example #6
0
def test_to_lang_text(lang_code):
    len_lang_code = max([
        len(lang_code) for lang_code in main.settings_global['langs'].values()
    ])
    lang_text = wl_conversion.to_lang_text(main, lang_code)

    assert lang_text == {
        lang_code: lang_text
        for lang_text, lang_code in main.settings_global['langs'].items()
    }[lang_code]
Example #7
0
    def update_table(self):
        self.table.blockSignals(True)
        self.table.setUpdatesEnabled(False)

        files = self.main.settings_custom['files']['files_open']

        if files:
            self.table.clear_table(len(files))

            for i, file in enumerate(files):
                checkbox_name = QTableWidgetItem(file['name'])
                combo_box_lang = wl_box.Wl_Combo_Box_Lang(self.table)
                combo_box_tokenized = wl_box.Wl_Combo_Box_Yes_No(self.table)
                combo_box_tagged = wl_box.Wl_Combo_Box_Yes_No(self.table)
                combo_box_encoding = wl_box.Wl_Combo_Box_Encoding(self.table)

                if file['selected']:
                    checkbox_name.setCheckState(Qt.Checked)
                else:
                    checkbox_name.setCheckState(Qt.Unchecked)

                combo_box_lang.setCurrentText(
                    wl_conversion.to_lang_text(self.main, file['lang']))
                combo_box_tokenized.setCurrentText(file['tokenized'])
                combo_box_tagged.setCurrentText(file['tagged'])
                combo_box_encoding.setCurrentText(
                    wl_conversion.to_encoding_text(self.main,
                                                   file['encoding']))

                combo_box_lang.currentTextChanged.connect(
                    lambda: self.table.itemChanged.emit(self.table.item(i, 1)))
                combo_box_tokenized.currentTextChanged.connect(
                    lambda: self.table.itemChanged.emit(self.table.item(i, 2)))
                combo_box_tagged.currentTextChanged.connect(
                    lambda: self.table.itemChanged.emit(self.table.item(i, 3)))
                combo_box_encoding.currentTextChanged.connect(
                    lambda: self.table.itemChanged.emit(self.table.item(i, 5)))

                self.table.setItem(i, 0, checkbox_name)
                self.table.setCellWidget(i, 1, combo_box_lang)
                self.table.setCellWidget(i, 2, combo_box_tokenized)
                self.table.setCellWidget(i, 3, combo_box_tagged)
                self.table.setItem(i, 4, QTableWidgetItem(file['path']))
                self.table.setCellWidget(i, 5, combo_box_encoding)
        else:
            self.table.clear_table(1)

        self.table.blockSignals(False)
        self.table.setUpdatesEnabled(True)

        self.table.itemChanged.emit(self.table.item(0, 0))
    def load_settings(self, defaults = False):
        if defaults:
            settings = copy.deepcopy(self.main.settings_default)
        else:
            settings = copy.deepcopy(self.main.settings_custom)

        for lang in settings['stop_word_lists']['stop_word_lists']:
            self.__dict__[f'combo_box_stop_word_list_{lang}'].setCurrentText(settings['stop_word_lists']['stop_word_lists'][lang])

        if not defaults:
            self.combo_box_stop_word_list_preview_lang.setCurrentText(wl_conversion.to_lang_text(self.main, settings['stop_word_lists']['preview_lang']))

        if defaults:
            self.main.settings_custom['stop_word_lists']['custom_lists'] = copy.deepcopy(self.main.settings_default['stop_word_lists']['custom_lists'])

        self.combo_box_stop_word_list_preview_lang.currentTextChanged.emit(self.combo_box_stop_word_list_preview_lang.currentText())
Example #9
0
def test_get_stop_word_list(lang, stop_word_list, show_results=False):
    lang_text = wl_conversion.to_lang_text(main, lang)
    stop_words = wl_stop_word_lists.wl_get_stop_word_list(
        main, lang, stop_word_list=stop_word_list)

    if show_results:
        print(f'{lang} / {stop_word_list}:')
        print(stop_words)

    if stop_word_list == 'Custom List':
        # Check if custom list is empty
        assert stop_words == []
    else:
        # Check if the list is empty
        assert len(stop_words)
        # Check if there are empty tokens in the list
        assert all([stop_word for stop_word in stop_words])
Example #10
0
    def load_settings(self, defaults=False):
        if defaults:
            settings = copy.deepcopy(self.main.settings_default)
        else:
            settings = copy.deepcopy(self.main.settings_custom)

        if not defaults:
            self.combo_box_tagsets_lang.blockSignals(True)
            self.combo_box_tagsets_pos_tagger.blockSignals(True)

            self.combo_box_tagsets_lang.setCurrentText(
                wl_conversion.to_lang_text(
                    self.main, settings['tagsets']['preview_lang']))
            self.combo_box_tagsets_pos_tagger.setCurrentText(
                settings['tagsets']['preview_pos_tagger'][settings['tagsets']
                                                          ['preview_lang']])

            self.combo_box_tagsets_lang.blockSignals(False)
            self.combo_box_tagsets_pos_tagger.blockSignals(False)
def test_get_stop_word_list(lang, stop_word_list):
    lang_text = wl_conversion.to_lang_text(main, lang)

    print(f'{lang_text} ({lang}) / {stop_word_list}:')

    stop_words = wl_stop_word_lists.wl_get_stop_word_list(main, lang, stop_word_list = stop_word_list)

    print(stop_words)

    if stop_word_list == 'custom':
        # Check if custom list is empty
        assert stop_words == []
    else:
        # Check for missing custom lists
        assert stop_word_list != 'Missing Custom List'
        # Check if the list is empty
        assert len(stop_words)
        # Check if there are empty tokens in the list
        assert all([stop_word for stop_word in stop_words])
Example #12
0
    def load_settings(self, defaults=False):
        if defaults:
            settings = copy.deepcopy(self.main.settings_default)
        else:
            settings = copy.deepcopy(self.main.settings_custom)

        self.spin_box_auto_detection_number_lines.setValue(
            settings['auto_detection']['detection_settings']['number_lines'])
        self.checkbox_auto_detection_number_lines_no_limit.setChecked(
            settings['auto_detection']['detection_settings']
            ['number_lines_no_limit'])

        self.combo_box_auto_detection_default_lang.setCurrentText(
            wl_conversion.to_lang_text(
                self.main, settings['auto_detection']['default_settings']
                ['default_lang']))
        self.combo_box_auto_detection_default_encoding.setCurrentText(
            wl_conversion.to_encoding_text(
                self.main, settings['auto_detection']['default_settings']
                ['default_encoding']))
def test_word_detokenize(lang, word_detokenizer, show_results=False):
    lang_text = wl_conversion.to_lang_text(main, lang)

    tokens = wl_word_tokenization.wl_word_tokenize(
        main,
        text=getattr(wl_test_lang_examples, f'SENTENCE_{lang.upper()}'),
        lang=lang)
    text = wl_word_detokenization.wl_word_detokenize(
        main, tokens=tokens, lang=lang, word_detokenizer=word_detokenizer)

    if show_results:
        print(f'{lang} / {word_detokenizer}:')
        print(text)

    if lang == 'cat':
        if word_detokenizer == 'NLTK - Penn Treebank Detokenizer':
            assert text == "El català (denominació oficial a Catalunya, a les Illes Balears, a Andorra, a la ciutat de l' Alguer i tradicional a Catalunya Nord) o valencià (denominació oficial al País Valencià i tradicional al Carxe) és una llengua romànica parlada a Catalunya, el País Valencià (tret d' algunes comarques i localitats de l' interior), les Illes Balears, Andorra, la Franja de Ponent (a l' Aragó), la ciutat de l' Alguer (a l' illa de Sardenya), la Catalunya del Nord,[8] el Carxe (un petit territori de Múrcia poblat per immigrats valencians),[9][10] i en petites comunitats arreu del món (entre les quals destaca la de l' Argentina, amb 195.000 parlants).[11 ]"
        elif word_detokenizer == 'Sacremoses - Moses Detokenizer':
            assert text == "El català (denominació oficial a Catalunya, a les Illes Balears, a Andorra, a la ciutat de l' Alguer i tradicional a Catalunya Nord) o valencià (denominació oficial al País Valencià i tradicional al Carxe) és una llengua romànica parlada a Catalunya, el País Valencià (tret d' algunes comarques i localitats de l' interior), les Illes Balears, Andorra, la Franja de Ponent (a l' Aragó), la ciutat de l' Alguer (a l' illa de Sardenya), la Catalunya del Nord,[8] el Carxe (un petit territori de Múrcia poblat per immigrats valencians),[9][10] i en petites comunitats arreu del món (entre les quals destaca la de l' Argentina, amb 195.000 parlants).[11]"
    elif lang == 'zho_cn':
        assert text == '汉语,又称汉文、中文、中国话、中国语、华语、华文、唐话[2],或被视为一个语族,或被视为隶属于汉藏语系汉语族之一种语言。'
    elif lang == 'zho_tw':
        assert text == '漢語,又稱漢文、中文、中國話、中國語、華語、華文、唐話[2],或被視為一個語族,或被視為隸屬於漢藏語系漢語族之一種語言。'
    elif lang == 'ces':
        assert text == 'Čeština neboli český jazyk je západoslovanský jazyk, nejbližší slovenštině, poté lužické srbštině a polštině.'
    elif lang == 'nld':
        assert text == 'Het Nederlands is een West-Germaanse taal en de moedertaal van de meeste inwoners van Nederland, België en Suriname.'
    elif lang == 'eng':
        if word_detokenizer == 'NLTK - Penn Treebank Detokenizer':
            assert text == 'English is a West Germanic language that was first spoken in early medieval England and eventually became a global lingua franca.[4][5 ]'
        elif word_detokenizer == 'Sacremoses - Moses Detokenizer':
            assert text == 'English is a West Germanic language that was first spoken in early medieval England and eventually became a global lingua franca.[4][5]'
    elif lang == 'fin':
        assert text == 'Suomen kieli (suomi) on uralilaisten kielten itämerensuomalaiseen ryhmään kuuluva kieli.'
    elif lang == 'fra':
        assert text == 'Le français est une langue indo-européenne de la famille des langues romanes.'
    elif lang == 'deu':
        if word_detokenizer == 'NLTK - Penn Treebank Detokenizer':
            assert text == 'Die deutsche Sprache bzw. Deutsch ([ dɔʏ̯t͡ʃ]; abgekürzt dt . oder dtsch .) ist eine westgermanische Sprache.'
        elif word_detokenizer == 'Sacremoses - Moses Detokenizer':
            assert text == 'Die deutsche Sprache bzw. Deutsch ([dɔʏ̯t͡ʃ]; abgekürzt dt. oder dtsch.) ist eine westgermanische Sprache.'
    elif lang == 'ell':
        assert text == 'Η ελληνική γλώσσα ανήκει στην ινδοευρωπαϊκή οικογένεια[9] και συγκεκριμένα στον ελληνικό κλάδο, μαζί με την τσακωνική, ενώ είναι η επίσημη γλώσσα της Ελλάδος και της Κύπρου.'
    elif lang == 'hun':
        assert text == 'A magyar nyelv az uráli nyelvcsalád tagja, a finnugor nyelvek közé tartozó ugor nyelvek egyike.'
    elif lang == 'isl':
        if word_detokenizer == 'NLTK - Penn Treebank Detokenizer':
            assert text == 'Íslenska er vesturnorrænt, germanskt og indóevrópskt tungumál sem er einkum talað og ritað á Íslandi og er móðurmál langflestra Íslendinga.[4 ]'
        elif word_detokenizer == 'Sacremoses - Moses Detokenizer':
            assert text == 'Íslenska er vesturnorrænt, germanskt og indóevrópskt tungumál sem er einkum talað og ritað á Íslandi og er móðurmál langflestra Íslendinga.[4]'
    elif lang == 'gle':
        assert text == 'Is ceann de na teangacha Ceilteacha í an Ghaeilge (nó Gaeilge na hÉireann mar a thugtar uirthi corruair), agus ceann den dtrí cinn de theangacha Ceilteacha ar a dtugtar na teangacha Gaelacha (.i. an Ghaeilge, Gaeilge na hAlban agus Gaeilge Mhanann) go háirithe.'
    elif lang == 'ita':
        if word_detokenizer == 'NLTK - Penn Treebank Detokenizer':
            assert text == "L' italiano ([ itaˈljaːno][Nota 1] ascolta[?·info] ) è una lingua romanza parlata principalmente in Italia."
        elif word_detokenizer == 'Sacremoses - Moses Detokenizer':
            assert text == "L'italiano ([itaˈljaːno][Nota 1] ascolta[?·info]) è una lingua romanza parlata principalmente in Italia."
    elif lang == 'jpn':
        assert text == '日本語(にほんご、にっぽんご[注1])は、主に日本国内や日本人同士の間で使用されている言語である。'
    elif lang == 'lav':
        if word_detokenizer == 'NLTK - Penn Treebank Detokenizer':
            assert text == 'Latviešu valoda ir dzimtā valoda apmēram 1,7 miljoniem cilvēku, galvenokārt Latvijā, kur tā ir vienīgā valsts valoda . [3 ]'
        elif word_detokenizer == 'Sacremoses - Moses Detokenizer':
            assert text == 'Latviešu valoda ir dzimtā valoda apmēram 1,7 miljoniem cilvēku, galvenokārt Latvijā, kur tā ir vienīgā valsts valoda. [3]'
    elif lang == 'lit':
        assert text == 'Lietuvių kalba – iš baltų prokalbės kilusi lietuvių tautos kalba, kuri Lietuvoje yra valstybinė, o Europos Sąjungoje – viena iš oficialiųjų kalbų.'
    elif lang == 'pol':
        assert text == 'Język polski, polszczyzna, skrót: pol. – język naturalny należący do grupy języków zachodniosłowiańskich (do której należą również czeski, słowacki, kaszubski, dolnołużycki, górnołużycki i wymarły połabski), stanowiącej część rodziny języków indoeuropejskich.'
    elif lang == 'por':
        assert text == 'A língua portuguesa, também designada português, é uma língua românica flexiva ocidental originada no galego-português falado no Reino da Galiza e no norte de Portugal.'
    elif lang == 'ron':
        assert text == 'Limba română este o limbă indo - europeană, din grupul italic și din subgrupul oriental al limbilor romanice.'
    elif lang == 'rus':
        if word_detokenizer == 'NLTK - Penn Treebank Detokenizer':
            assert text == 'Ру́сский язы́к ([ ˈruskʲɪi̯ jɪˈzɨk] Информация о файле слушать) [~ 3] [⇨] — один из восточнославянских языков, национальный язык русского народа.'
        elif word_detokenizer == 'Sacremoses - Moses Detokenizer':
            assert text == 'Ру́сский язы́к ([ˈruskʲɪi̯ jɪˈzɨk] Информация о файле слушать) [~ 3] [⇨] — один из восточнославянских языков, национальный язык русского народа.'
    elif lang == 'slk':
        assert text == 'Slovenčina patrí do skupiny západoslovanských jazykov (spolu s češtinou, poľštinou, hornou a dolnou lužickou srbčinou a kašubčinou).'
    elif lang == 'slv':
        assert text == 'Slovenščina [slovénščina] / [sloˈʋenʃtʃina] je združeni naziv za uradni knjižni jezik Slovencev in skupno ime za narečja in govore, ki jih govorijo ali so jih nekoč govorili Slovenci.'
    elif lang == 'spa':
        assert text == 'El español o castellano es una lengua romance procedente del latín hablado.'
    elif lang == 'swe':
        if word_detokenizer == 'NLTK - Penn Treebank Detokenizer':
            assert text == 'Svenska (svenska (info) ) är ett östnordiskt språk som talas av ungefär tio miljoner personer främst i Sverige där språket har en dominant ställning som huvudspråk, men även som det ena nationalspråket i Finland och som enda officiella språk på Åland.'
        elif word_detokenizer == 'Sacremoses - Moses Detokenizer':
            assert text == 'Svenska (svenska (info)) är ett östnordiskt språk som talas av ungefär tio miljoner personer främst i Sverige där språket har en dominant ställning som huvudspråk, men även som det ena nationalspråket i Finland och som enda officiella språk på Åland.'
    elif lang == 'tam':
        assert text == 'தமிழ் மொழி (Tamil language) தமிழர்களினதும், தமிழ் பேசும் பலரதும் தாய்மொழி ஆகும்.'
    elif lang == 'tha':
        assert text == 'ภาษาไทยหรือภาษาไทยกลางเป็นภาษาราชการและภาษาประจำชาติของประเทศไทย'
    elif lang == 'bod':
        assert text == 'བོད་ཀྱི་སྐད་ཡིག་ནི་བོད་ཡུལ་དང་དེའི་ཉེ་འཁོར་གྱི་ས་ཁུལ་ཏེ།'
def test_word_tokenize(lang, word_tokenizer):
    lang_text = wl_conversion.to_lang_text(main, lang)

    print(f'{lang_text} ({lang}) / {word_tokenizer}:')

    tokens = wl_word_tokenization.wl_word_tokenize_flat(
        main,
        text = getattr(wl_test_lang_examples, f'SENTENCE_{lang.upper()}'),
        lang = lang,
        word_tokenizer = word_tokenizer
    )
    # Use 0 to 9 only since nagisa would split numerals into single numbers (except 24 and maybe some others)
    tokens_long_text = wl_word_tokenization.wl_word_tokenize_flat(
        main,
        text = ''.join([f'{i % 10}\n' for i in range(101)]),
        lang = lang,
        word_tokenizer = word_tokenizer
    )

    print(tokens)

    # The count of tokens should be more than 1
    assert len(tokens) > 1
    # The count of tokens should be more than the length of tokens split by space
    assert len(tokens) > len(f'SENTENCE_{lang.upper()}'.split())
    # Test long texts
    assert tokens_long_text == [str(i % 10) for i in range(101)]

    if lang == 'afr':
        assert tokens == ['Afrikaans', 'is', 'tipologies', 'beskou', "'", 'n', 'Indo', '-', 'Europese', ',', 'Wes', '-', 'Germaanse', ',', 'Nederfrankiese', 'taal,[2', ']', 'wat', 'aan', 'die', 'suidpunt', 'van', 'Afrika', 'onder', 'invloed', 'van', 'verskeie', 'ander', 'tale', 'en', 'taalgroepe', 'ontstaan', 'het', '.']
    elif lang == 'sqi':
        assert tokens == ['Gjuha', 'shqipe', '(', 'ose', 'thjeshtë', 'shqipja', ')', 'është', 'gjuhë', 'dhe', 'degë', 'e', 'veçantë', 'e', 'familjes', 'indo', '-', 'evropiane', 'të', 'folur', 'nga', 'më', 'shumë', 'se', '6', 'milionë', 'njerëz[4', ']', ',', 'kryesisht', 'në', 'Shqipëri', ',', 'Kosovë', 'dhe', 'Republikën', 'e', 'Maqedonisë', ',', 'por', 'edhe', 'në', 'zona', 'të', 'tjera', 'të', 'Evropës', 'Jugore', 'ku', 'ka', 'një', 'popullsi', 'shqiptare', ',', 'duke', 'përfshirë', 'Malin', 'e', 'Zi', 'dhe', 'Luginën', 'e', 'Preshevës', '.']
    elif lang == 'amh':
        assert tokens == ['አማርኛ[1', ']', '፡', 'የኢትዮጵያ', '፡', 'መደበኛ', '፡', 'ቋንቋ', '፡', 'ነው', '።']
    elif lang == 'ara':
        assert tokens == ['اللُّغَة', 'العَرَبِيّة', 'هي', 'أكثر', 'اللغات', 'السامية', 'تحدثاً', 'وإحدى', 'أكثر', 'اللغات', 'انتشاراً', 'في', 'العالم', '،', 'يتحدثها', 'أكثر', 'من', '467', 'مليون', 'نسمة،(1', ')', 'ويتوزع', 'متحدثوها', 'في', 'الوطن', 'العربي', '،', 'بالإضافة', 'إلى', 'العديد', 'من', 'المناطق', 'الأخرى', 'المجاورة', 'كالأهواز', 'وتركيا', 'وتشاد', 'ومالي', 'والسنغال', 'وإرتيريا', 'وإثيوبيا', 'وجنوب', 'السودان', 'وإيران', '.']
    elif lang == 'hye':
        assert tokens == ['Հայերեն', '(', 'ավանդական՝', 'հայերէն', ')', ',', 'հնդեվրոպական', 'լեզվաընտանիքի', 'առանձին', 'ճյուղ', 'հանդիսացող', 'լեզու։']
    elif lang == 'asm':
        assert tokens == ['অসমীয়া', 'ভাষা', 'হৈছে', 'সকলোতকৈ', 'পূৰ্বীয়', 'ভাৰতীয়-আৰ্য', 'ভাষা', '।']
    elif lang == 'aze':
        assert tokens == ['Azərbaycan', 'dili[1][2][3', ']', '—', 'Azərbaycan', 'Respublikasının', 'və', 'Rusiya', 'Federasiyasının', 'Dağıstan', 'Respublikasının[4', ']', 'rəsmi', 'dövlət', 'dilidir', '.']
    elif lang == 'eus':
        assert tokens == ['Euskara', 'Euskal', 'Herriko', 'hizkuntza', 'da.[5', ']']
    elif lang == 'ben':
        assert tokens == ['বাংলা', 'ভাষা', '(', 'বাঙলা', ',', 'বাঙ্গলা', ',', 'তথা', 'বাঙ্গালা', 'নামগুলোতেও', 'পরিচিত', ')', 'একটি', 'ইন্দো', '-', 'আর্য', 'ভাষা', ',', 'যা', 'দক্ষিণ', 'এশিয়ার', 'বাঙালি', 'জাতির', 'প্রধান', 'কথ্য', 'ও', 'লেখ্য', 'ভাষা', '।']
    elif lang == 'bul':
        assert tokens == ['Бъ̀лгарският', 'езѝк', 'е', 'индоевропейски', 'език', 'от', 'групата', 'на', 'южнославянските', 'езици', '.']
    elif lang == 'cat':
        assert tokens == ['El', 'català', '(', 'denominació', 'oficial', 'a', 'Catalunya', ',', 'a', 'les', 'Illes', 'Balears', ',', 'a', 'Andorra', ',', 'a', 'la', 'ciutat', 'de', "l'", 'Alguer', 'i', 'tradicional', 'a', 'Catalunya', 'Nord', ')', 'o', 'valencià', '(', 'denominació', 'oficial', 'a', 'l', 'País', 'Valencià', 'i', 'tradicional', 'a', 'l', 'Carxe', ')', 'és', 'una', 'llengua', 'romànica', 'parlada', 'a', 'Catalunya', ',', 'el', 'País', 'Valencià', '(', 'tret', "d'", 'algunes', 'comarques', 'i', 'localitats', 'de', "l'", 'interior', ')', ',', 'les', 'Illes', 'Balears', ',', 'Andorra', ',', 'la', 'Franja', 'de', 'Ponent', '(', 'a', "l'", 'Aragó', ')', ',', 'la', 'ciutat', 'de', "l'", 'Alguer', '(', 'a', "l'", 'illa', 'de', 'Sardenya', ')', ',', 'la', 'Catalunya', 'd', 'el', 'Nord,[8', ']', 'el', 'Carxe', '(', 'un', 'petit', 'territori', 'de', 'Múrcia', 'poblat', 'per', 'immigrats', 'valencians),[9][10', ']', 'i', 'en', 'comunitats', 'arreu', 'd', 'el', 'món', '(', 'entre', 'les', 'quals', 'destaca', 'la', 'de', "l'", 'Argentina', ',', 'amb', '198.000', 'parlants).[11', ']']
    elif lang == 'zho_cn':
        if word_tokenizer == 'jieba_zho':
            assert tokens == ['汉语', ',', '又称', '汉文', '、', '中文', '、', '中国', '话', '、', '中国', '语', '、', '华语', '、', '华文', '、', '唐话', '[', '2', ']', ',', '或', '被', '视为', '一个', '语族', ',', '或', '被', '视为', '隶属于', '汉藏语系', '汉语', '族', '之', '一种', '语言', '。']
        elif word_tokenizer == 'pkuseg_zho':
            assert tokens == ['汉语', ',', '又', '称', '汉文', '、', '中文', '、', '中国话', '、', '中国语', '、', '华语', '、', '华文', '、', '唐', '话[', '2', ']', ',', '或', '被', '视为', '一个', '语族', ',', '或', '被', '视为', '隶属于', '汉藏', '语系', '汉语族', '之一', '种', '语言', '。']
        elif word_tokenizer == 'spacy_zho':
            assert tokens == ['汉语', ',', '又', '称', '汉文', '、', '中文', '、', '中国话', '、', '中国语', '、', '华语', '、', '华文', '、', '唐话', '[', '2', ']', ',', '或', '被', '视为', '一个', '语族', ',', '或', '被', '视为', '隶属于', '汉藏', '语系', '汉语族', '之一', '种', '语言', '。']
        elif word_tokenizer == 'wordless_zho_char':
            assert tokens == ['汉', '语', ',', '又', '称', '汉', '文', '、', '中', '文', '、', '中', '国', '话', '、', '中', '国', '语', '、', '华', '语', '、', '华', '文', '、', '唐', '话', '[', '2', ']', ',', '或', '被', '视', '为', '一', '个', '语', '族', ',', '或', '被', '视', '为', '隶', '属', '于', '汉', '藏', '语', '系', '汉', '语', '族', '之', '一', '种', '语', '言', '。']
        else:
            raise Exception(f'Error: Tests for word tokenizer "{word_tokenizer}" is skipped!')
    elif lang == 'zho_tw':
        if word_tokenizer == 'jieba_zho':
            assert tokens == ['漢語', ',', '又', '稱漢文', '、', '中文', '、', '中國話', '、', '中國語', '、', '華語', '、', '華文', '、', '唐話', '[', '2', ']', ',', '或', '被', '視為', '一個', '語族', ',', '或', '被', '視為', '隸屬', '於', '漢藏語', '系漢', '語族', '之一', '種語', '言', '。']
        elif word_tokenizer == 'pkuseg_zho':
            assert tokens == ['漢語', ',', '又', '稱', '漢文', '、', '中文', '、', '中', '國話', '、', '中國語', '、', '華語', '、', '華文', '、', '唐', '話[', '2', ']', ',', '或', '被', '視為', '一', '個', '語族', ',', '或', '被', '視', '為隸', '屬於', '漢藏', '語系', '漢語族', '之一', '種', '語言', '。']
        elif word_tokenizer == 'spacy_zho':
            assert tokens == ['漢語', ',', '又', '稱', '漢文', '、', '中文', '、', '中國話', '、', '中國語', '、', '華語', '、', '華文', '、', '唐話[', '2', ']', ',', '或', '被', '視為', '一', '個', '語族', ',', '或', '被', '視為', '隸屬', '於漢', '藏語', '系漢', '語族', '之一', '種', '語言', '。']
        elif word_tokenizer == 'wordless_zho_char':
            assert tokens == ['漢', '語', ',', '又', '稱', '漢', '文', '、', '中', '文', '、', '中', '國', '話', '、', '中', '國', '語', '、', '華', '語', '、', '華', '文', '、', '唐', '話', '[', '2', ']', ',', '或', '被', '視', '為', '一', '個', '語', '族', ',', '或', '被', '視', '為', '隸', '屬', '於', '漢', '藏', '語', '系', '漢', '語', '族', '之', '一', '種', '語', '言', '。']
        else:
            raise Exception(f'Error: Tests for word tokenizer "{word_tokenizer}" is skipped!')
    elif lang == 'hrv':
        assert tokens == ['Hrvatski', 'jezik', '(', 'ISO', '639', '-', '3', ':', 'hrv', ')', 'skupni', 'je', 'naziv', 'za', 'nacionalni', 'standardni', 'jezik', 'Hrvata', ',', 'te', 'za', 'skup', 'narječja', 'i', 'govora', 'kojima', 'govore', 'ili', 'su', 'nekada', 'govorili', 'Hrvati', '.']
    elif lang == 'ces':
        assert tokens == ['Čeština', 'neboli', 'český', 'jazyk', 'je', 'západoslovanský', 'jazyk', ',', 'nejbližší', 'slovenštině', ',', 'poté', 'lužické', 'srbštině', 'a', 'polštině', '.']
    elif lang == 'dan':
        assert tokens == ['Dansk', 'er', 'et', 'nordgermansk', 'sprog', 'af', 'den', 'østnordiske', '(', 'kontinentale', ')', 'gruppe', ',', 'der', 'tales', 'af', 'ca.', 'seks', 'millioner', 'mennesker', '.']
    elif lang == 'nld':
        assert tokens == ['Het', 'Nederlands', 'is', 'een', 'West-Germaanse', 'taal', 'en', 'de', 'officiële', 'taal', 'van', 'Nederland', ',', 'Suriname', 'en', 'een', 'van', 'de', 'drie', 'officiële', 'talen', 'van', 'België', '.']
    elif lang in ['eng_gb', 'eng_us']:
        if word_tokenizer in ['nltk_nist', 'nltk_twitter', 'sacremoses_moses']:
            assert tokens == ['English', 'is', 'a', 'West', 'Germanic', 'language', 'of', 'the', 'Indo-European', 'language', 'family', ',', 'originally', 'spoken', 'by', 'the', 'inhabitants', 'of', 'early', 'medieval', 'England', '.', '[', '3', ']', '[', '4', ']', '[', '5', ']']
        elif word_tokenizer in ['nltk_nltk', 'nltk_penn_treebank']:
            assert tokens == ['English', 'is', 'a', 'West', 'Germanic', 'language', 'of', 'the', 'Indo-European', 'language', 'family', ',', 'originally', 'spoken', 'by', 'the', 'inhabitants', 'of', 'early', 'medieval', 'England.', '[', '3', ']', '[', '4', ']', '[', '5', ']']
        elif word_tokenizer == 'nltk_tok_tok':
            assert tokens == ['English', 'is', 'a', 'West', 'Germanic', 'language', 'of', 'the', 'Indo-European', 'language', 'family', ',', 'originally', 'spoken', 'by', 'the', 'inhabitants', 'of', 'early', 'medieval', 'England.[', '3', ']', '[', '4', ']', '[', '5', ']']
        elif word_tokenizer == 'spacy_eng':
            assert tokens == ['English', 'is', 'a', 'West', 'Germanic', 'language', 'of', 'the', 'Indo', '-', 'European', 'language', 'family', ',', 'originally', 'spoken', 'by', 'the', 'inhabitants', 'of', 'early', 'medieval', 'England.[3][4][5', ']']
        else:
            raise Exception(f'Error: Tests for word tokenizer "{word_tokenizer}" is skipped!')
    elif lang == 'est':
        assert tokens == ['Eesti', 'keel', '(', 'varasem', 'nimetus', 'maakeel', ')', 'on', 'läänemeresoome', 'lõunarühma', 'kuuluv', 'keel', '.']
    elif lang == 'fin':
        assert tokens == ['Suomen', 'kieli', '(', 'suomi', ')', 'on', 'uralilaisten', 'kielten', 'itämerensuomalaiseen', 'ryhmään', 'kuuluva', 'kieli', '.']
    elif lang == 'fra':
        assert tokens == ['Le', 'français', 'est', 'une', 'langue', 'indo-européenne', 'de', 'la', 'famille', 'des', 'langues', 'romanes', 'dont', 'les', 'locuteurs', 'sont', 'appelés', 'francophones', '.']
    elif lang in ['deu_at', 'deu_de', 'deu_ch']:
        assert tokens == ['Die', 'deutsche', 'Sprache', 'bzw.', 'das', 'Deutsche', '(', '[', 'dɔɪ̯tʃ];[26', ']', 'abgekürzt', 'dt', '.', 'oder', 'dtsch', '.', ')', 'ist', 'eine', 'westgermanische', 'Sprache', ',', 'die', 'weltweit', 'etwa', '90', 'bis', '105', 'Millionen', 'Menschen', 'als', 'Muttersprache', 'und', 'weiteren', 'rund', '80', 'Millionen', 'als', 'Zweit-', 'oder', 'Fremdsprache', 'dient', '.']
    elif lang == 'grc':
        assert tokens == ['Ὅτι', 'μὲν', 'ὑμεῖς', ',', 'ὦ', 'ἄνδρες', 'Ἀθηναῖοι', ',', 'πεπόνθατε', 'ὑπὸ', 'τῶν', 'ἐμῶν', 'κατηγόρων', ',', 'οὐκ', 'οἶδα', '·', 'ἐγὼ', "δ'", 'οὖν', 'καὶ', 'αὐτὸς', "ὑπ'", 'αὐτῶν', 'ὀλίγου', 'ἐμαυτοῦ', 'ἐπελαθόμην', ',', 'οὕτω', 'πιθανῶς', 'ἔλεγον', '.']
    elif lang == 'ell':
        assert tokens == ['Η', 'ελληνική', 'γλώσσα', 'ανήκει', 'στην', 'ινδοευρωπαϊκή', 'οικογένεια[10', ']', 'και', 'αποτελεί', 'το', 'μοναδικό', 'μέλος', 'του', 'ελληνικού', 'κλάδου', ',', 'ενώ', 'είναι', 'η', 'επίσημη', 'γλώσσα', 'της', 'Ελλάδος', 'και', 'της', 'Κύπρου', '.']
    elif lang == 'guj':
        assert tokens == ['ગુજરાતી', '\u200d(/ɡʊdʒəˈrɑːti/[૭', ']', ',', 'રોમન', 'લિપિમાં', ':', 'Gujarātī', ',', 'ઉચ્ચાર', ':', '[', 'ɡudʒəˈɾɑːtiː', ']', ')', 'ભારત', 'દેશના', 'ગુજરાત', 'રાજ્યની', 'ઇન્ડો-આર્યન', 'ભાષા', 'છે', ',', 'અને', 'મુખ્યત્વે', 'ગુજરાતી', 'લોકો', 'દ્વારા', 'બોલાય', 'છે.']
    elif lang == 'heb':
        assert tokens == ['עִבְרִית', 'היא', 'שפה', 'שמית', ',', 'ממשפחת', 'השפות', 'האפרו', '-', 'אסיאתיות', ',', 'הידועה', 'כשפתם', 'של', 'היהודים', 'ושל', 'השומרונים', ',', 'אשר', 'ניב', 'מודרני', 'שלה', '(', 'עברית', 'ישראלית', ')', 'הוא', 'שפתה', 'הרשמית', 'של', 'מדינת', 'ישראל', ',', 'מעמד', 'שעוגן', 'בשנת', '2018', 'בחוק', 'יסוד', ':', 'ישראל', '–', 'מדינת', 'הלאום', 'של', 'העם', 'היהודי', '.']
    elif lang == 'hin':
        assert tokens == ['हिन्दी', 'विश्व', 'की', 'एक', 'प्रमुख', 'भाषा', 'है', 'एवं', 'भारत', 'की', 'राजभाषा', 'है', '।']
    elif lang == 'hun':
        assert tokens == ['A', 'magyar', 'nyelv', 'az', 'uráli', 'nyelvcsalád', 'tagja', ',', 'a', 'finnugor', 'nyelvek', 'közé', 'tartozó', 'ugor', 'nyelvek', 'egyike', '.']
    elif lang == 'isl':
        if word_tokenizer == 'tokenizer_isl':
            assert tokens == ['Íslenska', 'er', 'vesturnorrænt', ',', 'germanskt', 'og', 'indóevrópskt', 'tungumál', 'sem', 'er', 'einkum', 'talað', 'og', 'ritað', 'á', 'Íslandi', 'og', 'er', 'móðurmál', 'langflestra', 'Íslendinga', '.', '[', '4', ']']
        elif word_tokenizer == 'spacy_isl':
            assert tokens == ['Íslenska', 'er', 'vesturnorrænt', ',', 'germanskt', 'og', 'indóevrópskt', 'tungumál', 'sem', 'er', 'einkum', 'talað', 'og', 'ritað', 'á', 'Íslandi', 'og', 'er', 'móðurmál', 'langflestra', 'Íslendinga.[4', ']']
        else:
            raise Exception(f'Error: Tests for word tokenizer "{word_tokenizer}" is skipped!')
    elif lang == 'ind':
        assert tokens == ['Bahasa', 'Indonesia', 'adalah', 'bahasa', 'Melayu', 'baku', 'yang', 'dijadikan', 'sebagai', 'bahasa', 'resmi', 'Republik', 'Indonesia[1', ']', 'dan', 'bahasa', 'persatuan', 'bangsa', 'Indonesia.[2', ']']
    elif lang == 'gle':
        assert tokens == ['Is', 'ceann', 'de', 'na', 'teangacha', 'Ceilteacha', 'í', 'an', 'Ghaeilge', '(', 'nó', 'Gaeilge', 'na', 'hÉireann', 'mar', 'a', 'thugtar', 'uirthi', 'corruair', ')', ',', 'agus', 'ceann', 'den', 'dtrí', 'cinn', 'de', 'theangacha', 'Ceilteacha', 'ar', 'a', 'dtugtar', 'na', 'teangacha', 'Gaelacha', '(', '.i.', 'an', 'Ghaeilge', ',', 'Gaeilge', 'na', 'hAlban', 'agus', 'Gaeilge', 'Mhanann', ')', 'go', 'háirithe', '.']
    elif lang == 'ita':
        assert tokens == ["L'", 'italiano', '(', '[', 'itaˈljaːno][Nota', '1', ']', 'ascolta[?·info', ']', ')', 'è', 'una', 'lingua', 'romanza', 'parlata', 'principalmente', 'in', 'Italia', '.']
    elif lang == 'jpn':
        if word_tokenizer == 'nagisa_jpn':
            assert tokens == ['日本', '語', '(', 'にほんご', '、', 'にっぽん', 'ご', '[', '注', '2', ']', '、', '英', ':', 'Japanese', ')', 'は', '、', '日本', '国', '内', 'や', '、', 'かつて', 'の', '日本', '領', 'だっ', 'た', '国', '、', 'そして', '日本', '人', '同士', 'の', '間', 'で', '使用', 'さ', 'れ', 'て', 'いる', '言語', '。']
        elif word_tokenizer in [
            'spacy_jpn',
            'sudachipy_jpn_split_mode_a'
        ]:
            assert tokens == ['日本', '語', '(', 'にほん', 'ご', '、', 'にっぽん', 'ご', '[', '注', '2', ']', '、', '英', ':', 'Japanese', ')', 'は', '、', '日本', '国', '内', 'や', '、', 'かつて', 'の', '日本', '領', 'だっ', 'た', '国', '、', 'そして', '日本', '人', '同士', 'の', '間', 'で', '使用', 'さ', 'れ', 'て', 'いる', '言語', '。']
        elif word_tokenizer in [
            'sudachipy_jpn_split_mode_b',
            'sudachipy_jpn_split_mode_c'
        ]:
            assert tokens == ['日本語', '(', 'にほん', 'ご', '、', 'にっぽん', 'ご', '[', '注', '2', ']', '、', '英', ':', 'Japanese', ')', 'は', '、', '日本', '国', '内', 'や', '、', 'かつて', 'の', '日本', '領', 'だっ', 'た', '国', '、', 'そして', '日本人', '同士', 'の', '間', 'で', '使用', 'さ', 'れ', 'て', 'いる', '言語', '。']
        elif word_tokenizer == 'wordless_jpn_kanji':
            assert tokens == ['日', '本', '語', '(', 'にほんご', '、', 'にっぽん', 'ご', '[', '注', '2', ']', '、', '英', ':', 'Japanese', ')', 'は', '、', '日', '本', '国', '内', 'や', '、', 'かつて', 'の', '日', '本', '領', 'だっ', 'た', '国', '、', 'そして', '日', '本', '人', '同', '士', 'の', '間', 'で', '使', '用', 'さ', 'れ', 'て', 'いる', '言', '語', '。']
        else:
            raise Exception(f'Error: Tests for word tokenizer "{word_tokenizer}" is skipped!')
    elif lang == 'kan':
        assert tokens == ['ದ್ರಾವಿಡ', 'ಭಾಷೆಗಳಲ್ಲಿ', 'ಪ್ರಾಮುಖ್ಯವುಳ್ಳ', 'ಭಾಷೆಯೂ', 'ಭಾರತದ', 'ಪುರಾತನವಾದ', 'ಭಾಷೆಗಳಲ್ಲಿ', 'ಒಂದೂ', 'ಆಗಿರುವ', 'ಕನ್ನಡ', 'ಭಾಷೆಯನ್ನು', 'ಅದರ', 'ವಿವಿಧ', 'ರೂಪಗಳಲ್ಲಿ', 'ಸುಮಾರು', '೪೫', 'ದಶಲಕ್ಷ', 'ಜನರು', 'ಆಡು', 'ನುಡಿಯಾಗಿ', 'ಬಳಸುತ್ತಲಿದ್ದಾರೆ', '.']
    elif lang == 'kir':
        assert tokens == ['Кыргыз', 'тили', '—', 'Кыргыз', 'Республикасынын', 'мамлекеттик', 'тили', ',', 'түрк', 'тилдеринин', 'курамына', ',', 'анын', 'ичинде', 'кыргыз-кыпчак', 'тобуна', 'кирет', '.']
    elif lang == 'lav':
        assert tokens == ['Latviešu', 'valoda', 'ir', 'dzimtā', 'valoda', 'apmēram', '1,7', 'miljoniem', 'cilvēku', ',', 'galvenokārt', 'Latvijā', ',', 'kur', 'tā', 'ir', 'vienīgā', 'valsts', 'valoda.[3', ']']
    elif lang == 'lij':
        assert tokens == ['O', 'Lìgure', '(', 'in', 'monegasco', ':', 'lenga', 'ligüra', 'e', 'lenga', 'lìgura', ')', 'o', "l'", 'é', "'", 'na', 'lengoa[1', ']', 'do', 'gruppo', 'lengoìstego', 'itàlico', 'oçidentâ', 'parlâ', 'in', 'Italia', '(', 'Liguria', ',', 'Piemonte', ',', 'Emilia', '-', 'Romagna', 'e', 'Sardegna', ')', ',', 'into', 'sud', 'da', 'Fransa', ',', 'in', 'Còrsega', ',', 'e', 'into', 'Prinçipato', 'de', 'Monego', '.']
    elif lang == 'lit':
        assert tokens == ['Lietuvių', 'kalba', '–', 'iš', 'baltų', 'prokalbės', 'kilusi', 'lietuvių', 'tautos', 'kalba', ',', 'kuri', 'Lietuvoje', 'yra', 'valstybinė', ',', 'o', 'Europos', 'Sąjungoje', '–', 'viena', 'iš', 'oficialiųjų', 'kalbų', '.']
    elif lang == 'ltz':
        assert tokens == ["D'", 'Lëtzebuergesch', 'gëtt', 'an', 'der', 'däitscher', 'Dialektologie', 'als', 'ee', 'westgermaneschen', ',', 'mëtteldäitschen', 'Dialekt', 'aklasséiert', ',', 'deen', 'zum', 'Muselfränkesche', 'gehéiert', '.']
    elif lang == 'mkd':
        assert tokens == ['Македонски', 'јазик', '—', 'јужнословенски', 'јазик', ',', 'дел', 'од', 'групата', 'на', 'словенски', 'јазици', 'од', 'јазичното', 'семејство', 'на', 'индоевропски', 'јазици', '.']
    elif lang == 'mal':
        assert tokens == ['ഇന്ത്യയിൽ', 'പ്രധാനമായും', 'കേരള', 'സംസ്ഥാനത്തിലും', 'ലക്ഷദ്വീപിലും', 'പുതുച്ചേരിയുടെ', 'ഭാഗമായ', 'മയ്യഴിയിലും', 'സംസാരിക്കപ്പെടുന്ന', 'ഭാഷയാണ്', 'മലയാളം.']
    elif lang == 'mar':
        assert tokens == ['मराठीभाषा', 'ही', 'इंडो', '-', 'युरोपीय', 'भाषाकुलातील', 'एक', 'भाषा', 'आहे', '.']
    elif lang == 'mni':
        assert tokens == ['ꯃꯤꯇꯩꯂꯣꯟ', 'ꯍꯥꯏꯕꯁꯤ', 'ꯏꯟꯗꯤꯌꯥ', 'ꯑꯋꯥꯡ-ꯅꯣꯡꯄꯣꯛꯇ', 'ꯂꯩꯕ', 'ꯃꯅꯤꯄꯨꯔꯗ', 'ꯃꯔꯨꯑꯣꯏꯅ', 'ꯉꯥꯡꯅꯕ', 'ꯇꯤꯕꯦꯇꯣ-ꯕꯔꯃꯟ', 'ꯀꯥꯡꯂꯨꯞꯇ', 'ꯆꯤꯡꯕ', 'ꯂꯣꯟ', 'ꯑꯃꯅꯤ', '꯫', 'ꯚꯥꯔꯠ', 'ꯂꯩꯉꯥꯛꯅꯥ', 'ꯁꯛꯈꯪꯂꯕ', 'ꯂꯣꯟ', '꯲꯲', 'ꯁꯤꯡꯒꯤ', 'ꯃꯅꯨꯡꯗ', 'ꯃꯤꯇꯩꯂꯣꯟꯁꯤꯁꯨ', 'ꯑꯃꯅꯤ', '꯫', 'ꯃꯤꯇꯩꯂꯣꯟ', 'ꯑꯁꯤ', 'ꯏꯟꯗꯤꯌꯥꯒꯤ', 'ꯁ', '꯭', 'ꯇꯦꯠ', 'ꯑꯣꯏꯔꯤꯕ', 'ꯑꯁꯥꯝ', 'ꯑꯃꯁꯨꯡ', 'ꯇ', '꯭', 'ꯔꯤꯄꯨꯔꯥ', 'ꯑꯃꯗꯤ', 'ꯑꯇꯩ', 'ꯂꯩꯕꯥꯛꯁꯤꯡꯗ', 'ꯍꯥꯏꯕꯗꯤ', 'ꯕꯥꯡꯂꯥꯗꯦꯁ', 'ꯑꯃꯁꯨꯡ', 'ꯑꯋꯥꯗꯁꯨ', 'ꯉꯥꯡꯅꯩ', '꯫', 'ꯏꯪ', 'ꯀꯨꯝꯖ', '꯲꯰꯱꯱', 'ꯒꯤ', 'ꯃꯤꯀꯣꯛ', 'ꯊꯤꯕꯗ', 'ꯃꯤꯇꯩꯂꯣꯟꯕꯨ', 'ꯏꯃꯥꯂꯣꯟ', 'ꯑꯣꯢꯅ', 'ꯉꯥꯡꯕꯒꯤ', 'ꯃꯤꯁꯤꯡ', 'ꯂꯤꯆꯥ', '꯱꯸', 'ꯃꯨꯛ', 'ꯁꯨꯢ', '꯫']
    elif lang == 'nep':
        assert tokens == ['नेपाली', 'भाषा', '(', 'अन्तर्राष्ट्रिय', 'ध्वन्यात्मक', 'वर्णमाला', '[', 'neˈpali', 'bʱaʂa', ']', ')', 'नेपालको', 'सम्पर्क', 'भाषा', 'तथा', 'भारत', ',', 'भुटान', 'र', 'म्यानमारको', 'केही', 'भागमा', 'मातृभाषाको', 'रूपमा', 'बोलिने', 'भाषा', 'हो', '।']
    elif lang == 'nob':
        assert tokens == ['Bokmål', 'er', 'en', 'varietet', 'av', 'norsk', 'språk', '.']
    elif lang == 'ori':
        assert tokens == ['ଓଡ଼ିଆ', '(', 'ଇଂରାଜୀ', 'ଭାଷାରେ', 'Odia', '/', 'əˈdiːə', '/', 'or', 'Oriya', '/', 'ɒˈriːə', '/', ',', ')', 'ଏକ', 'ଭାରତୀୟ', 'ଭାଷା', 'ଯାହା', 'ଏକ', 'ଇଣ୍ଡୋ-ଇଉରୋପୀୟ', 'ଭାଷାଗୋଷ୍ଠୀ', 'ଅନ୍ତର୍ଗତ', 'ଇଣ୍ଡୋ-ଆର୍ଯ୍ୟ', 'ଭାଷା', '।']
    elif lang == 'fas':
        assert tokens == ['فارسی', 'یا', 'پارسی', 'یکی', 'از', 'زبان\u200cهای', 'هندواروپایی', 'در', 'شاخهٔ', 'زبان\u200cهای', 'ایرانی', 'جنوب', 'غربی', 'است', 'که', 'در', 'کشورهای', 'ایران', '،', 'افغانستان،[۳', ']', 'تاجیکستان[۴', ']', 'و', 'ازبکستان[۵', ']', 'به', 'آن', 'سخن', 'می\u200cگویند', '.']
    elif lang == 'pol':
        assert tokens == ['Język', 'polski', ',', 'polszczyzna', '–', 'język', 'lechicki', 'z', 'grupy', 'zachodniosłowiańskiej', '(', 'do', 'której', 'należą', 'również', 'czeski', ',', 'kaszubski', ',', 'słowacki', 'i', 'języki', 'łużyckie', ')', ',', 'stanowiącej', 'część', 'rodziny', 'indoeuropejskiej', '.']
    elif lang in ['por_br', 'por_pt']:
        assert tokens == ['A', 'língua', 'portuguesa', ',', 'também', 'designada', 'português', ',', 'é', 'uma', 'língua', 'românica', 'flexiva', 'ocidental', 'originada', 'no', 'galego-português', 'falado', 'no', 'Reino', 'da', 'Galiza', 'e', 'no', 'norte', 'de', 'Portugal', '.']
    elif lang == 'pan':
        assert tokens == ['ਪੰਜਾਬੀ', 'ਭਾਸ਼ਾ', '/', 'pʌnˈdʒɑːbi', '/', '(', 'ਸ਼ਾਹਮੁਖੀ', ':', '\u200e', 'پنجابی', '\u200e', ')', '(', 'ਗੁਰਮੁਖੀ', ':', 'ਪੰਜਾਬੀ', ')', 'ਪੰਜਾਬ', 'ਦੀ', 'ਭਾਸ਼ਾ', ',', 'ਜਿਸ', 'ਨੂੰ', 'ਪੰਜਾਬ', 'ਖੇਤਰ', 'ਦੇ', 'ਵਸਨੀਕ', 'ਜਾਂ', 'ਸੰਬੰਧਿਤ', 'ਲੋਕ', 'ਬੋਲਦੇ', 'ਹਨ', '।', '[', '1', ']']
    elif lang == 'ron':
        assert tokens == ['Limba', 'română', 'este', 'o', 'limbă', 'indo-europeană', ',', 'din', 'grupul', 'italic', 'și', 'din', 'subgrupul', 'oriental', 'al', 'limbilor', 'romanice', '.']
    elif lang == 'rus':
        assert tokens == ['Ру́сский', 'язы́к', '(', '[', 'ˈruskʲɪi̯', 'jɪˈzɨk', ']', 'Информация', 'о', 'файле', 'слушать)[~', '3', ']', '[', '⇨', ']', '—', 'один', 'из', 'восточнославянских', 'языков', ',', 'национальный', 'язык', 'русского', 'народа', '.']
    elif lang == 'san':
        assert tokens == ['संस्कृतम्', '(', 'IPA', ':', '[', 'ˈsɐ̃skr̩tɐm', ']', '(', 'शृणु', ')', ')', 'जगतः', 'एकतमा', 'अतिप्राचीना', 'समृद्धा', 'शास्त्रीया', 'च', 'भाषा', 'वर्तते', '।']
    elif lang == 'srp_cyrl':
        assert tokens == ['Српски', 'језик', 'припада', 'словенској', 'групи', 'језика', 'породице', 'индоевропских', 'језика.[12', ']']
    elif lang == 'srp_latn':
        assert tokens == ['Srpski', 'jezik', 'pripada', 'slovenskoj', 'grupi', 'jezika', 'porodice', 'indoevropskih', 'jezika.[12', ']']
    elif lang == 'sin':
        assert tokens == ['ශ්\u200dරී', 'ලංකාවේ', 'ප්\u200dරධාන', 'ජාතිය', 'වන', 'සිංහල', 'ජනයාගේ', 'මව්', 'බස', 'සිංහල', 'වෙයි', '.']
    elif lang == 'slk':
        assert tokens == ['Slovenčina', 'patrí', 'do', 'skupiny', 'západoslovanských', 'jazykov', '(', 'spolu', 's', 'češtinou', ',', 'poľštinou', ',', 'hornou', 'a', 'dolnou', 'lužickou', 'srbčinou', 'a', 'kašubčinou', ')', '.']
    elif lang == 'slv':
        assert tokens == ['Slovenščina', '[', 'slovénščina', ']', '/', '[', 'sloˈʋenʃtʃina', ']', 'je', 'združeni', 'naziv', 'za', 'uradni', 'knjižni', 'jezik', 'Slovencev', 'in', 'skupno', 'ime', 'za', 'narečja', 'in', 'govore', ',', 'ki', 'jih', 'govorijo', 'ali', 'so', 'jih', 'nekoč', 'govorili', 'Slovenci', '.']
    elif lang == 'spa':
        assert tokens == ['El', 'español', 'o', 'castellano', 'es', 'una', 'lengua', 'romance', 'procedente', 'del', 'latín', 'hablado', ',', 'perteneciente', 'a', 'la', 'familia', 'de', 'lenguas', 'indoeuropeas', '.']
    elif lang == 'swe':
        assert tokens == ['Svenska', '(', 'svenska', '(', 'info', ')', ')', 'är', 'ett', 'östnordiskt', 'språk', 'som', 'talas', 'av', 'ungefär', 'tio', 'miljoner', 'personer', 'främst', 'i', 'Sverige', 'där', 'språket', 'har', 'en', 'dominant', 'ställning', 'som', 'huvudspråk', ',', 'men', 'även', 'som', 'det', 'ena', 'nationalspråket', 'i', 'Finland', 'och', 'som', 'enda', 'officiella', 'språk', 'på', 'Åland', '.']
    elif lang == 'tgl':
        assert tokens == ['Ang', 'Wikang', 'Tagalog[2', ']', '(', 'Baybayin', ':', 'ᜏᜒᜃᜅ᜔', 'ᜆᜄᜎᜓᜄ᜔', ')', ',', 'na', 'kilala', 'rin', 'sa', 'payak', 'na', 'pangalang', 'Tagalog', ',', 'ay', 'isa', 'sa', 'mga', 'pangunahing', 'wika', 'ng', 'Pilipinas', 'at', 'sinasabing', 'ito', 'ang', 'de', 'facto', '(', '"', 'sa', 'katunayan', '"', ')', 'ngunit', 'hindî', 'de', 'jure', '(', '"', 'sa', 'batas', '"', ')', 'na', 'batayan', 'na', 'siyang', 'pambansang', 'Wikang', 'Filipino', '(', 'mula', '1961', 'hanggang', '1987', ':', 'Pilipino).[2', ']']
    elif lang == 'tgk':
        assert tokens == ['Забони', 'тоҷикӣ', '—', 'забоне', ',', 'ки', 'дар', 'Эрон', ':', 'форсӣ', ',', 'ва', 'дар', 'Афғонистон', 'дарӣ', 'номида', 'мешавад', ',', 'забони', 'давлатии', 'кишварҳои', 'Тоҷикистон', ',', 'Эрон', 'ва', 'Афғонистон', 'мебошад', '.']
    elif lang == 'tam':
        assert tokens == ['தமிழ்', 'மொழி', '(', 'Tamil', 'language', ')', 'தமிழர்களினதும்', ',', 'தமிழ்', 'பேசும்', 'பலரதும்', 'தாய்மொழி', 'ஆகும்', '.']
    elif lang == 'tat':
        assert tokens == ['Татар', 'теле', '—', 'татарларның', 'милли', 'теле', ',', 'Татарстанның', 'дәүләт', 'теле', ',', 'таралышы', 'буенча', 'Русиядә', 'икенче', 'тел', '.']
    elif lang == 'tel':
        tokens == ['ఆంధ్ర', 'ప్రదేశ్', ',', 'తెలంగాణ', 'రాష్ట్రాల', 'అధికార', 'భాష', 'తెలుగు', '.']
    elif lang == 'tdt':
        tokens == ['Tetun', '(', 'iha', 'portugés', ':', 'tétum', ';', 'iha', 'inglés', ':', 'Tetum', ')', 'ne', "'", 'e', 'lian', 'nasionál', 'no', 'ko-ofisiál', 'Timór', 'Lorosa', "'", 'e', 'nian', '.']
    elif lang == 'tha':
        if word_tokenizer in [
            'pythainlp_longest_matching',
            'pythainlp_max_matching_tcc',
            'pythainlp_max_matching_tcc_safe_mode',
            'pythainlp_nercut'
        ]:
            assert tokens == ['ภาษาไทย', 'หรือ', 'ภาษาไทย', 'กลาง', 'เป็น', 'ภาษาราชการ', 'และ', 'ภาษาประจำชาติ', 'ของ', 'ประเทศ', 'ไทย']
        elif word_tokenizer == 'pythainlp_max_matching':
            assert tokens == ['ภาษาไทย', 'หรือ', 'ภาษาไทยกลาง', 'เป็น', 'ภาษาราชการ', 'และ', 'ภาษาประจำชาติ', 'ของ', 'ประเทศ', 'ไทย']
        else:
            raise Exception(f'Error: Tests for word tokenizer "{word_tokenizer}" is skipped!')
    elif lang == 'bod':
        assert tokens == ['བོད་', 'ཀྱི་', 'སྐད་ཡིག་', 'ནི་', 'བོད་ཡུལ་', 'དང་', 'དེ', 'འི་', 'ཉེ་འཁོར་', 'གྱི་', 'ས་ཁུལ་', 'ཏེ', '།']
    elif lang == 'tir':
        assert tokens == ['ትግርኛ', 'ኣብ', 'ኤርትራን', 'ኣብ', 'ሰሜናዊ', 'ኢትዮጵያን', 'ኣብ', 'ክልል', 'ትግራይ', 'ዝዝረብ', 'ሴማዊ', 'ቋንቋ', 'እዩ', '።']
    elif lang == 'tsn':
        assert tokens == ['Setswana', 'ke', 'teme', 'e', 'e', 'buiwang', 'mo', 'mafatsheng', 'a', 'Aforika', 'Borwa', ',', 'Botswana', ',', 'Namibia', 'le', 'Zimbabwe', '.']
    elif lang == 'tur':
        assert tokens == ['Türkçe', 'ya', 'da', 'Türk', 'dili', ',', 'batıda', 'Balkanlar’dan', 'başlayıp', 'doğuda', 'Hazar', 'Denizi', 'sahasına', 'kadar', 'konuşulan', 'Türkî', 'diller', 'dil', 'ailesine', 'ait', 'sondan', 'eklemeli', 'bir', 'dil.[12', ']']
    elif lang == 'ukr':
        assert tokens == ['Украї́нська', 'мо́ва', '(', 'МФА', ':', '[', 'ukrɑ̽ˈjɪnʲsʲkɑ̽', 'ˈmɔwɑ̽', ']', ',', 'історичні', 'назви', '—', 'ру́ська', ',', 'руси́нська[9][10][11', ']', '[', '*', '2', ']', ')', '—', 'національна', 'мова', 'українців', '.']
    elif lang == 'urd':
        assert tokens == ['اُردُو', 'لشکری', 'زبان[8', ']', '(', 'یا', 'جدید', 'معیاری', 'اردو', ')', 'برصغیر', 'کی', 'معیاری', 'زبانوں', 'میں', 'سے', 'ایک', 'ہے', '۔']
    elif lang == 'vie':
        assert tokens == ['Tiếng', 'Việt', ',', 'cũng', 'gọi là', 'tiếng', 'Việt Nam', '[', '5 ]', 'hay', 'Việt ngữ', 'là', 'ngôn ngữ', 'của', 'người', 'Việt', 'và', 'là', 'ngôn ngữ', 'chính thức', 'tại', 'Việt Nam', '.']
    elif lang == 'yor':
        assert tokens == ['Èdè', 'Yorùbá', 'Ni', 'èdè', 'tí', 'ó', 'ṣàkójọ', 'pọ̀', 'gbogbo', 'kú', 'oótu', 'o', '-', 'ò', '-', 'jíire', 'bí', ',', 'níapá', 'ìwọ̀', 'Oòrùn', 'ilẹ̀', 'Nàìjíríà', ',', 'tí', 'a', 'bá', 'wo', 'èdè', 'Yorùbá', ',', 'àwọn', 'onímọ̀', 'pín', 'èdè', 'náà', 'sábẹ́', 'ẹ̀yà', 'Kwa', 'nínú', 'ẹbí', 'èdè', 'Niger', '-', 'Congo', '.']
    else:
        raise Exception(f'Error: Tests for language "{lang}" is skipped!')
def test_sentence_tokenize(lang, sentence_tokenizer, show_results = False):
    lang_text = wl_conversion.to_lang_text(main, lang)

    sentences = wl_sentence_tokenization.wl_sentence_tokenize(
        main,
        text = getattr(wl_test_lang_examples, f'TEXT_{lang.upper()}'),
        lang = lang,
        sentence_tokenizer = sentence_tokenizer)

    if show_results:
        print(f'{lang} / {sentence_tokenizer}:')
        print(sentences)

    if lang == 'afr':
        assert sentences == ["Afrikaans is tipologies gesien 'n Indo-Europese, Wes-Germaanse, Nederfrankiese taal,[2] wat sy ontstaan aan die suidpunt van Afrika gehad het onder invloed van verskeie ander tale en taalgroepe.", "Afrikaans is op 8 Mei 1925 as 'n amptelike taal van Suid-Afrika erken en is tans die derde jongste Germaanse taal wat amptelike status geniet, naas Faroëes wat in 1948 grondwetlik erken is en Luxemburgs wat hierdie status in 1984 gekry het."]
    elif lang == 'sqi':
        assert sentences == ['Gjuha shqipe (ose thjeshtë shqipja) është gjuhë dhe degë e veçantë e familjes indo-evropiane të folur nga më shumë se 6 milionë njerëz[4], kryesisht në Shqipëri, Kosovë dhe Republikën e Maqedonisë, por edhe në zona të tjera të Evropës Jugore ku ka një popullsi shqiptare, duke përfshirë Malin e Zi dhe Luginën e Preshevës.', 'Është gjuha zyrtare e Shqipërisë dhe Kosovës.']
    elif lang == 'ara':
        assert sentences == ['اللُّغَة العَرَبِيّة هي أكثر اللغات تحدثاً ونطقاً ضمن مجموعة اللغات السامية، وإحدى أكثر اللغات انتشاراً في العالم، يتحدثها أكثر من 467 مليون نسمة،(1) ويتوزع متحدثوها في الوطن العربي، بالإضافة إلى العديد من المناطق الأخرى المجاورة كالأحواز وتركيا وتشاد ومالي والسنغال وإرتيريا وإثيوبيا وجنوب السودان وإيران.', 'اللغة العربية ذات أهمية قصوى لدى المسلمين، فهي عندهم لغة مقدسة إذ أنها لغة القرآن، وهي لغة الصلاة وأساسية في القيام بالعديد من العبادات والشعائر الإسلامية.', 'العربية هي أيضاً لغة شعائرية رئيسية لدى عدد من الكنائس المسيحية في الوطن العربي، كما كتبت بها كثير من أهم الأعمال الدينية والفكرية اليهودية في العصور الوسطى.', 'ارتفعت مكانة اللغة العربية إثر انتشار الإسلام بين الدول إذ أصبحت لغة السياسة والعلم والأدب لقرون طويلة في الأراضي التي حكمها المسلمون.', 'وللغة العربية تأثير مباشر وغير مباشر على كثير من اللغات الأخرى في العالم الإسلامي، كالتركية والفارسية والأمازيغية والكردية والأردية والماليزية والإندونيسية والألبانية وبعض اللغات الإفريقية الأخرى مثل الهاوسا والسواحيلية والتجرية والأمهرية والصومالية، وبعض اللغات الأوروبية وخاصةً المتوسطية كالإسبانية والبرتغالية والمالطية والصقلية ؛ ودخلت الكثير من مصطلحاتها في اللغة الإنجليزية واللغات الأخرى، مثل أدميرال والتعريفة والكحول والجبر وأسماء النجوم.', 'كما أنها تُدرَّس بشكل رسمي أو غير رسمي في الدول الإسلامية والدول الإفريقية المحاذية للوطن العربي.']
    elif lang == 'ben':
        assert sentences == ['বাংলা ভাষা (বাঙলা, বাঙ্গলা, তথা বাঙ্গালা নামগুলোতেও পরিচিত) একটি ইন্দো-আর্য ভাষা, যা দক্ষিণ এশিয়ার বাঙালি জাতির প্রধান কথ্য ও লেখ্য ভাষা।', 'মাতৃভাষীর সংখ্যায় বাংলা ইন্দো-ইউরোপীয় ভাষা পরিবারের চতুর্থ ও বিশ্বের ষষ্ঠ বৃহত্তম ভাষা।[৫] মোট ব্যবহারকারীর সংখ্যা অনুসারে বাংলা বিশ্বের সপ্তম বৃহত্তম ভাষা।', 'বাংলা সার্বভৌম ভাষাভিত্তিক জাতিরাষ্ট্র বাংলাদেশের একমাত্র রাষ্ট্রভাষা তথা সরকারি ভাষা[৬] এবং ভারতের পশ্চিমবঙ্গ, ত্রিপুরা, আসামের বরাক উপত্যকার সরকারি ভাষা।', 'বঙ্গোপসাগরে অবস্থিত আন্দামান দ্বীপপুঞ্জের প্রধান কথ্য ভাষা বাংলা।', 'এছাড়া ভারতের ঝাড়খণ্ড, বিহার, মেঘালয়, মিজোরাম, উড়িষ্যা রাজ্যগুলোতে উল্লেখযোগ্য পরিমাণে বাংলাভাষী জনগণ রয়েছে।', 'ভারতে হিন্দির পরেই সর্বাধিক প্রচলিত ভাষা বাংলা।[৭][৮] এছাড়াও মধ্য প্রাচ্য, আমেরিকা ও ইউরোপে উল্লেখযোগ্য পরিমাণে বাংলাভাষী অভিবাসী রয়েছে।[৯] সারা বিশ্বে সব মিলিয়ে ২৬ কোটির অধিক লোক দৈনন্দিন জীবনে বাংলা ব্যবহার করে।[২] বাংলাদেশের জাতীয় সঙ্গীত এবং ভারতের জাতীয় সঙ্গীত ও স্তোত্র বাংলাতে রচিত।']
    elif lang == 'bul':
        assert sentences == ['Бъ̀лгарският езѝк е индоевропейски език от групата на южнославянските езици.', 'Той е официалният език на Република България и един от 24-те официални езика на Европейския съюз.', 'Българският език е плурицентричен език – има няколко книжовни норми.', 'Наред с използваната в България основна норма, съществуват още македонска норма, която също използва кирилица, и банатска норма, която използва латиница.']
    elif lang == 'cat':
        assert sentences == ["El català (denominació oficial a Catalunya, a les Illes Balears, a Andorra, a la ciutat de l'Alguer i tradicional a Catalunya Nord) o valencià (denominació oficial al País Valencià i tradicional al Carxe) és una llengua romànica parlada a Catalunya, el País Valencià (tret d'algunes comarques i localitats de l'interior), les Illes Balears, Andorra, la Franja de Ponent (a l'Aragó), la ciutat de l'Alguer (a l'illa de Sardenya), la Catalunya del Nord,[8] el Carxe (un petit territori de Múrcia poblat per immigrats valencians),[9][10] i en petites comunitats arreu del món (entre les quals destaca la de l'Argentina, amb 195.000 parlants).[11] Té deu milions de parlants, dels quals quasi la meitat ho són de llengua materna; el seu domini lingüístic, amb una superfície de 68.730 km² i 13.529.127 d'habitants (2009),[12] inclou 1.687 termes municipals.", "Com a llengua materna, és parlada per quatre milions de parlants (29% de la població del territori lingüístic), repartits 2.263.000 a Catalunya,[13] 1.321.000 al País Valencià[14] i 417.000 a les Illes Balears.[15] Com les altres llengües romàniques, el català prové del llatí vulgar que parlaven els romans que s'establiren a Hispània durant l'edat antiga."]
    elif lang == 'zho_cn':
        assert sentences == ['作为语言而言,为世界使用人数最多的语言,目前世界有五分之一人口做为母语。', '汉语有多种分支,当中官话最为流行,为中华人民共和国的国家通用语言(又称为普通话)、以及中华民国的国语。', '此外,中文还是联合国正式语文[3],并被上海合作组织等国际组织采用为官方语言。', '在中国大陆,汉语通称为“汉语”。', '在联合国[4]、 台湾[5]、 香港[6]及 澳门[7] ,通称为“中文”。', '在新加坡及马来西亚,通称为“华语”[注 1]。']
    elif lang == 'zho_tw':
        assert sentences == ['作為語言而言,為世界使用人數最多的語言,目前世界有五分之一人口做為母語。', '漢語有多種分支,當中官話最為流行,為中華人民共和國的國家通用語言(又稱為普通話)、以及中華民國的國語。', '此外,中文還是聯合國正式語文[3],並被上海合作組織等國際組織採用為官方語言。', '在中國大陸,漢語通稱為「漢語」。', '在聯合國[4]、 臺灣[5]、 香港[6]及 澳門[7] ,通稱為「中文」。', '在新加坡及馬來西亞,通稱為「華語」[註 1]。']
    elif lang == 'hrv':
        assert sentences == ['Hrvatski jezik (ISO 639-3: hrv) skupni je naziv za nacionalni standardni jezik Hrvata, te za skup narječja i govora kojima govore ili su nekada govorili Hrvati.', 'Njime govori oko 5,546.590 ljudi, poglavito Hrvata u Hrvatskoj (3,980.000; popis iz 2001.)', 'i Bosni i Hercegovini (469.000; 2004.).', 'Također hrvatski je materinski jezik za Hrvate u drugim zemljama; Sjedinjenim Američkim Državama (58.400; popis iz 2000.)[1]; Austrija, 19.400 (popis iz 2001.);', 'Srbija 19.223 popis 2011.;', 'Mađarska, (14.300; popis iz 2001.);', 'Italija (3.500; Vincent 1987.);', 'Crna Gora (6.810; 2006.);', 'Slovačka, 890; popis iz 2001.).']
    elif lang == 'ces':
        if sentence_tokenizer == 'NLTK - Punkt Sentence Tokenizer':
            assert sentences == ['Čeština neboli český jazyk je západoslovanský jazyk, nejbližší slovenštině, poté lužické srbštině a polštině.', 'Patří mezi slovanské jazyky, do rodiny jazyků indoevropských.', 'Čeština se vyvinula ze západních nářečí praslovanštiny na konci 10. století.', 'Je částečně ovlivněná latinou a němčinou.', 'Česky psaná literatura se objevuje od 14. století.', 'První písemné památky jsou však již z 12. století.']
        elif sentence_tokenizer == 'spaCy - Sentencizer':
            assert sentences == ['Čeština neboli český jazyk je západoslovanský jazyk, nejbližší slovenštině, poté lužické srbštině a polštině.', 'Patří mezi slovanské jazyky, do rodiny jazyků indoevropských.', 'Čeština se vyvinula ze západních nářečí praslovanštiny na konci 10.', 'století.', 'Je částečně ovlivněná latinou a němčinou.', 'Česky psaná literatura se objevuje od 14.', 'století.', 'První písemné památky jsou však již z 12.', 'století.']
    elif lang == 'dan':
        assert sentences == ['Dansk er et nordgermansk sprog af den østnordiske (kontinentale) gruppe, der tales af ca. seks millioner mennesker.', 'Det er stærkt påvirket af plattysk.', 'Dansk tales også i Sydslesvig (i Flensborg ca. 20 %) samt på Færøerne og Grønland [1].', 'Dansk er tæt forbundet med norsk.', 'Både dansk, norsk og svensk er skandinaviske sprog og minder meget om hinanden.']
    elif lang == 'nld':
        assert sentences == ['Het Nederlands is een West-Germaanse taal en de moedertaal van de meeste inwoners van Nederland, België en Suriname.', 'In de Europese Unie spreken ongeveer 25 miljoen mensen Nederlands als eerste taal, en een bijkomende acht miljoen als tweede taal.', 'Verder is het Nederlands ook een officiële taal van de Caraïbische (ei)landen Aruba, Curaçao en Sint-Maarten, terwijl de Franse Westhoek en de regio rondom de Duitse stad Kleef van oudsher Nederlandstalige gebieden zijn, waar Nederlandse dialecten mogelijk nog gesproken worden door de oudste generaties.', 'Ook in de voormalige kolonie Indonesië kunnen in sommige gebieden de oudste generaties nog Nederlands spreken.', 'Het aantal sprekers van het Nederlands in de Verenigde Staten, Canada en Australië wordt geschat op ruim een half miljoen.', 'De Kaap-Hollandse dialecten van Zuid-Afrika en Namibië werden gestandaardiseerd tot Afrikaans, een dochtertaal van het Nederlands.']
    elif lang == 'eng':
        if sentence_tokenizer == 'NLTK - Punkt Sentence Tokenizer':
            assert sentences == ['English is a West Germanic language that was first spoken in early medieval England and eventually became a global lingua franca.', '[5][6] It is named after the Angles, one of the Germanic tribes that migrated to the area of Great Britain that later took their name, as England.', 'Both names derive from Anglia, a peninsula in the Baltic Sea.', 'The language is closely related to Frisian and Low Saxon, and its vocabulary has been significantly influenced by other Germanic languages, particularly Norse (a North Germanic language), and to a greater extent by Latin and French.', '[7]']
        elif sentence_tokenizer == 'spaCy - Sentencizer':
            assert sentences == ['English is a West Germanic language that was first spoken in early medieval England and eventually became a global lingua franca.[5][6] It is named after the Angles, one of the Germanic tribes that migrated to the area of Great Britain that later took their name, as England.', 'Both names derive from Anglia, a peninsula in the Baltic Sea.', 'The language is closely related to Frisian and Low Saxon, and its vocabulary has been significantly influenced by other Germanic languages, particularly Norse (a North Germanic language), and to a greater extent by Latin and French.[7]']
    elif lang == 'est':
        assert sentences == ['Eesti keel (varasem nimetus: maakeel) on läänemeresoome lõunarühma kuuluv keel.', 'Selle lähemad sugulased on läänemeresoome keeled vadja ja liivi keel.']
    elif lang == 'fin':
        assert sentences == ['Suomen kieli (suomi) on uralilaisten kielten itämerensuomalaiseen ryhmään kuuluva kieli.', 'Sitä puhuu äidinkielenään Suomessa 4,9 miljoonaa ja toisena kielenä 0,5 miljoonaa henkilöä.', 'Suurimmat suomea puhuvat vähemmistöt ovat Ruotsissa, Norjassa ja Venäjällä.']
    elif lang == 'fra':
        assert sentences == ['Le français est une langue indo-européenne de la famille des langues romanes.', "Le français s'est formé en France (variété de la « langue d’oïl », qui est la langue de la partie septentrionale du pays).", "Il est parlé, en 2018, sur tous les continents par environ 300 millions de personnes1,4 : 235 millions l'emploient quotidiennement et 77 millions2 en sont des locuteurs natifs.", "En 2018, 80 millions d'élèves et étudiants s'instruisent en français dans le monde5.", "Selon l'Organisation Internationale de la Francophonie, il y aura 700 millions de francophones dans le monde en 20506."]
    elif lang == 'deu':
        if sentence_tokenizer == 'NLTK - Punkt Sentence Tokenizer':
            assert sentences == ['Ihr Sprachraum umfasst Deutschland, Österreich, die Deutschschweiz, Liechtenstein, Luxemburg, Ostbelgien, Südtirol, das Elsass und Lothringen sowie Nordschleswig.', 'Außerdem ist sie eine Minderheitensprache in einigen europäischen und außereuropäischen Ländern, z.', 'B. in Rumänien und Südafrika, sowie Nationalsprache im afrikanischen Namibia.']
        elif sentence_tokenizer == 'spaCy - Sentencizer':
            assert sentences == ['Ihr Sprachraum umfasst Deutschland, Österreich, die Deutschschweiz, Liechtenstein, Luxemburg, Ostbelgien, Südtirol, das Elsass und Lothringen sowie Nordschleswig.', 'Außerdem ist sie eine Minderheitensprache in einigen europäischen und außereuropäischen Ländern, z. B. in Rumänien und Südafrika, sowie Nationalsprache im afrikanischen Namibia.']
    elif lang == 'ell':
        assert sentences == ['Η ελληνική γλώσσα ανήκει στην ινδοευρωπαϊκή οικογένεια[9] και συγκεκριμένα στον ελληνικό κλάδο, μαζί με την τσακωνική, ενώ είναι η επίσημη γλώσσα της Ελλάδος και της Κύπρου.', 'Ανήκει επίσης στον βαλκανικό γλωσσικό δεσμό.', 'Στην ελληνική γλώσσα, έχουμε γραπτά κείμενα ήδη από τον 15ο αιώνα π.Χ.']
    elif lang == 'heb':
        assert sentences == ['שם השפה עברית פירושה "לשונו של עֵבֶר",[3] ונגזר מהשם של הדמות המקראית עֵבֶר, אביהם הקדמון של עמים רבים, בהם עם ישראל.', 'לפי המסורת היהודית,[4] עבר סירב לקחת חלק בבניית מגדל בבל, ועל כן הוא וצאצאיו לא נענשו על בניית המגדל, ושפתם לא נתבלבלה.', 'עבר שימר את השפה האוניברסלית המקורית - העברית.']
    elif lang == 'hin':
        assert sentences == ['हिन्दी विश्व की एक प्रमुख भाषा है एवं भारत की राजभाषा है।', 'केन्द्रीय स्तर पर भारत में दूसरी आधिकारिक भाषा अंग्रेजी है।', 'यह हिंदुस्तानी भाषा की एक मानकीकृत रूप है जिसमें संस्कृत के तत्सम तथा तद्भव शब्दों का प्रयोग अधिक है और अरबी-फ़ारसी शब्द कम हैं।', 'हिंदी संवैधानिक रूप से भारत की राजभाषा और भारत की सबसे अधिक बोली और समझी जाने वाली भाषा है।', 'हालाँकि, हिन्दी भारत की राष्ट्रभाषा नहीं है,[3] क्योंकि भारत के संविधान में कोई भी भाषा को ऐसा दर्जा नहीं दिया गया था।[4][5] चीनी के बाद यह विश्व में सबसे अधिक बोली जाने वाली भाषा भी है।', 'विश्व आर्थिक मंच की गणना के अनुसार यह विश्व की दस शक्तिशाली भाषाओं में से एक है।[6]']
    elif lang == 'hun':
        assert sentences == ['A magyar nyelv az uráli nyelvcsalád tagja, a finnugor nyelvek közé tartozó ugor nyelvek egyike.', 'Legközelebbi rokonai a manysi és a hanti nyelv, majd utánuk az udmurt, a komi, a mari és a mordvin nyelvek.', 'Vannak olyan vélemények, melyek szerint a moldvai csángó önálló nyelv - különösen annak északi, középkori változata -, így ez volna a magyar legközelebbi rokonnyelve.[1]']
    elif lang == 'isl':
        assert sentences == ['Íslenska er vesturnorrænt, germanskt og indóevrópskt tungumál sem er einkum talað og ritað á Íslandi og er móðurmál langflestra Íslendinga.[4] Það hefur tekið minni breytingum frá fornnorrænu en önnur norræn mál[4] og er skyldara norsku og færeysku en sænsku og dönsku.[1][2]']
    elif lang == 'ind':
        assert sentences == ['Bahasa Indonesia adalah bahasa Melayu baku yang dijadikan sebagai bahasa resmi Republik Indonesia[1] dan bahasa persatuan bangsa Indonesia.[2] Bahasa Indonesia diresmikan penggunaannya setelah Proklamasi Kemerdekaan Indonesia, tepatnya sehari sesudahnya, bersamaan dengan mulai berlakunya konstitusi.', 'Di Timor Leste, bahasa Indonesia berstatus sebagai bahasa kerja.']
    elif lang == 'gle':
        assert sentences == ['Is ceann de na teangacha Ceilteacha í an Ghaeilge (nó Gaeilge na hÉireann mar a thugtar uirthi corruair), agus ceann den dtrí cinn de theangacha Ceilteacha ar a dtugtar na teangacha Gaelacha (.i. an Ghaeilge, Gaeilge na hAlban agus Gaeilge Mhanann) go háirithe.', 'Labhraítear in Éirinn go príomha í, ach tá cainteoirí Gaeilge ina gcónaí in áiteanna eile ar fud an domhain.']
    elif lang == 'ita':
        if sentence_tokenizer == 'NLTK - Punkt Sentence Tokenizer':
            assert sentences == ['È classificato al 21º posto tra le lingue per numero di parlanti nel mondo e, in Italia, è utilizzato da circa 58 milioni di residenti.', "[4] Nel 2015 era considerato la lingua materna del 90,4% dei cittadini italiani residenti in Italia,[5] in diminuizione rispetto al 95% del 2006[6] che spesso lo acquisiscono e lo usano insieme alle varianti regionali dell'italiano, alle lingue regionali e ai dialetti.", "In Italia viene ampiamente usato per tutti i tipi di comunicazione della vita quotidiana ed è la lingua della quasi totalità dei mezzi di comunicazione nazionali, dell'editoria e dell'amministrazione pubblica dello Stato italiano."]
        elif sentence_tokenizer == 'spaCy - Sentencizer':
            assert sentences == ["È classificato al 21º posto tra le lingue per numero di parlanti nel mondo e, in Italia, è utilizzato da circa 58 milioni di residenti.[4] Nel 2015 era considerato la lingua materna del 90,4% dei cittadini italiani residenti in Italia,[5] in diminuizione rispetto al 95% del 2006[6] che spesso lo acquisiscono e lo usano insieme alle varianti regionali dell'italiano, alle lingue regionali e ai dialetti.", "In Italia viene ampiamente usato per tutti i tipi di comunicazione della vita quotidiana ed è la lingua della quasi totalità dei mezzi di comunicazione nazionali, dell'editoria e dell'amministrazione pubblica dello Stato italiano."]
    elif lang == 'jpn':
        assert sentences == ['使用人口について正確な統計はないが、日本国内の人口、および日本国外に住む日本人や日系人、日本がかつて統治した地域の一部住民など、約1億3千万人以上と考えられている[7]。', '統計によって前後する場合もあるが、この数は世界の母語話者数で上位10位以内に入る人数である。']
    elif lang == 'kan':
        assert sentences == ['ದ್ರಾವಿಡ ಭಾಷೆಗಳಲ್ಲಿ ಪ್ರಾಮುಖ್ಯವುಳ್ಳ ಭಾಷೆಯೂ ಭಾರತದ ಪುರಾತನವಾದ ಭಾಷೆಗಳಲ್ಲಿ ಒಂದೂ ಆಗಿರುವ ಕನ್ನಡ ಭಾಷೆಯನ್ನು ಅದರ ವಿವಿಧ ರೂಪಗಳಲ್ಲಿ ಸುಮಾರು ೪೫ ದಶಲಕ್ಷ ಜನರು ಆಡು ನುಡಿಯಾಗಿ ಬಳಸುತ್ತಲಿದ್ದಾರೆ.', 'ಕನ್ನಡ ಕರ್ನಾಟಕ ರಾಜ್ಯದ ಆಡಳಿತ ಭಾಷೆ.[೧೧] ಜಗತ್ತಿನಲ್ಲಿ ಅತ್ಯಂತ ಹೆಚ್ಚು ಮಂದಿ ಮಾತನಾಡುವ ಭಾಷೆಯೆಂಬ ನೆಲೆಯಲ್ಲಿ ಇಪ್ಪತೊಂಬತ್ತನೆಯ ಸ್ಥಾನ ಕನ್ನಡಕ್ಕಿದೆ.', '೨೦೧೧ರ ಜನಗಣತಿಯ ಪ್ರಕಾರ ಜಗತ್ತಿನಲ್ಲಿ ೬.', '೪ ಕೋಟಿ ಜನಗಳು ಕನ್ನಡ ಮಾತನಾಡುತ್ತಾರೆ ಎಂದು ತಿಳಿದುಬಂದಿದೆ.', 'ಇವರಲ್ಲಿ ೫.', '೫ ಕೋಟಿ ಜನಗಳ ಮಾತೃಭಾಷೆ ಕನ್ನಡವಾಗಿದೆ.', 'ಬ್ರಾಹ್ಮಿ ಲಿಪಿಯಿಂದ ರೂಪುಗೊಂಡ ಕನ್ನಡ ಲಿಪಿಯನ್ನು ಉಪಯೋಗಿಸಿ ಕನ್ನಡ ಭಾಷೆಯನ್ನು ಬರೆಯಲಾಗುತ್ತದೆ.', 'ಕನ್ನಡ ಬರಹದ ಮಾದರಿಗಳಿಗೆ ಸಾವಿರದ ಐನೂರು ವರುಷಗಳ ಚರಿತ್ರೆಯಿದೆ.', 'ಕ್ರಿ.', 'ಶ.', 'ಆರನೆಯ ಶತಮಾನದ ಪಶ್ಚಿಮ ಗಂಗ ಸಾಮ್ರಾಜ್ಯದ ಕಾಲದಲ್ಲಿ [೧೨] ಮತ್ತು ಒಂಬತ್ತನೆಯ ಶತಮಾನದ ರಾಷ್ಟ್ರಕೂಟ ಸಾಮ್ರಾಜ್ಯದ ಕಾಲದಲ್ಲಿ ಹಳಗನ್ನಡ ಸಾಹಿತ್ಯ ಅತ್ಯಂತ ಹೆಚ್ಚಿನ ರಾಜಾಶ್ರಯ ಪಡೆಯಿತು.[೧೩][೧೪] ಅದಲ್ಲದೆ ಸಾವಿರ ವರುಷಗಳ ಸಾಹಿತ್ಯ ಪರಂಪರೆ ಕನ್ನಡಕ್ಕಿದೆ.[೧೫]ವಿನೋಬಾ ಭಾವೆ ಕನ್ನಡ ಲಿಪಿಯನ್ನು ಲಿಪಿಗಳ ರಾಣಿಯೆಂದು ಹೊಗಳಿದ್ದಾರೆ.[ಸೂಕ್ತ ಉಲ್ಲೇಖನ ಬೇಕು]']
    elif lang == 'lav':
        assert sentences == ['Latviešu valoda ir dzimtā valoda apmēram 1,7 miljoniem cilvēku, galvenokārt Latvijā, kur tā ir vienīgā valsts valoda.[3] Lielākās latviešu valodas pratēju kopienas ārpus Latvijas ir Apvienotajā Karalistē, ASV, Īrijā, Austrālijā, Vācijā, Zviedrijā, Kanādā, Brazīlijā, Krievijas Federācijā.', 'Latviešu valoda pieder pie indoeiropiešu valodu saimes baltu valodu grupas.', 'Senākie rakstu paraugi latviešu valodā — jau no 15.', 'gadsimta — ir atrodami Jāņa ģildes alus nesēju biedrības grāmatās.', 'Tajā lielākoties bija latvieši, un no 1517.', 'gada arī brālības vecākie bija latvieši.', 'Pirmais teksts latviski iespiests 1507.', 'gadā izdotajā baznīcas rokasgrāmatā „AGENDA”.[4]']
    elif lang == 'lit':
        assert sentences == ['Lietuvių kalba – iš baltų prokalbės kilusi lietuvių tautos kalba, kuri Lietuvoje yra valstybinė, o Europos Sąjungoje – viena iš oficialiųjų kalbų.', 'Lietuviškai kalba apie tris milijonus žmonių (daugumas jų gyvena Lietuvoje).', 'Drauge su latvių, mirusiomis prūsų, jotvingių ir kitomis baltų kalbomis, priklauso indoeuropiečių kalbų šeimos baltų kalbų grupei.']
    elif lang == 'ltz':
        assert sentences == ["D'Lëtzebuergesch gëtt an der däitscher Dialektologie als ee westgermaneschen, mëtteldäitschen Dialekt aklasséiert, deen zum Muselfränkesche gehéiert.", 'An der Linguistik gëtt et och alt zu de sougenannten "Ausbausproochen", bzw. "Kultursproochen", gezielt.']
    elif lang == 'nob':
        if sentence_tokenizer == 'NLTK - Punkt Sentence Tokenizer':
            assert sentences == ['Bokmål er en varietet av norsk språk.', 'Bokmål er en av to offisielle målformer av norsk skriftspråk, hvorav den andre er nynorsk.', 'I skrift benyttes bokmål av anslagsvis 90 % av befolkningen i Norge.', '[1][2] Etter skriftreformene av riksmål i 1987 og bokmål i 1981 og 2005 er det lite som skiller bokmål og riksmål i alminnelig bruk.']
        elif sentence_tokenizer == 'spaCy - Sentencizer':
            assert sentences == ['Bokmål er en varietet av norsk språk.', 'Bokmål er en av to offisielle målformer av norsk skriftspråk, hvorav den andre er nynorsk.', 'I skrift benyttes bokmål av anslagsvis 90 % av befolkningen i Norge.[1][2] Etter skriftreformene av riksmål i 1987 og bokmål i 1981 og 2005 er det lite som skiller bokmål og riksmål i alminnelig bruk.']
    elif lang == 'nno':
        assert sentences == ['Nynorsk, før 1929 offisielt kalla landsmål, er sidan jamstillingsvedtaket av 12. mai 1885 ei av to offisielle målformer av norsk; den andre forma er bokmål.', 'Nynorsk blir i dag nytta av om lag 10–15% av innbyggjarane[1][2] i Noreg.', 'Skriftspråket er basert på nynorsk talemål, det vil seie dei moderne norske dialektane til skilnad frå gamalnorsk og mellomnorsk.', 'Når ein seier at nokon snakkar nynorsk, meiner ein helst at dei snakkar nynorsk normaltalemål.', 'Dei færraste dialekttalande nordmenn seier at dei snakkar nynorsk, men det er ikkje uvanleg i kjerneområda til nynorsken.', 'Dette tilhøvet mellom tale og skrift ligg bak målrørsla sitt slagord sidan 1970-talet: «Snakk dialekt – skriv nynorsk!» Nynorske dialektar blir snakka over heile landet, men det er berre på Vestlandet utanom dei største byene og i dei austlandske fjellbygdene at skriftspråket står sterkt.', 'Det vil seie at dei fleste dialekttalarane har bokmål som det primære skriftspråket sitt.']
    elif lang == 'fas':
        assert sentences == ['فارسی یا پارسی یکی از زبان\u200cهای هندواروپایی در شاخهٔ زبان\u200cهای ایرانی جنوب غربی است که در کشورهای ایران، افغانستان،[۳] تاجیکستان[۴] و ازبکستان[۵] به آن سخن می\u200cگویند.', 'فارسی زبان رسمی کشورهای ایران و تاجیکستان و یکی از دو زبان رسمی افغانستان (در کنار پشتو) است.', 'زبان رسمی کشور هندوستان نیز تا پیش از ورود استعمار انگلیس، فارسی بود.[۶]']
    elif lang == 'pol':
        if sentence_tokenizer == 'NLTK - Punkt Sentence Tokenizer':
            assert sentences == ['Język polski, polszczyzna, skrót: pol.', '– język naturalny należący do grupy języków zachodniosłowiańskich (do której należą również czeski, słowacki, kaszubski, dolnołużycki, górnołużycki i wymarły połabski), stanowiącej część rodziny języków indoeuropejskich.', 'Polszczyzna jest jednym z oficjalnych języków Unii Europejskiej.']
        elif sentence_tokenizer == 'spaCy - Sentencizer':
            assert sentences == ['Język polski, polszczyzna, skrót: pol. – język naturalny należący do grupy języków zachodniosłowiańskich (do której należą również czeski, słowacki, kaszubski, dolnołużycki, górnołużycki i wymarły połabski), stanowiącej część rodziny języków indoeuropejskich.', 'Polszczyzna jest jednym z oficjalnych języków Unii Europejskiej.']
    elif lang == 'por':
        if sentence_tokenizer == 'NLTK - Punkt Sentence Tokenizer':
            assert sentences == ['A língua portuguesa, também designada português, é uma língua românica flexiva ocidental originada no galego-português falado no Reino da Galiza e no norte de Portugal.', 'Com a criação do Reino de Portugal em 1139 e a expansão para o sul como parte da Reconquista deu-se a difusão da língua pelas terras conquistadas e mais tarde, com as descobertas portuguesas, para o Brasil, África e outras partes do mundo.', '[3] O português foi usado, naquela época, não somente nas cidades conquistadas pelos portugueses, mas também por muitos governantes locais nos seus contatos com outros estrangeiros poderosos.', 'Especialmente nessa altura a língua portuguesa também influenciou várias línguas.', '[4]']
        elif sentence_tokenizer == 'spaCy - Sentencizer':
            assert sentences == ['A língua portuguesa, também designada português, é uma língua românica flexiva ocidental originada no galego-português falado no Reino da Galiza e no norte de Portugal.', 'Com a criação do Reino de Portugal em 1139 e a expansão para o sul como parte da Reconquista deu-se a difusão da língua pelas terras conquistadas e mais tarde, com as descobertas portuguesas, para o Brasil, África e outras partes do mundo.[3] O português foi usado, naquela época, não somente nas cidades conquistadas pelos portugueses, mas também por muitos governantes locais nos seus contatos com outros estrangeiros poderosos.', 'Especialmente nessa altura a língua portuguesa também influenciou várias línguas.[4]']
    elif lang == 'ron':
        assert sentences == ['Limba română este o limbă indo-europeană, din grupul italic și din subgrupul oriental al limbilor romanice.', 'Printre limbile romanice, româna este a cincea după numărul de vorbitori, în urma spaniolei, portughezei, francezei și italienei.', 'Din motive de diferențiere tipologică, limba română mai este numită în lingvistica comparată limba dacoromână sau dialectul dacoromân.', 'De asemenea, este înregistrată ca limbă de stat atât în România cât și în Republica Moldova, unde circa 75% din populație o consideră limbă maternă (inclusiv sub denumirea de „limba moldovenească”).']
    elif lang == 'rus':
        assert sentences == ['Ру́сский язы́к ([ˈruskʲɪi̯ jɪˈzɨk] Информация о файле слушать)[~ 3][⇨] — один из восточнославянских языков, национальный язык русского народа.', 'Является одним из наиболее распространённых языков мира — шестым среди всех языков мира по общей численности говорящих и восьмым по численности владеющих им как родным[9].', 'Русский является также самым распространённым славянским языком[10] и самым распространённым языком в Европе — географически и по числу носителей языка как родного[7].']
    elif lang == 'sin':
        assert sentences == ['ශ්\u200dරී ලංකාවේ ප්\u200dරධාන ජාතිය වන සිංහල ජනයාගේ මව් බස සිංහල වෙයි.', 'අද වන විට මිලියන 20 කට අධික සිංහල සහ මිලියන 3කට අධික සිංහල නොවන ජනගහනයක් සිංහල භාෂාව භාවිත කරති.', 'සිංහල\u200d ඉන්දු-යුරෝපීය භාෂාවල උප ගණයක් වන ඉන්දු-ආර්ය භාෂා ගණයට අයිති වන අතර මාල දිවයින භාවිත කරන දිවෙහි භාෂාව සිංහලයෙන් පැවත එන්නකි.', 'සිංහල ශ්\u200dරී ලංකාවේ නිල භාෂාවයි .']
    elif lang == 'slk':
        assert sentences == ['ešte Bulharsko, Francúzsko, Nemecko, Belgicko, Škandinávia, Taliansko, Švajčiarsko, Holandsko, Cyprus, Rusko, Izrael, JAR, Argentína, Brazília, Uruguaj, Austrália, Nový Zéland, Spojené kráľovstvo a v ďalších krajinách.', 'Celkový odhadovaný počet osôb slovenského pôvodu v zahraničí roku 2001 je 2 016 000.']
    elif lang == 'slv':
        if sentence_tokenizer == 'NLTK - Punkt Sentence Tokenizer':
            assert sentences == ['Slovenčina je oficiálne úradným jazykom Slovenska, Vojvodiny a od 1. mája 2004 jedným z jazykov Európskej únie.', 'Jazykový kód alebo po anglicky Language Code je sk príp.', 'slk podľa ISO 639.', 'Slovenčina je známa ako „esperanto“ slovanských jazykov, vníma sa ako najzrozumiteľnejšia aj pre používateľov iných slovanských jazykov.', '[1] V súvislosti so širokou zrozumiteľnosťou slovenčiny umožňuje český právny poriadok používať slovenčinu, na rozdiel od iných menšinových jazykov, bez prekladateľa či tlmočníka v právnych a úradných úkonoch.', 'Týka sa to mnohých aspektov spoločenského života na celom území Česka.', 'Napríklad Správny poriadok (zákon č. 500/2004 Zb.)', 'stanovuje: "V řízení se jedná a písemnosti se vyhotovují v českém jazyce.', 'Účastníci řízení mohou jednat a písemnosti mohou být předkládány i v jazyce slovenském" (§16, odsek 1).', '[1]']
        elif sentence_tokenizer == 'spaCy - Sentencizer':
            assert sentences == ['Slovenčina je oficiálne úradným jazykom Slovenska, Vojvodiny a od 1.', 'mája 2004 jedným z jazykov Európskej únie.', 'Jazykový kód alebo po anglicky Language Code je sk príp.', 'slk podľa ISO 639.', 'Slovenčina je známa ako „esperanto“ slovanských jazykov, vníma sa ako najzrozumiteľnejšia aj pre používateľov iných slovanských jazykov.[1] V súvislosti so širokou zrozumiteľnosťou slovenčiny umožňuje český právny poriadok používať slovenčinu, na rozdiel od iných menšinových jazykov, bez prekladateľa či tlmočníka v právnych a úradných úkonoch.', 'Týka sa to mnohých aspektov spoločenského života na celom území Česka.', 'Napríklad Správny poriadok (zákon č.', '500/2004 Zb.)', 'stanovuje: "V řízení se jedná a písemnosti se vyhotovují v českém jazyce.', 'Účastníci řízení mohou jednat a písemnosti mohou být předkládány i v jazyce slovenském" (§16, odsek 1).[1]']
    elif lang == 'spa':
        assert sentences == ['El español o castellano es una lengua romance procedente del latín hablado.', 'Pertenece al grupo ibérico y es originaria de Castilla, reino medieval de la península ibérica.', 'Se conoce también por el americanismo coloquial de castilla (por ejemplo: «hablar castilla», «entender castilla»),nota 1\u200b32\u200b33\u200b común en algunas áreas rurales e indígenas entre México y la Patagonia,34\u200b pues el castellano se empezó a enseñar poco después de la incorporación de los nuevos territorios a la Corona de Castilla.35\u200b36\u200b37\u200b38\u200b39\u200b40\u200b']
    elif lang == 'swe':
        assert sentences == ['Svenska (svenska\u2009(info)) är ett östnordiskt språk som talas av ungefär tio miljoner personer främst i Sverige där språket har en dominant ställning som huvudspråk, men även som det ena nationalspråket i Finland och som enda officiella språk på Åland.', 'I övriga Finland talas det som modersmål framförallt i de finlandssvenska kustområdena i Österbotten, Åboland och Nyland.', 'En liten minoritet svenskspråkiga finns även i Estland.', 'Svenska är nära besläktat och i hög grad ömsesidigt begripligt med danska och norska.', 'De andra nordiska språken, isländska och färöiska, är mindre ömsesidigt begripliga med svenska.', 'Liksom de övriga nordiska språken härstammar svenskan från en gren av fornnordiska, vilket var det språk som talades av de germanska folken i Skandinavien.']
    elif lang == 'tgl':
        assert sentences == ['Ang Wikang Tagalog[2] (Baybayin: ᜏᜒᜃᜅ᜔ ᜆᜄᜎᜓᜄ᜔), na kilala rin sa payak na pangalang Tagalog, ay isa sa mga pangunahing wika ng Pilipinas at sinasabing ito ang de facto ("sa katunayan") ngunit hindî de jure ("sa batas") na batayan na siyang pambansang Wikang Filipino (mula 1961 hanggang 1987: Pilipino).[2] Ito ang katutubong wika ng mga lalawigan sa Rehiyon IV (CALABARZON at MIMAROPA), ng Bulacan, at ng Kalakhang Maynila.', 'Ang wikang ito ay ginagamit din sa Hilagang Kapuluang Mariana, kung saan ang mga Pilipino ang pinakamalaking pangkat-etnolinguistico.', 'Bilang isang pangunahing wika sa Pilipinas, ang karaniwan at pamantayang anyo nito ang pangunahing wika sa pambansang telebisyon at radyo, bagaman halos nasa Ingles ang buong kayarian ng mga pahayagan.', 'Bilang Filipino, kasama ang Ingles, isa ang Tagalog sa kasamang-opisyal at tanging pambansang wika sa Pilipinas.', 'Malawak na ginagamit ang Tagalog bilang lingua franca o "pangkaraniwang wika" sa buong bansa, at sa mga pamayanang Pilipino na nasa labas ng Pilipinas.', "Subalit, habang kalát ang Tagalog sa maraming mga larangan, higit na laganap ang Ingles, sa iba't ibang antas ng katatasan, sa mga larangan ng pamahalaan at kalakalan.", 'Tinatawag na mananagalog o mananalita ang isang may mataas, may kahusayan, at kaalaman sa pananagalog.[2]']
    elif lang == 'tam':
        assert sentences == ['தமிழ் மொழி (Tamil language) தமிழர்களினதும், தமிழ் பேசும் பலரதும் தாய்மொழி ஆகும்.', 'தமிழ் திராவிட மொழிக் குடும்பத்தின் முதன்மையான மொழிகளில் ஒன்றும் செம்மொழியும் ஆகும்.', 'இந்தியா, இலங்கை, மலேசியா, சிங்கப்பூர் ஆகிய நாடுகளில் அதிக அளவிலும், ஐக்கிய அரபு அமீரகம், தென்னாப்பிரிக்கா, மொரிசியசு, பிஜி, ரீயூனியன், டிரினிடாட் போன்ற நாடுகளில் சிறிய அளவிலும் தமிழ் பேசப்படுகிறது.', '1997ஆம் ஆண்டுப் புள்ளி விவரப்படி உலகம் முழுவதிலும் 8 கோடி (80 மில்லியன்) மக்களால் பேசப்படும் தமிழ்[13], ஒரு மொழியைத் தாய்மொழியாகக் கொண்டு பேசும் மக்களின் எண்ணிக்கை அடிப்படையில் பதினெட்டாவது இடத்தில் உள்ளது.[14] இணையத்தில் அதிகம் பயன்படுத்தப்படும் இந்திய மொழிகளில் தமிழ் முதன்மையாக உள்ளதாக 2017 ஆவது ஆண்டில் நடைபெற்ற கூகுள் கணக்கெடுப்பில் தெரிய வந்தது.[15]']
    elif lang == 'tat':
        assert sentences == ['Татар теле — татарларның милли теле, Татарстанның дәүләт теле, таралышы буенча Русиядә икенче тел.', 'Төрки телләрнең кыпчак төркеменә керә.', 'ЮНЕСКО игълан иткән 14 иң коммуникатив тел исемлегенә керә.[2]']
    elif lang == 'tel':
        assert sentences == ['ఆంధ్ర ప్రదేశ్, తెలంగాణ రాష్ట్రాల అధికార భాష తెలుగు.', 'భారత దేశంలో తెలుగు మాతృభాషగా మాట్లాడే 8.7 కోట్ల (2001) జనాభాతో [1] ప్రాంతీయ భాషలలో మొదటి స్థానంలో ఉంది.', 'ప్రపంచంలోని ప్రజలు అత్యధికముగా మాట్లాడే భాషలలో 15 స్థానములోనూ, భారత దేశములో హిందీ, తర్వాత స్థానములోనూ నిలుస్తుంది.', 'పాతవైన ప్రపంచ భాష గణాంకాల (ఎథ్నోలాగ్) ప్రకారం ప్రపంచవ్యాప్తంగా 7.4 కోట్లు మందికి మాతృభాషగా ఉంది.[2] మొదటి భాషగా మాట్లాడతారు.', 'అతి ప్రాచీన దేశ భాషలలో సంస్కృతము తమిళముతో బాటు తెలుగు భాషను 2008 అక్టోబరు 31న భారత ప్రభుత్వము గుర్తించింది.']
    elif lang == 'tha':
        assert sentences == ['ภาษาไทย หรือ ภาษาไทยกลาง เป็นภาษาราชการและภาษาประจำชาติของประเทศไทย', 'ภาษาไทยเป็นภาษาในกลุ่มภาษาไทซึ่งเป็นกลุ่มย่อยของตระกูลภาษาขร้า-ไท สันนิษฐานว่า ภาษาในตระกูลนี้มีถิ่นกำเนิดจากทางตอนใต้ของประเทศจีน และนักภาษาศาสตร์บางส่วนเสนอว่า ภาษาไทยน่าจะมีความเชื่อมโยงกับตระกูลภาษาออสโตร-เอเชียติก', 'ตระกูลภาษาออสโตรนีเซียน และตระกูลภาษาจีน-ทิเบต']
    elif lang == 'bod':
        assert sentences == ['བོད་ཀྱི་སྐད་ཡིག་ནི་བོད་ཡུལ་དང་དེའི་ཉེ་འཁོར་གྱི་ས་ཁུལ་ཏེ།', 'བལ་ཡུལ་དང་། འབྲུག འབྲས་ལྗོངས། ལ་དྭགས་ནས་ལྷོ་མོན་རོང་སོགས་སུ་བེད་སྤྱོད་བྱེད་པའི་སྐད་ཡིག་སྟེ།', 'ད་ཆར་ཡོངས་གྲགས་སུ་བོད་ཀྱི་ཡུལ་གྲུ་སྟོད་སྨད་བར་གསུམ་ལ་བལྟས་ཏེ་ནང་གསེས་རིགས་གསུམ་དུ་ཕྱེ་བ་སྟེ།', 'སྟོད་དབུས་གཙང་གི་སྐད་དང་། བར་ཁམས་པའི་སྐད་དང་། སྨད་ཨ་མདོའི་སྐད་རྣམས་སོ།', 'བོད་སྐད་ནི་ཧོར་སོག་ལ་སོགས་པ་གྲངས་ཉུང་མི་རིགས་གཞན་པ་ཁག་ཅིག་གིས་ཀྱང་བེད་སྤྱོད་གཏོང་བཞིན་ཡོད་པར་མ་ཟད། བལ་ཡུལ་དང་། འབྲས་ལྗོངས། འབྲུག་ཡུལ། རྒྱ་གར་ཤར་དང་བྱང་རྒྱུད་མངའ་སྡེ་ཁག་གཅིག་བཅས་ཀྱི་རྒྱལ་ཁབ་རྣམས་སུའང་བེད་སྤྱོད་གཏོང་བཞིན་ཡོད།']
    elif lang == 'tur':
        if sentence_tokenizer == 'NLTK - Punkt Sentence Tokenizer':
            assert sentences == ['Türkçe ya da Türk dili, batıda Balkanlar’dan başlayıp doğuda Hazar Denizi sahasına kadar konuşulan Türkî diller dil ailesine ait sondan eklemeli bir dil.', '[12] Türki diller ailesinin Oğuz dil grubundan Osmanlı Türkçesinin devamını oluşturur.', 'Başta Türkiye olmak üzere eski Osmanlı İmparatorluğu coğrafyasında konuşulan Türkçe, dünyada en fazla konuşulan 22.', 'dildir.', "[13] Türkçe'nin sondan eklemeli olması kullanılan herhangi bir eylem üzerinden istenildiği kadar sözcük türetilebilmesine olanak sağlamaktadır.", '[14] Türkiye Türkçesi bu yönünden dolayı diğer Türk dilleriyle ortak ya da ayrık bulunan onlarca eke sahiptir.', '[15] Türkçe geniş kullanımıyla birlikte zengin bir dil olmasının yanı sıra, genel itibarıyla “özne-nesne-yüklem” biçimindeki cümle kuruluşuna sahiptir.']
        elif sentence_tokenizer == 'spaCy - Sentencizer':
            assert sentences == ['Türkçe ya da Türk dili, batıda Balkanlar’dan başlayıp doğuda Hazar Denizi sahasına kadar konuşulan Türkî diller dil ailesine ait sondan eklemeli bir dil.[12] Türki diller ailesinin Oğuz dil grubundan Osmanlı Türkçesinin devamını oluşturur.', 'Başta Türkiye olmak üzere eski Osmanlı İmparatorluğu coğrafyasında konuşulan Türkçe, dünyada en fazla konuşulan 22.', "dildir.[13] Türkçe'nin sondan eklemeli olması kullanılan herhangi bir eylem üzerinden istenildiği kadar sözcük türetilebilmesine olanak sağlamaktadır.[14] Türkiye Türkçesi bu yönünden dolayı diğer Türk dilleriyle ortak ya da ayrık bulunan onlarca eke sahiptir.[15] Türkçe geniş kullanımıyla birlikte zengin bir dil olmasının yanı sıra, genel itibarıyla “özne-nesne-yüklem” biçimindeki cümle kuruluşuna sahiptir."]
    elif lang == 'ukr':
        assert sentences == ['Украї́нська мо́ва (МФА: [ukrɑ̽ˈjɪnʲsʲkɑ̽ ˈmɔwɑ̽], історичні назви — ру́ська, руси́нська[9][10][11][* 2]) — національна мова українців.', "Належить до слов'янської групи індоєвропейської мовної сім'ї[* 3].", 'Є державною мовою в Україні[12].']
    elif lang == 'urd':
        assert sentences == ['اُردُو لشکری زبان[8] (یا جدید معیاری اردو) برصغیر کی معیاری زبانوں میں سے ایک ہے۔', 'یہ پاکستان کی قومی اور رابطہ عامہ کی زبان ہے، جبکہ بھارت کی چھے ریاستوں کی دفتری زبان کا درجہ رکھتی ہے۔', 'آئین ہند کے مطابق اسے 22 دفتری شناخت زبانوں میں شامل کیا جاچکا ہے۔', '2001ء کی مردم شماری کے مطابق اردو کو بطور مادری زبان بھارت میں 5.01% فیصد لوگ بولتے ہیں اور اس لحاظ سے یہ بھارت کی چھٹی بڑی زبان ہے جبکہ پاکستان میں اسے بطور مادری زبان 7.59% فیصد لوگ استعمال کرتے ہیں، یہ پاکستان کی پانچویں بڑی زبان ہے۔', 'اردو تاریخی طور پر ہندوستان کی مسلم آبادی سے جڑی ہے۔[حوالہ درکار] بعض ذخیرہ الفاظ کے علاوہ یہ زبان معیاری ہندی سے قابل فہم ہے جو اس خطے کی ہندوؤں سے منسوب ہے۔[حوالہ درکار] زبانِ اردو کو پہچان و ترقی اس وقت ملی جب برطانوی دور میں انگریز حکمرانوں نے اسے فارسی کی بجائے انگریزی کے ساتھ شمالی ہندوستان کے علاقوں اور جموں و کشمیر میں اسے سنہ 1846ء اور پنجاب میں سنہ 1849ء میں بطور دفتری زبان نافذ کیا۔', 'اس کے علاوہ خلیجی، یورپی، ایشیائی اور امریکی علاقوں میں اردو بولنے والوں کی ایک بڑی تعداد آباد ہے جو بنیادی طور پر جنوبی ایشیاء سے کوچ کرنے والے اہلِ اردو ہیں۔', '1999ء کے اعداد وشمار کے مطابق اردو زبان کے مجموعی متکلمین کی تعداد دس کروڑ ساٹھ لاکھ کے لگ بھگ تھی۔', 'اس لحاظ سے یہ دنیا کی نویں بڑی زبان ہے۔']
    elif lang == 'vie':
        assert sentences ==['Tiếng Việt, còn gọi tiếng Việt Nam[5], tiếng Kinh hay Việt ngữ, là ngôn ngữ của người Việt (dân tộc Kinh) và là ngôn ngữ chính thức tại Việt Nam.', 'Đây là tiếng mẹ đẻ của khoảng 85% dân cư Việt Nam, cùng với hơn 4 triệu Việt kiều.', 'Tiếng Việt còn là ngôn ngữ thứ hai của các dân tộc thiểu số tại Việt Nam.', 'Mặc dù tiếng Việt có một số từ vựng vay mượn từ tiếng Hán và trước đây dùng chữ Nôm – một hệ chữ viết dựa trên chữ Hán – để viết nhưng tiếng Việt được coi là một trong số các ngôn ngữ thuộc ngữ hệ Nam Á có số người nói nhiều nhất (nhiều hơn một số lần so với các ngôn ngữ khác cùng hệ cộng lại).', 'Ngày nay, tiếng Việt dùng bảng chữ cái Latinh, gọi là chữ Quốc ngữ, cùng các dấu thanh để viết.']
Example #16
0
    def __init__(self, main):
        super().__init__(main)

        self.pos_tag_mappings_loaded = False

        settings_global = self.main.settings_global['pos_taggers']

        self.settings_tagsets = QWidget(self)

        # Preview Settings
        group_box_preview_settings = QGroupBox(self.tr('Preview Settings:'),
                                               self)

        self.label_tagsets_lang = QLabel(self.tr('Language:'), self)
        self.combo_box_tagsets_lang = wl_box.Wl_Combo_Box(self)
        self.label_tagsets_pos_tagger = QLabel(self.tr('POS Tagger:'), self)
        self.combo_box_tagsets_pos_tagger = wl_box.Wl_Combo_Box_Adjustable(
            self)

        self.combo_box_tagsets_lang.addItems(
            wl_conversion.to_lang_text(self.main, list(settings_global)))

        self.combo_box_tagsets_lang.currentTextChanged.connect(
            self.preview_lang_changed)
        self.combo_box_tagsets_pos_tagger.currentTextChanged.connect(
            self.preview_pos_tagger_changed)

        group_box_preview_settings.setLayout(wl_layout.Wl_Layout())
        group_box_preview_settings.layout().addWidget(self.label_tagsets_lang,
                                                      0, 0)
        group_box_preview_settings.layout().addWidget(
            self.combo_box_tagsets_lang, 0, 1, Qt.AlignLeft)
        group_box_preview_settings.layout().addWidget(
            self.label_tagsets_pos_tagger, 1, 0)
        group_box_preview_settings.layout().addWidget(
            self.combo_box_tagsets_pos_tagger, 1, 1, Qt.AlignLeft)

        group_box_preview_settings.layout().setColumnStretch(2, 1)

        # Mapping Settings
        group_box_mapping_settings = QGroupBox(self.tr('Mapping Settings'))

        self.label_tagsets_num_pos_tags = QLabel('', self)
        self.button_tagsets_reset = QPushButton(self.tr('Reset'), self)
        self.button_tagsets_reset_all = QPushButton(self.tr('Reset All'), self)
        self.table_mappings = wl_table.Wl_Table(
            self,
            headers=[
                self.tr('POS Tag'),
                self.tr('Universal POS Tag'),
                self.tr('Description'),
                self.tr('Examples')
            ])

        self.button_tagsets_reset.setFixedWidth(100)
        self.button_tagsets_reset_all.setFixedWidth(100)

        self.button_tagsets_reset.clicked.connect(self.reset_mappings)
        self.button_tagsets_reset_all.clicked.connect(self.reset_all_mappings)

        group_box_mapping_settings.setLayout(wl_layout.Wl_Layout())
        group_box_mapping_settings.layout().addWidget(
            self.label_tagsets_num_pos_tags, 0, 0)
        group_box_mapping_settings.layout().addWidget(
            self.button_tagsets_reset, 0, 2)
        group_box_mapping_settings.layout().addWidget(
            self.button_tagsets_reset_all, 0, 3)
        group_box_mapping_settings.layout().addWidget(self.table_mappings, 1,
                                                      0, 1, 4)

        group_box_mapping_settings.layout().setColumnStretch(1, 1)

        self.setLayout(wl_layout.Wl_Layout())
        self.layout().addWidget(group_box_preview_settings, 0, 0)
        self.layout().addWidget(group_box_mapping_settings, 1, 0)

        self.layout().setContentsMargins(6, 4, 6, 4)
        self.layout().setRowStretch(1, 1)
def test_syl_tokenize(lang, syl_tokenizer):
    lang_text = wl_conversion.to_lang_text(main, lang)

    print(f'{lang_text} ({lang}) / {syl_tokenizer}:')

    # Untokenized
    syls = wl_syl_tokenization.wl_syl_tokenize(main,
                                               inputs=getattr(
                                                   wl_test_lang_examples,
                                                   f'SENTENCE_{lang.upper()}'),
                                               lang=lang,
                                               syl_tokenizer=syl_tokenizer)

    # Tokenized
    tokens = wl_word_tokenization.wl_word_tokenize_flat(
        main,
        text=getattr(wl_test_lang_examples, f'SENTENCE_{lang.upper()}'),
        lang=lang)
    syls_tokenized = wl_syl_tokenization.wl_syl_tokenize(
        main, inputs=tokens, lang=lang, syl_tokenizer=syl_tokenizer)

    syls_long_text = wl_syl_tokenization.wl_syl_tokenize(
        main,
        inputs=''.join([f'{i}\n' for i in range(101)]),
        lang=lang,
        syl_tokenizer=syl_tokenizer)
    syls_long_text_tokenized = wl_syl_tokenization.wl_syl_tokenize(
        main,
        inputs=[str(i) for i in range(101) for j in range(50)],
        lang=lang,
        syl_tokenizer=syl_tokenizer)

    print(syls)

    # Check for missing syllables
    assert all(True for syls_token in syls if all(syls_token))

    # The count of syllables should be more than 1
    assert sum([len(syls_token) for syls_token in syls]) > 1

    # Tokenization should not be modified
    assert len(tokens) == len(syls_tokenized)

    # Test long texts
    assert syls_long_text == [[str(i)] for i in range(101)]
    assert syls_long_text_tokenized == [[str(i)] for i in range(101)
                                        for j in range(50)]

    if lang == 'afr':
        assert syls == [['Afri', 'kaans'], ['is'], ['ti', 'po', 'lo', 'gies'],
                        ['be', 'skou'], ["'"], ['n'], ['In', 'do'], ['', ''],
                        ['Eu', 'ro', 'pe', 'se'], [','], ['Wes'], ['', ''],
                        ['Ger', 'maan', 'se'], [','],
                        ['Ne', 'derfran', 'kie', 'se'], ['taal', ',[2'], [']'],
                        ['wat'], ['aan'], ['die'], ['suid', 'punt'], ['van'],
                        ['Afri', 'ka'], ['on', 'der'], ['in', 'vloed'],
                        ['van'], ['ver', 'skeie'], ['an', 'der'], ['ta', 'le'],
                        ['en'], ['taal', 'groe', 'pe'], ['ont', 'staan'],
                        ['het'], ['.']]
    elif lang == 'sqi':
        assert syls == [['Gju', 'ha'], ['shqi', 'pe'], ['('], ['ose'],
                        ['thje', 'sh', 'të'], ['shqi', 'p', 'ja'], [')'],
                        ['ësh', 'të'], ['gju', 'hë'], ['dhe'], ['de', 'gë'],
                        ['e'], ['ve', 'ça', 'n', 'të'], ['e'],
                        ['fa', 'mi', 'l', 'jes'], ['in', 'do'], ['', ''],
                        ['ev', 'ro', 'pi', 'ane'], ['të'], ['fo', 'lur'],
                        ['nga'], ['më'], ['shu', 'më'], ['se'], ['6'],
                        ['mi', 'li', 'onë'], ['nje', 'rëz[4'], [']'], [','],
                        ['kry', 'esisht'], ['në'], ['Shqi', 'pë', 'ri'], [','],
                        ['Ko', 'so', 'vë'], ['dhe'],
                        ['Re', 'pu', 'b', 'li', 'kën'], ['e'],
                        ['Ma', 'qe', 'do', 'ni',
                         'së'], [','], ['por'], ['edhe'], ['në'], ['zo', 'na'],
                        ['të'], ['tje', 'ra'], ['të'], ['Ev', 'ro', 'pës'],
                        ['Ju', 'go', 're'], ['ku'], ['ka'], ['një'],
                        ['po', 'pu', 'll', 'si'], ['shqi', 'p', 'ta', 're'],
                        [','], ['du', 'ke'], ['pë', 'r', 'f', 'shi', 'rë'],
                        ['Ma', 'lin'], ['e'], ['Zi'], ['dhe'],
                        ['Lu', 'gi', 'nën'], ['e'], ['Pre', 'she', 'vës'],
                        ['.']]
    elif lang == 'bel':
        assert syls == [['Бе', 'ла', 'ру́с', 'кая'], ['мо́', 'ва'], ['—'],
                        ['на', 'цы', 'я', 'на', 'ль', 'ная'], ['мо', 'ва'],
                        ['бе', 'ла', 'ру', 'саў'], [','],
                        ['ува', 'хо', 'дзіць'], ['у'],
                        ['ін', 'да', 'еў', 'ра', 'пей', 'с', 'кую'],
                        ['моў', 'ную'], ['ся', "м'ю"], [','],
                        ['сла', 'вя', 'н', 'с', 'кую'], ['гру', 'пу'], [','],
                        [
                            'ус', 'хо', 'д', 'не', 'с', 'ла', 'вя', 'н', 'с',
                            'кую'
                        ], ['па', 'д', 'г', 'ру', 'пу'], ['.']]
    elif lang == 'bul':
        assert syls == [['Бъ', '̀л', 'гар', 'с', 'ки', 'ят'], ['ез', 'ѝк'],
                        ['е'], ['ин', 'до', 'ев', 'ро', 'пейс', 'ки'],
                        ['език'], ['от'], ['гру', 'па', 'та'], ['на'],
                        ['юж', 'нос', 'ла', 'вян', 'с', 'ки', 'те'],
                        ['ези', 'ци'], ['.']]
    elif lang == 'hrv':
        assert syls == [['Hr', 'vat', 'ski'], ['je', 'zik'], ['('], ['ISO'],
                        ['639'], ['', ''], ['3'], [':'], ['hrv'], [')'],
                        ['skup', 'ni'], ['je'], ['na', 'ziv'], ['za'],
                        ['na', 'ci', 'onal', 'ni'], ['stan', 'dard', 'ni'],
                        ['je', 'zik'], ['Hr',
                                        'va', 'ta'], [','], ['te'], ['za'],
                        ['skup'], ['na', 'rje', 'čja'], ['i'],
                        ['go', 'vo', 'ra'], ['ko', 'ji', 'ma'],
                        ['go', 'vo', 're'], ['ili'], ['su'],
                        ['ne', 'ka', 'da'], ['go', 'vo', 'ri', 'li'],
                        ['Hr', 'va', 'ti'], ['.']]
    elif lang == 'ces':
        assert syls == [['Češ', 'ti', 'na'], ['ne', 'bo', 'li'], ['čes', 'ký'],
                        ['ja', 'zyk'], ['je'],
                        ['zá', 'pa', 'doslo', 'van', 'ský'], ['ja', 'zyk'],
                        [','], ['nej', 'bliž', 'ší'],
                        ['slo', 'ven', 'šti', 'ně'], [','], ['po', 'té'],
                        ['lužic', 'ké'], ['srbšti', 'ně'], ['a'],
                        ['pol', 'šti', 'ně'], ['.']]
    elif lang == 'dan':
        assert syls == [['Dansk'], ['er'], ['et'], ['nord', 'ger', 'mansk'],
                        ['sprog'], ['af'], ['den'],
                        ['øst', 'n', 'or', 'di', 'ske'], ['('],
                        ['kon', 'ti', 'nen', 'tale'], [')'], ['grup', 'pe'],
                        [','], ['der'], ['ta', 'les'], ['af'], ['ca.'],
                        ['seks'], ['mil', 'li', 'o', 'ner'],
                        ['men', 'ne', 'sker'], ['.']]
    elif lang == 'nld':
        assert syls == [['Het'], ['Ne', 'der', 'lands'], ['is'], ['een'],
                        ['Wes', 't', 'Ger', 'maan', 'se'], ['taal'], ['en'],
                        ['de'], ['of', 'fi', 'ci', 'ë', 'le'], ['taal'],
                        ['van'], ['Ne', 'der', 'land'], [','],
                        ['Su', 'ri', 'na', 'me'], ['en'], ['een'], ['van'],
                        ['de'], ['drie'], ['of', 'fi', 'ci', 'ë', 'le'],
                        ['ta', 'len'], ['van'], ['Bel', 'gië'], ['.']]
    elif lang == 'eng_gb':
        assert syls == [['Eng', 'lish'], ['is'], ['a'], ['West'],
                        ['Ger', 'man', 'ic'], ['lan', 'guage'], ['of'],
                        ['the'], ['Indo'], ['', ''], ['European'],
                        ['lan', 'guage'], ['fam', 'ily'], [','],
                        ['ori', 'gin', 'ally'], ['spoken'], ['by'], ['the'],
                        ['in', 'hab', 'it', 'ants'], ['of'], ['early'],
                        ['me', 'di', 'ev', 'al'], ['Eng', 'land.[3][4][5'],
                        [']']]
    elif lang == 'eng_us':
        assert syls == [['Eng', 'lish'], ['is'], ['a'], ['West'],
                        ['Ger', 'man', 'ic'], ['lan', 'guage'], ['of'],
                        ['the'], ['In', 'do'], ['', ''], ['Eu', 'ro', 'pean'],
                        ['lan', 'guage'], ['fam', 'i', 'ly'], [','],
                        ['orig', 'i', 'nal', 'ly'], ['spo', 'ken'], ['by'],
                        ['the'], ['in', 'hab', 'i', 'tants'], ['of'],
                        ['ear', 'ly'], ['me', 'dieval'],
                        ['Eng', 'land.[3][4][5'], [']']]
    elif lang == 'epo':
        assert syls == [['Es', 'pe', 'r', 'anto'], [','], ['ori', 'gi', 'ne'],
                        ['la'], ['Lin', 'g', 'vo'],
                        ['In', 'ter', 'na', 'ci', 'a', ',[4'], [']'],
                        ['es', 'tas'], ['la'], ['plej'],
                        ['dis', 'vas', 't', 'iĝ', 'inta'],
                        ['in', 'ter', 'na', 'cia'],
                        ['plan', 'lin', 'g', 'vo', '.[5'], [']']]
    elif lang == 'est':
        assert syls == [['Ees', 'ti'], ['keel'], ['('], ['vara', 'sem'],
                        ['ni', 'me', 'tus'], ['maa', 'keel'], [')'], ['on'],
                        ['lää', 'ne', 'me', 're', 'soo', 'me'],
                        ['lõu', 'na', 'rüh', 'ma'], ['kuu', 'luv'], ['keel'],
                        ['.']]
    elif lang == 'fra':
        assert syls == [['Le'], ['fran', 'çais'], ['est'], ['une'], ['langue'],
                        ['in', 'do', 'eu', 'ro', 'péenne'], ['de'], ['la'],
                        ['fa', 'mille'], ['des'], ['langues'], ['ro', 'manes'],
                        ['dont'], ['les'], ['lo', 'cu', 'teurs'], ['sont'],
                        ['ap', 'pe', 'lés'], ['fran', 'co', 'phones'], ['.']]
    elif lang == 'glg':
        assert syls == [['O'], ['ga', 'le', 'go'], ['('], ['['], ['ɡaˈleɣo̝'],
                        [']'], [')'], ['é'], ['unha'], ['lin', 'gua'],
                        ['in', 'do', 'eu', 'ro', 'pea'], ['que'],
                        ['per', 'ten', 'ce'], ['á'], ['póla'], ['de'],
                        ['lin', 'guas'], ['ro', 'má', 'ni', 'cas'], ['.']]
    elif lang in ['deu_at', 'deu_de', 'deu_ch']:
        assert syls == [['Die'], ['deut', 'sche'], ['Spra', 'che'], ['bzw.'],
                        ['das'], ['Deut', 'sche'], ['('], ['['],
                        ['dɔɪ̯tʃ];[26'], [']'], ['ab', 'ge', 'kürzt'], ['dt'],
                        ['.'], ['oder'], ['dtsch'], ['.'], [')'], ['ist'],
                        ['ei', 'ne'], ['west', 'ger', 'ma', 'ni', 'sche'],
                        ['Spra', 'che'], [','], ['die'], ['welt', 'weit'],
                        ['et', 'wa'], ['90'], ['bis'], ['105'],
                        ['Mil', 'li', 'o', 'nen'], ['Men', 'schen'], ['als'],
                        ['Mut', 'ter', 'spra', 'che'], ['und'],
                        ['wei', 'te', 'ren'], ['rund'], ['80'],
                        ['Mil', 'li', 'o', 'nen'], ['als'], ['Zweit', ''],
                        ['oder'], ['Fremd', 'spra', 'che'], ['dient'], ['.']]
    elif lang == 'ell':
        assert syls == [['Η'], ['ελ', 'λη', 'νι', 'κή'], ['γλώσ', 'σα'],
                        ['ανή', 'κει'], ['στην'],
                        ['ιν', 'δο', 'ευ', 'ρω', 'παϊκή'],
                        ['οι', 'κο', 'γένεια', '[10'], [']'], ['και'],
                        ['απο', 'τε', 'λεί'], ['το'], ['μο', 'να', 'δι', 'κό'],
                        ['μέλος'], ['του'], ['ελ', 'λη', 'νι', 'κού'],
                        ['κλάδου'], [','], ['ενώ'], ['εί', 'ναι'], ['η'],
                        ['επί', 'ση', 'μη'], ['γλώσ', 'σα'], ['της'],
                        ['Ελ', 'λάδος'], ['και'], ['της'], ['Κύ', 'πρου'],
                        ['.']]
    elif lang == 'hun':
        assert syls == [['A'], ['ma', 'gyar'], ['nyelv'], ['az'],
                        ['urá', 'li'], ['nyelv', 'csa', 'lád'], ['tag', 'ja'],
                        [','], ['a'], ['finn', 'ugor'], ['nyel', 'vek'],
                        ['kö', 'zé'], ['tar', 'to', 'zó'], ['ugor'],
                        ['nyel', 'vek'], ['egyi', 'ke'], ['.']]
    elif lang == 'isl':
        assert syls == [['Ís', 'lenska'],
                        ['er'], ['vest', 'ur', 'nor', 'rænt'], [','],
                        ['germ', 'anskt'], ['og'], ['indó', 'evr', 'ópskt'],
                        ['tungu', 'mál'], ['sem'], ['er'], ['eink', 'um'],
                        ['tal', 'að'], ['og'], ['rit', 'að'], ['á'],
                        ['Ís', 'landi'], ['og'], ['er'], ['móð', 'ur', 'mál'],
                        ['lang', 'flestra'], ['Ís', 'lend', 'inga'], ['.'],
                        ['['], ['4'], [']']]
    elif lang == 'ind':
        assert syls == [['Ba', 'ha', 'sa'], ['In', 'do', 'ne', 'sia'],
                        ['ada', 'lah'], ['ba', 'ha', 'sa'], ['Me', 'la', 'yu'],
                        ['ba', 'ku'], ['yang'], ['di', 'ja', 'di', 'kan'],
                        ['se', 'ba', 'gai'], ['ba', 'ha', 'sa'], ['res', 'mi'],
                        ['Re', 'pub', 'lik'], ['In', 'do', 'ne', 'si', 'a[1'],
                        [']'], ['dan'], ['ba', 'ha', 'sa'],
                        ['per', 'sa', 'tu', 'an'], ['bang', 'sa'],
                        ['In', 'do', 'ne', 'si', 'a.[2'], [']']]
    elif lang == 'ita':
        assert syls == [["L'"], ['ita', 'lia', 'no'], ['('], ['['],
                        ['itaˈ', 'l', 'jaː', 'no][', 'No', 'ta'], ['1'], [']'],
                        ['ascol', 'ta[?·in', 'fo'], [']'],
                        [')'], ['è'], ['una'], ['lin', 'gua'],
                        ['ro', 'man', 'za'], ['par', 'la', 'ta'],
                        ['prin', 'ci', 'pal', 'men', 'te'], ['in'],
                        ['Ita', 'lia'], ['.']]
    elif lang == 'lit':
        assert syls == [['Lie', 'tu', 'vių'], ['kal', 'ba'], ['–'], ['iš'],
                        ['bal', 'tų'], ['pro', 'kal',
                                        'bės'], ['ki', 'lu', 'si'],
                        ['lie', 'tu', 'vių'], ['tau', 'tos'], ['kal', 'ba'],
                        [','], ['ku', 'ri'], ['Lie', 'tu', 'vo', 'je'],
                        ['yra'], ['vals', 'ty', 'bi', 'nė'], [','], ['o'],
                        ['Eu', 'ro', 'pos'], ['Są', 'jun', 'go', 'je'], ['–'],
                        ['vie', 'na'], ['iš'], ['ofi', 'cia', 'lių', 'jų'],
                        ['kal', 'bų'], ['.']]
    elif lang == 'lav':
        assert syls == [['Lat', 'vie', 'šu'], ['va', 'lo', 'da'], ['ir'],
                        ['dzim', 'tā'], ['va', 'lo',
                                         'da'], ['ap', 'mē', 'ram'], ['1,7'],
                        ['mil', 'jo', 'niem'], ['cil', 'vē', 'ku'], [','],
                        ['gal', 've', 'no', 'kārt'], ['Lat', 'vi', 'jā'],
                        [','], ['kur'], ['tā'], ['ir'], ['vien', 'ī', 'gā'],
                        ['valsts'], ['va', 'lo', 'da.[3'], [']']]
    elif lang == 'lav':
        assert syls == [['Lat', 'vie', 'šu'], ['va', 'lo', 'da'], ['ir'],
                        ['dzim', 'tā'], ['va', 'lo',
                                         'da'], ['ap', 'mē', 'ram'], ['1,7'],
                        ['mil', 'jo', 'niem'], ['cil', 'vē', 'ku'], [','],
                        ['gal', 've', 'no', 'kārt'], ['Lat', 'vi', 'jā'],
                        [','], ['kur'], ['tā'], ['ir'], ['vien', 'ī', 'gā'],
                        ['valsts'], ['va', 'lo', 'da.[3'], [']']]
    elif lang == 'mon':
        assert syls == [['Мон', 'гол'], ['хэл'], ['нь'], ['Мон', 'гол'],
                        ['ул', 'сын'], ['ал', 'бан'], ['ёс', 'ны'], ['хэл'],
                        ['юм'], ['.']]
    elif lang == 'nob':
        assert syls == [['Bok', 'mål'], ['er'], ['en'], ['va', 'rie', 'tet'],
                        ['av'], ['norsk'], ['språk'], ['.']]
    elif lang == 'nno':
        assert syls == [['Ny', 'norsk'], [','], ['før'], ['1929'],
                        ['of', 'fi', 'si', 'elt'], ['kal', 'la'],
                        ['lands', 'mål'], [','], ['er'], ['si', 'dan'],
                        ['jam', 'stil', 'lings', 'ved', 'ta', 'ket'], ['av'],
                        ['12'], ['.'], ['mai'], ['1885'], ['ei'], ['av'],
                        ['dei'], ['to'], ['of', 'fi', 'si', 'el', 'le'],
                        ['mål', 'for', 'me', 'ne'], ['av'], ['norsk'], [';'],
                        ['den'], ['and', 're'], ['for', 'ma'], ['er'],
                        ['bok', 'mål'], ['.']]
    elif lang == 'pol':
        assert syls == [['Ję', 'zyk'], ['pol', 'ski'], [','],
                        ['pol', 'sz', 'czy', 'zna'], ['–'], ['ję', 'zyk'],
                        ['le', 'chic', 'ki'], ['z'], ['gru', 'py'],
                        ['za', 'chod', 'nio', 'sło', 'wiań', 'skiej'], ['('],
                        ['do'], ['któ', 'rej'], ['na', 'le', 'żą'],
                        ['rów', 'nież'], ['cze', 'ski'], [','],
                        ['ka', 'szub', 'ski'], [','], ['sło', 'wac', 'ki'],
                        ['i'], ['ję', 'zy', 'ki'], ['łu', 'życ', 'kie'], [')'],
                        [','], ['sta', 'no', 'wią', 'cej'], ['część'],
                        ['ro', 'dzi', 'ny'],
                        ['in', 'do', 'eu', 'ro', 'pej', 'skiej'], ['.']]
    elif lang in ['por_br', 'por_pt']:
        assert syls == [['A'], ['lín', 'gua'], ['por', 'tu',
                                                'gue', 'sa'], [','],
                        ['tam', 'bém'], ['de', 'sig', 'na', 'da'],
                        ['por', 'tu', 'guês'], [','], ['é'], ['uma'],
                        ['lín', 'gua'], ['ro', 'mâ', 'ni', 'ca'],
                        ['fle', 'xi', 'va'], ['oci', 'den', 'tal'],
                        ['ori', 'gi', 'na', 'da'], ['no'],
                        ['ga', 'le', 'go', 'por', 'tu', 'guês'],
                        ['fa', 'la', 'do'], ['no'], ['Rei', 'no'], ['da'],
                        ['Ga', 'li', 'za'], ['e'], ['no'], ['nor', 'te'],
                        ['de'], ['Por', 'tu', 'gal'], ['.']]
    elif lang == 'ron':
        assert syls == [['Lim', 'ba'], ['ro', 'mâ', 'nă'], ['es', 'te'], ['o'],
                        ['lim', 'bă'],
                        ['in', 'do', 'e', 'u', 'ro', 'pe', 'a', 'nă'], [','],
                        ['din'], ['gru', 'pul'], ['ita',
                                                  'lic'], ['și'], ['din'],
                        ['sub', 'gru', 'pul'], ['orien', 'tal'], ['al'],
                        ['lim', 'bi', 'lor'], ['ro', 'ma', 'ni', 'ce'], ['.']]
    elif lang == 'rus':
        assert syls == [['Ру́с',
                         'ский'], ['язы́к'], ['('], ['['], ['ˈruskʲɪi̯'],
                        ['jɪˈzɨk'], [']'], ['Ин', 'фор', 'ма', 'ция'], ['о'],
                        ['фай', 'ле'], ['слу', 'шать)[~'], ['3'], [']'], ['['],
                        ['⇨'], [']'], ['—'], ['один'], ['из'],
                        ['вос', 'точ', 'но', 'сла', 'вян', 'ских'],
                        ['язы', 'ков'], [','],
                        ['на', 'ци', 'о', 'наль', 'ный'], ['язык'],
                        ['рус', 'ско', 'го'], ['на', 'ро', 'да'], ['.']]
    elif lang == 'srp_cyrl':
        assert syls == [['Срп', 'ски'], ['је', 'зик'], ['при', 'па', 'да'],
                        ['сло', 'вен', 'ској'], ['гру', 'пи'],
                        ['је', 'зи', 'ка'], ['по', 'ро', 'ди', 'це'],
                        ['ин', 'до', 'е', 'вроп', 'ских'],
                        ['је', 'зи', 'ка', '.[12'], [']']]
    elif lang == 'srp_latn':
        assert syls == [['Srpski'], ['jezik'], ['pripada'], ['slovenskoj'],
                        ['grupi'], ['jezika'], ['porodice'], ['indoevropskih'],
                        ['jezika.[12'], [']']]
    elif lang == 'slk':
        assert syls == [['Slo', 'ven', 'či', 'na'], ['pat', 'rí'], ['do'],
                        ['sku', 'pi', 'ny'],
                        ['zá', 'pa', 'do', 'slo', 'van', 'ských'],
                        ['ja', 'zy', 'kov'], ['('], ['spo', 'lu'], ['s'],
                        ['češ', 'ti', 'nou'], [','], ['poľš', 'ti', 'nou'],
                        [','], ['hor', 'nou'], ['a'], ['dol', 'nou'],
                        ['lu', 'žic', 'kou'], ['srb', 'či', 'nou'], ['a'],
                        ['ka', 'šub', 'či', 'nou'], [')'], ['.']]
    elif lang == 'slv':
        assert syls == [['Slo', 'ven', 'šči', 'na'], ['['],
                        ['slo', 'vén', 'šči', 'na'], [']'], ['/'], ['['],
                        ['slo', 'ˈʋe', 'nʃtʃi', 'na'], [']'], ['je'],
                        ['zdru', 'že', 'ni'], ['na', 'ziv'], ['za'],
                        ['ura', 'dni'], ['knji', 'žni'], ['je', 'zik'],
                        ['Slo', 'ven', 'cev'], ['in'], ['sku', 'pno'], ['ime'],
                        ['za'], ['na', 're', 'čja'], ['in'],
                        ['go', 'vo', 're'], [','], ['ki'], ['jih'],
                        ['go', 'vo', 'ri', 'jo'], ['ali'], ['so'], ['jih'],
                        ['ne', 'koč'], ['go', 'vo', 'ri', 'li'],
                        ['Slo', 'ven', 'ci'], ['.']]
    elif lang == 'spa':
        assert syls == [['El'], ['es', 'pa', 'ñol'], ['o'],
                        ['cas', 'te', 'llano'], ['es'], ['una'],
                        ['len', 'gua'], ['ro', 'man', 'ce'],
                        ['pro', 'ce', 'den', 'te'], ['del'], ['la', 'tín'],
                        ['ha', 'bla', 'do'], [','],
                        ['per', 'te', 'ne', 'cien', 'te'], ['a'], ['la'],
                        ['fa', 'mi', 'lia'], ['de'], ['len', 'guas'],
                        ['in', 'doeu', 'ro', 'peas'], ['.']]
    elif lang == 'swe':
        assert syls == [['Svens', 'ka'], ['('], ['svens', 'ka'], ['('],
                        ['in', 'fo'], [')'], [')'], ['är'], ['ett'],
                        ['öst', 'nor', 'diskt'], ['språk'], ['som'],
                        ['ta', 'las'], ['av'], ['un', 'ge', 'fär'], ['tio'],
                        ['mil', 'jo', 'ner'], ['per', 'so', 'ner'], ['främst'],
                        ['i'], ['Sve', 'ri', 'ge'], ['där'], ['språ', 'ket'],
                        ['har'], ['en'], ['do', 'mi', 'nant'],
                        ['ställ', 'ning'], ['som'], ['hu', 'vud', 'språk'],
                        [','], ['men'], ['även'], ['som'], ['det'], ['ena'],
                        ['na', 'tio', 'nal', 'språ', 'ket'], ['i'],
                        ['Fin', 'land'], ['och'], ['som'], ['en', 'da'],
                        ['of', 'fi', 'ci', 'el', 'la'], ['språk'], ['på'],
                        ['Åland'], ['.']]
    elif lang == 'tel':
        assert syls == [['ఆం', 'ధ్ర'], ['ప్ర', 'దే', 'శ్'], [','],
                        ['తె', 'లం', 'గాణ'], ['రా', 'ష్ట్రాల'], ['అధి', 'కార'],
                        ['భాష'], ['తె', 'లు', 'గు'], ['.']]
    elif lang == 'tha':
        assert syls == [['ภา', 'ษา', 'ไทย'], ['หรือ'], ['ภา', 'ษา', 'ไทย'],
                        ['กลาง'], ['เป็น'], ['ภา', 'ษา', 'ราช', 'การ'],
                        ['และ'], ['ภา', 'ษา', 'ประ', 'จำ', 'ชาติ'], ['ของ'],
                        ['ประ', 'เทศ'], ['ไทย']]
    elif lang == 'ukr':
        assert syls == [['Укра', 'ї', '́', 'н', 'сь', 'ка'], ['мо', '́',
                                                              'ва'], ['('],
                        ['МФА'], [':'], ['['], ['ukrɑ̽ˈjɪnʲsʲkɑ̽'], ['ˈmɔwɑ̽'],
                        [']'], [','], ['іс', 'то', 'ри', 'ч', 'ні'],
                        ['на', 'зви'], ['—'], ['ру', '́', 'сь', 'ка'], [','],
                        ['ру', 'си', '́', 'н', 'сь', 'ка', '[9][10][11'],
                        [']'], ['['], ['*'], ['2'], [']'], [')'], ['—'],
                        ['на', 'ціо', 'на', 'ль', 'на'], ['мо', 'ва'],
                        ['укра', 'ї', 'н', 'ців'], ['.']]
    elif lang == 'zul':
        assert syls == [['Zu', 'lu'], ['/ˈzu', 'ːlu',
                                       'ː/'], [','], ['no', 'ma'],
                        ['isi', 'Zu', 'lu'], ['wu', 'li', 'mi'],
                        ['lwa', 'ba', 'ntu'], ['ba', 'se'],
                        ['Ni', 'ngi', 'zi', 'mu'], ['neA', 'fri', 'ka'],
                        ['aba', 'yi', 'ngxe', 'nye'],
                        ['ya', 'ma', 'Ngu', 'ni'], ['.']]
    else:
        raise Exception(f'Error: Tests for language "{lang}" is skipped!')
Example #18
0
def test_pos_tag(lang, pos_tagger, show_results=False):
    lang_text = wl_conversion.to_lang_text(main, lang)

    tokens = wl_word_tokenization.wl_word_tokenize(
        main,
        text=getattr(wl_test_lang_examples, f'SENTENCE_{lang.upper()}'),
        lang=lang)

    tokens_tagged = wl_pos_tagging.wl_pos_tag(main,
                                              tokens=tokens,
                                              lang=lang,
                                              pos_tagger=pos_tagger)
    tokens_tagged_universal = wl_pos_tagging.wl_pos_tag(main,
                                                        tokens=tokens,
                                                        lang=lang,
                                                        pos_tagger=pos_tagger,
                                                        tagset='universal')

    if show_results:
        print(f'{lang} / {pos_tagger}:')
        print(tokens_tagged)
        print(tokens_tagged_universal)

    if lang == 'zho_cn':
        assert tokens_tagged == [('汉语', 'nz'), (',', 'x'), ('又称', 'n'),
                                 ('汉文', 'nz'), ('、', 'x'), ('中文', 'nz'),
                                 ('、', 'x'), ('中国', 'ns'), ('话', 'n'),
                                 ('、', 'x'), ('中国', 'ns'), ('语', 'ng'),
                                 ('、', 'x'), ('华语', 'nz'), ('、', 'x'),
                                 ('华文', 'nz'), ('、', 'x'), ('唐', 'nr'),
                                 ('话', 'n'), ('[', 'x'), ('2', 'x'),
                                 (']', 'x'), (',', 'x'),
                                 ('或', 'c'), ('被', 'p'), ('视为', 'v'),
                                 ('一个', 'm'), ('语族', 'n'), (',', 'x'),
                                 ('或', 'c'), ('被', 'p'), ('视为', 'v'),
                                 ('隶属于', 'n'), ('汉藏语系', 'nz'), ('汉语', 'nz'),
                                 ('族', 'ng'), ('之', 'u'), ('一种', 'm'),
                                 ('语言', 'n'), ('。', 'x')]
        assert tokens_tagged_universal == [('汉语', 'PROPN'), (',', 'PUNCT/SYM'),
                                           ('又称', 'NOUN'), ('汉文', 'PROPN'),
                                           ('、', 'PUNCT/SYM'), ('中文', 'PROPN'),
                                           ('、', 'PUNCT/SYM'), ('中国', 'PROPN'),
                                           ('话', 'NOUN'), ('、', 'PUNCT/SYM'),
                                           ('中国', 'PROPN'), ('语', 'NOUN'),
                                           ('、', 'PUNCT/SYM'), ('华语', 'PROPN'),
                                           ('、', 'PUNCT/SYM'), ('华文', 'PROPN'),
                                           ('、', 'PUNCT/SYM'), ('唐', 'PRONP'),
                                           ('话', 'NOUN'), ('[', 'PUNCT/SYM'),
                                           ('2', 'PUNCT/SYM'),
                                           (']', 'PUNCT/SYM'),
                                           (',', 'PUNCT/SYM'), ('或', 'CONJ'),
                                           ('被', 'ADP'), ('视为', 'VERB'),
                                           ('一个', 'NUM'), ('语族', 'NOUN'),
                                           (',', 'PUNCT/SYM'), ('或', 'CONJ'),
                                           ('被', 'ADP'), ('视为', 'VERB'),
                                           ('隶属于', 'NOUN'), ('汉藏语系', 'PROPN'),
                                           ('汉语', 'PROPN'), ('族', 'NOUN'),
                                           ('之', 'PART'), ('一种', 'NUM'),
                                           ('语言', 'NOUN'), ('。', 'PUNCT/SYM')]
    elif lang == 'zho_tw':
        assert tokens_tagged == [
            ('漢語', 'nz'), (',', 'x'), ('又', 'd'), ('稱', 'v'), ('漢文', 'nz'),
            ('、', 'x'), ('中文', 'nz'), ('、', 'x'), ('中國', 'ns'), ('話', 'n'),
            ('、', 'x'), ('中國', 'ns'), ('語', 'n'), ('、', 'x'), ('華語', 'nz'),
            ('、', 'x'), ('華文', 'nz'), ('、', 'x'), ('唐', 'nr'), ('話', 'n'),
            ('[', 'x'), ('2', 'x'), (']', 'x'), (',', 'x'), ('或', 'c'),
            ('被', 'p'), ('視為', 'v'), ('一個', 'm'), ('語族', 'n'), (',', 'x'),
            ('或', 'c'), ('被', 'p'), ('視為', 'v'), ('隸', 'j'), ('屬', 'v'),
            ('於', 'nr'), ('漢藏語', 'nz'), ('系漢', 'n'), ('語族', 'n'), ('之一', 'r'),
            ('種語', 'n'), ('言', 'vg'), ('。', 'x')
        ]
        assert tokens_tagged_universal == [('漢語', 'PROPN'), (',', 'PUNCT/SYM'),
                                           ('又', 'ADV'), ('稱', 'VERB'),
                                           ('漢文', 'PROPN'), ('、', 'PUNCT/SYM'),
                                           ('中文', 'PROPN'), ('、', 'PUNCT/SYM'),
                                           ('中國', 'PROPN'), ('話', 'NOUN'),
                                           ('、', 'PUNCT/SYM'), ('中國', 'PROPN'),
                                           ('語', 'NOUN'), ('、', 'PUNCT/SYM'),
                                           ('華語', 'PROPN'), ('、', 'PUNCT/SYM'),
                                           ('華文', 'PROPN'), ('、', 'PUNCT/SYM'),
                                           ('唐', 'PRONP'), ('話', 'NOUN'),
                                           ('[', 'PUNCT/SYM'),
                                           ('2', 'PUNCT/SYM'),
                                           (']', 'PUNCT/SYM'),
                                           (',', 'PUNCT/SYM'), ('或', 'CONJ'),
                                           ('被', 'ADP'), ('視為', 'VERB'),
                                           ('一個', 'NUM'), ('語族', 'NOUN'),
                                           (',', 'PUNCT/SYM'), ('或', 'CONJ'),
                                           ('被', 'ADP'), ('視為', 'VERB'),
                                           ('隸', 'X'), ('屬', 'VERB'),
                                           ('於', 'PRONP'), ('漢藏語', 'PROPN'),
                                           ('系漢', 'NOUN'), ('語族', 'NOUN'),
                                           ('之一', 'PRON'), ('種語', 'NOUN'),
                                           ('言', 'VERB'), ('。', 'PUNCT/SYM')]
    elif lang == 'nld':
        assert tokens_tagged == [
            ('Het',
             'Art|bep|onzijd|neut__Definite=Def|Gender=Neut|PronType=Art'),
            ('Nederlands', 'Adj|zelfst|stell|onverv__Degree=Pos'),
            ('is',
             'V|hulpofkopp|ott|3|ev__Aspect=Imp|Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin'
             ),
            ('een',
             'Art|onbep|zijdofonzijd|neut__Definite=Ind|Number=Sing|PronType=Art'
             ),
            ('West-Germaanse', 'Adj|attr|stell|vervneut__Case=Nom|Degree=Pos'),
            ('taal', 'N|soort|ev|neut__Number=Sing'), ('en', 'Conj|neven___'),
            ('de', 'Art|bep|zijdofmv|neut__Definite=Def|PronType=Art'),
            ('moedertaal', 'N|soort|ev|neut__Number=Sing'),
            ('van', 'Prep|voor__AdpType=Prep'),
            ('de', 'Art|bep|zijdofmv|neut__Definite=Def|PronType=Art'),
            ('meeste', 'Num__Case=Nom|Degree=Sup|NumType=Card|PronType=Ind'),
            ('inwoners', 'N|soort|mv|neut__Number=Plur'),
            ('van', 'Prep|voor__AdpType=Prep'),
            ('Nederland', 'N|eigen|ev|neut__Number=Sing'),
            (',', 'Punc|komma__PunctType=Comm'),
            ('België', 'N|eigen|ev|neut__Number=Sing'),
            ('en', 'Conj|neven___'),
            ('Suriname', 'N|eigen|ev|neut__Number=Sing'),
            ('.', 'Punc|punt__PunctType=Peri')
        ]
        assert tokens_tagged_universal == [
            ('Het', 'DET'), ('Nederlands', 'ADJ'), ('is', 'VERB'),
            ('een', 'DET'), ('West-Germaanse', 'ADJ'), ('taal', 'NOUN'),
            ('en', 'CONJ'), ('de', 'DET'), ('moedertaal', 'NOUN'),
            ('van', 'ADP'), ('de', 'DET'), ('meeste', 'NUM'),
            ('inwoners', 'NOUN'), ('van', 'ADP'), ('Nederland', 'NOUN'),
            (',', 'PUNCT'), ('België', 'NOUN'), ('en', 'CONJ'),
            ('Suriname', 'NOUN'), ('.', 'PUNCT')
        ]
    elif lang == 'eng':
        if pos_tagger == 'NLTK - Perceptron POS Tagger':
            assert tokens_tagged == [('English', 'NNP'), ('is', 'VBZ'),
                                     ('a', 'DT'), ('West', 'NNP'),
                                     ('Germanic', 'NNP'), ('language', 'NN'),
                                     ('that', 'WDT'), ('was', 'VBD'),
                                     ('first', 'RB'), ('spoken', 'VBN'),
                                     ('in', 'IN'), ('early', 'JJ'),
                                     ('medieval', 'NN'), ('England', 'NNP'),
                                     ('and', 'CC'), ('eventually', 'RB'),
                                     ('became', 'VBD'), ('a', 'DT'),
                                     ('global', 'JJ'), ('lingua', 'NN'),
                                     ('franca.[4][5', 'NN'), (']', 'NN')]
            assert tokens_tagged_universal == [('English', 'PROPN'),
                                               ('is', 'VERB'), ('a', 'DET'),
                                               ('West', 'PROPN'),
                                               ('Germanic', 'PROPN'),
                                               ('language', 'NOUN'),
                                               ('that', 'DET'), ('was',
                                                                 'VERB'),
                                               ('first', 'ADV'),
                                               ('spoken', 'VERB'),
                                               ('in', 'ADP/SCONJ'),
                                               ('early', 'ADJ'),
                                               ('medieval', 'NOUN'),
                                               ('England', 'PROPN'),
                                               ('and', 'CCONJ'),
                                               ('eventually', 'ADV'),
                                               ('became', 'VERB'),
                                               ('a', 'DET'), ('global', 'ADJ'),
                                               ('lingua', 'NOUN'),
                                               ('franca.[4][5', 'NOUN'),
                                               (']', 'NOUN')]
        elif pos_tagger == 'spaCy - English POS Tagger':
            assert tokens_tagged == [('English', 'NNP'), ('is', 'VBZ'),
                                     ('a', 'DT'), ('West', 'NNP'),
                                     ('Germanic', 'JJ'), ('language', 'NN'),
                                     ('that', 'WDT'), ('was', 'VBD'),
                                     ('first', 'RB'), ('spoken', 'VBN'),
                                     ('in', 'IN'), ('early', 'JJ'),
                                     ('medieval', 'NN'), ('England', 'NNP'),
                                     ('and', 'CC'), ('eventually', 'RB'),
                                     ('became', 'VBD'), ('a', 'DT'),
                                     ('global', 'JJ'), ('lingua', 'NN'),
                                     ('franca.[4][5', 'NN'), (']', '-RRB-')]
            assert tokens_tagged_universal == [('English', 'PROPN'),
                                               ('is', 'VERB'), ('a', 'DET'),
                                               ('West', 'PROPN'),
                                               ('Germanic', 'ADJ'),
                                               ('language', 'NOUN'),
                                               ('that', 'DET'), ('was',
                                                                 'VERB'),
                                               ('first', 'ADV'),
                                               ('spoken', 'VERB'),
                                               ('in', 'ADP/SCONJ'),
                                               ('early', 'ADJ'),
                                               ('medieval', 'NOUN'),
                                               ('England', 'PROPN'),
                                               ('and', 'CCONJ'),
                                               ('eventually', 'ADV'),
                                               ('became', 'VERB'),
                                               ('a', 'DET'), ('global', 'ADJ'),
                                               ('lingua', 'NOUN'),
                                               ('franca.[4][5', 'NOUN'),
                                               (']', 'PUNCT')]
    elif lang == 'fra':
        assert tokens_tagged == [
            ('Le', 'DET__Definite=Def|Gender=Masc|Number=Sing|PronType=Art'),
            ('français', 'NOUN__Gender=Masc|Number=Sing'),
            ('est',
             'AUX__Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin'),
            ('une', 'DET__Definite=Ind|Gender=Fem|Number=Sing|PronType=Art'),
            ('langue', 'NOUN__Gender=Fem|Number=Sing'),
            ('indo-européenne', 'ADJ___'), ('de', 'ADP___'),
            ('la', 'DET__Definite=Def|Gender=Fem|Number=Sing|PronType=Art'),
            ('famille', 'NOUN__Gender=Fem|Number=Sing'),
            ('des', 'DET__Definite=Ind|Number=Plur|PronType=Art'),
            ('langues', 'ADJ__Number=Plur'),
            ('romanes', 'ADJ__Gender=Fem|Number=Plur'), ('.', 'PUNCT___')
        ]
        assert tokens_tagged_universal == [('Le', 'DET'), ('français', 'NOUN'),
                                           ('est', 'AUX'), ('une', 'DET'),
                                           ('langue', 'NOUN'),
                                           ('indo-européenne', 'ADJ'),
                                           ('de', 'ADP'), ('la', 'DET'),
                                           ('famille', 'NOUN'), ('des', 'DET'),
                                           ('langues', 'ADJ'),
                                           ('romanes', 'ADJ'), ('.', 'PUNCT')]
    elif lang == 'deu':
        assert tokens_tagged == [('Die', 'ART'), ('deutsche', 'ADJA'),
                                 ('Sprache', 'NN'), ('bzw.', 'VVFIN'),
                                 ('Deutsch', 'NN'), ('(', '$('), ('[', 'NN'),
                                 ('dɔʏ̯t͡ʃ', 'NE'), (']', 'PTKVZ'),
                                 (';', '$.'), ('abgekürzt', 'VVFIN'),
                                 ('dt', 'XY'), ('.', '$.'), ('oder', 'KON'),
                                 ('dtsch', 'ADJD'), ('.', '$.'), (')', '$('),
                                 ('ist', 'VAFIN'), ('eine', 'ART'),
                                 ('westgermanische', 'ADJA'),
                                 ('Sprache', 'NN'), ('.', '$.')]
        assert tokens_tagged_universal == [('Die', 'DET'), ('deutsche', 'ADJ'),
                                           ('Sprache', 'NOUN'),
                                           ('bzw.', 'VERB'),
                                           ('Deutsch', 'NOUN'), ('(', 'PUNCT'),
                                           ('[', 'NOUN'), ('dɔʏ̯t͡ʃ', 'PROPN'),
                                           (']', 'PART'), (';', 'PUNCT'),
                                           ('abgekürzt', 'VERB'), ('dt', 'X'),
                                           ('.', 'PUNCT'), ('oder', 'CCONJ'),
                                           ('dtsch', 'ADJ'), ('.', 'PUNCT'),
                                           (')', 'PUNCT'), ('ist', 'AUX'),
                                           ('eine', 'DET'),
                                           ('westgermanische', 'ADJ'),
                                           ('Sprache', 'NOUN'), ('.', 'PUNCT')]
    elif lang == 'ell':
        assert tokens_tagged == [('Η', 'DET'), ('ελληνική', 'ADJ'),
                                 ('γλώσσα', 'NOUN'), ('ανήκει', 'VERB'),
                                 ('στην', 'ADJ'), ('ινδοευρωπαϊκή', 'ADJ'),
                                 ('οικογένεια[9', 'NOUN'), (']', 'NUM'),
                                 ('και', 'CCONJ'), ('συγκεκριμένα', 'ADV'),
                                 ('στον', 'ADV'), ('ελληνικό', 'ADJ'),
                                 ('κλάδο', 'NOUN'), (',', 'PUNCT'),
                                 ('μαζί', 'ADV'), ('με', 'ADP'),
                                 ('την', 'DET'), ('τσακωνική', 'ADJ'),
                                 (',', 'PUNCT'), ('ενώ', 'SCONJ'),
                                 ('είναι', 'AUX'), ('η', 'DET'),
                                 ('επίσημη', 'ADJ'), ('γλώσσα', 'NOUN'),
                                 ('της', 'DET'), ('Ελλάδος', 'PROPN'),
                                 ('και', 'CCONJ'), ('της', 'DET'),
                                 ('Κύπρου', 'PROPN'), ('.', 'PUNCT')]
        assert tokens_tagged_universal == [('Η', 'DET'), ('ελληνική', 'ADJ'),
                                           ('γλώσσα', 'NOUN'),
                                           ('ανήκει', 'VERB'), ('στην', 'ADJ'),
                                           ('ινδοευρωπαϊκή', 'ADJ'),
                                           ('οικογένεια[9', 'NOUN'),
                                           (']', 'NUM'), ('και', 'CCONJ'),
                                           ('συγκεκριμένα', 'ADV'),
                                           ('στον', 'ADV'),
                                           ('ελληνικό', 'ADJ'),
                                           ('κλάδο', 'NOUN'), (',', 'PUNCT'),
                                           ('μαζί', 'ADV'), ('με', 'ADP'),
                                           ('την', 'DET'), ('τσακωνική',
                                                            'ADJ'),
                                           (',', 'PUNCT'), ('ενώ', 'SCONJ'),
                                           ('είναι', 'AUX'), ('η', 'DET'),
                                           ('επίσημη', 'ADJ'),
                                           ('γλώσσα', 'NOUN'), ('της', 'DET'),
                                           ('Ελλάδος', 'PROPN'),
                                           ('και', 'CCONJ'), ('της', 'DET'),
                                           ('Κύπρου', 'PROPN'), ('.', 'PUNCT')]
    elif lang == 'ita':
        assert tokens_tagged == [
            ("L'", 'RD__Definite=Def|Number=Sing|PronType=Art'),
            ('italiano', 'S__Gender=Masc|Number=Sing'), ('(', 'FB___'),
            ('[', 'FB___'), ('itaˈljaːno][Nota', 'A__Gender=Fem|Number=Sing'),
            ('1', 'N__NumType=Card'), (']', 'FB___'),
            ('ascolta[?·info', 'SP___'), (']', 'FB___'), (')', 'FB___'),
            ('è', 'V__Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin'),
            ('una', 'RI__Definite=Ind|Gender=Fem|Number=Sing|PronType=Art'),
            ('lingua', 'S__Gender=Fem|Number=Sing'),
            ('romanza', 'S__Gender=Fem|Number=Sing'),
            ('parlata', 'V__Gender=Fem|Number=Sing|Tense=Past|VerbForm=Part'),
            ('principalmente', 'B___'), ('in', 'E___'), ('Italia', 'SP___'),
            ('.', 'FS___')
        ]
        assert tokens_tagged_universal == [("L'", 'DET'), ('italiano', 'NOUN'),
                                           ('(', 'PUNCT'), ('[', 'PUNCT'),
                                           ('itaˈljaːno][Nota', 'ADJ'),
                                           ('1', 'NUM'), (']', 'PUNCT'),
                                           ('ascolta[?·info', 'PROPN'),
                                           (']', 'PUNCT'), (')', 'PUNCT'),
                                           ('è', 'VERB'), ('una', 'DET'),
                                           ('lingua', 'NOUN'),
                                           ('romanza', 'NOUN'),
                                           ('parlata', 'VERB'),
                                           ('principalmente', 'ADV'),
                                           ('in', 'ADP'), ('Italia', 'PROPN'),
                                           ('.', 'PUNCT')]
    elif lang == 'jpn':
        assert tokens_tagged == [('日本', '名詞'), ('語', '名詞'), ('(', '補助記号'),
                                 ('にほんご', '名詞'), ('、', '補助記号'), ('にっぽん', '名詞'),
                                 ('ご', '接尾辞'), ('[', '補助記号'), ('注', '名詞'),
                                 ('1', '名詞'), (']', '補助記号'), (')', '補助記号'),
                                 ('は', '助詞'), ('、', '補助記号'), ('主に', '副詞'),
                                 ('日本', '名詞'), ('国', '接尾辞'), ('内', '接尾辞'),
                                 ('や', '助詞'), ('日本', '名詞'), ('人', '接尾辞'),
                                 ('同士', '接尾辞'), ('の', '助詞'), ('間', '名詞'),
                                 ('で', '助詞'), ('使用', '名詞'), ('さ', '動詞'),
                                 ('れ', '助動詞'), ('て', '助詞'), ('いる', '動詞'),
                                 ('言語', '名詞'), ('で', '助動詞'), ('ある', '動詞'),
                                 ('。', '補助記号')]
        assert tokens_tagged_universal == [('日本', 'NOUN'), ('語', 'NOUN'),
                                           ('(', 'PUNCT/SYM'), ('にほんご',
                                                                'NOUN'),
                                           ('、', 'PUNCT/SYM'),
                                           ('にっぽん', 'NOUN'), ('ご', 'PART'),
                                           ('[', 'PUNCT/SYM'), ('注', 'NOUN'),
                                           ('1', 'NOUN'), (']', 'PUNCT/SYM'),
                                           (')', 'PUNCT/SYM'), ('は', 'PART'),
                                           ('、', 'PUNCT/SYM'), ('主に', 'ADV'),
                                           ('日本', 'NOUN'), ('国', 'PART'),
                                           ('内', 'PART'), ('や', 'PART'),
                                           ('日本', 'NOUN'), ('人', 'PART'),
                                           ('同士', 'PART'), ('の', 'PART'),
                                           ('間', 'NOUN'), ('で', 'PART'),
                                           ('使用', 'NOUN'), ('さ', 'VERB'),
                                           ('れ', 'AUX'), ('て', 'PART'),
                                           ('いる', 'VERB'), ('言語', 'NOUN'),
                                           ('で', 'AUX'), ('ある', 'VERB'),
                                           ('。', 'PUNCT/SYM')]
    elif lang == 'lit':
        assert tokens_tagged == [
            ('Lietuvių', 'Ncmpgn-'), ('kalba', 'Ncfsnn-'), ('–', 'Z'),
            ('iš', 'Sgg'), ('baltų', 'Agpmpgy'), ('prokalbės', 'Ncfsgn-'),
            ('kilusi', 'Agpmsin'), ('lietuvių', 'Ncmpgn-'),
            ('tautos', 'Ncfsgn-'), ('kalba', 'Ncfsin-'), (',', 'Z'),
            ('kuri', 'Pgfsnn'), ('Lietuvoje', 'Npfslng'),
            ('yra', 'Vgmp3s--n--ni-'), ('valstybinė', 'Agpfsnn'), (',', 'Z'),
            ('o', 'Cg'), ('Europos', 'Npfsgng'), ('Sąjungoje', 'Npfslng'),
            ('–', 'Z'), ('viena', 'Pgn--n'), ('iš', 'Sgg'),
            ('oficialiųjų', 'Agpmpgy'), ('kalbų', 'Ncmsnn-'), ('.', 'Z')
        ]
        assert tokens_tagged_universal == [
            ('Lietuvių', 'NOUN'), ('kalba', 'NOUN'), ('–', 'PUNCT'),
            ('iš', 'ADP'), ('baltų', 'ADJ'), ('prokalbės', 'NOUN'),
            ('kilusi', 'ADJ'), ('lietuvių', 'NOUN'), ('tautos', 'NOUN'),
            ('kalba', 'NOUN'), (',', 'PUNCT'), ('kuri', 'PRON'),
            ('Lietuvoje', 'PROPN'), ('yra', 'VERB'), ('valstybinė', 'ADJ'),
            (',', 'PUNCT'), ('o', 'CONJ'), ('Europos', 'PROPN'),
            ('Sąjungoje', 'PROPN'), ('–', 'PUNCT'), ('viena', 'PRON'),
            ('iš', 'ADP'), ('oficialiųjų', 'ADJ'), ('kalbų', 'NOUN'),
            ('.', 'PUNCT')
        ]
    elif lang == 'nob':
        assert tokens_tagged == [
            ('Bokmål', 'NOUN__Definite=Ind|Gender=Neut|Number=Sing'),
            ('er', 'VERB__Mood=Ind|Tense=Pres|VerbForm=Fin'),
            ('en', 'DET__Gender=Masc|Number=Sing'),
            ('varietet', 'ADJ__Definite=Ind|Number=Sing'), ('av', 'ADP___'),
            ('norsk', 'ADJ__Definite=Ind|Degree=Pos|Gender=Neut|Number=Sing'),
            ('språk', 'NOUN__Definite=Ind|Gender=Neut|Number=Sing'),
            ('.', 'PUNCT___')
        ]
        assert tokens_tagged_universal == [('Bokmål', 'NOUN'), ('er', 'VERB'),
                                           ('en', 'DET'), ('varietet', 'ADJ'),
                                           ('av', 'ADP'), ('norsk', 'ADJ'),
                                           ('språk', 'NOUN'), ('.', 'PUNCT')]
    elif lang == 'por':
        assert tokens_tagged == [('A', '<artd>|ART|F|S|@>N'),
                                 ('língua', '<np-def>|N|F|S|@SUBJ>'),
                                 ('portuguesa', 'ADJ|F|S|@N<'),
                                 (',', 'PU|@PU'), ('também', 'ADV|@ADVL>'),
                                 ('designada', '<mv>|V|PCP|F|S|@ICL-N<PRED'),
                                 ('português', 'ADJ|F|S|@N<'), (',', 'PU|@PU'),
                                 ('é', '<mv>|V|PR|3S|IND|@FS-STA'),
                                 ('uma', '<arti>|ART|F|S|@>N'),
                                 ('língua', '<np-idf>|N|F|S|@<SC'),
                                 ('românica', 'ADJ|F|S|@N<'),
                                 ('flexiva', 'ADJ|F|S|@N<'),
                                 ('ocidental', 'ADJ|F|S|@N<'),
                                 ('originada', '<mv>|V|PCP|F|S|@ICL-N<'),
                                 ('no', 'PRP|@<OC'),
                                 ('galego-português', '<np-def>|N|M|S|@<ACC'),
                                 ('falado', '<mv>|V|PCP|M|S|@ICL-N<'),
                                 ('no', '<artd>|ART|M|S|@>N'),
                                 ('Reino', 'PROP|M|S|@P<'), ('da', 'PRP|@N<'),
                                 ('Galiza', 'PROPN'),
                                 ('e', '<co-prparg>|KC|@CO'),
                                 ('no', '<cjt>|PRP|@N<'), ('norte', 'N|@P<'),
                                 ('de', 'PRP|@N<'),
                                 ('Portugal', 'PROP|M|S|@P<'), ('.', 'PU|@PU')]
        assert tokens_tagged_universal == [
            ('A', 'DET'), ('língua', 'NOUN'), ('portuguesa', 'ADJ'),
            (',', 'PUNCT'), ('também', 'ADV'), ('designada', 'VERB'),
            ('português', 'ADJ'), (',', 'PUNCT'), ('é', 'VERB'),
            ('uma', 'DET'), ('língua', 'NOUN'), ('românica', 'ADJ'),
            ('flexiva', 'ADJ'), ('ocidental', 'ADJ'), ('originada', 'VERB'),
            ('no', 'ADP'), ('galego-português', 'NOUN'), ('falado', 'VERB'),
            ('no', 'DET'), ('Reino', 'PROPN'), ('da', 'ADP'),
            ('Galiza', 'PROPN'), ('e', 'CCONJ'), ('no', 'ADP'),
            ('norte', 'NOUN'), ('de', 'ADP'), ('Portugal', 'PROPN'),
            ('.', 'PUNCT')
        ]
    elif lang == 'rus':
        if pos_tagger == 'NLTK - Perceptron POS Tagger':
            assert tokens_tagged == [('Ру́сский', 'A=m'), ('язы́к', 'S'),
                                     ('(', 'NONLEX'), ('[', 'NONLEX'),
                                     ('ˈruskʲɪi̯', 'NONLEX'),
                                     ('jɪˈzɨk', 'NONLEX'), (']', 'NONLEX'),
                                     ('Информация', 'S'), ('о', 'PR'),
                                     ('файле', 'S'), ('слушать', 'V'),
                                     (')', 'NONLEX'), ('[', 'NONLEX'),
                                     ('~', 'NONLEX'), ('3', 'NUM=ciph'),
                                     (']', 'NONLEX'), ('[', 'NONLEX'),
                                     ('⇨', 'NONLEX'), (']', 'NONLEX'),
                                     ('—', 'NONLEX'), ('один', 'A-PRO=m'),
                                     ('из', 'PR'),
                                     ('восточнославянских', 'A=pl'),
                                     ('языков', 'S'), (',', 'NONLEX'),
                                     ('национальный', 'A=m'), ('язык', 'S'),
                                     ('русского', 'A=m'), ('народа', 'S'),
                                     ('.', 'NONLEX')]
            assert tokens_tagged_universal == [('Ру́сский', 'ADJ'),
                                               ('язы́к', 'NOUN'),
                                               ('(', 'PUNCT'), ('[', 'PUNCT'),
                                               ('ˈruskʲɪi̯', 'PUNCT'),
                                               ('jɪˈzɨk', 'PUNCT'),
                                               (']', 'PUNCT'),
                                               ('Информация', 'NOUN'),
                                               ('о', 'ADP'), ('файле', 'NOUN'),
                                               ('слушать', 'VERB'),
                                               (')', 'PUNCT'), ('[', 'PUNCT'),
                                               ('~', 'PUNCT'), ('3', 'NUM'),
                                               (']', 'PUNCT'), ('[', 'PUNCT'),
                                               ('⇨', 'PUNCT'), (']', 'PUNCT'),
                                               ('—', 'PUNCT'),
                                               ('один', 'PRON'), ('из', 'ADP'),
                                               ('восточнославянских', 'ADJ'),
                                               ('языков', 'NOUN'),
                                               (',', 'PUNCT'),
                                               ('национальный', 'ADJ'),
                                               ('язык', 'NOUN'),
                                               ('русского', 'ADJ'),
                                               ('народа', 'NOUN'),
                                               ('.', 'PUNCT')]
        elif pos_tagger == 'pymorphy2 - Morphological Analyzer':
            assert tokens_tagged == [
                ('Ру́сский', 'NOUN'), ('язы́к', 'NOUN'), ('(', 'PNCT'),
                ('[', 'PNCT'), ('ˈruskʲɪi̯', 'UNKN'), ('jɪˈzɨk', 'UNKN'),
                (']', 'PNCT'), ('Информация', 'NOUN'), ('о', 'PREP'),
                ('файле', 'NOUN'), ('слушать', 'INFN'), (')', 'PNCT'),
                ('[', 'PNCT'), ('~', 'UNKN'), ('3', 'NUMB'), (']', 'PNCT'),
                ('[', 'PNCT'), ('⇨', 'UNKN'), (']', 'PNCT'), ('—', 'PNCT'),
                ('один', 'ADJF'), ('из', 'PREP'),
                ('восточнославянских', 'ADJF'), ('языков', 'NOUN'),
                (',', 'PNCT'), ('национальный', 'ADJF'), ('язык', 'NOUN'),
                ('русского', 'ADJF'), ('народа', 'NOUN'), ('.', 'PNCT')
            ]
            assert tokens_tagged_universal == [('Ру́сский', 'NOUN'),
                                               ('язы́к', 'NOUN'),
                                               ('(', 'PUNCT'), ('[', 'PUNCT'),
                                               ('ˈruskʲɪi̯', 'SYM/X'),
                                               ('jɪˈzɨk', 'SYM/X'),
                                               (']', 'PUNCT'),
                                               ('Информация', 'NOUN'),
                                               ('о', 'ADP'), ('файле', 'NOUN'),
                                               ('слушать', 'VERB'),
                                               (')', 'PUNCT'), ('[', 'PUNCT'),
                                               ('~', 'SYM/X'), ('3', 'NUM'),
                                               (']', 'PUNCT'), ('[', 'PUNCT'),
                                               ('⇨', 'SYM/X'), (']', 'PUNCT'),
                                               ('—', 'PUNCT'), ('один', 'ADJ'),
                                               ('из', 'ADP'),
                                               ('восточнославянских', 'ADJ'),
                                               ('языков', 'NOUN'),
                                               (',', 'PUNCT'),
                                               ('национальный', 'ADJ'),
                                               ('язык', 'NOUN'),
                                               ('русского', 'ADJ'),
                                               ('народа', 'NOUN'),
                                               ('.', 'PUNCT')]
    elif lang == 'spa':
        assert tokens_tagged == [
            ('El', 'DET__Definite=Def|Gender=Masc|Number=Sing|PronType=Art'),
            ('español', 'NOUN__Gender=Masc|Number=Sing'), ('o', 'CCONJ___'),
            ('castellano', 'NOUN__Gender=Masc|Number=Sing'),
            ('es',
             'AUX__Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin'),
            ('una', 'DET__Definite=Ind|Gender=Fem|Number=Sing|PronType=Art'),
            ('lengua', 'NOUN__Gender=Fem|Number=Sing'),
            ('romance', 'NOUN__Gender=Masc|Number=Sing'),
            ('procedente', 'ADJ__Number=Sing'),
            ('del', 'ADP__AdpType=Preppron|Gender=Masc|Number=Sing'),
            ('latín', 'NOUN__Gender=Masc|Number=Sing'),
            ('hablado', 'ADJ__Gender=Masc|Number=Sing|VerbForm=Part'),
            ('.', 'PUNCT__PunctType=Peri')
        ]
        assert tokens_tagged_universal == [('El', 'DET'), ('español', 'NOUN'),
                                           ('o', 'CCONJ'),
                                           ('castellano', 'NOUN'),
                                           ('es', 'AUX'), ('una', 'DET'),
                                           ('lengua', 'NOUN'),
                                           ('romance', 'NOUN'),
                                           ('procedente', 'ADJ'),
                                           ('del', 'ADP'), ('latín', 'NOUN'),
                                           ('hablado', 'ADJ'), ('.', 'PUNCT')]
    elif lang == 'tha':
        if pos_tagger == 'PyThaiNLP - Perceptron Tagger (ORCHID)':
            assert tokens_tagged == [('ภาษาไทย', 'NPRP'), ('หรือ', 'JCRG'),
                                     ('ภาษาไทย', 'NPRP'), ('กลาง', 'VATT'),
                                     ('เป็น', 'VSTA'), ('ภาษาราชการ', 'NCMN'),
                                     ('และ', 'JCRG'),
                                     ('ภาษาประจำชาติ', 'NCMN'),
                                     ('ของ', 'RPRE'), ('ประเทศ', 'NCMN'),
                                     ('ไทย', 'NPRP')]
            assert tokens_tagged_universal == [('ภาษาไทย', 'PROPN'),
                                               ('หรือ', 'CCONJ'),
                                               ('ภาษาไทย', 'PROPN'),
                                               ('กลาง', 'VERB'),
                                               ('เป็น', 'VERB'),
                                               ('ภาษาราชการ', 'NOUN'),
                                               ('และ', 'CCONJ'),
                                               ('ภาษาประจำชาติ', 'NOUN'),
                                               ('ของ', 'ADP'),
                                               ('ประเทศ', 'NOUN'),
                                               ('ไทย', 'PROPN')]
        elif pos_tagger == 'PyThaiNLP - Perceptron Tagger (PUD)':
            assert tokens_tagged == [('ภาษาไทย', 'NOUN'), ('หรือ', 'CCONJ'),
                                     ('ภาษาไทย', 'NOUN'), ('กลาง', 'NOUN'),
                                     ('เป็น', 'AUX'), ('ภาษาราชการ', 'NOUN'),
                                     ('และ', 'CCONJ'),
                                     ('ภาษาประจำชาติ', 'NOUN'), ('ของ', 'ADP'),
                                     ('ประเทศ', 'NOUN'), ('ไทย', 'PROPN')]
            assert tokens_tagged_universal == [('ภาษาไทย', 'NOUN'),
                                               ('หรือ', 'CCONJ'),
                                               ('ภาษาไทย', 'NOUN'),
                                               ('กลาง', 'NOUN'),
                                               ('เป็น', 'AUX'),
                                               ('ภาษาราชการ', 'NOUN'),
                                               ('และ', 'CCONJ'),
                                               ('ภาษาประจำชาติ', 'NOUN'),
                                               ('ของ', 'ADP'),
                                               ('ประเทศ', 'NOUN'),
                                               ('ไทย', 'PROPN')]
    elif lang == 'bod':
        assert tokens_tagged == [('བོད་', 'PROPN'), ('ཀྱི་', 'NO_POS'),
                                 ('སྐད་ཡིག་', 'NOUN'), ('ནི་', 'NO_POS'),
                                 ('བོད་ཡུལ་', 'PROPN'), ('དང་', 'NO_POS'),
                                 ('དེ', 'DET'), ('འི་', 'PART'),
                                 ('ཉེ་འཁོར་', 'NOUN'), ('གྱི་', 'NO_POS'),
                                 ('ས་ཁུལ་', 'OTHER'), ('ཏེ', 'NO_POS'),
                                 ('།', 'PUNCT')]
        assert tokens_tagged_universal == [('བོད་', 'PROPN'), ('ཀྱི་', 'X'),
                                           ('སྐད་ཡིག་', 'NOUN'), ('ནི་', 'X'),
                                           ('བོད་ཡུལ་', 'PROPN'), ('དང་', 'X'),
                                           ('དེ', 'DET'), ('འི་', 'PART'),
                                           ('ཉེ་འཁོར་', 'NOUN'), ('གྱི་', 'X'),
                                           ('ས་ཁུལ་', 'X'), ('ཏེ', 'X'),
                                           ('།', 'PUNCT')]
    elif lang == 'ukr':
        assert tokens_tagged == [('Украї́нська', 'ADJF'), ('мо́ва', 'ADJF'),
                                 ('(', 'PNCT'), ('МФА', 'UNKN'), (':', 'PNCT'),
                                 ('[', 'PNCT'), ('ukrɑ̽ˈjɪnʲsʲkɑ̽', 'UNKN'),
                                 ('ˈmɔwɑ̽', 'UNKN'), (']', 'PNCT'),
                                 (',', 'PNCT'), ('історичні', 'ADJF'),
                                 ('назви', 'NOUN'), ('—', 'PNCT'),
                                 ('ру́ська', 'ADJF'), (',', 'PNCT'),
                                 ('руси́нська[9][10][11', 'UNKN'),
                                 (']', 'PNCT'), ('[', 'PNCT'), ('*', 'PNCT'),
                                 ('2', 'NUMB'), (']', 'PNCT'), (')', 'PNCT'),
                                 ('—', 'PNCT'), ('національна', 'ADJF'),
                                 ('мова', 'NOUN'), ('українців', 'NOUN'),
                                 ('.', 'PNCT')]
        assert tokens_tagged_universal == [('Украї́нська', 'ADJ'),
                                           ('мо́ва', 'ADJ'), ('(', 'PUNCT'),
                                           ('МФА', 'SYM/X'), (':', 'PUNCT'),
                                           ('[', 'PUNCT'),
                                           ('ukrɑ̽ˈjɪnʲsʲkɑ̽', 'SYM/X'),
                                           ('ˈmɔwɑ̽', 'SYM/X'), (']', 'PUNCT'),
                                           (',', 'PUNCT'),
                                           ('історичні', 'ADJ'),
                                           ('назви', 'NOUN'), ('—', 'PUNCT'),
                                           ('ру́ська', 'ADJ'), (',', 'PUNCT'),
                                           ('руси́нська[9][10][11', 'SYM/X'),
                                           (']', 'PUNCT'), ('[', 'PUNCT'),
                                           ('*', 'PUNCT'), ('2', 'NUM'),
                                           (']', 'PUNCT'), (')', 'PUNCT'),
                                           ('—', 'PUNCT'),
                                           ('національна', 'ADJ'),
                                           ('мова', 'NOUN'),
                                           ('українців', 'NOUN'),
                                           ('.', 'PUNCT')]
    elif lang == 'vie':
        assert tokens_tagged == [('Tiếng', 'N'), ('Việt', 'Np'), (',', 'CH'),
                                 ('còn', 'C'), ('gọi', 'V'), ('tiếng', 'N'),
                                 ('Việt Nam', 'Np'), ('[', 'V'), ('5', 'M'),
                                 (']', 'CH'), (',', 'CH'), ('tiếng Kinh', 'N'),
                                 ('hay', 'C'), ('Việt ngữ', 'V'), (',', 'CH'),
                                 ('là', 'V'), ('ngôn ngữ', 'N'), ('của', 'E'),
                                 ('người', 'Nc'), ('Việt', 'Np'), ('(', 'CH'),
                                 ('dân tộc', 'N'), ('Kinh', 'Np'), (')', 'CH'),
                                 ('và', 'C'), ('là', 'V'), ('ngôn ngữ', 'N'),
                                 ('chính thức', 'A'), ('tại', 'E'),
                                 ('Việt Nam', 'Np'), ('.', 'CH')]
        assert tokens_tagged_universal == [
            ('Tiếng', 'NOUN'), ('Việt', 'PROPN'), (',', 'PUNCT'),
            ('còn', 'CCONJ'), ('gọi', 'VERB'), ('tiếng', 'NOUN'),
            ('Việt Nam', 'PROPN'), ('[', 'VERB'), ('5', 'NUM'), (']', 'PUNCT'),
            (',', 'PUNCT'), ('tiếng Kinh', 'NOUN'), ('hay', 'CCONJ'),
            ('Việt ngữ', 'VERB'), (',', 'PUNCT'), ('là', 'VERB'),
            ('ngôn ngữ', 'NOUN'), ('của', 'ADP'), ('người', 'NOUN'),
            ('Việt', 'PROPN'), ('(', 'PUNCT'), ('dân tộc', 'NOUN'),
            ('Kinh', 'PROPN'), (')', 'PUNCT'), ('và', 'CCONJ'), ('là', 'VERB'),
            ('ngôn ngữ', 'NOUN'), ('chính thức', 'ADJ'), ('tại', 'ADP'),
            ('Việt Nam', 'PROPN'), ('.', 'PUNCT')
        ]
    def __init__(self, main):
        super().__init__(main)

        settings_global = self.main.settings_global['stop_words']

        # Stop Words Settings
        group_box_stop_words_settings = QGroupBox(
            self.tr('Stop Words Settings'), self)

        table_stop_words = wl_table.Wl_Table(
            self,
            headers=[self.tr('Language'),
                     self.tr('Lists of Stop Words')],
            cols_stretch=[self.tr('Lists of Stop Words')])

        table_stop_words.verticalHeader().setHidden(True)
        table_stop_words.setRowCount(len(settings_global))

        for i, lang in enumerate(settings_global):
            table_stop_words.setItem(
                i, 0,
                QTableWidgetItem(wl_conversion.to_lang_text(self.main, lang)))

            self.__dict__[
                f'combo_box_stop_words_{lang}'] = wl_box.Wl_Combo_Box(self)

            self.__dict__[f'combo_box_stop_words_{lang}'].addItems(
                settings_global[lang])

            self.__dict__[
                f'combo_box_stop_words_{lang}'].currentTextChanged.connect(
                    lambda text, lang=lang: self.stop_words_changed(lang))

            table_stop_words.setCellWidget(
                i, 1, self.__dict__[f'combo_box_stop_words_{lang}'])

        group_box_stop_words_settings.setLayout(wl_layout.Wl_Layout())
        group_box_stop_words_settings.layout().addWidget(
            table_stop_words, 0, 0)

        # Preview
        group_box_preview = QGroupBox(self.tr('Preview'), self)

        self.label_stop_words_preview_lang = QLabel(
            self.tr('Select language:'), self)
        self.combo_box_stop_words_preview_lang = wl_box.Wl_Combo_Box(self)
        self.combo_box_stop_words_preview_lang.addItems(
            wl_conversion.to_lang_text(self.main,
                                       list(settings_global.keys())))
        self.label_stop_words_preview_count = QLabel('', self)

        self.list_stop_words_preview_results = wl_list.Wl_List_Stop_Words(self)

        self.combo_box_stop_words_preview_lang.currentTextChanged.connect(
            self.preview_settings_changed)
        self.combo_box_stop_words_preview_lang.currentTextChanged.connect(
            self.preview_results_changed)

        layout_preview_settings = wl_layout.Wl_Layout()
        layout_preview_settings.addWidget(self.label_stop_words_preview_lang,
                                          0, 0)
        layout_preview_settings.addWidget(
            self.combo_box_stop_words_preview_lang, 0, 1)
        layout_preview_settings.addWidget(self.label_stop_words_preview_count,
                                          0, 3)

        layout_preview_settings.setColumnStretch(2, 1)

        group_box_preview.setLayout(wl_layout.Wl_Layout())
        group_box_preview.layout().addLayout(layout_preview_settings, 0, 0, 1,
                                             5)
        group_box_preview.layout().addWidget(
            self.list_stop_words_preview_results, 1, 0, 1, 5)
        group_box_preview.layout().addWidget(
            self.list_stop_words_preview_results.button_add, 2, 0)
        group_box_preview.layout().addWidget(
            self.list_stop_words_preview_results.button_remove, 2, 1)
        group_box_preview.layout().addWidget(
            self.list_stop_words_preview_results.button_clear, 2, 2)
        group_box_preview.layout().addWidget(
            self.list_stop_words_preview_results.button_import, 2, 3)
        group_box_preview.layout().addWidget(
            self.list_stop_words_preview_results.button_export, 2, 4)

        self.setLayout(wl_layout.Wl_Layout())
        self.layout().addWidget(group_box_stop_words_settings, 0, 0)
        self.layout().addWidget(group_box_preview, 1, 0)

        self.layout().setContentsMargins(6, 4, 6, 4)
        self.layout().setRowStretch(0, 3)
        self.layout().setRowStretch(1, 2)

        self.preview_results_changed()
Example #20
0
def test_pos_tag(lang, pos_tagger, show_results=False):
    lang_text = wl_conversion.to_lang_text(main, lang)

    tokens = wl_word_tokenization.wl_word_tokenize(
        main,
        text=getattr(wl_test_lang_examples, f'SENTENCE_{lang.upper()}'),
        lang=lang)
    tokens = list(wl_misc.flatten_list(tokens))

    tokens_tagged = wl_pos_tagging.wl_pos_tag(main,
                                              tokens=tokens,
                                              lang=lang,
                                              pos_tagger=pos_tagger)
    tokens_tagged_universal = wl_pos_tagging.wl_pos_tag(main,
                                                        tokens=tokens,
                                                        lang=lang,
                                                        pos_tagger=pos_tagger,
                                                        tagset='universal')

    if show_results:
        print(f'{lang} / {pos_tagger}:')
        print(tokens_tagged)
        print(tokens_tagged_universal)

    if lang == 'zho_cn':
        assert tokens_tagged == [('汉语', 'nz'), (',', 'x'), ('又', 'd'),
                                 ('称', 'v'), ('汉文', 'nz'), ('、', 'x'),
                                 ('中文', 'nz'), ('、', 'x'), ('中国', 'ns'),
                                 ('话', 'n'), ('、', 'x'), ('中国', 'ns'),
                                 ('语', 'ng'), ('、', 'x'), ('华语', 'nz'),
                                 ('、', 'x'), ('华文', 'nz'), ('、', 'x'),
                                 ('唐', 'nr'), ('话', 'n'), ('[', 'x'),
                                 ('2', 'x'), (']', 'x'), (',', 'x'),
                                 ('或', 'c'), ('被', 'p'), ('视为', 'v'),
                                 ('一个', 'm'), ('语族', 'n'), (',', 'x'),
                                 ('或', 'c'), ('被', 'p'), ('视为', 'v'),
                                 ('隶属于', 'n'), ('汉藏', 'ns'), ('语系', 'n'),
                                 ('汉语', 'nz'), ('族', 'ng'), ('之一', 'r'),
                                 ('种', 'm'), ('语言', 'n'), ('。', 'x')]
        assert tokens_tagged_universal == [('汉语', 'PROPN'), (',', 'PUNCT/SYM'),
                                           ('又', 'ADV'), ('称', 'VERB'),
                                           ('汉文', 'PROPN'), ('、', 'PUNCT/SYM'),
                                           ('中文', 'PROPN'), ('、', 'PUNCT/SYM'),
                                           ('中国', 'PROPN'), ('话', 'NOUN'),
                                           ('、', 'PUNCT/SYM'), ('中国', 'PROPN'),
                                           ('语', 'NOUN'), ('、', 'PUNCT/SYM'),
                                           ('华语', 'PROPN'), ('、', 'PUNCT/SYM'),
                                           ('华文', 'PROPN'), ('、', 'PUNCT/SYM'),
                                           ('唐', 'PRONP'), ('话', 'NOUN'),
                                           ('[', 'PUNCT/SYM'),
                                           ('2', 'PUNCT/SYM'),
                                           (']', 'PUNCT/SYM'),
                                           (',', 'PUNCT/SYM'), ('或', 'CONJ'),
                                           ('被', 'ADP'), ('视为', 'VERB'),
                                           ('一个', 'NUM'), ('语族', 'NOUN'),
                                           (',', 'PUNCT/SYM'), ('或', 'CONJ'),
                                           ('被', 'ADP'), ('视为', 'VERB'),
                                           ('隶属于', 'NOUN'), ('汉藏', 'PROPN'),
                                           ('语系', 'NOUN'), ('汉语', 'PROPN'),
                                           ('族', 'NOUN'), ('之一', 'PRON'),
                                           ('种', 'NUM'), ('语言', 'NOUN'),
                                           ('。', 'PUNCT/SYM')]
    elif lang == 'zho_tw':
        assert tokens_tagged == [
            ('漢語', 'nz'), (',', 'x'), ('又', 'd'), ('稱', 'zg'), ('漢文', 'nz'),
            ('、', 'x'), ('中文', 'nz'), ('、', 'x'), ('中', 'f'), ('國話', 'n'),
            ('、', 'x'), ('中國', 'ns'), ('語', 'n'), ('、', 'x'), ('華語', 'nz'),
            ('、', 'x'), ('華文', 'nz'), ('、', 'x'), ('唐', 'nr'), ('話', 'x'),
            ('[', 'x'), ('2', 'x'), (']', 'x'), (',', 'x'), ('或', 'c'),
            ('被', 'p'), ('視為', 'v'), ('一', 'm'), ('個', 'zg'), ('語族', 'n'),
            (',', 'x'), ('或', 'c'), ('被', 'p'), ('視', 'x'), ('為', 'p'),
            ('隸', 'j'), ('屬', 'v'), ('於', 'nr'), ('漢', 'j'), ('藏', 'j'),
            ('語系', 'n'), ('漢語', 'nz'), ('族', 'ng'), ('之一', 'r'), ('種', 'x'),
            ('語言', 'n'), ('。', 'x')
        ]
        assert tokens_tagged_universal == [('漢語', 'PROPN'), (',', 'PUNCT/SYM'),
                                           ('又', 'ADV'), ('稱', 'PART'),
                                           ('漢文', 'PROPN'), ('、', 'PUNCT/SYM'),
                                           ('中文', 'PROPN'), ('、', 'PUNCT/SYM'),
                                           ('中', 'ADP'), ('國話', 'NOUN'),
                                           ('、', 'PUNCT/SYM'), ('中國', 'PROPN'),
                                           ('語', 'NOUN'), ('、', 'PUNCT/SYM'),
                                           ('華語', 'PROPN'), ('、', 'PUNCT/SYM'),
                                           ('華文', 'PROPN'), ('、', 'PUNCT/SYM'),
                                           ('唐', 'PRONP'), ('話', 'PUNCT/SYM'),
                                           ('[', 'PUNCT/SYM'),
                                           ('2', 'PUNCT/SYM'),
                                           (']', 'PUNCT/SYM'),
                                           (',', 'PUNCT/SYM'), ('或', 'CONJ'),
                                           ('被', 'ADP'), ('視為', 'VERB'),
                                           ('一', 'NUM'), ('個', 'PART'),
                                           ('語族', 'NOUN'), (',', 'PUNCT/SYM'),
                                           ('或', 'CONJ'), ('被', 'ADP'),
                                           ('視', 'PUNCT/SYM'), ('為', 'ADP'),
                                           ('隸', 'X'), ('屬', 'VERB'),
                                           ('於', 'PRONP'), ('漢', 'X'),
                                           ('藏', 'X'), ('語系', 'NOUN'),
                                           ('漢語', 'PROPN'), ('族', 'NOUN'),
                                           ('之一', 'PRON'), ('種', 'PUNCT/SYM'),
                                           ('語言', 'NOUN'), ('。', 'PUNCT/SYM')]
    elif lang == 'dan':
        assert tokens_tagged == [
            ('Dansk', 'ADJ__Definite=Ind|Degree=Pos|Number=Sing'),
            ('er', 'AUX__Mood=Ind|Tense=Pres|VerbForm=Fin|Voice=Act'),
            ('et', 'DET__Gender=Neut|Number=Sing|PronType=Ind'),
            ('nordgermansk', 'ADJ__Definite=Ind|Degree=Pos|Number=Sing'),
            ('sprog', 'NOUN__Definite=Ind|Gender=Neut|Number=Sing'),
            ('af', 'ADP__AdpType=Prep'),
            ('den', 'DET__Gender=Com|Number=Sing|PronType=Dem'),
            ('østnordiske', 'ADJ__Definite=Def|Degree=Pos|Number=Sing'),
            ('(', 'PUNCT'), ('kontinentale', 'ADJ__Degree=Pos|Number=Plur'),
            (')', 'PUNCT'),
            ('gruppe', 'NOUN__Definite=Ind|Gender=Com|Number=Sing'),
            (',', 'PUNCT'), ('der', 'PRON__PartType=Inf'),
            ('tales', 'VERB__Mood=Ind|Tense=Pres|VerbForm=Fin|Voice=Pass'),
            ('af', 'ADP__AdpType=Prep'), ('ca.', 'ADV'),
            ('seks', 'NUM__NumType=Card'),
            ('millioner', 'NOUN__Definite=Ind|Gender=Com|Number=Plur'),
            ('mennesker', 'NOUN__Definite=Ind|Gender=Neut|Number=Plur'),
            ('.', 'PUNCT')
        ]
        assert tokens_tagged_universal == [('Dansk', 'ADJ'), ('er', 'AUX'),
                                           ('et', 'DET'),
                                           ('nordgermansk', 'ADJ'),
                                           ('sprog', 'NOUN'), ('af', 'ADP'),
                                           ('den', 'DET'),
                                           ('østnordiske', 'ADJ'),
                                           ('(', 'PUNCT'),
                                           ('kontinentale', 'ADJ'),
                                           (')', 'PUNCT'), ('gruppe', 'NOUN'),
                                           (',', 'PUNCT'), ('der', 'PRON'),
                                           ('tales', 'VERB'), ('af', 'ADP'),
                                           ('ca.', 'ADV'), ('seks', 'NUM'),
                                           ('millioner', 'NOUN'),
                                           ('mennesker', 'NOUN'),
                                           ('.', 'PUNCT')]
    elif lang == 'nld':
        assert tokens_tagged == [
            ('Het', 'LID|bep|stan|evon__Definite=Def'),
            ('Nederlands',
             'N|eigen|ev|basis|onz|stan__Gender=Neut|Number=Sing'),
            ('is', 'WW|pv|tgw|ev__Number=Sing|Tense=Pres|VerbForm=Fin'),
            ('een', 'LID|onbep|stan|agr__Definite=Ind'),
            ('West-Germaanse', 'ADJ|prenom|basis|met-e|stan__Degree=Pos'),
            ('taal', 'N|soort|ev|basis|zijd|stan__Gender=Com|Number=Sing'),
            ('en', 'VG|neven'), ('de', 'LID|bep|stan|rest__Definite=Def'),
            ('moedertaal',
             'N|soort|ev|basis|zijd|stan__Gender=Com|Number=Sing'),
            ('van', 'VZ|init'), ('de', 'LID|bep|stan|rest__Definite=Def'),
            ('meeste', 'VNW|onbep|grad|stan|prenom|met-e|agr|sup'),
            ('inwoners', 'N|soort|mv|basis__Number=Plur'), ('van', 'VZ|init'),
            ('Nederland',
             'N|eigen|ev|basis|onz|stan__Gender=Neut|Number=Sing'),
            (',', 'LET'),
            ('België', 'N|eigen|ev|basis|onz|stan__Gender=Neut|Number=Sing'),
            ('en', 'VG|neven'),
            ('Suriname', 'N|eigen|ev|basis|onz|stan__Gender=Neut|Number=Sing'),
            ('.', 'LET')
        ]
        assert tokens_tagged_universal == [
            ('Het', 'DET'), ('Nederlands', 'PROPN'), ('is', 'VERB'),
            ('een', 'DET'), ('West-Germaanse', 'ADJ'), ('taal', 'NOUN'),
            ('en', 'CCONJ'), ('de', 'DET'), ('moedertaal', 'NOUN'),
            ('van', 'ADP'), ('de', 'DET'), ('meeste', 'ADV'),
            ('inwoners', 'NOUN'), ('van', 'ADP'), ('Nederland', 'PROPN'),
            (',', 'SYM'), ('België', 'PROPN'), ('en', 'CCONJ'),
            ('Suriname', 'PROPN'), ('.', 'SYM')
        ]
    elif lang == 'eng':
        if pos_tagger == 'NLTK - Perceptron POS Tagger':
            assert tokens_tagged == [('English', 'NNP'), ('is', 'VBZ'),
                                     ('a', 'DT'), ('West', 'NNP'),
                                     ('Germanic', 'NNP'), ('language', 'NN'),
                                     ('that', 'WDT'), ('was', 'VBD'),
                                     ('first', 'RB'), ('spoken', 'VBN'),
                                     ('in', 'IN'), ('early', 'JJ'),
                                     ('medieval', 'NN'), ('England', 'NNP'),
                                     ('and', 'CC'), ('eventually', 'RB'),
                                     ('became', 'VBD'), ('a', 'DT'),
                                     ('global', 'JJ'), ('lingua', 'NN'),
                                     ('franca.[4][5', 'NN'), (']', 'NN')]
            assert tokens_tagged_universal == [('English', 'PROPN'),
                                               ('is', 'VERB'), ('a', 'DET'),
                                               ('West', 'PROPN'),
                                               ('Germanic', 'PROPN'),
                                               ('language', 'NOUN'),
                                               ('that', 'DET'), ('was',
                                                                 'VERB'),
                                               ('first', 'ADV'),
                                               ('spoken', 'VERB'),
                                               ('in', 'ADP/SCONJ'),
                                               ('early', 'ADJ'),
                                               ('medieval', 'NOUN'),
                                               ('England', 'PROPN'),
                                               ('and', 'CCONJ'),
                                               ('eventually', 'ADV'),
                                               ('became', 'VERB'),
                                               ('a', 'DET'), ('global', 'ADJ'),
                                               ('lingua', 'NOUN'),
                                               ('franca.[4][5', 'NOUN'),
                                               (']', 'NOUN')]
        elif pos_tagger == 'spaCy - English POS Tagger':
            assert tokens_tagged == [('English', 'NNP'), ('is', 'VBZ'),
                                     ('a', 'DT'), ('West', 'NNP'),
                                     ('Germanic', 'NNP'), ('language', 'NN'),
                                     ('that', 'WDT'), ('was', 'VBD'),
                                     ('first', 'RB'), ('spoken', 'VBN'),
                                     ('in', 'IN'), ('early', 'JJ'),
                                     ('medieval', 'JJ'), ('England', 'NNP'),
                                     ('and', 'CC'), ('eventually', 'RB'),
                                     ('became', 'VBD'), ('a', 'DT'),
                                     ('global', 'JJ'), ('lingua', 'NN'),
                                     ('franca.[4][5', 'NNP'), (']', '-RRB-')]
            assert tokens_tagged_universal == [('English', 'PROPN'),
                                               ('is', 'AUX'), ('a', 'DET'),
                                               ('West', 'PROPN'),
                                               ('Germanic', 'PROPN'),
                                               ('language', 'NOUN'),
                                               ('that', 'DET'), ('was', 'AUX'),
                                               ('first', 'ADV'),
                                               ('spoken', 'VERB'),
                                               ('in', 'ADP'), ('early', 'ADJ'),
                                               ('medieval', 'ADJ'),
                                               ('England', 'PROPN'),
                                               ('and', 'CCONJ'),
                                               ('eventually', 'ADV'),
                                               ('became', 'VERB'),
                                               ('a', 'DET'), ('global', 'ADJ'),
                                               ('lingua', 'NOUN'),
                                               ('franca.[4][5', 'PROPN'),
                                               (']', 'PUNCT')]
    elif lang == 'fra':
        assert tokens_tagged == [
            ('Le', 'DET__Definite=Def|Gender=Masc|Number=Sing|PronType=Art'),
            ('français', 'ADJ__Gender=Masc'),
            ('est',
             'AUX__Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin'),
            ('une', 'DET__Definite=Ind|Gender=Fem|Number=Sing|PronType=Art'),
            ('langue', 'NOUN__Gender=Fem|Number=Sing'),
            ('indo-européenne', 'ADJ__Gender=Fem|Number=Sing'), ('de', 'ADP'),
            ('la', 'DET__Definite=Def|Gender=Fem|Number=Sing|PronType=Art'),
            ('famille', 'NOUN__Gender=Fem|Number=Sing'),
            ('des', 'ADP_DET__Definite=Def|Number=Plur|PronType=Art'),
            ('langues', 'NOUN__Gender=Fem|Number=Plur'),
            ('romanes', 'ADJ__Gender=Fem|Number=Plur'), ('.', 'PUNCT')
        ]
        assert tokens_tagged_universal == [('Le', 'DET'), ('français', 'ADJ'),
                                           ('est', 'AUX'), ('une', 'DET'),
                                           ('langue', 'NOUN'),
                                           ('indo-européenne', 'ADJ'),
                                           ('de', 'ADP'), ('la', 'DET'),
                                           ('famille', 'NOUN'), ('des', 'ADP'),
                                           ('langues', 'NOUN'),
                                           ('romanes', 'ADJ'), ('.', 'PUNCT')]
    elif lang == 'deu':
        assert tokens_tagged == [('Die', 'ART'), ('deutsche', 'ADJA'),
                                 ('Sprache', 'NN'), ('bzw.', 'ADJA'),
                                 ('Deutsch', 'NN'), ('(', '$('), ('[', 'NE'),
                                 ('dɔʏ̯t͡ʃ', 'NE'), (']', 'NE'), (';', '$.'),
                                 ('abgekürzt', 'VVFIN'), ('dt', 'NE'),
                                 ('.', '$.'), ('oder', 'KON'),
                                 ('dtsch', 'ADJD'), ('.', '$.'), (')', '$('),
                                 ('ist', 'VAFIN'), ('eine', 'ART'),
                                 ('westgermanische', 'ADJA'),
                                 ('Sprache', 'NN'), ('.', '$.')]
        assert tokens_tagged_universal == [('Die', 'DET'), ('deutsche', 'ADJ'),
                                           ('Sprache', 'NOUN'), ('bzw.',
                                                                 'ADJ'),
                                           ('Deutsch', 'NOUN'), ('(', 'PUNCT'),
                                           ('[', 'PROPN'),
                                           ('dɔʏ̯t͡ʃ', 'PROPN'),
                                           (']', 'PROPN'), (';', 'PUNCT'),
                                           ('abgekürzt', 'VERB'),
                                           ('dt', 'PROPN'), ('.', 'PUNCT'),
                                           ('oder', 'CCONJ'), ('dtsch', 'ADJ'),
                                           ('.', 'PUNCT'), (')', 'PUNCT'),
                                           ('ist', 'AUX'), ('eine', 'DET'),
                                           ('westgermanische', 'ADJ'),
                                           ('Sprache', 'NOUN'), ('.', 'PUNCT')]
    elif lang == 'ell':
        assert tokens_tagged == [
            ('Η',
             'DET__Case=Nom|Definite=Def|Gender=Fem|Number=Sing|PronType=Art'),
            ('ελληνική', 'ADJ__Case=Nom|Gender=Fem|Number=Sing'),
            ('γλώσσα', 'NOUN__Case=Nom|Gender=Fem|Number=Sing'),
            ('ανήκει',
             'VERB__Aspect=Imp|Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin|Voice=Act'
             ), ('στην', 'AsPpSp_AtDf__Case=Acc|Gender=Fem|Number=Sing'),
            ('ινδοευρωπαϊκή', 'ADJ__Case=Acc|Gender=Fem|Number=Sing'),
            ('οικογένεια[9', 'NOUN__Case=Acc|Gender=Fem|Number=Sing'),
            (']',
             'VERB__Aspect=Perf|Mood=Ind|Number=Plur|Person=2|Tense=Past|VerbForm=Fin|Voice=Pass'
             ), ('και', 'CCONJ'), ('συγκεκριμένα', 'ADV'),
            ('στον', 'AsPpSp_AtDf__Case=Acc|Gender=Masc|Number=Sing'),
            ('ελληνικό', 'ADJ__Case=Acc|Gender=Masc|Number=Sing'),
            ('κλάδο', 'NOUN__Case=Acc|Gender=Masc|Number=Sing'),
            (',', 'PUNCT'), ('μαζί', 'ADV'), ('με', 'ADP'),
            ('την',
             'DET__Case=Acc|Definite=Def|Gender=Fem|Number=Sing|PronType=Art'),
            ('τσακωνική', 'NOUN__Case=Acc|Gender=Fem|Number=Sing'),
            (',', 'PUNCT'), ('ενώ', 'SCONJ'),
            ('είναι',
             'AUX__Aspect=Imp|Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin|Voice=Pass'
             ),
            ('η',
             'DET__Case=Nom|Definite=Def|Gender=Fem|Number=Sing|PronType=Art'),
            ('επίσημη', 'ADJ__Case=Nom|Gender=Fem|Number=Sing'),
            ('γλώσσα', 'NOUN__Case=Nom|Gender=Fem|Number=Sing'),
            ('της',
             'DET__Case=Gen|Definite=Def|Gender=Fem|Number=Sing|PronType=Art'),
            ('Ελλάδος', 'PROPN__Case=Gen|Gender=Fem|Number=Sing'),
            ('και', 'CCONJ'),
            ('της',
             'DET__Case=Gen|Definite=Def|Gender=Fem|Number=Sing|PronType=Art'),
            ('Κύπρου', 'PROPN__Case=Gen|Gender=Fem|Number=Sing'),
            ('.', 'PUNCT')
        ]
        assert tokens_tagged_universal == [('Η', 'DET'), ('ελληνική', 'ADJ'),
                                           ('γλώσσα', 'NOUN'),
                                           ('ανήκει', 'VERB'), ('στην', 'ADP'),
                                           ('ινδοευρωπαϊκή', 'ADJ'),
                                           ('οικογένεια[9', 'NOUN'),
                                           (']', 'VERB'), ('και', 'CCONJ'),
                                           ('συγκεκριμένα', 'ADV'),
                                           ('στον', 'ADP'),
                                           ('ελληνικό', 'ADJ'),
                                           ('κλάδο', 'NOUN'), (',', 'PUNCT'),
                                           ('μαζί', 'ADV'), ('με', 'ADP'),
                                           ('την', 'DET'), ('τσακωνική',
                                                            'NOUN'),
                                           (',', 'PUNCT'), ('ενώ', 'SCONJ'),
                                           ('είναι', 'AUX'), ('η', 'DET'),
                                           ('επίσημη', 'ADJ'),
                                           ('γλώσσα', 'NOUN'), ('της', 'DET'),
                                           ('Ελλάδος', 'PROPN'),
                                           ('και', 'CCONJ'), ('της', 'DET'),
                                           ('Κύπρου', 'PROPN'), ('.', 'PUNCT')]
    elif lang == 'ita':
        assert tokens_tagged == [
            ("L'", 'RD__Definite=Def|Number=Sing|PronType=Art'),
            ('italiano', 'S__Gender=Masc|Number=Sing'), ('(', 'FB'),
            ('[', 'FB'), ('itaˈljaːno][Nota', 'S__Gender=Masc|Number=Sing'),
            ('1', 'N__NumType=Card'), (']', 'FB'), ('ascolta[?·info', 'S'),
            (']', 'FB'), (')', 'FB'),
            ('è', 'V__Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin'),
            ('una', 'RI__Definite=Ind|Gender=Fem|Number=Sing|PronType=Art'),
            ('lingua', 'S__Gender=Fem|Number=Sing'),
            ('romanza', 'S__Gender=Fem|Number=Sing'),
            ('parlata', 'A__Gender=Fem|Number=Sing'), ('principalmente', 'B'),
            ('in', 'E'), ('Italia', 'SP'), ('.', 'FS')
        ]
        assert tokens_tagged_universal == [("L'", 'DET'), ('italiano', 'NOUN'),
                                           ('(', 'PUNCT'), ('[', 'PUNCT'),
                                           ('itaˈljaːno][Nota', 'NOUN'),
                                           ('1', 'NUM'), (']', 'PUNCT'),
                                           ('ascolta[?·info', 'NOUN'),
                                           (']', 'PUNCT'), (')', 'PUNCT'),
                                           ('è', 'VERB'), ('una', 'DET'),
                                           ('lingua', 'NOUN'),
                                           ('romanza', 'NOUN'),
                                           ('parlata', 'ADJ'),
                                           ('principalmente', 'ADV'),
                                           ('in', 'ADP'), ('Italia', 'PROPN'),
                                           ('.', 'PUNCT')]
    elif lang == 'jpn':
        assert tokens_tagged == [('日本', '名詞'), ('語', '名詞'), ('(', '補助記号'),
                                 ('にほんご', '名詞'), ('、', '補助記号'), ('にっぽん', '名詞'),
                                 ('ご', '接尾辞'), ('[', '補助記号'), ('注', '名詞'),
                                 ('1', '名詞'), (']', '補助記号'), (')', '補助記号'),
                                 ('は', '助詞'), ('、', '補助記号'), ('主に', '副詞'),
                                 ('日本', '名詞'), ('国', '接尾辞'), ('内', '接尾辞'),
                                 ('や', '助詞'), ('日本', '名詞'), ('人', '接尾辞'),
                                 ('同士', '接尾辞'), ('の', '助詞'), ('間', '名詞'),
                                 ('で', '助詞'), ('使用', '名詞'), ('さ', '動詞'),
                                 ('れ', '助動詞'), ('て', '助詞'), ('いる', '動詞'),
                                 ('言語', '名詞'), ('で', '助動詞'), ('ある', '動詞'),
                                 ('。', '補助記号')]
        assert tokens_tagged_universal == [('日本', 'NOUN'), ('語', 'NOUN'),
                                           ('(', 'PUNCT/SYM'), ('にほんご',
                                                                'NOUN'),
                                           ('、', 'PUNCT/SYM'),
                                           ('にっぽん', 'NOUN'), ('ご', 'PART'),
                                           ('[', 'PUNCT/SYM'), ('注', 'NOUN'),
                                           ('1', 'NOUN'), (']', 'PUNCT/SYM'),
                                           (')', 'PUNCT/SYM'), ('は', 'PART'),
                                           ('、', 'PUNCT/SYM'), ('主に', 'ADV'),
                                           ('日本', 'NOUN'), ('国', 'PART'),
                                           ('内', 'PART'), ('や', 'PART'),
                                           ('日本', 'NOUN'), ('人', 'PART'),
                                           ('同士', 'PART'), ('の', 'PART'),
                                           ('間', 'NOUN'), ('で', 'PART'),
                                           ('使用', 'NOUN'), ('さ', 'VERB'),
                                           ('れ', 'AUX'), ('て', 'PART'),
                                           ('いる', 'VERB'), ('言語', 'NOUN'),
                                           ('で', 'AUX'), ('ある', 'VERB'),
                                           ('。', 'PUNCT/SYM')]
    elif lang == 'lit':
        assert tokens_tagged == [
            ('Lietuvių', 'dkt.vyr.dgs.K.__Case=Gen|Gender=Masc|Number=Plur'),
            ('kalba', 'dkt.mot.vns.Įn.__Case=Ins|Gender=Fem|Number=Sing'),
            ('–', 'skyr.'), ('iš', 'prl.K.__AdpType=Prep|Case=Gen'),
            ('baltų',
             'bdv.nelygin.mot.vns.K.__Case=Gen|Definite=Ind|Degree=Pos|Gender=Fem|Number=Sing'
             ),
            ('prokalbės', 'dkt.mot.vns.K.__Case=Gen|Gender=Fem|Number=Sing'),
            ('kilusi',
             'bdv.aukšč.vyr.dgs.V.__Case=Nom|Definite=Ind|Degree=Sup|Gender=Masc|Number=Plur'
             ),
            ('lietuvių', 'dkt.vyr.dgs.K.__Case=Gen|Gender=Masc|Number=Plur'),
            ('tautos', 'dkt.mot.vns.K.__Case=Gen|Gender=Fem|Number=Sing'),
            ('kalba', 'dkt.mot.vns.Įn.__Case=Ins|Gender=Fem|Number=Sing'),
            (',', 'skyr.'),
            ('kuri',
             'įv.mot.vns.V.__Case=Nom|Definite=Ind|Gender=Fem|Number=Sing|PronType=Int'
             ),
            ('Lietuvoje',
             'dkt.tikr.mot.vns.Vt.__Case=Loc|Gender=Fem|Number=Sing'),
            ('yra',
             'vksm.asm.tiesiog.es.vns.3.__Mood=Ind|Number=Sing|Person=3|Polarity=Pos|Tense=Pres|VerbForm=Fin'
             ),
            ('valstybinė',
             'bdv.nelygin.mot.vns.V.__Case=Nom|Definite=Ind|Degree=Pos|Gender=Fem|Number=Sing'
             ), (',', 'skyr.'), ('o', 'jng.'),
            ('Europos',
             'dkt.tikr.mot.vns.K.__Case=Gen|Gender=Fem|Number=Sing'),
            ('Sąjungoje', 'dkt.mot.vns.Vt.__Case=Loc|Gender=Fem|Number=Sing'),
            ('–', 'skyr.'),
            ('viena',
             'įv.mot.vns.V.__Case=Nom|Definite=Ind|Gender=Fem|Number=Sing|PronType=Ind'
             ), ('iš', 'prl.K.__AdpType=Prep|Case=Gen'),
            ('oficialiųjų',
             'bdv.nelygin.įvardž.vyr.dgs.K.__Case=Gen|Definite=Def|Degree=Pos|Gender=Masc|Number=Plur'
             ), ('kalbų', 'dkt.vyr.dgs.V.__Case=Nom|Gender=Masc|Number=Plur'),
            ('.', 'skyr.')
        ]
        assert tokens_tagged_universal == [
            ('Lietuvių', 'NOUN'), ('kalba', 'NOUN'), ('–', 'PUNCT'),
            ('iš', 'ADP'), ('baltų', 'ADJ'), ('prokalbės', 'NOUN'),
            ('kilusi', 'ADJ'), ('lietuvių', 'NOUN'), ('tautos', 'NOUN'),
            ('kalba', 'NOUN'), (',', 'PUNCT'), ('kuri', 'DET'),
            ('Lietuvoje', 'PROPN'), ('yra', 'AUX'), ('valstybinė', 'ADJ'),
            (',', 'PUNCT'), ('o', 'CCONJ'), ('Europos', 'PROPN'),
            ('Sąjungoje', 'NOUN'), ('–', 'PUNCT'), ('viena', 'PRON'),
            ('iš', 'ADP'), ('oficialiųjų', 'ADJ'), ('kalbų', 'NOUN'),
            ('.', 'PUNCT')
        ]
    elif lang == 'nob':
        assert tokens_tagged == [
            ('Bokmål', 'PROPN'),
            ('er', 'AUX__Mood=Ind|Tense=Pres|VerbForm=Fin'),
            ('en', 'DET__Gender=Masc|Number=Sing|PronType=Art'),
            ('varietet', 'NOUN__Definite=Ind|Gender=Masc|Number=Sing'),
            ('av', 'ADP'),
            ('norsk', 'ADJ__Definite=Ind|Degree=Pos|Gender=Neut|Number=Sing'),
            ('språk', 'NOUN__Definite=Ind|Gender=Neut|Number=Sing'),
            ('.', 'PUNCT')
        ]
        assert tokens_tagged_universal == [('Bokmål', 'PROPN'), ('er', 'AUX'),
                                           ('en', 'DET'), ('varietet', 'NOUN'),
                                           ('av', 'ADP'), ('norsk', 'ADJ'),
                                           ('språk', 'NOUN'), ('.', 'PUNCT')]
    elif lang == 'pol':
        assert tokens_tagged == [('Język', 'SUBST'), ('polski', 'ADJ'),
                                 (',', 'INTERP'), ('polszczyzna', 'SUBST'),
                                 (',', 'INTERP'), ('skrót', 'SUBST'),
                                 (':', 'INTERP'), ('pol', 'BREV'),
                                 ('.', 'INTERP'), ('–', 'INTERP'),
                                 ('język', 'SUBST'), ('naturalny', 'ADJ'),
                                 ('należący', 'PACT'), ('do', 'PREP'),
                                 ('grupy', 'SUBST'), ('języków', 'SUBST'),
                                 ('zachodniosłowiańskich', 'ADJ'),
                                 ('(', 'INTERP'), ('do', 'PREP'),
                                 ('której', 'ADJ'), ('należą', 'FIN'),
                                 ('również', 'QUB'), ('czeski', 'ADJ'),
                                 (',', 'INTERP'), ('słowacki', 'ADJ'),
                                 (',', 'INTERP'), ('kaszubski', 'ADJ'),
                                 (',', 'INTERP'), ('dolnołużycki', 'ADJ'),
                                 (',', 'INTERP'), ('górnołużycki', 'SUBST'),
                                 ('i', 'CONJ'), ('wymarły', 'SUBST'),
                                 ('połabski', 'ADJ'), (')', 'INTERP'),
                                 (',', 'INTERP'), ('stanowiącej', 'PACT'),
                                 ('część', 'SUBST'), ('rodziny', 'SUBST'),
                                 ('języków', 'SUBST'),
                                 ('indoeuropejskich', 'ADJ'), ('.', 'INTERP')]
        assert tokens_tagged_universal == [
            ('Język', 'NOUN'), ('polski', 'ADJ'), (',', 'PUNCT'),
            ('polszczyzna', 'NOUN'), (',', 'PUNCT'), ('skrót', 'NOUN'),
            (':', 'PUNCT'), ('pol', 'X'), ('.', 'PUNCT'), ('–', 'PUNCT'),
            ('język', 'NOUN'), ('naturalny', 'ADJ'), ('należący', 'VERB'),
            ('do', 'ADP'), ('grupy', 'NOUN'), ('języków', 'NOUN'),
            ('zachodniosłowiańskich', 'ADJ'), ('(', 'PUNCT'), ('do', 'ADP'),
            ('której', 'ADJ'), ('należą', 'VERB'), ('również', 'PART'),
            ('czeski', 'ADJ'), (',', 'PUNCT'), ('słowacki', 'ADJ'),
            (',', 'PUNCT'), ('kaszubski', 'ADJ'), (',', 'PUNCT'),
            ('dolnołużycki', 'ADJ'), (',', 'PUNCT'), ('górnołużycki', 'NOUN'),
            ('i', 'CCONJ'), ('wymarły', 'NOUN'), ('połabski', 'ADJ'),
            (')', 'PUNCT'), (',', 'PUNCT'), ('stanowiącej', 'VERB'),
            ('część', 'NOUN'), ('rodziny', 'NOUN'), ('języków', 'NOUN'),
            ('indoeuropejskich', 'ADJ'), ('.', 'PUNCT')
        ]
    elif lang == 'por':
        assert tokens_tagged == [
            ('A', 'DET__Definite=Def|Gender=Fem|Number=Sing|PronType=Art'),
            ('língua', 'NOUN__Gender=Fem|Number=Sing'),
            ('portuguesa', 'ADJ__Gender=Fem|Number=Sing'), (',', 'PUNCT'),
            ('também', 'ADV'),
            ('designada', 'VERB__Gender=Fem|Number=Sing|VerbForm=Part'),
            ('português', 'NOUN__Gender=Masc|Number=Sing'), (',', 'PUNCT'),
            ('é',
             'AUX__Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin'),
            ('uma', 'DET__Definite=Ind|Gender=Fem|Number=Sing|PronType=Art'),
            ('língua', 'NOUN__Gender=Fem|Number=Sing'),
            ('românica', 'ADJ__Gender=Fem|Number=Sing'),
            ('flexiva', 'ADJ__Gender=Fem|Number=Sing'),
            ('ocidental', 'ADJ__Gender=Fem|Number=Sing'),
            ('originada', 'VERB__Gender=Fem|Number=Sing|VerbForm=Part'),
            ('no',
             'ADP_DET__Definite=Def|Gender=Masc|Number=Sing|PronType=Art'),
            ('galego-português', 'NOUN__Gender=Masc|Number=Sing'),
            ('falado', 'VERB__Gender=Masc|Number=Sing|VerbForm=Part'),
            ('no',
             'ADP_DET__Definite=Def|Gender=Masc|Number=Sing|PronType=Art'),
            ('Reino', 'PROPN__Gender=Masc|Number=Sing'),
            ('da',
             'ADP_DET__Definite=Def|Gender=Fem|Number=Sing|PronType=Art'),
            ('Galiza', 'PROPN__Number=Sing'), ('e', 'CCONJ'),
            ('no',
             'ADP_DET__Definite=Def|Gender=Masc|Number=Sing|PronType=Art'),
            ('norte', 'NOUN__Gender=Masc|Number=Sing'), ('de', 'ADP'),
            ('Portugal', 'PROPN__Gender=Masc|Number=Sing'), ('.', 'PUNCT')
        ]
        assert tokens_tagged_universal == [
            ('A', 'DET'), ('língua', 'NOUN'), ('portuguesa', 'ADJ'),
            (',', 'PUNCT'), ('também', 'ADV'), ('designada', 'VERB'),
            ('português', 'NOUN'), (',', 'PUNCT'), ('é', 'AUX'),
            ('uma', 'DET'), ('língua', 'NOUN'), ('românica', 'ADJ'),
            ('flexiva', 'ADJ'), ('ocidental', 'ADJ'), ('originada', 'VERB'),
            ('no', 'DET'), ('galego-português', 'NOUN'), ('falado', 'VERB'),
            ('no', 'DET'), ('Reino', 'PROPN'), ('da', 'DET'),
            ('Galiza', 'PROPN'), ('e', 'CCONJ'), ('no', 'DET'),
            ('norte', 'NOUN'), ('de', 'ADP'), ('Portugal', 'PROPN'),
            ('.', 'PUNCT')
        ]
    elif lang == 'ron':
        assert tokens_tagged == [('Limba', 'Ncfsry'), ('română', 'Afpfsrn'),
                                 ('este', 'Vmip3s'), ('o', 'Tifsr'),
                                 ('limbă', 'Ncfsrn'),
                                 ('indo-europeană', 'Afpfsrn'), (',', 'COMMA'),
                                 ('din', 'Spsa'), ('grupul', 'Ncmsry'),
                                 ('italic', 'Afpms-n'), ('și', 'Crssp'),
                                 ('din', 'Spsa'), ('subgrupul', 'Ncmsry'),
                                 ('oriental', 'Afpms-n'), ('al', 'Tsms'),
                                 ('limbilor', 'Ncfpoy'),
                                 ('romanice', 'Afpfp-n'), ('.', 'PERIOD')]
        assert tokens_tagged_universal == [('Limba', 'NOUN'),
                                           ('română', 'ADJ'), ('este', 'AUX'),
                                           ('o', 'DET'), ('limbă', 'NOUN'),
                                           ('indo-europeană', 'ADJ'),
                                           (',', 'PUNCT'), ('din', 'ADP'),
                                           ('grupul', 'NOUN'), ('italic',
                                                                'ADJ'),
                                           ('și', 'CCONJ'), ('din', 'ADP'),
                                           ('subgrupul', 'NOUN'),
                                           ('oriental', 'ADJ'), ('al', 'DET'),
                                           ('limbilor', 'NOUN'),
                                           ('romanice', 'ADJ'), ('.', 'PUNCT')]
    elif lang == 'rus':
        if pos_tagger == 'NLTK - Perceptron POS Tagger':
            assert tokens_tagged == [('Ру́сский', 'A=m'), ('язы́к', 'S'),
                                     ('(', 'NONLEX'), ('[', 'NONLEX'),
                                     ('ˈruskʲɪi̯', 'NONLEX'),
                                     ('jɪˈzɨk', 'NONLEX'), (']', 'NONLEX'),
                                     ('Информация', 'S'), ('о', 'PR'),
                                     ('файле', 'S'), ('слушать', 'V'),
                                     (')', 'NONLEX'), ('[', 'NONLEX'),
                                     ('~', 'NONLEX'), ('3', 'NUM=ciph'),
                                     (']', 'NONLEX'), ('[', 'NONLEX'),
                                     ('⇨', 'NONLEX'), (']', 'NONLEX'),
                                     ('—', 'NONLEX'), ('один', 'A-PRO=m'),
                                     ('из', 'PR'),
                                     ('восточнославянских', 'A=pl'),
                                     ('языков', 'S'), (',', 'NONLEX'),
                                     ('национальный', 'A=m'), ('язык', 'S'),
                                     ('русского', 'A=m'), ('народа', 'S'),
                                     ('.', 'NONLEX')]
            assert tokens_tagged_universal == [('Ру́сский', 'ADJ'),
                                               ('язы́к', 'NOUN'),
                                               ('(', 'PUNCT'), ('[', 'PUNCT'),
                                               ('ˈruskʲɪi̯', 'PUNCT'),
                                               ('jɪˈzɨk', 'PUNCT'),
                                               (']', 'PUNCT'),
                                               ('Информация', 'NOUN'),
                                               ('о', 'ADP'), ('файле', 'NOUN'),
                                               ('слушать', 'VERB'),
                                               (')', 'PUNCT'), ('[', 'PUNCT'),
                                               ('~', 'PUNCT'), ('3', 'NUM'),
                                               (']', 'PUNCT'), ('[', 'PUNCT'),
                                               ('⇨', 'PUNCT'), (']', 'PUNCT'),
                                               ('—', 'PUNCT'),
                                               ('один', 'PRON'), ('из', 'ADP'),
                                               ('восточнославянских', 'ADJ'),
                                               ('языков', 'NOUN'),
                                               (',', 'PUNCT'),
                                               ('национальный', 'ADJ'),
                                               ('язык', 'NOUN'),
                                               ('русского', 'ADJ'),
                                               ('народа', 'NOUN'),
                                               ('.', 'PUNCT')]
        elif pos_tagger == 'pymorphy2 - Morphological Analyzer':
            assert tokens_tagged == [
                ('Ру́сский', 'NOUN'), ('язы́к', 'NOUN'), ('(', 'PNCT'),
                ('[', 'PNCT'), ('ˈruskʲɪi̯', 'UNKN'), ('jɪˈzɨk', 'UNKN'),
                (']', 'PNCT'), ('Информация', 'NOUN'), ('о', 'PREP'),
                ('файле', 'NOUN'), ('слушать', 'INFN'), (')', 'PNCT'),
                ('[', 'PNCT'), ('~', 'UNKN'), ('3', 'NUMB'), (']', 'PNCT'),
                ('[', 'PNCT'), ('⇨', 'UNKN'), (']', 'PNCT'), ('—', 'PNCT'),
                ('один', 'ADJF'), ('из', 'PREP'),
                ('восточнославянских', 'ADJF'), ('языков', 'NOUN'),
                (',', 'PNCT'), ('национальный', 'ADJF'), ('язык', 'NOUN'),
                ('русского', 'ADJF'), ('народа', 'NOUN'), ('.', 'PNCT')
            ]
            assert tokens_tagged_universal == [('Ру́сский', 'NOUN'),
                                               ('язы́к', 'NOUN'),
                                               ('(', 'PUNCT'), ('[', 'PUNCT'),
                                               ('ˈruskʲɪi̯', 'SYM/X'),
                                               ('jɪˈzɨk', 'SYM/X'),
                                               (']', 'PUNCT'),
                                               ('Информация', 'NOUN'),
                                               ('о', 'ADP'), ('файле', 'NOUN'),
                                               ('слушать', 'VERB'),
                                               (')', 'PUNCT'), ('[', 'PUNCT'),
                                               ('~', 'SYM/X'), ('3', 'NUM'),
                                               (']', 'PUNCT'), ('[', 'PUNCT'),
                                               ('⇨', 'SYM/X'), (']', 'PUNCT'),
                                               ('—', 'PUNCT'), ('один', 'ADJ'),
                                               ('из', 'ADP'),
                                               ('восточнославянских', 'ADJ'),
                                               ('языков', 'NOUN'),
                                               (',', 'PUNCT'),
                                               ('национальный', 'ADJ'),
                                               ('язык', 'NOUN'),
                                               ('русского', 'ADJ'),
                                               ('народа', 'NOUN'),
                                               ('.', 'PUNCT')]
    elif lang == 'spa':
        assert tokens_tagged == [
            ('El', 'DET__Definite=Def|Gender=Masc|Number=Sing|PronType=Art'),
            ('español', 'NOUN__Gender=Masc|Number=Sing'), ('o', 'CCONJ'),
            ('castellano', 'NOUN__Gender=Masc|Number=Sing'),
            ('es',
             'AUX__Mood=Ind|Number=Sing|Person=3|Tense=Pres|VerbForm=Fin'),
            ('una', 'DET__Definite=Ind|Gender=Fem|Number=Sing|PronType=Art'),
            ('lengua', 'NOUN__Gender=Fem|Number=Sing'),
            ('romance', 'NOUN__Gender=Masc|Number=Sing'),
            ('procedente', 'ADJ__Number=Sing'),
            ('del', 'ADP__AdpType=Preppron'),
            ('latín', 'NOUN__Gender=Masc|Number=Sing'),
            ('hablado', 'ADJ__Gender=Masc|Number=Sing|VerbForm=Part'),
            ('.', 'PUNCT__PunctType=Peri')
        ]
        assert tokens_tagged_universal == [('El', 'DET'), ('español', 'NOUN'),
                                           ('o', 'CCONJ'),
                                           ('castellano', 'NOUN'),
                                           ('es', 'AUX'), ('una', 'DET'),
                                           ('lengua', 'NOUN'),
                                           ('romance', 'NOUN'),
                                           ('procedente', 'ADJ'),
                                           ('del', 'ADP'), ('latín', 'NOUN'),
                                           ('hablado', 'ADJ'), ('.', 'PUNCT')]
    elif lang == 'tha':
        if pos_tagger == 'PyThaiNLP - Perceptron Tagger (ORCHID)':
            assert tokens_tagged == [('ภาษา', 'NCMN'), ('ไทย', 'NPRP'),
                                     ('หรือ', 'JCRG'), ('ภาษา', 'NCMN'),
                                     ('ไทย', 'NPRP'), ('กลาง', 'VATT'),
                                     ('เป็น', 'VSTA'), ('ภาษา', 'NCMN'),
                                     ('ราชการ', 'NCMN'), ('และ', 'JCRG'),
                                     ('ภาษา', 'NCMN'), ('ประจำ', 'RPRE'),
                                     ('ชาติ', 'NCMN'), ('ของ', 'RPRE'),
                                     ('ประเทศไทย', 'NPRP')]
            assert tokens_tagged_universal == [('ภาษา', 'NOUN'),
                                               ('ไทย', 'PROPN'),
                                               ('หรือ', 'CCONJ'),
                                               ('ภาษา', 'NOUN'),
                                               ('ไทย', 'PROPN'),
                                               ('กลาง', 'VERB'),
                                               ('เป็น', 'VERB'),
                                               ('ภาษา', 'NOUN'),
                                               ('ราชการ', 'NOUN'),
                                               ('และ', 'CCONJ'),
                                               ('ภาษา', 'NOUN'),
                                               ('ประจำ', 'ADP'),
                                               ('ชาติ', 'NOUN'),
                                               ('ของ', 'ADP'),
                                               ('ประเทศไทย', 'PROPN')]
        elif pos_tagger == 'PyThaiNLP - Perceptron Tagger (PUD)':
            assert tokens_tagged == [('ภาษา', 'NOUN'), ('ไทย', 'PROPN'),
                                     ('หรือ', 'CCONJ'), ('ภาษา', 'NOUN'),
                                     ('ไทย', 'PROPN'), ('กลาง', 'NOUN'),
                                     ('เป็น', 'AUX'), ('ภาษา', 'NOUN'),
                                     ('ราชการ', 'NOUN'), ('และ', 'CCONJ'),
                                     ('ภาษา', 'NOUN'), ('ประจำ', 'VERB'),
                                     ('ชาติ', 'NOUN'), ('ของ', 'ADP'),
                                     ('ประเทศไทย', 'PROPN')]
            assert tokens_tagged_universal == [
                ('ภาษา', 'NOUN'), ('ไทย', 'PROPN'), ('หรือ', 'CCONJ'),
                ('ภาษา', 'NOUN'), ('ไทย', 'PROPN'), ('กลาง', 'NOUN'),
                ('เป็น', 'AUX'), ('ภาษา', 'NOUN'), ('ราชการ', 'NOUN'),
                ('และ', 'CCONJ'), ('ภาษา', 'NOUN'), ('ประจำ', 'VERB'),
                ('ชาติ', 'NOUN'), ('ของ', 'ADP'), ('ประเทศไทย', 'PROPN')
            ]
    elif lang == 'bod':
        assert tokens_tagged == [('བོད་', 'PROPN'), ('ཀྱི་', 'NO_POS'),
                                 ('སྐད་ཡིག་', 'NOUN'), ('ནི་', 'NO_POS'),
                                 ('བོད་ཡུལ་', 'PROPN'), ('དང་', 'NO_POS'),
                                 ('དེ', 'DET'), ('འི་', 'PART'),
                                 ('ཉེ་འཁོར་', 'NOUN'), ('གྱི་', 'NO_POS'),
                                 ('ས་ཁུལ་', 'OTHER'), ('ཏེ', 'NO_POS'),
                                 ('།', 'PUNCT')]
        assert tokens_tagged_universal == [('བོད་', 'PROPN'), ('ཀྱི་', 'X'),
                                           ('སྐད་ཡིག་', 'NOUN'), ('ནི་', 'X'),
                                           ('བོད་ཡུལ་', 'PROPN'), ('དང་', 'X'),
                                           ('དེ', 'DET'), ('འི་', 'PART'),
                                           ('ཉེ་འཁོར་', 'NOUN'), ('གྱི་', 'X'),
                                           ('ས་ཁུལ་', 'X'), ('ཏེ', 'X'),
                                           ('།', 'PUNCT')]
    elif lang == 'ukr':
        assert tokens_tagged == [('Украї́нська', 'ADJF'), ('мо́ва', 'ADJF'),
                                 ('(', 'PNCT'), ('МФА', 'UNKN'), (':', 'PNCT'),
                                 ('[', 'PNCT'), ('ukrɑ̽ˈjɪnʲsʲkɑ̽', 'UNKN'),
                                 ('ˈmɔwɑ̽', 'UNKN'), (']', 'PNCT'),
                                 (',', 'PNCT'), ('історичні', 'ADJF'),
                                 ('назви', 'NOUN'), ('—', 'PNCT'),
                                 ('ру́ська', 'ADJF'), (',', 'PNCT'),
                                 ('руси́нська[9][10][11', 'UNKN'),
                                 (']', 'PNCT'), ('[', 'PNCT'), ('*', 'PNCT'),
                                 ('2', 'NUMB'), (']', 'PNCT'), (')', 'PNCT'),
                                 ('—', 'PNCT'), ('національна', 'ADJF'),
                                 ('мова', 'NOUN'), ('українців', 'NOUN'),
                                 ('.', 'PNCT')]
        assert tokens_tagged_universal == [('Украї́нська', 'ADJ'),
                                           ('мо́ва', 'ADJ'), ('(', 'PUNCT'),
                                           ('МФА', 'SYM/X'), (':', 'PUNCT'),
                                           ('[', 'PUNCT'),
                                           ('ukrɑ̽ˈjɪnʲsʲkɑ̽', 'SYM/X'),
                                           ('ˈmɔwɑ̽', 'SYM/X'), (']', 'PUNCT'),
                                           (',', 'PUNCT'),
                                           ('історичні', 'ADJ'),
                                           ('назви', 'NOUN'), ('—', 'PUNCT'),
                                           ('ру́ська', 'ADJ'), (',', 'PUNCT'),
                                           ('руси́нська[9][10][11', 'SYM/X'),
                                           (']', 'PUNCT'), ('[', 'PUNCT'),
                                           ('*', 'PUNCT'), ('2', 'NUM'),
                                           (']', 'PUNCT'), (')', 'PUNCT'),
                                           ('—', 'PUNCT'),
                                           ('національна', 'ADJ'),
                                           ('мова', 'NOUN'),
                                           ('українців', 'NOUN'),
                                           ('.', 'PUNCT')]
    elif lang == 'vie':
        assert tokens_tagged == [('Tiếng', 'N'), ('Việt', 'Np'), (',', 'CH'),
                                 ('còn', 'C'), ('gọi', 'V'), ('tiếng', 'N'),
                                 ('Việt Nam', 'Np'), ('[', 'V'), ('5', 'M'),
                                 (']', 'CH'), (',', 'CH'), ('tiếng Kinh', 'N'),
                                 ('hay', 'C'), ('Việt ngữ', 'V'), (',', 'CH'),
                                 ('là', 'V'), ('ngôn ngữ', 'N'), ('của', 'E'),
                                 ('người', 'Nc'), ('Việt', 'Np'), ('(', 'CH'),
                                 ('dân tộc', 'N'), ('Kinh', 'Np'), (')', 'CH'),
                                 ('và', 'C'), ('là', 'V'), ('ngôn ngữ', 'N'),
                                 ('chính thức', 'A'), ('tại', 'E'),
                                 ('Việt Nam', 'Np'), ('.', 'CH')]
        assert tokens_tagged_universal == [
            ('Tiếng', 'NOUN'), ('Việt', 'PROPN'), (',', 'PUNCT'),
            ('còn', 'CCONJ'), ('gọi', 'VERB'), ('tiếng', 'NOUN'),
            ('Việt Nam', 'PROPN'), ('[', 'VERB'), ('5', 'NUM'), (']', 'PUNCT'),
            (',', 'PUNCT'), ('tiếng Kinh', 'NOUN'), ('hay', 'CCONJ'),
            ('Việt ngữ', 'VERB'), (',', 'PUNCT'), ('là', 'VERB'),
            ('ngôn ngữ', 'NOUN'), ('của', 'ADP'), ('người', 'NOUN'),
            ('Việt', 'PROPN'), ('(', 'PUNCT'), ('dân tộc', 'NOUN'),
            ('Kinh', 'PROPN'), (')', 'PUNCT'), ('và', 'CCONJ'), ('là', 'VERB'),
            ('ngôn ngữ', 'NOUN'), ('chính thức', 'ADJ'), ('tại', 'ADP'),
            ('Việt Nam', 'PROPN'), ('.', 'PUNCT')
        ]
    def __init__(self, main):
        super().__init__(main)

        settings_global = self.main.settings_global['lemmatizers']

        # Lemmatizer Settings
        group_box_lemmatizer_settings = QGroupBox(
            self.tr('Lemmatizer Settings'), self)

        table_lemmatizers = wl_table.Wl_Table(
            self,
            headers=[self.tr('Language'),
                     self.tr('Lemmatizers')],
            cols_stretch=[self.tr('Lemmatizers')])

        table_lemmatizers.verticalHeader().setHidden(True)
        table_lemmatizers.setRowCount(len(settings_global))

        for i, lang in enumerate(settings_global):
            table_lemmatizers.setItem(
                i, 0,
                QTableWidgetItem(wl_conversion.to_lang_text(self.main, lang)))

            self.__dict__[
                f'combo_box_lemmatizer_{lang}'] = wl_box.Wl_Combo_Box(self)
            self.__dict__[f'combo_box_lemmatizer_{lang}'].addItems(
                settings_global[lang])

            table_lemmatizers.setCellWidget(
                i, 1, self.__dict__[f'combo_box_lemmatizer_{lang}'])

        group_box_lemmatizer_settings.setLayout(wl_layout.Wl_Layout())
        group_box_lemmatizer_settings.layout().addWidget(
            table_lemmatizers, 0, 0)

        # Preview
        group_box_preview = QGroupBox(self.tr('Preview'), self)

        self.label_lemmatization_preview_lang = QLabel(
            self.tr('Select language:'), self)
        self.combo_box_lemmatization_preview_lang = wl_box.Wl_Combo_Box(self)
        self.button_lemmatization_start_processing = QPushButton(
            self.tr('Start processing'), self)
        self.text_edit_lemmatization_preview_samples = QTextEdit(self)
        self.text_edit_lemmatization_preview_results = QTextEdit(self)

        self.combo_box_lemmatization_preview_lang.addItems(
            wl_conversion.to_lang_text(self.main,
                                       list(settings_global.keys())))

        self.button_lemmatization_start_processing.setFixedWidth(150)
        self.text_edit_lemmatization_preview_samples.setAcceptRichText(False)
        self.text_edit_lemmatization_preview_results.setReadOnly(True)

        self.combo_box_lemmatization_preview_lang.currentTextChanged.connect(
            self.preview_changed)
        self.button_lemmatization_start_processing.clicked.connect(
            self.preview_results_changed)
        self.text_edit_lemmatization_preview_samples.textChanged.connect(
            self.preview_changed)
        self.text_edit_lemmatization_preview_results.textChanged.connect(
            self.preview_changed)

        layout_preview_settings = wl_layout.Wl_Layout()
        layout_preview_settings.addWidget(
            self.label_lemmatization_preview_lang, 0, 0)
        layout_preview_settings.addWidget(
            self.combo_box_lemmatization_preview_lang, 0, 1)
        layout_preview_settings.addWidget(
            self.button_lemmatization_start_processing, 0, 3)

        layout_preview_settings.setColumnStretch(2, 1)

        group_box_preview.setLayout(wl_layout.Wl_Layout())
        group_box_preview.layout().addLayout(layout_preview_settings, 0, 0, 1,
                                             2)
        group_box_preview.layout().addWidget(
            self.text_edit_lemmatization_preview_samples, 1, 0)
        group_box_preview.layout().addWidget(
            self.text_edit_lemmatization_preview_results, 1, 1)

        self.setLayout(wl_layout.Wl_Layout())
        self.layout().addWidget(group_box_lemmatizer_settings, 0, 0)
        self.layout().addWidget(group_box_preview, 1, 0)

        self.layout().setContentsMargins(6, 4, 6, 4)
        self.layout().setRowStretch(0, 3)
        self.layout().setRowStretch(1, 2)
    def __init__(self, main):
        super().__init__(main)

        self.settings_global = self.main.settings_global['pos_taggers']
        self.settings_default = self.main.settings_default['pos_tagging']
        self.settings_custom = self.main.settings_custom['pos_tagging']

        # POS Tagger Settings
        group_box_pos_tagger_settings = QGroupBox(
            self.tr('POS Tagger Settings'), self)

        self.table_pos_taggers = wl_tables.Wl_Table(
            self,
            headers=[self.tr('Language'),
                     self.tr('POS Taggers')],
            editable=True)

        self.checkbox_to_universal_pos_tags = QCheckBox(
            self.tr('Convert all POS tags to universal POS tags'))

        self.table_pos_taggers.verticalHeader().setHidden(True)
        self.table_pos_taggers.model().setRowCount(len(self.settings_global))

        self.table_pos_taggers.disable_updates()

        for i, lang in enumerate(self.settings_global):
            self.table_pos_taggers.model().setItem(
                i, 0,
                QStandardItem(wl_conversion.to_lang_text(self.main, lang)))
            self.table_pos_taggers.model().setItem(i, 1, QStandardItem())

            self.table_pos_taggers.setItemDelegateForRow(
                i,
                wl_item_delegates.Wl_Item_Delegate_Combo_Box(
                    parent=self.table_pos_taggers,
                    items=list(
                        wl_nlp_utils.to_lang_util_texts(
                            self.main,
                            util_type='pos_taggers',
                            util_codes=self.settings_global[lang])),
                    col=1))

        self.table_pos_taggers.enable_updates()

        group_box_pos_tagger_settings.setLayout(wl_layouts.Wl_Layout())
        group_box_pos_tagger_settings.layout().addWidget(
            self.table_pos_taggers, 0, 0)
        group_box_pos_tagger_settings.layout().addWidget(
            self.checkbox_to_universal_pos_tags, 1, 0)

        # Preview
        group_box_preview = QGroupBox(self.tr('Preview'), self)

        self.label_pos_tagging_preview_lang = QLabel(
            self.tr('Select language:'), self)
        self.combo_box_pos_tagging_preview_lang = wl_boxes.Wl_Combo_Box(self)
        self.button_pos_tagging_show_preview = QPushButton(
            self.tr('Show preview'), self)
        self.text_edit_pos_tagging_preview_samples = QTextEdit(self)
        self.text_edit_pos_tagging_preview_results = QTextEdit(self)

        self.combo_box_pos_tagging_preview_lang.addItems(
            wl_conversion.to_lang_texts(self.main, self.settings_global))

        self.button_pos_tagging_show_preview.setFixedWidth(150)
        self.text_edit_pos_tagging_preview_samples.setAcceptRichText(False)
        self.text_edit_pos_tagging_preview_results.setReadOnly(True)

        self.combo_box_pos_tagging_preview_lang.currentTextChanged.connect(
            self.preview_changed)
        self.button_pos_tagging_show_preview.clicked.connect(
            self.preview_results_changed)
        self.text_edit_pos_tagging_preview_samples.textChanged.connect(
            self.preview_changed)
        self.text_edit_pos_tagging_preview_results.textChanged.connect(
            self.preview_changed)

        layout_preview_settings = wl_layouts.Wl_Layout()
        layout_preview_settings.addWidget(self.label_pos_tagging_preview_lang,
                                          0, 0)
        layout_preview_settings.addWidget(
            self.combo_box_pos_tagging_preview_lang, 0, 1)
        layout_preview_settings.addWidget(self.button_pos_tagging_show_preview,
                                          0, 3)

        layout_preview_settings.setColumnStretch(2, 1)

        group_box_preview.setLayout(wl_layouts.Wl_Layout())
        group_box_preview.layout().addLayout(layout_preview_settings, 0, 0, 1,
                                             2)
        group_box_preview.layout().addWidget(
            self.text_edit_pos_tagging_preview_samples, 1, 0)
        group_box_preview.layout().addWidget(
            self.text_edit_pos_tagging_preview_results, 1, 1)

        self.setLayout(wl_layouts.Wl_Layout())
        self.layout().addWidget(group_box_pos_tagger_settings, 0, 0)
        self.layout().addWidget(group_box_preview, 1, 0)

        self.layout().setContentsMargins(6, 4, 6, 4)
        self.layout().setRowStretch(0, 3)
        self.layout().setRowStretch(1, 2)
Example #23
0
    def __init__(self, main):
        super().__init__(main)

        self.settings_global = self.main.settings_global['stop_word_lists']
        self.settings_default = self.main.settings_default['stop_word_lists']
        self.settings_custom = self.main.settings_custom['stop_word_lists']

        # Stop Word Lists Settings
        group_box_stop_word_lists_settings = QGroupBox(
            self.tr('Stop Word Lists Settings'), self)

        self.table_stop_word_lists = wl_tables.Wl_Table(
            self,
            headers=[self.tr('Language'),
                     self.tr('Stop Word List')],
            editable=True)

        self.table_stop_word_lists.verticalHeader().setHidden(True)
        self.table_stop_word_lists.model().setRowCount(
            len(self.settings_global))

        self.table_stop_word_lists.disable_updates()

        for i, lang in enumerate(self.settings_global):
            self.table_stop_word_lists.model().setItem(
                i, 0,
                QStandardItem(wl_conversion.to_lang_text(self.main, lang)))
            self.table_stop_word_lists.model().setItem(i, 1, QStandardItem())
            self.table_stop_word_lists.setItemDelegateForRow(
                i,
                wl_item_delegates.Wl_Item_Delegate_Combo_Box(
                    parent=self.table_stop_word_lists,
                    items=list(
                        wl_nlp_utils.to_lang_util_texts(
                            self.main,
                            util_type='stop_word_lists',
                            util_codes=self.settings_global[lang])),
                    col=1))

        self.table_stop_word_lists.enable_updates()

        self.table_stop_word_lists.model().dataChanged.connect(
            self.stop_word_list_changed)

        group_box_stop_word_lists_settings.setLayout(wl_layouts.Wl_Layout())
        group_box_stop_word_lists_settings.layout().addWidget(
            self.table_stop_word_lists, 0, 0)

        # Preview
        group_box_preview = QGroupBox(self.tr('Preview'), self)

        self.label_stop_word_list_preview_lang = QLabel(
            self.tr('Select language:'), self)
        self.combo_box_stop_word_list_preview_lang = wl_boxes.Wl_Combo_Box(
            self)
        self.combo_box_stop_word_list_preview_lang.addItems(
            wl_conversion.to_lang_texts(self.main, self.settings_global))
        self.label_stop_word_list_preview_count = QLabel('', self)

        self.list_stop_word_list_preview_results = wl_lists.Wl_List_Stop_Words(
            self)

        self.combo_box_stop_word_list_preview_lang.currentTextChanged.connect(
            self.preview_settings_changed)
        self.combo_box_stop_word_list_preview_lang.currentTextChanged.connect(
            self.preview_results_changed)

        layout_preview_settings = wl_layouts.Wl_Layout()
        layout_preview_settings.addWidget(
            self.label_stop_word_list_preview_lang, 0, 0)
        layout_preview_settings.addWidget(
            self.combo_box_stop_word_list_preview_lang, 0, 1)
        layout_preview_settings.addWidget(
            self.label_stop_word_list_preview_count, 0, 3)

        layout_preview_settings.setColumnStretch(2, 1)

        group_box_preview.setLayout(wl_layouts.Wl_Layout())
        group_box_preview.layout().addLayout(layout_preview_settings, 0, 0, 1,
                                             6)
        group_box_preview.layout().addWidget(
            self.list_stop_word_list_preview_results, 1, 0, 1, 6)
        group_box_preview.layout().addWidget(
            self.list_stop_word_list_preview_results.button_add, 2, 0)
        group_box_preview.layout().addWidget(
            self.list_stop_word_list_preview_results.button_ins, 2, 1)
        group_box_preview.layout().addWidget(
            self.list_stop_word_list_preview_results.button_del, 2, 2)
        group_box_preview.layout().addWidget(
            self.list_stop_word_list_preview_results.button_clr, 2, 3)
        group_box_preview.layout().addWidget(
            self.list_stop_word_list_preview_results.button_imp, 2, 4)
        group_box_preview.layout().addWidget(
            self.list_stop_word_list_preview_results.button_exp, 2, 5)

        self.setLayout(wl_layouts.Wl_Layout())
        self.layout().addWidget(group_box_stop_word_lists_settings, 0, 0)
        self.layout().addWidget(group_box_preview, 1, 0)

        self.layout().setContentsMargins(6, 4, 6, 4)
        self.layout().setRowStretch(0, 3)
        self.layout().setRowStretch(1, 2)

        self.load_settings()
        self.preview_results_changed()
Example #24
0
    def __init__(self, main):
        super().__init__(main)

        settings_global = self.main.settings_global['pos_taggers']

        # POS Tagger Settings
        group_box_pos_tagger_settings = QGroupBox(
            self.tr('POS Tagger Settings'), self)

        self.table_pos_taggers = wl_table.Wl_Table(
            self,
            headers=[self.tr('Language'),
                     self.tr('POS Taggers')],
            cols_stretch=[self.tr('POS Taggers')])

        self.checkbox_to_universal_pos_tags = QCheckBox(
            self.tr('Convert all POS tags to universal POS tags'))

        self.table_pos_taggers.verticalHeader().setHidden(True)
        self.table_pos_taggers.setRowCount(len(settings_global))

        for i, lang in enumerate(settings_global):
            self.table_pos_taggers.setItem(
                i, 0,
                QTableWidgetItem(wl_conversion.to_lang_text(self.main, lang)))

            self.__dict__[
                f'combo_box_pos_tagger_{lang}'] = wl_box.Wl_Combo_Box(self)

            self.__dict__[f'combo_box_pos_tagger_{lang}'].addItems(
                settings_global[lang])

            self.__dict__[
                f'combo_box_pos_tagger_{lang}'].currentTextChanged.connect(
                    lambda text, lang=lang: self.pos_taggers_changed(lang))

            self.table_pos_taggers.setCellWidget(
                i, 1, self.__dict__[f'combo_box_pos_tagger_{lang}'])

        self.checkbox_to_universal_pos_tags.stateChanged.connect(
            self.preview_results_changed)

        group_box_pos_tagger_settings.setLayout(wl_layout.Wl_Layout())
        group_box_pos_tagger_settings.layout().addWidget(
            self.table_pos_taggers, 0, 0)
        group_box_pos_tagger_settings.layout().addWidget(
            self.checkbox_to_universal_pos_tags, 1, 0)

        # Preview
        group_box_preview = QGroupBox(self.tr('Preview'), self)

        self.label_pos_tagging_preview_lang = QLabel(
            self.tr('Select language:'), self)
        self.combo_box_pos_tagging_preview_lang = wl_box.Wl_Combo_Box(self)
        self.label_pos_tagging_preview_processing = QLabel('', self)
        self.text_edit_pos_tagging_preview_samples = QTextEdit(self)
        self.text_edit_pos_tagging_preview_results = QTextEdit(self)

        self.combo_box_pos_tagging_preview_lang.addItems(
            wl_conversion.to_lang_text(self.main, list(settings_global)))

        self.text_edit_pos_tagging_preview_samples.setAcceptRichText(False)
        self.text_edit_pos_tagging_preview_results.setReadOnly(True)

        self.combo_box_pos_tagging_preview_lang.currentTextChanged.connect(
            self.preview_changed)
        self.combo_box_pos_tagging_preview_lang.currentTextChanged.connect(
            self.preview_results_changed)
        self.text_edit_pos_tagging_preview_samples.textChanged.connect(
            self.preview_changed)
        self.text_edit_pos_tagging_preview_samples.textChanged.connect(
            self.preview_results_changed)
        self.text_edit_pos_tagging_preview_results.textChanged.connect(
            self.preview_changed)

        layout_preview_settings = wl_layout.Wl_Layout()
        layout_preview_settings.addWidget(self.label_pos_tagging_preview_lang,
                                          0, 0)
        layout_preview_settings.addWidget(
            self.combo_box_pos_tagging_preview_lang, 0, 1)
        layout_preview_settings.addWidget(
            self.label_pos_tagging_preview_processing, 0, 3)

        layout_preview_settings.setColumnStretch(2, 1)

        group_box_preview.setLayout(wl_layout.Wl_Layout())
        group_box_preview.layout().addLayout(layout_preview_settings, 0, 0, 1,
                                             2)
        group_box_preview.layout().addWidget(
            self.text_edit_pos_tagging_preview_samples, 1, 0)
        group_box_preview.layout().addWidget(
            self.text_edit_pos_tagging_preview_results, 1, 1)

        self.setLayout(wl_layout.Wl_Layout())
        self.layout().addWidget(group_box_pos_tagger_settings, 0, 0)
        self.layout().addWidget(group_box_preview, 1, 0)

        self.layout().setContentsMargins(6, 4, 6, 4)
        self.layout().setRowStretch(0, 3)
        self.layout().setRowStretch(1, 2)
def test_word_tokenize(lang, word_tokenizer, show_results = False):
    lang_text = wl_conversion.to_lang_text(main, lang)

    tokens = wl_word_tokenization.wl_word_tokenize(
        main,
        text = getattr(wl_test_lang_examples, f'SENTENCE_{lang.upper()}'),
        lang = lang,
        word_tokenizer = word_tokenizer
    )
    tokens = list(wl_misc.flatten_list(tokens))

    if show_results:
        print(f'{lang} / {word_tokenizer}:')
        print(tokens)

    if lang == 'afr':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - Penn Treebank Tokenizer']:
            assert tokens == ['Afrikaans', 'is', 'tipologies', 'gesien', "'n", 'Indo-Europese', ',', 'Wes-Germaanse', ',', 'Nederfrankiese', 'taal', ',', '[', '2', ']', 'wat', 'sy', 'ontstaan', 'aan', 'die', 'suidpunt', 'van', 'Afrika', 'gehad', 'het', 'onder', 'invloed', 'van', 'verskeie', 'ander', 'tale', 'en', 'taalgroepe', '.']
        elif word_tokenizer == ['NLTK - NLTK Tokenizer',
                                'NLTK - Twitter Tokenizer']:
            assert tokens == ['Afrikaans', 'is', 'tipologies', 'gesien', "'", 'n', 'Indo-Europese', ',', 'Wes-Germaanse', ',', 'Nederfrankiese', 'taal', ',', '[', '2', ']', 'wat', 'sy', 'ontstaan', 'aan', 'die', 'suidpunt', 'van', 'Afrika', 'gehad', 'het', 'onder', 'invloed', 'van', 'verskeie', 'ander', 'tale', 'en', 'taalgroepe', '.']
        elif word_tokenizer == 'spaCy - Afrikaans Word Tokenizer':
            assert tokens == ['Afrikaans', 'is', 'tipologies', 'gesien', "'", 'n', 'Indo', '-', 'Europese', ',', 'Wes', '-', 'Germaanse', ',', 'Nederfrankiese', 'taal,[2', ']', 'wat', 'sy', 'ontstaan', 'aan', 'die', 'suidpunt', 'van', 'Afrika', 'gehad', 'het', 'onder', 'invloed', 'van', 'verskeie', 'ander', 'tale', 'en', 'taalgroepe', '.']
    elif lang == 'sqi':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer',
                              'NLTK - Twitter Tokenizer']:
            assert tokens == ['Gjuha', 'shqipe', '(', 'ose', 'thjeshtë', 'shqipja', ')', 'është', 'gjuhë', 'dhe', 'degë', 'e', 'veçantë', 'e', 'familjes', 'indo-evropiane', 'të', 'folur', 'nga', 'më', 'shumë', 'se', '6', 'milionë', 'njerëz', '[', '4', ']', ',', 'kryesisht', 'në', 'Shqipëri', ',', 'Kosovë', 'dhe', 'Republikën', 'e', 'Maqedonisë', ',', 'por', 'edhe', 'në', 'zona', 'të', 'tjera', 'të', 'Evropës', 'Jugore', 'ku', 'ka', 'një', 'popullsi', 'shqiptare', ',', 'duke', 'përfshirë', 'Malin', 'e', 'Zi', 'dhe', 'Luginën', 'e', 'Preshevës', '.']
        elif word_tokenizer == 'spaCy - Albanian Word Tokenizer':
            assert tokens == ['Gjuha', 'shqipe', '(', 'ose', 'thjeshtë', 'shqipja', ')', 'është', 'gjuhë', 'dhe', 'degë', 'e', 'veçantë', 'e', 'familjes', 'indo', '-', 'evropiane', 'të', 'folur', 'nga', 'më', 'shumë', 'se', '6', 'milionë', 'njerëz[4', ']', ',', 'kryesisht', 'në', 'Shqipëri', ',', 'Kosovë', 'dhe', 'Republikën', 'e', 'Maqedonisë', ',', 'por', 'edhe', 'në', 'zona', 'të', 'tjera', 'të', 'Evropës', 'Jugore', 'ku', 'ka', 'një', 'popullsi', 'shqiptare', ',', 'duke', 'përfshirë', 'Malin', 'e', 'Zi', 'dhe', 'Luginën', 'e', 'Preshevës', '.']
    elif lang == 'ara':
        assert tokens == ['اللُّغَة', 'العَرَبِيّة', 'هي', 'أكثر', 'اللغات', 'تحدثاً', 'ونطقاً', 'ضمن', 'مجموعة', 'اللغات', 'السامية', '،', 'وإحدى', 'أكثر', 'اللغات', 'انتشاراً', 'في', 'العالم', '،', 'يتحدثها', 'أكثر', 'من', '467', 'مليون', 'نسمة،(1', ')', 'ويتوزع', 'متحدثوها', 'في', 'الوطن', 'العربي', '،', 'بالإضافة', 'إلى', 'العديد', 'من', 'المناطق', 'الأخرى', 'المجاورة', 'كالأحواز', 'وتركيا', 'وتشاد', 'ومالي', 'والسنغال', 'وإرتيريا', 'وإثيوبيا', 'وجنوب', 'السودان', 'وإيران', '.']
    elif lang == 'hye':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer',
                              'spaCy - Armenian Word Tokenizer']:
            assert tokens == ['Հայոց', 'լեզվով', 'ստեղծվել', 'է', 'մեծ', 'գրականություն', ':', 'Գրաբարով', 'է', 'ավանդված', 'հայ', 'հին', 'պատմագրությունը', ',', 'գիտափիլիսոփայական', ',', 'մաթեմատիկական', ',', 'բժշկագիտական', ',', 'աստվածաբանական-դավանաբանական', 'գրականությունը։']
        elif word_tokenizer == 'NLTK - Twitter Tokenizer':
            assert tokens == ['Հայոց', 'լեզվով', 'ստեղծվել', 'է', 'մեծ', 'գրականություն', ':', 'Գրաբարով', 'է', 'ավանդված', 'հայ', 'հին', 'պատմագրությունը', ',', 'գիտափիլիսոփայական', ',', 'մաթեմատիկական', ',', 'բժշկագիտական', ',', 'աստվածաբանական-դավանաբանական', 'գրականությունը', '։']
    elif lang == 'eus':
        assert tokens == ['Euskara', 'Euskal', 'Herriko', 'hizkuntza', 'da.[5', ']']
    elif lang == 'ben':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer']:
            assert tokens == ['বাংলা', 'ভাষা', '(', 'বাঙলা', ',', 'বাঙ্গলা', ',', 'তথা', 'বাঙ্গালা', 'নামগুলোতেও', 'পরিচিত', ')', 'একটি', 'ইন্দো-আর্য', 'ভাষা', ',', 'যা', 'দক্ষিণ', 'এশিয়ার', 'বাঙালি', 'জাতির', 'প্রধান', 'কথ্য', 'ও', 'লেখ্য', 'ভাষা।']
        elif word_tokenizer == 'NLTK - Twitter Tokenizer':
            assert tokens == ['বাংলা', 'ভাষা', '(', 'বাঙলা', ',', 'বাঙ্গলা', ',', 'তথা', 'বাঙ্গালা', 'নামগুলোতেও', 'পরিচিত', ')', 'একটি', 'ইন্দো-আর্য', 'ভাষা', ',', 'যা', 'দক্ষিণ', 'এশিয়ার', 'বাঙালি', 'জাতির', 'প্রধান', 'কথ্য', 'ও', 'লেখ্য', 'ভাষা', '।']
        elif word_tokenizer == 'spaCy - Arabic Word Tokenizer':
            assert tokens == ['বাংলা', 'ভাষা', '(', 'বাঙলা', ',', 'বাঙ্গলা', ',', 'তথা', 'বাঙ্গালা', 'নামগুলোতেও', 'পরিচিত', ')', 'একটি', 'ইন্দো', '-', 'আর্য', 'ভাষা', ',', 'যা', 'দক্ষিণ', 'এশিয়ার', 'বাঙালি', 'জাতির', 'প্রধান', 'কথ্য', 'ও', 'লেখ্য', 'ভাষা', '।']
    elif lang == 'bul':
        assert tokens == ['Бъ̀лгарският', 'езѝк', 'е', 'индоевропейски', 'език', 'от', 'групата', 'на', 'южнославянските', 'езици', '.']
    elif lang == 'cat':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer']:
            assert tokens == ['El', 'català', '(', 'denominació', 'oficial', 'a', 'Catalunya', ',', 'a', 'les', 'Illes', 'Balears', ',', 'a', 'Andorra', ',', 'a', 'la', 'ciutat', 'de', "l'Alguer", 'i', 'tradicional', 'a', 'Catalunya', 'Nord', ')', 'o', 'valencià', '(', 'denominació', 'oficial', 'al', 'País', 'Valencià', 'i', 'tradicional', 'al', 'Carxe', ')', 'és', 'una', 'llengua', 'romànica', 'parlada', 'a', 'Catalunya', ',', 'el', 'País', 'Valencià', '(', 'tret', "d'algunes", 'comarques', 'i', 'localitats', 'de', "l'interior", ')', ',', 'les', 'Illes', 'Balears', ',', 'Andorra', ',', 'la', 'Franja', 'de', 'Ponent', '(', 'a', "l'Aragó", ')', ',', 'la', 'ciutat', 'de', "l'Alguer", '(', 'a', "l'illa", 'de', 'Sardenya', ')', ',', 'la', 'Catalunya', 'del', 'Nord', ',', '[', '8', ']', 'el', 'Carxe', '(', 'un', 'petit', 'territori', 'de', 'Múrcia', 'poblat', 'per', 'immigrats', 'valencians', ')', ',', '[', '9', ']', '[', '10', ']', 'i', 'en', 'petites', 'comunitats', 'arreu', 'del', 'món', '(', 'entre', 'les', 'quals', 'destaca', 'la', 'de', "l'Argentina", ',', 'amb', '195.000', 'parlants', ')', '.', '[', '11', ']']
        elif word_tokenizer == 'NLTK - Twitter Tokenizer':
            assert tokens == ['El', 'català', '(', 'denominació', 'oficial', 'a', 'Catalunya', ',', 'a', 'les', 'Illes', 'Balears', ',', 'a', 'Andorra', ',', 'a', 'la', 'ciutat', 'de', "l'Alguer", 'i', 'tradicional', 'a', 'Catalunya', 'Nord', ')', 'o', 'valencià', '(', 'denominació', 'oficial', 'al', 'País', 'Valencià', 'i', 'tradicional', 'al', 'Carxe', ')', 'és', 'una', 'llengua', 'romànica', 'parlada', 'a', 'Catalunya', ',', 'el', 'País', 'Valencià', '(', 'tret', "d'algunes", 'comarques', 'i', 'localitats', 'de', "l'interior", ')', ',', 'les', 'Illes', 'Balears', ',', 'Andorra', ',', 'la', 'Franja', 'de', 'Ponent', '(', 'a', "l'Aragó", ')', ',', 'la', 'ciutat', 'de', "l'Alguer", '(', 'a', "l'illa", 'de', 'Sardenya', ')', ',', 'la', 'Catalunya', 'del', 'Nord', ',', '[8', ']', 'el', 'Carxe', '(', 'un', 'petit', 'territori', 'de', 'Múrcia', 'poblat', 'per', 'immigrats', 'valencians', ')', ',', '[', '9', ']', '[', '10', ']', 'i', 'en', 'petites', 'comunitats', 'arreu', 'del', 'món', '(', 'entre', 'les', 'quals', 'destaca', 'la', 'de', "l'Argentina", ',', 'amb', '195.000', 'parlants', ')', '.', '[', '11', ']']
        elif word_tokenizer == 'Sacremoses - Moses Tokenizer':
            assert tokens == ['El', 'català', '(', 'denominació', 'oficial', 'a', 'Catalunya', ',', 'a', 'les', 'Illes', 'Balears', ',', 'a', 'Andorra', ',', 'a', 'la', 'ciutat', 'de', 'l', "'", 'Alguer', 'i', 'tradicional', 'a', 'Catalunya', 'Nord', ')', 'o', 'valencià', '(', 'denominació', 'oficial', 'al', 'País', 'Valencià', 'i', 'tradicional', 'al', 'Carxe', ')', 'és', 'una', 'llengua', 'romànica', 'parlada', 'a', 'Catalunya', ',', 'el', 'País', 'Valencià', '(', 'tret', 'd', "'", 'algunes', 'comarques', 'i', 'localitats', 'de', 'l', "'", 'interior', ')', ',', 'les', 'Illes', 'Balears', ',', 'Andorra', ',', 'la', 'Franja', 'de', 'Ponent', '(', 'a', 'l', "'", 'Aragó', ')', ',', 'la', 'ciutat', 'de', 'l', "'", 'Alguer', '(', 'a', 'l', "'", 'illa', 'de', 'Sardenya', ')', ',', 'la', 'Catalunya', 'del', 'Nord', ',', '[', '8', ']', 'el', 'Carxe', '(', 'un', 'petit', 'territori', 'de', 'Múrcia', 'poblat', 'per', 'immigrats', 'valencians', ')', ',', '[', '9', ']', '[', '10', ']', 'i', 'en', 'petites', 'comunitats', 'arreu', 'del', 'món', '(', 'entre', 'les', 'quals', 'destaca', 'la', 'de', 'l', "'", 'Argentina', ',', 'amb', '195.000', 'parlants', ')', '.', '[', '11', ']']
        elif word_tokenizer == 'spaCy - Catalan Word Tokenizer':
            assert tokens == ['El', 'català', '(', 'denominació', 'oficial', 'a', 'Catalunya', ',', 'a', 'les', 'Illes', 'Balears', ',', 'a', 'Andorra', ',', 'a', 'la', 'ciutat', 'de', "l'", 'Alguer', 'i', 'tradicional', 'a', 'Catalunya', 'Nord', ')', 'o', 'valencià', '(', 'denominació', 'oficial', 'al', 'País', 'Valencià', 'i', 'tradicional', 'al', 'Carxe', ')', 'és', 'una', 'llengua', 'romànica', 'parlada', 'a', 'Catalunya', ',', 'el', 'País', 'Valencià', '(', 'tret', "d'", 'algunes', 'comarques', 'i', 'localitats', 'de', "l'", 'interior', ')', ',', 'les', 'Illes', 'Balears', ',', 'Andorra', ',', 'la', 'Franja', 'de', 'Ponent', '(', 'a', "l'", 'Aragó', ')', ',', 'la', 'ciutat', 'de', "l'", 'Alguer', '(', 'a', "l'", 'illa', 'de', 'Sardenya', ')', ',', 'la', 'Catalunya', 'del', 'Nord,[8', ']', 'el', 'Carxe', '(', 'un', 'petit', 'territori', 'de', 'Múrcia', 'poblat', 'per', 'immigrats', 'valencians),[9][10', ']', 'i', 'en', 'petites', 'comunitats', 'arreu', 'del', 'món', '(', 'entre', 'les', 'quals', 'destaca', 'la', 'de', "l'", 'Argentina', ',', 'amb', '195.000', 'parlants).[11', ']']
    elif lang == 'zho_cn':
        if word_tokenizer == 'jieba - Chinese Word Tokenizer':
            assert tokens == ['汉语', ',', '又称', '汉文', '、', '中文', '、', '中国', '话', '、', '中国', '语', '、', '华语', '、', '华文', '、', '唐话', '[', '2', ']', ',', '或', '被', '视为', '一个', '语族', ',', '或', '被', '视为', '隶属于', '汉藏语系', '汉语', '族', '之', '一种', '语言', '。']
        elif word_tokenizer == 'pkuseg - Chinese Word Tokenizer':
            assert tokens == ['汉语', ',', '又', '称', '汉文', '、', '中文', '、', '中国话', '、', '中国语', '、', '华语', '、', '华文', '、', '唐', '话[', '2', ']', ',', '或', '被', '视为', '一个', '语族', ',', '或', '被', '视为', '隶属于', '汉藏', '语系', '汉语族', '之一', '种', '语言', '。']
        elif word_tokenizer == 'Wordless - Chinese Character Tokenizer':
            assert tokens == ['汉', '语', ',', '又', '称', '汉', '文', '、', '中', '文', '、', '中', '国', '话', '、', '中', '国', '语', '、', '华', '语', '、', '华', '文', '、', '唐', '话', '[', '2', ']', ',', '或', '被', '视', '为', '一', '个', '语', '族', ',', '或', '被', '视', '为', '隶', '属', '于', '汉', '藏', '语', '系', '汉', '语', '族', '之', '一', '种', '语', '言', '。']
    elif lang == 'zho_tw':
        if word_tokenizer == 'jieba - Chinese Word Tokenizer':
            assert tokens == ['漢語', ',', '又', '稱漢文', '、', '中文', '、', '中國話', '、', '中國語', '、', '華語', '、', '華文', '、', '唐話', '[', '2', ']', ',', '或', '被', '視為', '一個', '語族', ',', '或', '被', '視為', '隸屬', '於', '漢藏語', '系漢', '語族', '之一', '種語', '言', '。']
        elif word_tokenizer == 'pkuseg - Chinese Word Tokenizer':
            assert tokens == ['漢語', ',', '又', '稱', '漢文', '、', '中文', '、', '中', '國話', '、', '中國語', '、', '華語', '、', '華文', '、', '唐', '話[', '2', ']', ',', '或', '被', '視為', '一', '個', '語族', ',', '或', '被', '視', '為隸', '屬於', '漢藏', '語系', '漢語族', '之一', '種', '語言', '。']
        elif word_tokenizer == 'Wordless - Chinese Character Tokenizer':
            assert tokens == ['漢', '語', ',', '又', '稱', '漢', '文', '、', '中', '文', '、', '中', '國', '話', '、', '中', '國', '語', '、', '華', '語', '、', '華', '文', '、', '唐', '話', '[', '2', ']', ',', '或', '被', '視', '為', '一', '個', '語', '族', ',', '或', '被', '視', '為', '隸', '屬', '於', '漢', '藏', '語', '系', '漢', '語', '族', '之', '一', '種', '語', '言', '。']
    elif lang == 'hrv':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'spaCy - Croatian Word Tokenizer']:
            assert tokens == ['Hrvatski', 'jezik', '(', 'ISO', '639', '-', '3', ':', 'hrv', ')', 'skupni', 'je', 'naziv', 'za', 'nacionalni', 'standardni', 'jezik', 'Hrvata', ',', 'te', 'za', 'skup', 'narječja', 'i', 'govora', 'kojima', 'govore', 'ili', 'su', 'nekada', 'govorili', 'Hrvati', '.']
        elif word_tokenizer in ['NLTK - NLTK Tokenizer',
                                'NLTK - Penn Treebank Tokenizer',
                                'NLTK - Twitter Tokenizer']:
            assert tokens == ['Hrvatski', 'jezik', '(', 'ISO', '639-3', ':', 'hrv', ')', 'skupni', 'je', 'naziv', 'za', 'nacionalni', 'standardni', 'jezik', 'Hrvata', ',', 'te', 'za', 'skup', 'narječja', 'i', 'govora', 'kojima', 'govore', 'ili', 'su', 'nekada', 'govorili', 'Hrvati', '.']
        
    elif lang == 'ces':
        assert tokens == ['Čeština', 'neboli', 'český', 'jazyk', 'je', 'západoslovanský', 'jazyk', ',', 'nejbližší', 'slovenštině', ',', 'poté', 'lužické', 'srbštině', 'a', 'polštině', '.']
    elif lang == 'dan':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - Twitter Tokenizer']:
            assert tokens == ['Dansk', 'er', 'et', 'nordgermansk', 'sprog', 'af', 'den', 'østnordiske', '(', 'kontinentale', ')', 'gruppe', ',', 'der', 'tales', 'af', 'ca', '.', 'seks', 'millioner', 'mennesker', '.']
        elif word_tokenizer in ['NLTK - NLTK Tokenizer',
                                'NLTK - Penn Treebank Tokenizer',
                                'spaCy - Danish Word Tokenizer']:
            assert tokens == ['Dansk', 'er', 'et', 'nordgermansk', 'sprog', 'af', 'den', 'østnordiske', '(', 'kontinentale', ')', 'gruppe', ',', 'der', 'tales', 'af', 'ca.', 'seks', 'millioner', 'mennesker', '.']
        
    elif lang == 'nld':
        assert tokens == ['Het', 'Nederlands', 'is', 'een', 'West-Germaanse', 'taal', 'en', 'de', 'moedertaal', 'van', 'de', 'meeste', 'inwoners', 'van', 'Nederland', ',', 'België', 'en', 'Suriname', '.']
    elif lang == 'eng':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - Twitter Tokenizer',
                              'Sacremoses - Moses Tokenizer']:
            assert tokens == ['English', 'is', 'a', 'West', 'Germanic', 'language', 'that', 'was', 'first', 'spoken', 'in', 'early', 'medieval', 'England', 'and', 'eventually', 'became', 'a', 'global', 'lingua', 'franca', '.', '[', '4', ']', '[', '5', ']']
        elif word_tokenizer in ['NLTK - NLTK Tokenizer',
                                'NLTK - Penn Treebank Tokenizer',
                                'syntok - Word Tokenizer']:
            assert tokens == ['English', 'is', 'a', 'West', 'Germanic', 'language', 'that', 'was', 'first', 'spoken', 'in', 'early', 'medieval', 'England', 'and', 'eventually', 'became', 'a', 'global', 'lingua', 'franca.', '[', '4', ']', '[', '5', ']']
        elif word_tokenizer == 'NLTK - Tok-tok Tokenizer':
            assert tokens == ['English', 'is', 'a', 'West', 'Germanic', 'language', 'that', 'was', 'first', 'spoken', 'in', 'early', 'medieval', 'England', 'and', 'eventually', 'became', 'a', 'global', 'lingua', 'franca.[', '4', ']', '[', '5', ']']
        elif word_tokenizer == 'spaCy - English Word Tokenizer':
            assert tokens == ['English', 'is', 'a', 'West', 'Germanic', 'language', 'that', 'was', 'first', 'spoken', 'in', 'early', 'medieval', 'England', 'and', 'eventually', 'became', 'a', 'global', 'lingua', 'franca.[4][5', ']']
    elif lang == 'est':
        assert tokens == ['Eesti', 'keel', '(', 'varasem', 'nimetus', 'maakeel', ')', 'on', 'läänemeresoome', 'lõunarühma', 'kuuluv', 'keel', '.']
    elif lang == 'fin':
        assert tokens == ['Suomen', 'kieli', '(', 'suomi', ')', 'on', 'uralilaisten', 'kielten', 'itämerensuomalaiseen', 'ryhmään', 'kuuluva', 'kieli', '.']
    elif lang == 'fra':
        assert tokens == ['Le', 'français', 'est', 'une', 'langue', 'indo-européenne', 'de', 'la', 'famille', 'des', 'langues', 'romanes', '.']
    elif lang == 'deu':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'syntok - Word Tokenizer']:
            assert tokens == ['Die', 'deutsche', 'Sprache', 'bzw', '.', 'Deutsch', '(', '[', 'dɔʏ̯t͡ʃ', ']', ';', 'abgekürzt', 'dt', '.', 'oder', 'dtsch', '.', ')', 'ist', 'eine', 'westgermanische', 'Sprache', '.']
        elif word_tokenizer == ['NLTK - NLTK Tokenizer',
                                'NLTK - Penn Treebank Tokenizer',
                                'NLTK - Tok-tok Tokenizer']:
            assert tokens == ['Die', 'deutsche', 'Sprache', 'bzw.', 'Deutsch', '(', '[', 'dɔʏ̯t͡ʃ', ']', ';', 'abgekürzt', 'dt.', 'oder', 'dtsch.', ')', 'ist', 'eine', 'westgermanische', 'Sprache', '.']
        elif word_tokenizer == 'German / NLTK - Twitter Tokenizer':
            assert tokens == ['Die', 'deutsche', 'Sprache', 'bzw', '.', 'Deutsch', '(', '[', 'dɔʏ', '̯', 't', '͡', 'ʃ', '];', 'abgekürzt', 'dt', '.', 'oder', 'dtsch', '.', ')', 'ist', 'eine', 'westgermanische', 'Sprache', '.']
        elif word_tokenizer == 'Sacremoses - Moses Tokenizer':
            assert tokens == ['Die', 'deutsche', 'Sprache', 'bzw.', 'Deutsch', '(', '[', 'dɔʏ', '̯', 't', '͡', 'ʃ', ']', ';', 'abgekürzt', 'dt.', 'oder', 'dtsch', '.', ')', 'ist', 'eine', 'westgermanische', 'Sprache', '.']
        elif word_tokenizer == 'spaCy - German Word Tokenizer':
            assert tokens == ['Die', 'deutsche', 'Sprache', 'bzw.', 'Deutsch', '(', '[', 'dɔʏ̯t͡ʃ', ']', ';', 'abgekürzt', 'dt', '.', 'oder', 'dtsch', '.', ')', 'ist', 'eine', 'westgermanische', 'Sprache', '.']
    elif lang == 'ell':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer',
                              'NLTK - Twitter Tokenizer',
                              'Sacremoses - Moses Tokenizer']:
            assert tokens == ['Η', 'ελληνική', 'γλώσσα', 'ανήκει', 'στην', 'ινδοευρωπαϊκή', 'οικογένεια', '[', '9', ']', 'και', 'συγκεκριμένα', 'στον', 'ελληνικό', 'κλάδο', ',', 'μαζί', 'με', 'την', 'τσακωνική', ',', 'ενώ', 'είναι', 'η', 'επίσημη', 'γλώσσα', 'της', 'Ελλάδος', 'και', 'της', 'Κύπρου', '.']
        elif word_tokenizer == 'spaCy - Greek (Modern) Word Tokenizer':
            assert tokens == ['Η', 'ελληνική', 'γλώσσα', 'ανήκει', 'στην', 'ινδοευρωπαϊκή', 'οικογένεια[9', ']', 'και', 'συγκεκριμένα', 'στον', 'ελληνικό', 'κλάδο', ',', 'μαζί', 'με', 'την', 'τσακωνική', ',', 'ενώ', 'είναι', 'η', 'επίσημη', 'γλώσσα', 'της', 'Ελλάδος', 'και', 'της', 'Κύπρου', '.']
    elif lang == 'guj':
        assert tokens == ['ગુજરાતી', '\u200d(/ɡʊdʒəˈrɑːti/[૭', ']', ',', 'રોમન', 'લિપિમાં', ':', 'Gujarātī', ',', 'ઉચ્ચાર', ':', '[', 'ɡudʒəˈɾɑːtiː', ']', ')', 'ભારત', 'દેશના', 'ગુજરાત', 'રાજ્યની', 'ઇન્ડો-આર્યન', 'ભાષા', 'છે', ',', 'અને', 'મુખ્યત્વે', 'ગુજરાતી', 'લોકો', 'દ્વારા', 'બોલાય', 'છે.']
    elif lang == 'heb':
        assert tokens == ['עִבְרִית', 'היא', 'שפה', 'שמית', ',', 'ממשפחת', 'השפות', 'האפרו', '-', 'אסיאתיות', ',', 'הידועה', 'כשפתם', 'של', 'היהודים', 'ושל', 'השומרונים', ',', 'אשר', 'ניב', 'מודרני', 'שלה', '(', 'עברית', 'ישראלית', ')', 'הוא', 'שפתה', 'הרשמית', 'של', 'מדינת', 'ישראל', ',', 'מעמד', 'שעוגן', 'בשנת', '2018', 'בחוק', 'יסוד', ':', 'ישראל', '–', 'מדינת', 'הלאום', 'של', 'העם', 'היהודי', '.']
    elif lang == 'hin':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer']:
            assert tokens == ['हिन्दी', 'विश्व', 'की', 'एक', 'प्रमुख', 'भाषा', 'है', 'एवं', 'भारत', 'की', 'राजभाषा', 'है।']
        elif word_tokenizer == ['NLTK - Twitter Tokenizer',
                                'spaCy - Hindi Word Tokenizer']:
            assert tokens == ['हिन्दी', 'विश्व', 'की', 'एक', 'प्रमुख', 'भाषा', 'है', 'एवं', 'भारत', 'की', 'राजभाषा', 'है', '।']
    elif lang == 'hun':
        assert tokens == ['A', 'magyar', 'nyelv', 'az', 'uráli', 'nyelvcsalád', 'tagja', ',', 'a', 'finnugor', 'nyelvek', 'közé', 'tartozó', 'ugor', 'nyelvek', 'egyike', '.']
    elif lang == 'isl':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - Twitter Tokenizer',
                              'Sacremoses - Moses Tokenizer',
                              'Tokenizer - Icelandic Word Tokenizer']:
            assert tokens == ['Íslenska', 'er', 'vesturnorrænt', ',', 'germanskt', 'og', 'indóevrópskt', 'tungumál', 'sem', 'er', 'einkum', 'talað', 'og', 'ritað', 'á', 'Íslandi', 'og', 'er', 'móðurmál', 'langflestra', 'Íslendinga', '.', '[', '4', ']']
        elif word_tokenizer == ['NLTK - NLTK Tokenizer',
                                'NLTK - Penn Treebank Tokenizer']:
            assert tokens == ['Íslenska', 'er', 'vesturnorrænt', ',', 'germanskt', 'og', 'indóevrópskt', 'tungumál', 'sem', 'er', 'einkum', 'talað', 'og', 'ritað', 'á', 'Íslandi', 'og', 'er', 'móðurmál', 'langflestra', 'Íslendinga.', '[', '4', ']']
        elif word_tokenizer == 'spaCy - Icelandic Word Tokenizer':
            assert tokens == ['Íslenska', 'er', 'vesturnorrænt', ',', 'germanskt', 'og', 'indóevrópskt', 'tungumál', 'sem', 'er', 'einkum', 'talað', 'og', 'ritað', 'á', 'Íslandi', 'og', 'er', 'móðurmál', 'langflestra', 'Íslendinga.[4', ']']
    elif lang == 'ind':
        assert tokens == ['Bahasa', 'Indonesia', 'adalah', 'bahasa', 'Melayu', 'baku', 'yang', 'dijadikan', 'sebagai', 'bahasa', 'resmi', 'Republik', 'Indonesia[1', ']', 'dan', 'bahasa', 'persatuan', 'bangsa', 'Indonesia.[2', ']']
    elif lang == 'gle':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - Twitter Tokenizer']:
            assert tokens == ['Is', 'ceann', 'de', 'na', 'teangacha', 'Ceilteacha', 'í', 'an', 'Ghaeilge', '(', 'nó', 'Gaeilge', 'na', 'hÉireann', 'mar', 'a', 'thugtar', 'uirthi', 'corruair', ')', ',', 'agus', 'ceann', 'den', 'dtrí', 'cinn', 'de', 'theangacha', 'Ceilteacha', 'ar', 'a', 'dtugtar', 'na', 'teangacha', 'Gaelacha', '(', '.', 'i', '.', 'an', 'Ghaeilge', ',', 'Gaeilge', 'na', 'hAlban', 'agus', 'Gaeilge', 'Mhanann', ')', 'go', 'háirithe', '.']
        elif word_tokenizer in ['NLTK - NLTK Tokenizer',
                                'NLTK - Penn Treebank Tokenizer',
                                'Sacremoses - Moses Tokenizer',
                                'spaCy - Irish Word Tokenizer']:
            assert tokens == ['Is', 'ceann', 'de', 'na', 'teangacha', 'Ceilteacha', 'í', 'an', 'Ghaeilge', '(', 'nó', 'Gaeilge', 'na', 'hÉireann', 'mar', 'a', 'thugtar', 'uirthi', 'corruair', ')', ',', 'agus', 'ceann', 'den', 'dtrí', 'cinn', 'de', 'theangacha', 'Ceilteacha', 'ar', 'a', 'dtugtar', 'na', 'teangacha', 'Gaelacha', '(', '.i.', 'an', 'Ghaeilge', ',', 'Gaeilge', 'na', 'hAlban', 'agus', 'Gaeilge', 'Mhanann', ')', 'go', 'háirithe', '.']
    elif lang == 'ita':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer']:
            assert tokens == ["L'italiano", '(', '[', 'itaˈljaːno', ']', '[', 'Nota', '1', ']', 'ascolta', '[', '?', '·info', ']', ')', 'è', 'una', 'lingua', 'romanza', 'parlata', 'principalmente', 'in', 'Italia', '.']
        elif word_tokenizer == 'NLTK - Twitter Tokenizer':
            assert tokens == ["L'italiano", '(', '[', 'itaˈljaːno', ']', '[', 'Nota', '1', ']', 'ascolta', '[', '?', '·', 'info', ']', ')', 'è', 'una', 'lingua', 'romanza', 'parlata', 'principalmente', 'in', 'Italia', '.']
        elif word_tokenizer == 'Sacremoses - Moses Tokenizer':
            assert tokens == ["L'", 'italiano', '(', '[', 'itaˈljaːno', ']', '[', 'Nota', '1', ']', 'ascolta', '[', '?', '·', 'info', ']', ')', 'è', 'una', 'lingua', 'romanza', 'parlata', 'principalmente', 'in', 'Italia', '.']
        elif word_tokenizer == 'spaCy - Italian Word Tokenizer':
            assert tokens == ["L'", 'italiano', '(', '[', 'itaˈljaːno][Nota', '1', ']', 'ascolta[?·info', ']', ')', 'è', 'una', 'lingua', 'romanza', 'parlata', 'principalmente', 'in', 'Italia', '.']
    elif lang == 'jpn':
        if word_tokenizer == 'nagisa - Japanese Word Tokenizer':
            assert tokens == ['日本', '語', '(', 'にほんご', '、', 'にっぽん', 'ご', '[', '注', '1', ']', ')', 'は', '、', '主に', '日本', '国', '内', 'や', '日本', '人', '同士', 'の', '間', 'で', '使用', 'さ', 'れ', 'て', 'いる', '言語', 'で', 'ある', '。']
        elif word_tokenizer == 'Wordless - Japanese Kanji Tokenizer':
            assert tokens == ['日', '本', '語', '(', 'にほんご', '、', 'にっぽん', 'ご', '[', '注', '1', ']', ')', 'は', '、', '主', 'に', '日', '本', '国', '内', 'や', '日', '本', '人', '同', '士', 'の', '間', 'で', '使', '用', 'さ', 'れ', 'て', 'いる', '言', '語', 'で', 'ある', '。']
    elif lang == 'kan':
        assert tokens == ['ದ್ರಾವಿಡ', 'ಭಾಷೆಗಳಲ್ಲಿ', 'ಪ್ರಾಮುಖ್ಯವುಳ್ಳ', 'ಭಾಷೆಯೂ', 'ಭಾರತದ', 'ಪುರಾತನವಾದ', 'ಭಾಷೆಗಳಲ್ಲಿ', 'ಒಂದೂ', 'ಆಗಿರುವ', 'ಕನ್ನಡ', 'ಭಾಷೆಯನ್ನು', 'ಅದರ', 'ವಿವಿಧ', 'ರೂಪಗಳಲ್ಲಿ', 'ಸುಮಾರು', '೪೫', 'ದಶಲಕ್ಷ', 'ಜನರು', 'ಆಡು', 'ನುಡಿಯಾಗಿ', 'ಬಳಸುತ್ತಲಿದ್ದಾರೆ', '.']
    elif lang == 'lav':
        if word_tokenizer == ['NLTK - NIST Tokenizer',
                              'NLTK - Twitter Tokenizer',
                              'Sacremoses - Moses Tokenizer']:
            assert tokens == ['Latviešu', 'valoda', 'ir', 'dzimtā', 'valoda', 'apmēram', '1,7', 'miljoniem', 'cilvēku', ',', 'galvenokārt', 'Latvijā', ',', 'kur', 'tā', 'ir', 'vienīgā', 'valsts', 'valoda', '.', '[', '3', ']']
        elif word_tokenizer == ['NLTK - NLTK Tokenizer',
                                'NLTK - Penn Treebank Tokenizer']:
            assert tokens == ['Latviešu', 'valoda', 'ir', 'dzimtā', 'valoda', 'apmēram', '1,7', 'miljoniem', 'cilvēku', ',', 'galvenokārt', 'Latvijā', ',', 'kur', 'tā', 'ir', 'vienīgā', 'valsts', 'valoda.', '[', '3', ']']
        elif word_tokenizer == 'spaCy - Latvian Word Tokenizer':
            assert tokens == ['Latviešu', 'valoda', 'ir', 'dzimtā', 'valoda', 'apmēram', '1,7', 'miljoniem', 'cilvēku', ',', 'galvenokārt', 'Latvijā', ',', 'kur', 'tā', 'ir', 'vienīgā', 'valsts', 'valoda.[3', ']']
    elif lang == 'lij':
        if word_tokenizer == ['NLTK - NIST Tokenizer',
                              'NLTK - Penn Treebank Tokenizer',
                              'NLTK - Twitter Tokenizer']:
            assert tokens == ['O', 'Lìgure', '(', 'in', 'monegasco', ':', 'lenga', 'ligüra', 'e', 'lenga', 'lìgura', ')', 'o', "l'é", "'na", 'lengoa', '[', '1', ']', 'do', 'gruppo', 'lengoìstego', 'itàlico', 'oçidentâ', 'parlâ', 'in', 'Italia', '(', 'Liguria', ',', 'Piemonte', ',', 'Emilia-Romagna', 'e', 'Sardegna', ')', ',', 'into', 'sud', 'da', 'Fransa', ',', 'in', 'Còrsega', ',', 'e', 'into', 'Prinçipato', 'de', 'Monego', '.']
        elif word_tokenizer == 'NLTK - NLTK Tokenizer':
            assert tokens == ['O', 'Lìgure', '(', 'in', 'monegasco', ':', 'lenga', 'ligüra', 'e', 'lenga', 'lìgura', ')', 'o', 'l', "'", 'é', "'na", 'lengoa', '[', '1', ']', 'do', 'gruppo', 'lengoìstego', 'itàlico', 'oçidentâ', 'parlâ', 'in', 'Italia', '(', 'Liguria', ',', 'Piemonte', ',', 'Emilia-Romagna', 'e', 'Sardegna', ')', ',', 'into', 'sud', 'da', 'Fransa', ',', 'in', 'Còrsega', ',', 'e', 'into', 'Prinçipato', 'de', 'Monego', '.']
        elif word_tokenizer == 'spaCy - Ligurian Word Tokenizer':
            assert tokens == ['O', 'Lìgure', '(', 'in', 'monegasco', ':', 'lenga', 'ligüra', 'e', 'lenga', 'lìgura', ')', 'o', "l'", 'é', "'", 'na', 'lengoa[1', ']', 'do', 'gruppo', 'lengoìstego', 'itàlico', 'oçidentâ', 'parlâ', 'in', 'Italia', '(', 'Liguria', ',', 'Piemonte', ',', 'Emilia', '-', 'Romagna', 'e', 'Sardegna', ')', ',', 'into', 'sud', 'da', 'Fransa', ',', 'in', 'Còrsega', ',', 'e', 'into', 'Prinçipato', 'de', 'Monego', '.']
    elif lang == 'lit':
        assert tokens == ['Lietuvių', 'kalba', '–', 'iš', 'baltų', 'prokalbės', 'kilusi', 'lietuvių', 'tautos', 'kalba', ',', 'kuri', 'Lietuvoje', 'yra', 'valstybinė', ',', 'o', 'Europos', 'Sąjungoje', '–', 'viena', 'iš', 'oficialiųjų', 'kalbų', '.']
    elif lang == 'ltz':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer',
                              'NLTK - Twitter Tokenizer']:
            assert tokens == ["D'Lëtzebuergesch", 'gëtt', 'an', 'der', 'däitscher', 'Dialektologie', 'als', 'ee', 'westgermaneschen', ',', 'mëtteldäitschen', 'Dialekt', 'aklasséiert', ',', 'deen', 'zum', 'Muselfränkesche', 'gehéiert', '.']
        elif word_tokenizer == 'spaCy - Luxembourgish Word Tokenizer':
            assert tokens == ["D'", 'Lëtzebuergesch', 'gëtt', 'an', 'der', 'däitscher', 'Dialektologie', 'als', 'ee', 'westgermaneschen', ',', 'mëtteldäitschen', 'Dialekt', 'aklasséiert', ',', 'deen', 'zum', 'Muselfränkesche', 'gehéiert', '.']
    elif lang == 'mal':
        assert tokens == ['ഇന്ത്യയിൽ', 'പ്രധാനമായും', 'കേരള', 'സംസ്ഥാനത്തിലും', 'ലക്ഷദ്വീപിലും', 'പുതുച്ചേരിയുടെ', 'ഭാഗമായ', 'മയ്യഴിയിലും', 'സംസാരിക്കപ്പെടുന്ന', 'ഭാഷയാണ്', 'മലയാളം.']
    elif lang == 'mar':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer',
                              'NLTK - Twitter Tokenizer']:
            assert tokens == ['मराठीभाषा', 'ही', 'इंडो-युरोपीय', 'भाषाकुलातील', 'एक', 'भाषा', 'आहे', '.']
        elif word_tokenizer == 'spaCy - Marathi Word Tokenizer':
            assert tokens == ['मराठीभाषा', 'ही', 'इंडो', '-', 'युरोपीय', 'भाषाकुलातील', 'एक', 'भाषा', 'आहे', '.']
    elif lang == 'nep':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer']:
            assert tokens == ['नेपाली', 'भाषा', '(', 'अन्तर्राष्ट्रिय', 'ध्वन्यात्मक', 'वर्णमाला', '[', 'neˈpali', 'bʱaʂa', ']', ')', 'नेपालको', 'सम्पर्क', 'भाषा', 'तथा', 'भारत', ',', 'भुटान', 'र', 'म्यानमारको', 'केही', 'भागमा', 'मातृभाषाको', 'रूपमा', 'बोलिने', 'भाषा', 'हो।']
        elif word_tokenizer in ['NLTK - Twitter Tokenizer',
                                'spaCy - Nepali Word Tokenizer']:
            assert tokens == ['नेपाली', 'भाषा', '(', 'अन्तर्राष्ट्रिय', 'ध्वन्यात्मक', 'वर्णमाला', '[', 'neˈpali', 'bʱaʂa', ']', ')', 'नेपालको', 'सम्पर्क', 'भाषा', 'तथा', 'भारत', ',', 'भुटान', 'र', 'म्यानमारको', 'केही', 'भागमा', 'मातृभाषाको', 'रूपमा', 'बोलिने', 'भाषा', 'हो', '।']
    elif lang == 'nob':
        assert tokens == ['Bokmål', 'er', 'en', 'varietet', 'av', 'norsk', 'språk', '.']
    elif lang == 'fas':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer']:
            assert tokens == ['فارسی', 'یا', 'پارسی', 'یکی', 'از', 'زبان\u200cهای', 'هندواروپایی', 'در', 'شاخهٔ', 'زبان\u200cهای', 'ایرانی', 'جنوب', 'غربی', 'است', 'که', 'در', 'کشورهای', 'ایران،', 'افغانستان،', '[', '۳', ']', 'تاجیکستان', '[', '۴', ']', 'و', 'ازبکستان', '[', '۵', ']', 'به', 'آن', 'سخن', 'می\u200cگویند', '.']
        elif word_tokenizer == 'NLTK - Tok-tok Tokenizer':
            assert tokens == ['فارسی', 'یا', 'پارسی', 'یکی', 'از', 'زبان\u200cهای', 'هندواروپایی', 'در', 'شاخهٔ', 'زبان\u200cهای', 'ایرانی', 'جنوب', 'غربی', 'است', 'که', 'در', 'کشورهای', 'ایران', '،', 'افغانستان', '،', '[', '۳', ']', 'تاجیکستان[', '۴', ']', 'و', 'ازبکستان[', '۵', ']', 'به', 'آن', 'سخن', 'می\u200cگویند', '.']
        elif word_tokenizer == 'NLTK - Twitter Tokenizer':
            assert tokens == ['فارسی', 'یا', 'پارسی', 'یکی', 'از', 'زبان\u200cهای', 'هندواروپایی', 'در', 'شاخهٔ', 'زبان\u200cهای', 'ایرانی', 'جنوب', 'غربی', 'است', 'که', 'در', 'کشورهای', 'ایران', '،', 'افغانستان', '،', '[', '۳', ']', 'تاجیکستان', '[', '۴', ']', 'و', 'ازبکستان', '[', '۵', ']', 'به', 'آن', 'سخن', 'می\u200cگویند', '.']
        elif word_tokenizer == 'spaCy - Persian Word Tokenizer':
            assert tokens == ['فارسی', 'یا', 'پارسی', 'یکی', 'از', 'زبان\u200cهای', 'هندواروپایی', 'در', 'شاخهٔ', 'زبان\u200cهای', 'ایرانی', 'جنوب', 'غربی', 'است', 'که', 'در', 'کشورهای', 'ایران', '،', 'افغانستان،[۳', ']', 'تاجیکستان[۴', ']', 'و', 'ازبکستان[۵', ']', 'به', 'آن', 'سخن', 'می\u200cگویند', '.']
    elif lang == 'pol':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer',
                              'NLTK - Twitter Tokenizer',
                              'spaCy - Polish Word Tokenizer']:
            assert tokens == ['Język', 'polski', ',', 'polszczyzna', ',', 'skrót', ':', 'pol', '.', '–', 'język', 'naturalny', 'należący', 'do', 'grupy', 'języków', 'zachodniosłowiańskich', '(', 'do', 'której', 'należą', 'również', 'czeski', ',', 'słowacki', ',', 'kaszubski', ',', 'dolnołużycki', ',', 'górnołużycki', 'i', 'wymarły', 'połabski', ')', ',', 'stanowiącej', 'część', 'rodziny', 'języków', 'indoeuropejskich', '.']
        elif word_tokenizer == 'Sacremoses - Moses Tokenizer':
            assert tokens == ['Język', 'polski', ',', 'polszczyzna', ',', 'skrót', ':', 'pol.', '–', 'język', 'naturalny', 'należący', 'do', 'grupy', 'języków', 'zachodniosłowiańskich', '(', 'do', 'której', 'należą', 'również', 'czeski', ',', 'słowacki', ',', 'kaszubski', ',', 'dolnołużycki', ',', 'górnołużycki', 'i', 'wymarły', 'połabski', ')', ',', 'stanowiącej', 'część', 'rodziny', 'języków', 'indoeuropejskich', '.']
    elif lang == 'por':
        assert tokens == ['A', 'língua', 'portuguesa', ',', 'também', 'designada', 'português', ',', 'é', 'uma', 'língua', 'românica', 'flexiva', 'ocidental', 'originada', 'no', 'galego-português', 'falado', 'no', 'Reino', 'da', 'Galiza', 'e', 'no', 'norte', 'de', 'Portugal', '.']
    elif lang == 'ron':
        assert tokens == ['Limba', 'română', 'este', 'o', 'limbă', 'indo-europeană', ',', 'din', 'grupul', 'italic', 'și', 'din', 'subgrupul', 'oriental', 'al', 'limbilor', 'romanice', '.']
    elif lang == 'rus':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer',
                              'NLTK - Tok-tok Tokenizer',
                              'NLTK - Twitter Tokenizer',
                              'razdel - Russian Word Tokenizer']:
            assert tokens == ['Ру́сский', 'язы́к', '(', '[', 'ˈruskʲɪi̯', 'jɪˈzɨk', ']', 'Информация', 'о', 'файле', 'слушать', ')', '[', '~', '3', ']', '[', '⇨', ']', '—', 'один', 'из', 'восточнославянских', 'языков', ',', 'национальный', 'язык', 'русского', 'народа', '.']
        elif word_tokenizer == 'Sacremoses - Moses Tokenizer':
            assert tokens == ['Ру', '́', 'сский', 'язы', '́', 'к', '(', '[', 'ˈruskʲɪi', '̯', 'jɪˈzɨk', ']', 'Информация', 'о', 'файле', 'слушать', ')', '[', '~', '3', ']', '[', '⇨', ']', '—', 'один', 'из', 'восточнославянских', 'языков', ',', 'национальный', 'язык', 'русского', 'народа', '.']
        elif word_tokenizer == 'spaCy - Russian Word Tokenizer':
            assert tokens == ['Ру́сский', 'язы́к', '(', '[', 'ˈruskʲɪi̯', 'jɪˈzɨk', ']', 'Информация', 'о', 'файле', 'слушать)[~', '3', ']', '[', '⇨', ']', '—', 'один', 'из', 'восточнославянских', 'языков', ',', 'национальный', 'язык', 'русского', 'народа', '.']
    elif lang == 'srp_cyrl':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer',
                              'NLTK - Twitter Tokenizer']:
            assert tokens == ['Српски', 'језик', 'припада', 'словенској', 'групи', 'језика', 'породице', 'индоевропских', 'језика', '.', '[', '12', ']']
        elif word_tokenizer == 'spaCy - Serbian Word Tokenizer':
            assert tokens == ['Српски', 'језик', 'припада', 'словенској', 'групи', 'језика', 'породице', 'индоевропских', 'језика.[12', ']']
    elif lang == 'srp_latn':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer',
                              'NLTK - Twitter Tokenizer']:
            assert tokens == ['Srpski', 'jezik', 'pripada', 'slovenskoj', 'grupi', 'jezika', 'porodice', 'indoevropskih', 'jezika', '.', '[', '12', ']']
        elif word_tokenizer == 'spaCy - Serbian Word Tokenizer':
            assert tokens == ['Srpski', 'jezik', 'pripada', 'slovenskoj', 'grupi', 'jezika', 'porodice', 'indoevropskih', 'jezika.[12', ']']
    elif lang == 'sin':
        assert tokens == ['ශ්\u200dරී', 'ලංකාවේ', 'ප්\u200dරධාන', 'ජාතිය', 'වන', 'සිංහල', 'ජනයාගේ', 'මව්', 'බස', 'සිංහල', 'වෙයි', '.']
    elif lang == 'slk':
        assert tokens == ['Slovenčina', 'patrí', 'do', 'skupiny', 'západoslovanských', 'jazykov', '(', 'spolu', 's', 'češtinou', ',', 'poľštinou', ',', 'hornou', 'a', 'dolnou', 'lužickou', 'srbčinou', 'a', 'kašubčinou', ')', '.']
    elif lang == 'slv':
        assert tokens == ['Slovenščina', '[', 'slovénščina', ']', '/', '[', 'sloˈʋenʃtʃina', ']', 'je', 'združeni', 'naziv', 'za', 'uradni', 'knjižni', 'jezik', 'Slovencev', 'in', 'skupno', 'ime', 'za', 'narečja', 'in', 'govore', ',', 'ki', 'jih', 'govorijo', 'ali', 'so', 'jih', 'nekoč', 'govorili', 'Slovenci', '.']
    elif lang == 'spa':
        assert tokens == ['El', 'español', 'o', 'castellano', 'es', 'una', 'lengua', 'romance', 'procedente', 'del', 'latín', 'hablado', '.']
    elif lang == 'swe':
        assert tokens == ['Svenska', '(', 'svenska', '(', 'info', ')', ')', 'är', 'ett', 'östnordiskt', 'språk', 'som', 'talas', 'av', 'ungefär', 'tio', 'miljoner', 'personer', 'främst', 'i', 'Sverige', 'där', 'språket', 'har', 'en', 'dominant', 'ställning', 'som', 'huvudspråk', ',', 'men', 'även', 'som', 'det', 'ena', 'nationalspråket', 'i', 'Finland', 'och', 'som', 'enda', 'officiella', 'språk', 'på', 'Åland', '.']
    elif lang == 'tgl':
        assert tokens == ['Ang', 'Wikang', 'Tagalog[2', ']', '(', 'Baybayin', ':', 'ᜏᜒᜃᜅ᜔', 'ᜆᜄᜎᜓᜄ᜔', ')', ',', 'na', 'kilala', 'rin', 'sa', 'payak', 'na', 'pangalang', 'Tagalog', ',', 'ay', 'isa', 'sa', 'mga', 'pangunahing', 'wika', 'ng', 'Pilipinas', 'at', 'sinasabing', 'ito', 'ang', 'de', 'facto', '(', '"', 'sa', 'katunayan', '"', ')', 'ngunit', 'hindî', 'de', 'jure', '(', '"', 'sa', 'batas', '"', ')', 'na', 'batayan', 'na', 'siyang', 'pambansang', 'Wikang', 'Filipino', '(', 'mula', '1961', 'hanggang', '1987', ':', 'Pilipino).[2', ']']
    elif lang == 'tgk':
        assert tokens == ['Забони', 'тоҷикӣ', '—', 'забоне', ',', 'ки', 'дар', 'Эрон', ':', 'форсӣ', ',', 'ва', 'дар', 'Афғонистон', 'дарӣ', 'номида', 'мешавад', ',', 'забони', 'давлатии', 'кишварҳои', 'Тоҷикистон', ',', 'Эрон', 'ва', 'Афғонистон', 'мебошад', '.']
    elif lang == 'tam':
        if word_tokenizer == 'Sacremoses - Moses Tokenizer':
            assert tokens == ['தமிழ', '்', 'மொழி', '(', 'Tamil', 'language', ')', 'தமிழர', '்', 'களினதும', '்', ',', 'தமிழ', '்', 'பேசும', '்', 'பலரதும', '்', 'தாய', '்', 'மொழி', 'ஆகும', '்', '.']
        elif word_tokenizer == 'spaCy - Tamil Word Tokenizer':
            assert tokens == ['தமிழ்', 'மொழி', '(', 'Tamil', 'language', ')', 'தமிழர்களினதும்', ',', 'தமிழ்', 'பேசும்', 'பலரதும்', 'தாய்மொழி', 'ஆகும்', '.']
    elif lang == 'tat':
        assert tokens == ['Татар', 'теле', '—', 'татарларның', 'милли', 'теле', ',', 'Татарстанның', 'дәүләт', 'теле', ',', 'таралышы', 'буенча', 'Русиядә', 'икенче', 'тел', '.']
    elif lang == 'tel':
        tokens == ['ఆంధ్ర', 'ప్రదేశ్', ',', 'తెలంగాణ', 'రాష్ట్రాల', 'అధికార', 'భాష', 'తెలుగు', '.']
    elif lang == 'tha':
        if word_tokenizer == ('AttaCut - Thai Word Tokenizer'):
            assert tokens == ['ภาษา', 'ไทย', 'หรือ', 'ภาษา', 'ไทย', 'กลาง', 'เป็น', 'ภาษา', 'ราชการ', 'และ', 'ภาษา', 'ประจำ', 'ชาติ', 'ของ', 'ประเทศไทย']
        elif word_tokenizer in ['PyThaiNLP - Longest Matching',
                                'PyThaiNLP - Maximum Matching + TCC',
                                'PyThaiNLP - Maximum Matching + TCC (Safe Mode)']:
            assert tokens == ['ภาษาไทย', 'หรือ', 'ภาษาไทย', 'กลาง', 'เป็น', 'ภาษาราชการ', 'และ', 'ภาษาประจำชาติ', 'ของ', 'ประเทศ', 'ไทย']
        elif word_tokenizer == 'PyThaiNLP - Maximum Matching':
            assert tokens == ['ภาษาไทย', 'หรือ', 'ภาษาไทยกลาง', 'เป็น', 'ภาษาราชการ', 'และ', 'ภาษาประจำชาติ', 'ของ', 'ประเทศ', 'ไทย']
    elif lang == 'bod':
        assert tokens == ['བོད་', 'ཀྱི་', 'སྐད་ཡིག་', 'ནི་', 'བོད་ཡུལ་', 'དང་', 'དེ', 'འི་', 'ཉེ་འཁོར་', 'གྱི་', 'ས་ཁུལ་', 'ཏེ', '།']
    elif lang == 'tur':
        assert tokens == ['Türkçe', 'ya', 'da', 'Türk', 'dili', ',', 'batıda', 'Balkanlar’dan', 'başlayıp', 'doğuda', 'Hazar', 'Denizi', 'sahasına', 'kadar', 'konuşulan', 'Türkî', 'diller', 'dil', 'ailesine', 'ait', 'sondan', 'eklemeli', 'bir', 'dil.[12', ']']
    elif lang == 'ukr':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer',
                              'NLTK - Twitter Tokenizer']:
            assert tokens == ['Украї́нська', 'мо́ва', '(', 'МФА', ':', '[', 'ukrɑ̽ˈjɪnʲsʲkɑ̽', 'ˈmɔwɑ̽', ']', ',', 'історичні', 'назви', '—', 'ру́ська', ',', 'руси́нська', '[', '9', ']', '[', '10', ']', '[', '11', ']', '[', '*', '2', ']', ')', '—', 'національна', 'мова', 'українців', '.']
        elif word_tokenizer == 'spaCy - Ukrainian Word Tokenizer':
            assert tokens == ['Украї́нська', 'мо́ва', '(', 'МФА', ':', '[', 'ukrɑ̽ˈjɪnʲsʲkɑ̽', 'ˈmɔwɑ̽', ']', ',', 'історичні', 'назви', '—', 'ру́ська', ',', 'руси́нська[9][10][11', ']', '[', '*', '2', ']', ')', '—', 'національна', 'мова', 'українців', '.']
    elif lang == 'urd':
        if word_tokenizer in ['NLTK - NIST Tokenizer',
                              'NLTK - NLTK Tokenizer',
                              'NLTK - Penn Treebank Tokenizer']:
            assert tokens == ['اُردُو', 'لشکری', 'زبان', '[', '8', ']', '(', 'یا', 'جدید', 'معیاری', 'اردو', ')', 'برصغیر', 'کی', 'معیاری', 'زبانوں', 'میں', 'سے', 'ایک', 'ہے۔']
        elif word_tokenizer == 'NLTK - Twitter Tokenizer':
            assert tokens == ['اُردُو', 'لشکری', 'زبان', '[8', ']', '(', 'یا', 'جدید', 'معیاری', 'اردو', ')', 'برصغیر', 'کی', 'معیاری', 'زبانوں', 'میں', 'سے', 'ایک', 'ہے', '۔']
        elif word_tokenizer == 'spaCy - Ukrainian Word Tokenizer':
            assert tokens == ['اُردُو', 'لشکری', 'زبان[8', ']', '(', 'یا', 'جدید', 'معیاری', 'اردو', ')', 'برصغیر', 'کی', 'معیاری', 'زبانوں', 'میں', 'سے', 'ایک', 'ہے', '۔']
    elif lang == 'vie':
        if word_tokenizer == 'NLTK - Tok-tok Tokenizer':
            assert tokens == ['Tiếng', 'Việt', ',', 'còn', 'gọi', 'tiếng', 'Việt', 'Nam[', '5', ']', ',', 'tiếng', 'Kinh', 'hay', 'Việt', 'ngữ', ',', 'là', 'ngôn', 'ngữ', 'của', 'người', 'Việt', '(', 'dân', 'tộc', 'Kinh', ')', 'và', 'là', 'ngôn', 'ngữ', 'chính', 'thức', 'tại', 'Việt', 'Nam', '.']
        elif word_tokenizer == 'Underthesea - Vietnamese Word Tokenizer':
            assert tokens == ['Tiếng', 'Việt', ',', 'còn', 'gọi', 'tiếng', 'Việt Nam', '[', '5', ']', ',', 'tiếng Kinh', 'hay', 'Việt ngữ', ',', 'là', 'ngôn ngữ', 'của', 'người', 'Việt', '(', 'dân tộc', 'Kinh', ')', 'và', 'là', 'ngôn ngữ', 'chính thức', 'tại', 'Việt Nam', '.']
    elif lang == 'yor':
        assert tokens == ['Èdè', 'Yorùbá', 'Ni', 'èdè', 'tí', 'ó', 'ṣàkójọ', 'pọ̀', 'gbogbo', 'kú', 'oótu', 'o', '-', 'ò', '-', 'jíire', 'bí', ',', 'níapá', 'ìwọ̀', 'Oòrùn', 'ilẹ̀', 'Nàìjíríà', ',', 'tí', 'a', 'bá', 'wo', 'èdè', 'Yorùbá', ',', 'àwọn', 'onímọ̀', 'pín', 'èdè', 'náà', 'sábẹ́', 'ẹ̀yà', 'Kwa', 'nínú', 'ẹbí', 'èdè', 'Niger', '-', 'Congo', '.']
Example #26
0
def test_to_lang_text():
    for lang_code in TO_LANG_TEXT.keys():
        lang_text = wl_conversion.to_lang_text(main, lang_code)

        assert lang_text == TO_LANG_TEXT[lang_code]
Example #27
0
def test_lemmatize(lang, lemmatizer, show_results = False):
    lang_text = wl_conversion.to_lang_text(main, lang)

    tokens = wl_word_tokenization.wl_word_tokenize(
        main,
        text = getattr(wl_test_lang_examples, f'SENTENCE_{lang.upper()}'),
        lang = lang
    )
    
    lemmas = wl_lemmatization.wl_lemmatize(
        main,
        tokens = tokens,
        lang = lang,
        lemmatizer = lemmatizer
    )

    if show_results:
        print(f'{lang} / {lemmatizer}:')
        print(lemmas)

    if lang == 'ast':
        assert lemmas == ["L'asturianu", 'ser', 'unu', 'llingua', 'romance', 'propiu', "d'Asturies,[1", ']', 'perteneciente', 'al', 'subgrupu', 'asturllionés', '.']
    elif lang == 'bul':
        assert lemmas == ['Бъ̀лгарският', 'езѝк', 'съм', 'индоевропейски', 'език', 'от', 'група', 'на', 'южнославянските', 'език', '.']
    elif lang == 'cat':
        assert lemmas == ['El', 'català', '(', 'denominació', 'oficial', 'a', 'Catalunya', ',', 'a', 'ell', 'Illes', 'Balears', ',', 'a', 'Andorra', ',', 'a', 'ell', 'ciutat', 'de', 'ell', 'Alguer', 'i', 'tradicional', 'a', 'Catalunya', 'Nord', ')', 'o', 'valencià', '(', 'denominació', 'oficial', 'al', 'País', 'Valencià', 'i', 'tradicional', 'al', 'Carxe', ')', 'ser', 'un', 'llengua', 'romànic', 'parlar', 'a', 'Catalunya', ',', 'ell', 'País', 'Valencià', '(', 'treure', 'de', 'algun', 'comarca', 'i', 'localitat', 'de', 'ell', 'interior', ')', ',', 'ell', 'Illes', 'Balears', ',', 'Andorra', ',', 'ell', 'Franja', 'de', 'Ponent', '(', 'a', 'ell', 'Aragó', ')', ',', 'ell', 'ciutat', 'de', 'ell', 'Alguer', '(', 'a', 'ell', 'illa', 'de', 'Sardenya', ')', ',', 'ell', 'Catalunya', 'del', 'Nord,[8', ']', 'ell', 'Carxe', '(', 'un', 'petit', 'territori', 'de', 'Múrcia', 'poblar', 'per', 'immigrar', 'valencians),[9][10', ']', 'i', 'en', 'petita', 'comunitat', 'arreu', 'del', 'món', '(', 'entrar', 'ell', 'qual', 'destacar', 'ell', 'de', 'ell', 'Argentina', ',', 'amb', '195.000', 'parlants).[11', ']']
    elif lang == 'ces':
        assert lemmas == ['Čeština', 'neboli', 'český', 'jazyk', 'on', 'západoslovanský', 'jazyk', ',', 'blízký', 'slovenštině', ',', 'poté', 'lužické', 'srbštině', 'a', 'polštině', '.']
    elif lang == 'nld':
        assert lemmas == ['het', 'nederlands', 'zijn', 'een', 'west-germaans', 'taal', 'en', 'de', 'moedertaal', 'van', 'de', 'veel', 'inwoner', 'van', 'nederland', ',', 'belgië', 'en', 'suriname', '.']
    elif lang == 'eng':
        if lemmatizer == 'Lemmatization Lists - English Lemma List':
            assert lemmas == ['English', 'be', 'a', 'West', 'Germanic', 'language', 'that', 'be', '1', 'speak', 'in', 'early', 'medieval', 'England', 'and', 'eventually', 'become', 'a', 'global', 'lingua', 'franca.[4][5', ']']
        elif lemmatizer == 'NLTK - WordNet Lemmatizer':
            assert lemmas == ['English', 'be', 'a', 'West', 'Germanic', 'language', 'that', 'be', 'first', 'speak', 'in', 'early', 'medieval', 'England', 'and', 'eventually', 'become', 'a', 'global', 'lingua', 'franca.[4][5', ']']
        elif lemmatizer == 'spaCy - English Lemmatizer':
            assert lemmas == ['English', 'be', 'a', 'West', 'germanic', 'language', 'that', 'be', 'first', 'speak', 'in', 'early', 'medieval', 'England', 'and', 'eventually', 'become', 'a', 'global', 'lingua', 'franca.[4][5', ']']
    elif lang == 'est':
        assert lemmas == ['Eesti', 'kee', '(', 'varasem', 'nimetu', ':', 'maakeel', ')', 'olema', 'läänemeresoome', 'lõunarühma', 'kuuluma', 'kee', '.']
    elif lang == 'fra':
        if lemmatizer == 'Lemmatization Lists - French Lemma List':
            assert lemmas == ['Le', 'français', 'être', 'un', 'langue', 'indo-européen', 'de', 'le', 'famille', 'un', 'langue', 'roman', '.']
        elif lemmatizer == 'spaCy - French Lemmatizer':
            assert lemmas == ['le', 'français', 'être', 'un', 'langue', 'indo-européen', 'de', 'le', 'famille', 'un', 'langue', 'roman', '.']
    elif lang == 'glg':
        assert lemmas == ['O', 'galego', '(', '[', 'ɡaˈleɣo̝', ']', ')', 'ser', 'un', 'lingua', 'indoeuropeo', 'que', 'pertencer', 'á', 'póla', 'de', 'lingua', 'románico', '.']
    elif lang == 'deu':
        if lemmatizer == 'Lemmatization Lists - German Lemma List':
            assert lemmas == ['Die', 'deutsch', 'Sprache', 'bzw.', 'Deutsch', '(', '[', 'dɔʏ̯t͡ʃ', ']', ';', 'abkürzen', 'dt', '.', 'oder', 'dtsch', '.', ')', 'sein', 'einen', 'westgermanische', 'Sprache', '.']
        elif lemmatizer == 'spaCy - German Lemmatizer':
            assert lemmas == ['der', 'deutsch', 'Sprache', 'bzw.', 'Deutsch', '(', '[', 'dɔʏ̯t͡ʃ', ']', ';', 'abkürzen', 'dt', '.', 'oder', 'dtsch', '.', ')', 'sein', 'einen', 'westgermanische', 'Sprache', '.']
    elif lang == 'grc':
        assert lemmas == ['Με', 'τον', 'όρο', 'αρχαία', 'ελληνική', 'γλώσσα', 'εννοείται', 'μια', 'μορφή', 'της', 'ελληνικής', 'γλώσσας', ',', 'πού', 'ομιλούνταν', 'κατά', 'τους', 'αρχαϊκούς', 'χρόνους', 'και', 'την', 'κλασική', 'αρχαιότητα', '.']
    elif lang == 'ell':
        assert lemmas == ['η', 'ελληνικός', 'γλώσσα', 'ανήκω', 'στην', 'ινδοευρωπαϊκός', 'οικογένεια[9', ']', 'και', 'συγκεκριμένα', 'στον', 'ελληνικό', 'κλάδο', ',', 'μαζί', 'με', 'την', 'τσακωνικός', ',', 'ενώ', 'είναι', 'η', 'επίσημη', 'γλώσσα', 'της', 'Ελλάδος', 'και', 'της', 'Κύπρου', '.']
    elif lang == 'hun':
        assert lemmas == ['A', 'magyar', 'nyelv', 'az', 'uráli', 'nyelvcsalád', 'tag', ',', 'a', 'finnugor', 'nyelv', 'köz', 'tartozó', 'ugor', 'nyelv', 'egyik', '.']
    elif lang == 'gle':
        assert lemmas == ['Is', 'ceann', 'de', 'na', 'teangach', 'Ceilteacha', 'í', 'an', 'Ghaeilge', '(', 'nó', 'Gaeilge', 'na', 'hÉireann', 'mar', 'a', 'tabhair', 'ar', 'corruair', ')', ',', 'agus', 'ceann', 'den', 'trí', 'ceann', 'de', 'teangach', 'Ceilteacha', 'air', 'a', 'tabhair', 'na', 'teangach', 'Gaelacha', '(', '.i.', 'an', 'Ghaeilge', ',', 'Gaeilge', 'na', 'hAlban', 'agus', 'Gaeilge', 'Mhanann', ')', 'go', 'áirithe', '.']
    elif lang == 'ita':
        assert lemmas == ["L'", 'italiano', '(', '[', 'itaˈljaːno][Nota', '1', ']', 'ascolta[?·info', ']', ')', 'essere', 'una', 'lingua', 'romanzo', 'parlato', 'principalmente', 'in', 'Italia', '.']
    elif lang == 'lit':
        assert lemmas == ['lietuvė', 'kalbėti', '–', 'ižti', 'baltas', 'prokalbės', 'kilęs', 'lietuvė', 'tauta', 'kalbėti', ',', '-PRON-', 'Lietuvoje', 'būti', 'valstybinis', ',', 'o', 'Europos', 'sąjunga', '–', 'viena', 'ižti', 'oficialus', 'kalbus', '.']
    elif lang == 'glv':
        assert lemmas == ['She', 'Gaelg', '(', 'graït', ':', '/gɪlg/', ')', 'çhengey', 'Gaelagh', 'Mannin', '.']
    elif lang == 'nob':
        assert lemmas == ['bokmål', 'være', 'en', 'varietet', 'av', 'norsk', 'språk', '.']
    elif lang == 'fas':
        assert lemmas == ['فارسی', 'یا', 'پارسی', 'یکی', 'از', 'زبان\u200cهای', 'هندواروپایی', 'در', 'شاخهٔ', 'زبان\u200cهای', 'ایرانی', 'جنوب', 'غربی', 'است', 'که', 'در', 'کشورهای', 'ایران', '،', 'افغانستان،[۳', ']', 'تاجیکستان[۴', ']', 'را', 'ازبکستان[۵', ']', 'به', 'آن', 'سخن', 'می\u200cگویند', '.']
    elif lang == 'por':
        assert lemmas == ['A', 'língua', 'portuguesar', ',', 'também', 'designar', 'português', ',', 'ser', 'umar', 'língua', 'românico', 'flexivo', 'ocidental', 'originar', 'o', 'galego-português', 'falar', 'o', 'Reino', 'da', 'Galiza', 'e', 'o', 'norte', 'de', 'Portugal', '.']
    elif lang == 'ron':
        assert lemmas == ['Limba', 'român', 'fi', 'vrea', 'limbă', 'indo', '-', 'european', ',', 'din', 'grup', 'italic', 'și', 'din', 'subgrupul', 'oriental', 'al', 'limbă', 'romanice', '.']
    elif lang == 'rus':
        assert lemmas == ['ру́сский', 'язы́к', '(', '[', 'ˈruskʲɪi̯', 'jɪˈzɨk', ']', 'информация', 'о', 'файл', 'слушать', ')', '[', '~', '3', ']', '[', '⇨', ']', '—', 'один', 'из', 'восточнославянский', 'язык', ',', 'национальный', 'язык', 'русский', 'народ', '.']
    elif lang == 'gla':
        assert lemmas == ["'S", 'i', 'cànan', 'dùthchasach', 'na', 'h', '-', 'Alba', 'a', 'th', "'", 'anns', 'a', "'", 'Ghàidhlig', '.']
    elif lang == 'slk':
        assert lemmas == ['Slovenčina', 'patriť', 'do', 'skupina', 'západoslovanský', 'jazyk', '(', 'spolu', 's', 'čeština', ',', 'poľština', ',', 'horný', 'as', 'dolný', 'lužickou', 'srbčina', 'as', 'kašubčinou', ')', '.']
    elif lang == 'slv':
        assert lemmas == ['Slovenščina', '[', 'slovénščina', ']', '/', '[', 'sloˈʋenʃtʃina', ']', 'onbiti', 'združen', 'naziv', 'za', 'uraden', 'knjižen', 'jezik', 'Slovenec', 'in', 'skupen', 'ime', 'za', 'narečje', 'in', 'govoriti', ',', 'ki', 'on', 'govoriti', 'ali', 'biti', 'on', 'nekoč', 'govoriti', 'Slovenec', '.']
    elif lang == 'spa':
        assert lemmas == ['El', 'español', 'o', 'castellano', 'ser', 'uno', 'lengua', 'romance', 'procedente', 'del', 'latín', 'hablar', '.']
    elif lang == 'swe':
        assert lemmas == ['Svenska', '(', 'svensk', '(', 'info', ')', ')', 'vara', 'en', 'östnordiskt', 'språka', 'som', 'tala', 'av', 'ungefär', 'tio', 'miljon', 'person', 'främst', 'i', 'Sverige', 'där', 'språk', 'hare', 'man', 'dominant', 'ställning', 'som', 'huvudspråk', ',', 'mena', 'även', 'som', 'en', 'en', 'nationalspråk', 'i', 'Finland', 'och', 'som', 'enda', 'officiell', 'språka', 'på', 'Åland', '.']
    elif lang == 'bod':
        assert lemmas == ['བོད་', 'ཀྱི་', 'སྐད་ཡིག་', 'ནི་', 'བོད་ཡུལ་', 'དང་', 'དེ་', 'གི་', 'ཉེ་འཁོར་', 'གྱི་', 'ས་ཁུལ་', 'ཏེ་', ' །']
    elif lang == 'ukr':
        if lemmatizer == 'Lemmatization Lists - Ukrainian Lemma List':
            assert lemmas == ['Украї́нська', 'мо́ва', '(', 'МФА', ':', '[', 'ukrɑ̽ˈjɪnʲsʲkɑ̽', 'ˈmɔwɑ̽', ']', ',', 'історичний', 'назвати', '—', 'ру́ська', ',', 'руси́нська[9][10][11', ']', '[', '*', '2', ']', ')', '—', 'національний', 'мова', 'українець', '.']
        elif lemmatizer == 'pymorphy2 - Morphological Analyzer':
            assert lemmas == ['украї́нський', 'мо́вий', '(', 'мфа', ':', '[', 'ukrɑ̽ˈjɪnʲsʲkɑ̽', 'ˈmɔwɑ̽', ']', ',', 'історичний', 'назва', '—', 'ру́ський', ',', 'руси́нська[9][10][11', ']', '[', '*', '2', ']', ')', '—', 'національний', 'мова', 'українець', '.']
    elif lang == 'cym':
        assert lemmas == ['Aelod', "o'r", 'cangen', 'Frythonaidd', "o'r", 'iaith', 'Celtaidd', 'a', 'siarad', 'bod', 'brodorol', 'yn', 'Nghymru', ',', 'can', 'Gymry', 'a', 'pobl', 'arall', 'aredig', 'gwasgar', 'bod', 'Lloegr', ',', 'a', 'can', 'cymuno', 'bechan', 'bod', 'Y', 'Wladfa', ',', 'gwybod', 'Ariannin[7', ']', "yw'r", 'Gymraeg', '(', 'hefyd', 'Cymraeg', 'heb', 'yr', 'bannod', ')', '.']
Example #28
0
def test_lemmatize(lang, lemmatizer):
    lang_text = wl_conversion.to_lang_text(main, lang)

    print(f'{lang_text} ({lang}) / {lemmatizer}:')

    # Untokenized
    lemmas = wl_lemmatization.wl_lemmatize(
        main,
        inputs = getattr(wl_test_lang_examples, f'SENTENCE_{lang.upper()}'),
        lang = lang,
        lemmatizer = lemmatizer
    )

    # Tokenized
    tokens = wl_word_tokenization.wl_word_tokenize_flat(
        main,
        text = getattr(wl_test_lang_examples, f'SENTENCE_{lang.upper()}'),
        lang = lang
    )
    lemmas_tokenized = wl_lemmatization.wl_lemmatize(
        main,
        inputs = tokens,
        lang = lang,
        lemmatizer = lemmatizer
    )

    lemmas_long_text = wl_lemmatization.wl_lemmatize(
        main,
        inputs = ''.join([f'{i}\n' for i in range(101)]),
        lang = lang,
        lemmatizer = lemmatizer
    )
    lemmas_long_text_tokenized = wl_lemmatization.wl_lemmatize(
        main,
        inputs = [str(i) for i in range(101) for j in range(50)],
        lang = lang,
        lemmatizer = lemmatizer
    )

    print(lemmas)

    # Check for missing lemmas
    assert all(lemmas)
    assert all(lemmas_tokenized)

    # Tokenization should not be modified
    assert len(tokens) == len(lemmas_tokenized)

    # Test long texts
    if lemmatizer == 'botok_bod':
        assert lemmas_long_text == ['\n'.join([str(i) for i in range(100)]), '100']
    else:
        assert lemmas_long_text == [str(i) for i in range(101)]
    assert lemmas_long_text_tokenized == [str(i) for i in range(101) for j in range(50)]

    if lang == 'ast':
        assert lemmas == ["L'asturianu", 'ser', 'unu', 'llingua', 'romance', 'propiu', "d'Asturies,[1", ']', 'perteneciente', 'al', 'subgrupu', 'asturllionés', '.']
    elif lang == 'ben':
        assert lemmas == ['বাংলা', 'ভাষা', '(', 'বাঙলা', ',', 'বাঙ্গলা', ',', 'তথা', 'বাঙ্গালা', 'নামগুলোতেও', 'পরিচিত', ')', 'একটি', 'ইন্দো', '-', 'আর্য', 'ভাষা', ',', 'যা', 'দক্ষিণ', 'এশিয়ার', 'বাঙালি', 'জাতির', 'প্রধান', 'কথ্য', 'ও', 'লেখ্য', 'ভাষা', '।']
    elif lang == 'bul':
        assert lemmas == ['Бъ̀лгарският', 'езѝк', 'съм', 'индоевропейски', 'език', 'от', 'група', 'на', 'южнославянските', 'език', '.']
    elif lang == 'cat':
        if lemmatizer == 'lemmatization_lists_cat':
            assert lemmas == ['El', 'català', '(', 'denominació', 'oficial', 'a', 'Catalunya', ',', 'a', 'ell', 'Illes', 'Balears', ',', 'a', 'Andorra', ',', 'a', 'ell', 'ciutat', 'de', "l'Alguer", 'i', 'tradicional', 'a', 'Catalunya', 'Nord', ')', 'o', 'valencià', '(', 'denominació', 'oficial', 'al', 'País', 'Valencià', 'i', 'tradicional', 'al', 'Carxe', ')', 'ser', 'un', 'llengua', 'romànic', 'parlar', 'a', 'Catalunya', ',', 'ell', 'País', 'Valencià', '(', 'treure', "d'algunes", 'comarca', 'i', 'localitat', 'de', "l'interior", ')', ',', 'ell', 'Illes', 'Balears', ',', 'Andorra', ',', 'ell', 'Franja', 'de', 'Ponent', '(', 'a', "l'Aragó", ')', ',', 'ell', 'ciutat', 'de', "l'Alguer", '(', 'a', "l'illa", 'de', 'Sardenya', ')', ',', 'ell', 'Catalunya', 'del', 'Nord,[8', ']', 'ell', 'Carxe', '(', 'un', 'petit', 'territori', 'de', 'Múrcia', 'poblar', 'per', 'immigrar', 'valencians),[9][10', ']', 'i', 'en', 'comunitat', 'arreu', 'del', 'món', '(', 'entrar', 'ell', 'qual', 'destacar', 'ell', 'de', "l'Argentina", ',', 'amb', '198.000', 'parlants).[11', ']']
        elif lemmatizer == 'spacy_cat':
            assert lemmas == ['el', 'català', '(', 'denominació', 'oficial', 'a', 'Catalunya', ',', 'a', 'el', 'Illes', 'Balears', ',', 'a', 'Andorra', ',', 'a', 'el', 'ciutat', 'de', 'el', 'Alguer', 'i', 'tradicional', 'a', 'Catalunya', 'Nord', ')', 'o', 'valencià', '(', 'denominació', 'oficial', 'a', 'el', 'País', 'Valencià', 'i', 'tradicional', 'a', 'el', 'Carxe', ')', 'ser', 'un', 'llengua', 'romànic', 'parlat', 'a', 'Catalunya', ',', 'el', 'País', 'Valencià', '(', 'tret', 'de', 'algun', 'comarca', 'i', 'localitat', 'de', 'el', 'interior', ')', ',', 'el', 'Illes', 'Balears', ',', 'Andorra', ',', 'el', 'Franja', 'de', 'Ponent', '(', 'a', 'el', 'Aragó', ')', ',', 'el', 'ciutat', 'de', 'el', 'Alguer', '(', 'a', 'el', 'illa', 'de', 'Sardenya', ')', ',', 'el', 'Catalunya', 'de', 'el', 'Nord,[8', ']', 'el', 'Carxe', '(', 'un', 'petit', 'territori', 'de', 'Múrcia', 'poblat', 'per', 'immigrat', 'valencians),[9][10', ']', 'i', 'en', 'comunitat', 'arreu', 'de', 'el', 'món', '(', 'entre', 'el', 'qual', 'destacar', 'el', 'de', 'el', 'Argentina', ',', 'amb', '198.000', 'parlants).[11', ']']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'hrv':
        assert lemmas == ['Hrvatski', 'jezik', '(', 'ISO', '639', '-', '3', ':', 'hrv', ')', 'skupni', 'biti', 'naziv', 'za', 'nacionalan', 'standardan', 'jezik', 'Hrvata', ',', 'te', 'za', 'skup', 'narječje', 'i', 'govor', 'koji', 'govoriti', 'ili', 'biti', 'nekada', 'govoriti', 'Hrvati', '.']
    elif lang == 'ces':
        assert lemmas == ['Čeština', 'neboli', 'český', 'jazyk', 'on', 'západoslovanský', 'jazyk', ',', 'blízký', 'slovenštině', ',', 'poté', 'lužické', 'srbštině', 'a', 'polštině', '.']
    elif lang == 'dan':
        assert lemmas == ['Dansk', 'være', 'en', 'nordgermansk', 'sprog', 'af', 'den', 'østnordiske', '(', 'kontinental', ')', 'gruppe', ',', 'der', 'tale', 'af', 'ca.', 'seks', 'million', 'menneske', '.']
    elif lang == 'nld':
        assert lemmas == ['het', 'nederlands', 'is', 'een', 'west-germaans', 'taal', 'en', 'de', 'officieel', 'taal', 'van', 'nederland', ',', 'suriname', 'en', 'e', 'van', 'de', 'drie', 'officieel', 'taal', 'van', 'belgië', '.']
    elif lang in ['eng_gb', 'eng_us']:
        if lemmatizer in ['lemmatization_lists_eng', 'nltk_wordnet']:
            assert lemmas == ['English', 'be', 'a', 'West', 'Germanic', 'language', 'of', 'the', 'Indo', '-', 'European', 'language', 'family', ',', 'originally', 'speak', 'by', 'the', 'inhabitant', 'of', 'early', 'medieval', 'England.[3][4][5', ']']
        elif lemmatizer == 'spacy_eng':
            assert lemmas == ['English', 'be', 'a', 'West', 'Germanic', 'language', 'of', 'the', 'Indo', '-', 'european', 'language', 'family', ',', 'originally', 'speak', 'by', 'the', 'inhabitant', 'of', 'early', 'medieval', 'England.[3][4][5', ']']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'est':
        assert lemmas == ['Eesti', 'kee', '(', 'varasem', 'nimetu', 'maakeel', ')', 'olema', 'läänemeresoome', 'lõunarühma', 'kuuluma', 'kee', '.']
    elif lang == 'fra':
        if lemmatizer == 'lemmatization_lists_fra':
            assert lemmas == ['Le', 'français', 'être', 'un', 'langue', 'indo', '-', 'européen', 'de', 'le', 'famille', 'un', 'langue', 'roman', 'do', 'nt', 'le', 'locuteurs', 'être', 'appeler', 'francophone', '.']
        elif lemmatizer == 'spacy_fra':
            assert lemmas == ['le', 'français', 'être', 'un', 'langue', 'indo-européen', 'de', 'le', 'famille', 'de', 'langue', 'roman', 'dont', 'le', 'locuteur', 'être', 'appeler', 'francophone', '.']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'glg':
        assert lemmas == ['O', 'galego', '(', '[', 'ɡaˈleɣo̝', ']', ')', 'ser', 'un', 'lingua', 'indoeuropeo', 'que', 'pertencer', 'á', 'póla', 'de', 'lingua', 'románico', '.']
    elif lang in ['deu_at', 'deu_de', 'deu_ch']:
        if lemmatizer == 'lemmatization_lists_deu':
            assert lemmas == ['Die', 'deutsch', 'Sprache', 'bzw', '.', 'der', 'deutschen', '(', '[', 'dɔɪ̯tʃ];[26', ']', 'abkürzen', 'dt', '.', 'oder', 'dtsch', '.', ')', 'sein', 'einen', 'westgermanische', 'Sprache', ',', 'der', 'weltweit', 'etwa', '90', 'bis', '105', 'Million', 'Mensch', 'als', 'Muttersprache', 'und', 'weit', 'rund', '80', 'Million', 'als', 'Zweit-', 'oder', 'Fremdsprache', 'dienen', '.']
        elif lemmatizer == 'spacy_deu':
            assert lemmas == ['der', 'deutsch', 'Sprache', 'bzw.', 'der', 'deutschen', '(', '[', 'dɔɪ̯tʃ];[26', ']', 'abkürzen', 'dt', '.', 'oder', 'dtsch', '.', ')', 'sein', 'einen', 'westgermanische', 'Sprache', ',', 'der', 'weltweit', 'etwa', '90', 'bis', '105', 'Million', 'Mensch', 'als', 'Muttersprache', 'und', 'weit', 'rund', '80', 'Million', 'als', 'Zweit-', 'oder', 'Fremdsprache', 'dienen', '.']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'grc':
        assert lemmas == ['Ὅτι', 'μέν', 'σύ', ',', 'ὦ', 'ἀνήρ', 'Ἀθηναῖοι', ',', 'πάσχω', 'ὑπό', 'ὁ', 'ἐμός', 'κατηγόρων', ',', 'οὐ', 'οἶδα', '·', 'ἐγώ', 'δέ', 'οὖν', 'καί', 'αὐτός', 'ὑπό', 'αὐτός', 'ὀλίγος', 'ἐμαυτοῦ', 'ἐπελαθόμην', ',', 'οὕτως', 'πιθανῶς', 'λέγω', '.']
    elif lang == 'ell':
        assert lemmas == ['η', 'ελληνικός', 'γλώσσα', 'ανήκω', 'στην', 'ινδοευρωπαϊκός', 'οικογένεια[10', ']', 'και', 'αποτελώ', 'το', 'μοναδικό', 'μέλος', 'το', 'ελληνικός', 'κλάδος', ',', 'ενώ', 'είναι', 'η', 'επίσημη', 'γλώσσα', 'της', 'ελλάδος', 'και', 'της', 'κύπρος', '.']
    elif lang == 'hun':
        assert lemmas == ['A', 'magyar', 'nyelv', 'az', 'uráli', 'nyelvcsalád', 'tag', ',', 'a', 'finnugor', 'nyelv', 'köz', 'tartozó', 'ugor', 'nyelv', 'egyik', '.']
    elif lang == 'ind':
        assert lemmas == ['Bahasa', 'Indonesia', 'adalah', 'bahasa', 'Melayu', 'baku', 'yang', 'dijadikan', 'bagai', 'bahasa', 'resmi', 'Republik', 'Indonesia[1', ']', 'dan', 'bahasa', 'satu', 'bangsa', 'Indonesia.[2', ']']
    elif lang == 'gle':
        if lemmatizer == 'lemmatization_lists_gle':
            assert lemmas == ['Is', 'ceann', 'de', 'na', 'teangach', 'Ceilteacha', 'í', 'an', 'Ghaeilge', '(', 'nó', 'Gaeilge', 'na', 'hÉireann', 'mar', 'a', 'tabhair', 'ar', 'corruair', ')', ',', 'agus', 'ceann', 'den', 'trí', 'ceann', 'de', 'teangach', 'Ceilteacha', 'air', 'a', 'tabhair', 'na', 'teangach', 'Gaelacha', '(', '.i', '.', 'an', 'Ghaeilge', ',', 'Gaeilge', 'na', 'hAlban', 'agus', 'Gaeilge', 'Mhanann', ')', 'go', 'áirithe', '.']
        elif lemmatizer == 'spacy_gle':
            assert lemmas == ['is', 'ceann', 'de', 'na', 'teangacha', 'ceilteacha', 'í', 'an', 'ghaeilge', '(', 'nó', 'gaeilge', 'na', 'héireann', 'mar', 'a', 'thugtar', 'uirthi', 'corruair', ')', ',', 'agus', 'ceann', 'den', 'dtrí', 'cinn', 'de', 'theangacha', 'ceilteacha', 'ar', 'a', 'dtugtar', 'na', 'teangacha', 'gaelacha', '(', '.i.', 'an', 'ghaeilge', ',', 'gaeilge', 'na', 'halban', 'agus', 'gaeilge', 'mhanann', ')', 'go', 'háirithe', '.']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'ita':
        if lemmatizer == 'lemmatization_lists_ita':
            assert lemmas == ["L'italiano", '(', '[', 'itaˈljaːno][Nota', '1', ']', 'ascolta[?·info', ']', ')', 'essere', 'una', 'lingua', 'romanzo', 'parlato', 'principalmente', 'in', 'Italia', '.']
        elif lemmatizer == 'spacy_ita':
            assert lemmas == ['il', 'italiano', '(', '[', 'itaˈljaːno][nota', '1', ']', 'ascolta[?·info', ']', ')', 'essere', 'uno', 'lingua', 'romanza', 'parlare', 'principalmente', 'in', 'Italia', '.']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'jpn':
        if lemmatizer == 'spacy_jpn':
            assert lemmas == ['日本', '語', '(', 'にほん', 'ご', '、', 'にっぽん', 'ご', '[', '注', '2', ']', '、', '英', ':', 'Japanese', ')', 'は', '、', '日本', '国', '内', 'や', '、', 'かつて', 'の', '日本', '領', 'だ', 'た', '国', '、', 'そして', '日本', '人', '同士', 'の', '間', 'で', '使用', 'する', 'れる', 'て', 'いる', '言語', '。']
        elif lemmatizer == 'sudachipy_jpn':
            assert lemmas == ['日本語', '(', 'にほん', 'ご', '、', 'にっぽん', 'ご', '[', '注', '2', ']', '、', '英', ':', 'Japanese', ')', 'は', '、', '日本', '国', '内', 'や', '、', 'かつて', 'の', '日本', '領', 'だ', 'た', '国', '、', 'そして', '日本人', '同士', 'の', '間', 'で', '使用', 'する', 'れる', 'て', 'いる', '言語', '。']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'lit':
        assert lemmas == ['lietuvė', 'kalbėti', '–', 'ižti', 'baltas', 'prokalbės', 'kilęs', 'lietuvė', 'tauta', 'kalbėti', ',', 'kuri', 'Lietuvoje', 'irti', 'valstybinis', ',', 'o', 'Europos', 'sąjunga', '–', 'viena', 'ižti', 'oficialus', 'kalbus', '.']
    elif lang == 'ltz':
        assert lemmas == ["D'", 'Lëtzebuergesch', 'ginn', 'an', 'der', 'däitsch', 'Dialektologie', 'als', 'een', 'westgermanesch', ',', 'mëtteldäitsch', 'Dialekt', 'aklasséieren', ',', 'deen', 'zum', 'Muselfränkesche', 'gehéieren', '.']
    elif lang == 'mkd':
        assert lemmas == ['Македонски', 'јаз', '—', 'јужнословенски', 'јаз', ',', 'дел', 'од', 'група', 'на', 'словенски', 'јазик', 'од', 'јазичен', 'семејство', 'на', 'индоевропски', 'јазик', '.']
    elif lang == 'glv':
        assert lemmas == ['She', 'Gaelg', '(', 'graït', ':', '/gɪlg/', ')', 'çhengey', 'Gaelagh', 'Mannin', '.']
    elif lang == 'nob':
        assert lemmas == ['bokmål', 'er', 'en', 'varietet', 'av', 'norsk', 'språk', '.']
    elif lang == 'fas':
        if lemmatizer == 'lemmatization_lists_fas':
            assert lemmas == ['فارسی', 'یا', 'پارسی', 'یکی', 'از', 'زبان\u200cهای', 'هندواروپایی', 'در', 'شاخهٔ', 'زبان\u200cهای', 'ایرانی', 'جنوب', 'غربی', 'است', 'که', 'در', 'کشورهای', 'ایران', '،', 'افغانستان،[۳', ']', 'تاجیکستان[۴', ']', 'را', 'ازبکستان[۵', ']', 'به', 'آن', 'سخن', 'می\u200cگویند', '.']
        elif lemmatizer == 'spacy_fas':
            assert lemmas == ['فارسی', 'یا', 'پارسی', 'یکی', 'از', 'زبان\u200cهای', 'هندواروپایی', 'در', 'شاخهٔ', 'زبان\u200cهای', 'ایرانی', 'جنوب', 'غربی', 'است', 'که', 'در', 'کشورهای', 'ایران', '،', 'افغانستان،[۳', ']', 'تاجیکستان[۴', ']', 'و', 'ازبکستان[۵', ']', 'به', 'آن', 'سخن', 'می\u200cگویند', '.']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'pol':
        assert lemmas == ['język', 'polski', ',', 'polszczyzna', '–', 'język', 'lechicki', 'z', 'grupa', 'zachodniosłowiańskiej', '(', 'do', 'której', 'należeć', 'również', 'czeski', ',', 'kaszubski', ',', 'słowacki', 'i', 'język', 'łużycki', ')', ',', 'stanowiącej', 'część', 'rodzina', 'indoeuropejski', '.']
    elif lang in ['por_br', 'por_pt']:
        if lemmatizer == 'lemmatization_lists_por':
            assert lemmas == ['A', 'língua', 'portuguesar', ',', 'também', 'designar', 'português', ',', 'ser', 'umar', 'língua', 'românico', 'flexivo', 'ocidental', 'originar', 'o', 'galego', '-', 'português', 'falar', 'o', 'Reino', 'da', 'Galiza', 'e', 'o', 'norte', 'de', 'Portugal', '.']
        elif lemmatizer == 'spacy_por':
            assert lemmas == ['A', 'língua', 'portuguesar', ',', 'também', 'designar', 'português', ',', 'ser', 'umar', 'língua', 'românico', 'flexivo', 'ocidental', 'originar', 'o', 'galego-português', 'falar', 'o', 'Reino', 'da', 'Galiza', 'e', 'o', 'norte', 'de', 'Portugal', '.']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'ron':
        if lemmatizer == 'lemmatization_lists_ron':
            assert lemmas == ['Limba', 'român', 'fi', 'vrea', 'limbă', 'indo', '-', 'european', ',', 'din', 'grup', 'italic', 'și', 'din', 'subgrupul', 'oriental', 'al', 'limbă', 'romanice', '.']
        elif lemmatizer == 'spacy_ron':
            assert lemmas == ['Limba', 'român', 'fi', 'vrea', 'limbă', 'indo-european', ',', 'din', 'grup', 'italic', 'și', 'din', 'subgrupul', 'oriental', 'al', 'limbă', 'romanice', '.']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'rus':
        if lemmatizer == 'lemmatization_lists_rus':
            assert lemmas == ['Ру́сский', 'язы́к', '(', '[', 'ˈruskʲɪi̯', 'jɪˈzɨk', ']', 'Информация', 'о', 'файл', 'слушать)[~', '3', ']', '[', '⇨', ']', 'стальной', 'один', 'из', 'восточнославянский', 'языковый', ',', 'национальный', 'язык', 'русский', 'народ', '.']
        elif lemmatizer == 'pymorphy2_morphological_analyzer':
            assert lemmas == ['ру́сский', 'язы́к', '(', '[', 'ˈruskʲɪi̯', 'jɪˈzɨk', ']', 'информация', 'о', 'файл', 'слушать)[~', '3', ']', '[', '⇨', ']', '—', 'один', 'из', 'восточнославянский', 'язык', ',', 'национальный', 'язык', 'русский', 'народ', '.']
        elif lemmatizer == 'spacy_rus':
            assert lemmas == ['ру́сский', 'язы́к', '(', '[', 'ˈruskʲɪi̯', 'jɪˈzɨk', ']', 'информация', 'о', 'файл', 'слушать)[~', '3', ']', '[', '⇨', ']', '—', 'один', 'из', 'восточнославянский', 'язык', ',', 'национальный', 'язык', 'русский', 'народ', '.']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'gla':
        assert lemmas == ["'S", 'i', 'cànan', 'dùthchasach', 'na', 'h', '-', 'Alba', 'a', 'th', "'", 'anns', 'a', "'", 'Ghàidhlig', '.']
    elif lang == 'srp_cyrl':
        assert lemmas == ['Српски', 'језик', 'припадати', 'словенски', 'група', 'језик', 'породица', 'индоевропских', 'језика.[12', ']']
    elif lang == 'slk':
        assert lemmas == ['Slovenčina', 'patriť', 'do', 'skupina', 'západoslovanský', 'jazyk', '(', 'spolu', 's', 'čeština', ',', 'poľština', ',', 'horný', 'as', 'dolný', 'lužickou', 'srbčina', 'as', 'kašubčinou', ')', '.']
    elif lang == 'slv':
        assert lemmas == ['Slovenščina', '[', 'slovénščina', ']', '/', '[', 'sloˈʋenʃtʃina', ']', 'onbiti', 'združen', 'naziv', 'za', 'uraden', 'knjižen', 'jezik', 'Slovenec', 'in', 'skupen', 'ime', 'za', 'narečje', 'in', 'govoriti', ',', 'ki', 'on', 'govoriti', 'ali', 'biti', 'on', 'nekoč', 'govoriti', 'Slovenec', '.']
    elif lang == 'spa':
        if lemmatizer == 'lemmatization_lists_spa':
            assert lemmas == ['El', 'español', 'o', 'castellano', 'ser', 'uno', 'lengua', 'romance', 'procedente', 'del', 'latín', 'hablar', ',', 'perteneciente', 'a', 'lo', 'familia', 'de', 'lengua', 'indoeuropeo', '.']
        elif lemmatizer == 'spacy_spa':
            assert lemmas == ['el', 'español', 'o', 'castellano', 'ser', 'uno', 'lengua', 'romance', 'procedente', 'del', 'latín', 'hablado', ',', 'perteneciente', 'a', 'el', 'familia', 'de', 'lengua', 'indoeuropea', '.']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'swe':
        if lemmatizer == 'lemmatization_lists_swe':
            assert lemmas == ['Svenska', '(', 'svensk', '(', 'info', ')', ')', 'vara', 'en', 'östnordiskt', 'språka', 'som', 'tala', 'av', 'ungefär', 'tio', 'miljon', 'person', 'främst', 'i', 'Sverige', 'där', 'språk', 'hare', 'man', 'dominant', 'ställning', 'som', 'huvudspråk', ',', 'mena', 'även', 'som', 'en', 'en', 'nationalspråk', 'i', 'Finland', 'och', 'som', 'enda', 'officiell', 'språka', 'på', 'Åland', '.']
        elif lemmatizer == 'spacy_swe':
            assert lemmas == ['svenska', '(', 'svenska', '(', 'info', ')', ')', 'är', 'ett', 'östnordiskt', 'språk', 'som', 'talas', 'av', 'ungefär', 'tio', 'miljoner', 'personer', 'främst', 'i', 'sverige', 'där', 'språket', 'har', 'en', 'dominant', 'ställning', 'som', 'huvudspråk', ',', 'men', 'även', 'som', 'det', 'ena', 'nationalspråket', 'i', 'finland', 'och', 'som', 'enda', 'officiella', 'språk', 'på', 'åland', '.']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'tgl':
        assert lemmas == ['Ang', 'Wikang', 'Tagalog[2', ']', '(', 'Baybayin', ':', 'ᜏᜒᜃᜅ᜔', 'ᜆᜄᜎᜓᜄ᜔', ')', ',', 'na', 'kilala', 'rin', 'sa', 'payak', 'na', 'pangalang', 'Tagalog', ',', 'ay', 'isa', 'sa', 'mga', 'pangunahing', 'wika', 'ng', 'Pilipinas', 'at', 'sinasabing', 'ito', 'ang', 'de', 'facto', '(', '"', 'sa', 'katunayan', '"', ')', 'ngunit', 'hindî', 'de', 'jure', '(', '"', 'sa', 'batas', '"', ')', 'na', 'batayan', 'na', 'siyang', 'pambansang', 'Wikang', 'Filipino', '(', 'mula', '1961', 'hanggang', '1987', ':', 'Pilipino).[2', ']']
    elif lang == 'bod':
        assert lemmas == ['བོད་', 'གི་', 'སྐད་ཡིག་', 'ནི་', 'བོད་ཡུལ་', 'དང་', 'དེ་', 'གི་', 'ཉེ་འཁོར་', 'གི་', 'ས་ཁུལ་', 'སྟེ་', '།']
    elif lang == 'tur':
        assert lemmas == ['Türkçe', 'ya', 'da', 'Türk', 'dil', ',', 'batı', 'Balkanlar’dan', 'başla', 'doğu', 'Hazar', 'Denizi', 'saha', 'kadar', 'konuş', 'Türkî', 'dil', 'dil', 'aile', 'ait', 'son', 'ekle', 'bir', 'dil.[12', ']']
    elif lang == 'ukr':
        if lemmatizer == 'lemmatization_lists_ukr':
            assert lemmas == ['Украї́нська', 'мо́ва', '(', 'МФА', ':', '[', 'ukrɑ̽ˈjɪnʲsʲkɑ̽', 'ˈmɔwɑ̽', ']', ',', 'історичний', 'назвати', '—', 'ру́ська', ',', 'руси́нська[9][10][11', ']', '[', '*', '2', ']', ')', '—', 'національний', 'мова', 'українець', '.']
        elif lemmatizer == 'pymorphy2_morphological_analyzer':
            assert lemmas == ['украї́нський', 'мо́вий', '(', 'мфа', ':', '[', 'ukrɑ̽ˈjɪnʲsʲkɑ̽', 'ˈmɔwɑ̽', ']', ',', 'історичний', 'назва', '—', 'ру́ський', ',', 'руси́нська[9][10][11', ']', '[', '*', '2', ']', ')', '—', 'національний', 'мова', 'українець', '.']
        else:
            raise Exception(f'Error: Tests for lemmatizer "{lemmatizer}" is skipped!')
    elif lang == 'urd':
        assert lemmas == ['اُردُو', 'لشکری', 'زبان[8', ']', '(', 'یا', 'جدید', 'معیاری', 'اردو', ')', 'برصغیر', 'کم', 'معیاری', 'زبان', 'میں', 'سے', 'ایک', 'ہونا', '۔']
    elif lang == 'cym':
        assert lemmas == ['Aelod', "o'r", 'cangen', 'Frythonaidd', "o'r", 'iaith', 'Celtaidd', 'a', 'siarad', 'bod', 'brodorol', 'yn', 'Nghymru', ',', 'can', 'Gymry', 'a', 'pobl', 'arall', 'aredig', 'gwasgar', 'bod', 'Lloegr', ',', 'a', 'can', 'cymuno', 'bechan', 'bod', 'Y', 'Wladfa', ',', 'gwybod', 'Ariannin[7', ']', "yw'r", 'Gymraeg', '(', 'hefyd', 'Cymraeg', 'heb', 'yr', 'bannod', ')', '.']
    else:
        raise Exception(f'Error: Tests for language "{lang}" is skipped!')