code: 
  
  
  '''simple docstring'''
  
  
  
  
  
  import os
  import unittest
  
  from transformers import ElectraTokenizerFast
  from transformers.models.electra.tokenization_electra import (
      VOCAB_FILES_NAMES,
      BasicTokenizer,
      ElectraTokenizer,
      WordpieceTokenizer,
      _is_control,
      _is_punctuation,
      _is_whitespace,
  )
  from transformers.testing_utils import require_tokenizers, slow
  
  from ...test_tokenization_common import TokenizerTesterMixin, filter_non_english
  
  
  
  
  
  @require_tokenizers
  class    A					(     A_      ,       unittest.TestCase				):
  							UpperCamelCase_     :							Tuple =ElectraTokenizer
  							UpperCamelCase_     :							Tuple =ElectraTokenizerFast
  							UpperCamelCase_     :							Any =True
  							UpperCamelCase_     :							List[str] =True
  							UpperCamelCase_     :							Any =filter_non_english
  
  
  							def     _A (self      ):
  									super().setUp()
  
  									__lowercase=    [
  									    '[UNK]',
  									    '[CLS]',
  									    '[SEP]',
  									    '[PAD]',
  									    '[MASK]',
  									    'want',
  									    '##want',
  									    '##ed',
  									    'wa',
  									    'un',
  									    'runn',
  									    '##ing',
  									    ',',
  									    'low',
  									    'lowest',
  									]
  									__lowercase=    os.path.join(self.tmpdirname   ,       VOCAB_FILES_NAMES['vocab_file']      )
  									with open(self.vocab_file   ,       'w'   ,       encoding='utf-8'      ) as vocab_writer:
  											vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]      )      )
  
  
  							def     _A (self   ,       lowerCAmelCase      ):
  									__lowercase=    'UNwant\u00E9d,running'
  									__lowercase=    'unwanted, running'
  									return input_text, output_text
  
  
  							def     _A (self      ):
  									__lowercase=    self.tokenizer_class(self.vocab_file      )
  
  									__lowercase=    tokenizer.tokenize('UNwant\u00E9d,running'      )
  									self.assertListEqual(lowerCAmelCase   ,       ['un', '##want', '##ed', ',', 'runn', '##ing']      )
  									self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase      )   ,       [9, 6, 7, 1_2, 1_0, 1_1]      )
  
  
  							def     _A (self      ):
  									if not self.test_rust_tokenizer:
  											return
  
  									__lowercase=    self.get_tokenizer()
  									__lowercase=    self.get_rust_tokenizer()
  
  									__lowercase=    'UNwant\u00E9d,running'
  
  									__lowercase=    tokenizer.tokenize(lowerCAmelCase      )
  									__lowercase=    rust_tokenizer.tokenize(lowerCAmelCase      )
  									self.assertListEqual(lowerCAmelCase   ,       lowerCAmelCase      )
  
  									__lowercase=    tokenizer.encode(lowerCAmelCase   ,       add_special_tokens=lowerCAmelCase      )
  									__lowercase=    rust_tokenizer.encode(lowerCAmelCase   ,       add_special_tokens=lowerCAmelCase      )
  									self.assertListEqual(lowerCAmelCase   ,       lowerCAmelCase      )
  
  									__lowercase=    self.get_rust_tokenizer()
  									__lowercase=    tokenizer.encode(lowerCAmelCase      )
  									__lowercase=    rust_tokenizer.encode(lowerCAmelCase      )
  									self.assertListEqual(lowerCAmelCase   ,       lowerCAmelCase      )
  
  									# With lower casing
  									__lowercase=    self.get_tokenizer(do_lower_case=lowerCAmelCase      )
  									__lowercase=    self.get_rust_tokenizer(do_lower_case=lowerCAmelCase      )
  
  									__lowercase=    'UNwant\u00E9d,running'
  
  									__lowercase=    tokenizer.tokenize(lowerCAmelCase      )
  									__lowercase=    rust_tokenizer.tokenize(lowerCAmelCase      )
  									self.assertListEqual(lowerCAmelCase   ,       lowerCAmelCase      )
  
  									__lowercase=    tokenizer.encode(lowerCAmelCase   ,       add_special_tokens=lowerCAmelCase      )
  									__lowercase=    rust_tokenizer.encode(lowerCAmelCase   ,       add_special_tokens=lowerCAmelCase      )
  									self.assertListEqual(lowerCAmelCase   ,       lowerCAmelCase      )
  
  									__lowercase=    self.get_rust_tokenizer()
  									__lowercase=    tokenizer.encode(lowerCAmelCase      )
  									__lowercase=    rust_tokenizer.encode(lowerCAmelCase      )
  									self.assertListEqual(lowerCAmelCase   ,       lowerCAmelCase      )
  
  
  							def     _A (self      ):
  									__lowercase=    BasicTokenizer()
  
  									self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz'      )   ,       ['ah', '\u535A', '\u63A8', 'zz']      )
  
  
  							def     _A (self      ):
  									__lowercase=    BasicTokenizer(do_lower_case=lowerCAmelCase      )
  
  									self.assertListEqual(
  									    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '      )   ,       ['hello', '!', 'how', 'are', 'you', '?']      )
  									self.assertListEqual(tokenizer.tokenize('H\u00E9llo'      )   ,       ['hello']      )
  
  
  							def     _A (self      ):
  									__lowercase=    BasicTokenizer(do_lower_case=lowerCAmelCase   ,       strip_accents=lowerCAmelCase      )
  
  									self.assertListEqual(
  									    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '      )   ,       ['hällo', '!', 'how', 'are', 'you', '?']      )
  									self.assertListEqual(tokenizer.tokenize('H\u00E9llo'      )   ,       ['h\u00E9llo']      )
  
  
  							def     _A (self      ):
  									__lowercase=    BasicTokenizer(do_lower_case=lowerCAmelCase   ,       strip_accents=lowerCAmelCase      )
  
  									self.assertListEqual(
  									    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '      )   ,       ['hallo', '!', 'how', 'are', 'you', '?']      )
  									self.assertListEqual(tokenizer.tokenize('H\u00E9llo'      )   ,       ['hello']      )
  
  
  							def     _A (self      ):
  									__lowercase=    BasicTokenizer(do_lower_case=lowerCAmelCase      )
  
  									self.assertListEqual(
  									    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '      )   ,       ['hallo', '!', 'how', 'are', 'you', '?']      )
  									self.assertListEqual(tokenizer.tokenize('H\u00E9llo'      )   ,       ['hello']      )
  
  
  							def     _A (self      ):
  									__lowercase=    BasicTokenizer(do_lower_case=lowerCAmelCase      )
  
  									self.assertListEqual(
  									    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  '      )   ,       ['HeLLo', '!', 'how', 'Are', 'yoU', '?']      )
  
  
  							def     _A (self      ):
  									__lowercase=    BasicTokenizer(do_lower_case=lowerCAmelCase   ,       strip_accents=lowerCAmelCase      )
  
  									self.assertListEqual(
  									    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '      )   ,       ['HäLLo', '!', 'how', 'Are', 'yoU', '?']      )
  
  
  							def     _A (self      ):
  									__lowercase=    BasicTokenizer(do_lower_case=lowerCAmelCase   ,       strip_accents=lowerCAmelCase      )
  
  									self.assertListEqual(
  									    tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  '      )   ,       ['HaLLo', '!', 'how', 'Are', 'yoU', '?']      )
  
  
  							def     _A (self      ):
  									__lowercase=    BasicTokenizer(do_lower_case=lowerCAmelCase   ,       never_split=['[UNK]']      )
  
  									self.assertListEqual(
  									    tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]'      )   ,       ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]']      )
  
  
  							def     _A (self      ):
  									__lowercase=    ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']
  
  									__lowercase=    {}
  									for i, token in enumerate(lowerCAmelCase      ):
  											__lowercase=    i
  									__lowercase=    WordpieceTokenizer(vocab=lowerCAmelCase   ,       unk_token='[UNK]'      )
  
  									self.assertListEqual(tokenizer.tokenize(''      )   ,       []      )
  
  									self.assertListEqual(tokenizer.tokenize('unwanted running'      )   ,       ['un', '##want', '##ed', 'runn', '##ing']      )
  
  									self.assertListEqual(tokenizer.tokenize('unwantedX running'      )   ,       ['[UNK]', 'runn', '##ing']      )
  
  
  							def     _A (self      ):
  									self.assertTrue(_is_whitespace(' '      )      )
  									self.assertTrue(_is_whitespace('\t'      )      )
  									self.assertTrue(_is_whitespace('\r'      )      )
  									self.assertTrue(_is_whitespace('\n'      )      )
  									self.assertTrue(_is_whitespace('\u00A0'      )      )
  
  									self.assertFalse(_is_whitespace('A'      )      )
  									self.assertFalse(_is_whitespace('-'      )      )
  
  
  							def     _A (self      ):
  									self.assertTrue(_is_control('\u0005'      )      )
  
  									self.assertFalse(_is_control('A'      )      )
  									self.assertFalse(_is_control(' '      )      )
  									self.assertFalse(_is_control('\t'      )      )
  									self.assertFalse(_is_control('\r'      )      )
  
  
  							def     _A (self      ):
  									self.assertTrue(_is_punctuation('-'      )      )
  									self.assertTrue(_is_punctuation('$'      )      )
  									self.assertTrue(_is_punctuation('`'      )      )
  									self.assertTrue(_is_punctuation('.'      )      )
  
  									self.assertFalse(_is_punctuation('A'      )      )
  									self.assertFalse(_is_punctuation(' '      )      )
  
  
  							def     _A (self      ):
  									__lowercase=    self.get_tokenizer()
  									__lowercase=    self.get_rust_tokenizer()
  
  									# Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
  									self.assertListEqual([tokenizer.tokenize(lowerCAmelCase      ) for t in ['Test', '\xad', 'test']]   ,       [['[UNK]'], [], ['[UNK]']]      )
  
  									self.assertListEqual(
  									    [rust_tokenizer.tokenize(lowerCAmelCase      ) for t in ['Test', '\xad', 'test']]   ,       [['[UNK]'], [], ['[UNK]']]      )
  
  
  							@slow
  							def     _A (self      ):
  									__lowercase=    self.tokenizer_class.from_pretrained('google/electra-base-discriminator'      )
  
  									__lowercase=    tokenizer.encode('sequence builders'   ,       add_special_tokens=lowerCAmelCase      )
  									__lowercase=    tokenizer.encode('multi-sequence build'   ,       add_special_tokens=lowerCAmelCase      )
  
  									__lowercase=    tokenizer.build_inputs_with_special_tokens(lowerCAmelCase      )
  									__lowercase=    tokenizer.build_inputs_with_special_tokens(lowerCAmelCase   ,       lowerCAmelCase      )
  
  									assert encoded_sentence == [1_0_1] + text + [1_0_2]
  									assert encoded_pair == [1_0_1] + text + [1_0_2] + text_a + [1_0_2]
  
  
  							def     _A (self      ):
  									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
  											with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'      ):
  													__lowercase=    self.rust_tokenizer_class.from_pretrained(lowerCAmelCase   ,       **lowerCAmelCase      )
  
  													__lowercase=    f'A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'
  													__lowercase=    tokenizer_r.encode_plus(
  													    lowerCAmelCase   ,       return_attention_mask=lowerCAmelCase   ,       return_token_type_ids=lowerCAmelCase   ,       return_offsets_mapping=lowerCAmelCase   ,       add_special_tokens=lowerCAmelCase   ,       )
  
  													__lowercase=    tokenizer_r.do_lower_case if hasattr(lowerCAmelCase   ,       'do_lower_case'      ) else False
  													__lowercase=    (
  													    [
  													        ((0, 0), tokenizer_r.cls_token),
  													        ((0, 1), 'A'),
  													        ((1, 2), ','),
  													        ((3, 5), 'na'),
  													        ((5, 6), '##ï'),
  													        ((6, 8), '##ve'),
  													        ((9, 1_5), tokenizer_r.mask_token),
  													        ((1_6, 2_1), 'Allen'),
  													        ((2_1, 2_3), '##NL'),
  													        ((2_3, 2_4), '##P'),
  													        ((2_5, 3_3), 'sentence'),
  													        ((3_3, 3_4), '.'),
  													        ((0, 0), tokenizer_r.sep_token),
  													    ]
  													    if not do_lower_case
  													    else [
  													        ((0, 0), tokenizer_r.cls_token),
  													        ((0, 1), 'a'),
  													        ((1, 2), ','),
  													        ((3, 8), 'naive'),
  													        ((9, 1_5), tokenizer_r.mask_token),
  													        ((1_6, 2_1), 'allen'),
  													        ((2_1, 2_3), '##nl'),
  													        ((2_3, 2_4), '##p'),
  													        ((2_5, 3_3), 'sentence'),
  													        ((3_3, 3_4), '.'),
  													        ((0, 0), tokenizer_r.sep_token),
  													    ]
  													)
  
  													self.assertEqual(
  													    [e[1] for e in expected_results]   ,       tokenizer_r.convert_ids_to_tokens(tokens['input_ids']      )      )
  													self.assertEqual([e[0] for e in expected_results]   ,       tokens['offset_mapping']      )
  
  
  
  
  
  
  
  							def     _A (self      ):
  									__lowercase=    ['的', '人', '有']
  									__lowercase=    ''.join(lowerCAmelCase      )
  									for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
  											with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'      ):
  													__lowercase=    True
  													__lowercase=    self.tokenizer_class.from_pretrained(lowerCAmelCase   ,       **lowerCAmelCase      )
  													__lowercase=    self.rust_tokenizer_class.from_pretrained(lowerCAmelCase   ,       **lowerCAmelCase      )
  
  													__lowercase=    tokenizer_p.encode(lowerCAmelCase   ,       add_special_tokens=lowerCAmelCase      )
  													__lowercase=    tokenizer_r.encode(lowerCAmelCase   ,       add_special_tokens=lowerCAmelCase      )
  
  													__lowercase=    tokenizer_r.convert_ids_to_tokens(lowerCAmelCase      )
  													__lowercase=    tokenizer_p.convert_ids_to_tokens(lowerCAmelCase      )
  
  													# it is expected that each Chinese character is not preceded by "##"
  													self.assertListEqual(lowerCAmelCase   ,       lowerCAmelCase      )
  													self.assertListEqual(lowerCAmelCase   ,       lowerCAmelCase      )
  
  													__lowercase=    False
  													__lowercase=    self.rust_tokenizer_class.from_pretrained(lowerCAmelCase   ,       **lowerCAmelCase      )
  													__lowercase=    self.tokenizer_class.from_pretrained(lowerCAmelCase   ,       **lowerCAmelCase      )
  
  													__lowercase=    tokenizer_r.encode(lowerCAmelCase   ,       add_special_tokens=lowerCAmelCase      )
  													__lowercase=    tokenizer_p.encode(lowerCAmelCase   ,       add_special_tokens=lowerCAmelCase      )
  
  													__lowercase=    tokenizer_r.convert_ids_to_tokens(lowerCAmelCase      )
  													__lowercase=    tokenizer_p.convert_ids_to_tokens(lowerCAmelCase      )
  
  													# it is expected that only the first Chinese character is not preceded by "##".
  													__lowercase=    [
  													    f'##{token}' if idx != 0 else token for idx, token in enumerate(lowerCAmelCase      )
  													]
  													self.assertListEqual(lowerCAmelCase   ,       lowerCAmelCase      )
  													self.assertListEqual(lowerCAmelCase   ,       lowerCAmelCase      )
  
  
  
  
  
  
  
style_context: 
  
  
  import unittest
  
  from transformers import is_torch_available
  from transformers.testing_utils import require_torch, slow, torch_device
  
  
  if is_torch_available():
  	import torch
  
  	from transformers import XLMProphetNetForConditionalGeneration, XLMProphetNetTokenizer
  
  
  
  
  
  @require_torch
  class    A					(     unittest.TestCase				):
  
  
  							@slow
  							def     _A (self      ):
  									__lowercase=    XLMProphetNetForConditionalGeneration.from_pretrained('microsoft/xprophetnet-large-wiki100-cased'      )
  									model.to(lowerCAmelCase      )
  
  									# encoder-decoder outputs
  									__lowercase=    torch.tensor([[1_7, 9_6_2_0_8, 1_0_3_4_7_1, 2]]      ).to(lowerCAmelCase      )
  									__lowercase=    torch.tensor(
  									    [[2, 2_5_0, 9_9_5_3, 3_4, 6_9_4_8_9, 1_6_2_0, 3_2, 1_1_8_4_2_4, 6_2_4, 2_1_0, 1_0_5, 2_9_1_3, 1_0_3_2, 3_5_1]]      ).to(lowerCAmelCase      )
  									__lowercase=    model(
  									    input_ids=lowerCAmelCase   ,       attention_mask=lowerCAmelCase   ,       encoder_outputs=lowerCAmelCase   ,       decoder_input_ids=lowerCAmelCase      )
  									__lowercase=    output[0]
  									__lowercase=    torch.Size((1, 1_4, 2_5_0_0_1_2)      )
  									self.assertEqual(output_predited_logis.shape   ,       lowerCAmelCase      )
  									__lowercase=    torch.tensor(
  									    [[[-6.39_86, -8.23_91, 12.51_89], [-6.32_89, -8.08_64, 12.62_11], [-6.24_18, -8.04_45, 12.79_68]]]      ).to(lowerCAmelCase      )
  									self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]   ,       lowerCAmelCase   ,       atol=1E-4      )      )
  
  									# encoder outputs
  									__lowercase=    model.prophetnet.encoder(lowerCAmelCase      )[0]
  									__lowercase=    torch.tensor(
  									    [[[-1.42_60, -0.76_28, 0.84_53], [-1.47_19, -0.13_91, 0.78_07], [-1.76_78, 0.01_14, 0.46_46]]]      ).to(lowerCAmelCase      )
  									__lowercase=    torch.Size((1, 4, 1_0_2_4)      )
  									self.assertEqual(encoder_outputs.shape   ,       lowerCAmelCase      )
  									self.assertTrue(torch.allclose(encoder_outputs[:, :3, :3]   ,       lowerCAmelCase   ,       atol=1E-4      )      )
  
  									# decoder outputs
  									__lowercase=    model.prophetnet.decoder(
  									    lowerCAmelCase   ,       encoder_hidden_states=lowerCAmelCase   ,       )
  									__lowercase=    decoder_outputs[1].view(1   ,       model.config.ngram   ,       1_4   ,       -1      )
  									__lowercase=    model.lm_head(lowerCAmelCase      )
  									__lowercase=    predicting_streams_logits[:, 0]
  									self.assertTrue(torch.allclose(next_first_stream_logits[:, :3, :3]   ,       lowerCAmelCase   ,       atol=1E-4      )      )
  
  
  							@slow
  							def     _A (self      ):
  									__lowercase=    XLMProphetNetForConditionalGeneration.from_pretrained(
  									    'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'      )
  									model.to(lowerCAmelCase      )
  
  									__lowercase=    torch.tensor([[1_7, 9_6_2_0_8, 1_0_3_4_7_1, 2]]      ).to(lowerCAmelCase      )
  									__lowercase=    torch.tensor(
  									    [[2, 2_5_0, 9_9_5_3, 3_4, 6_9_4_8_9, 1_6_2_0, 3_2, 1_1_8_4_2_4, 6_2_4, 2_1_0, 1_0_5, 2_9_1_3, 1_0_3_2, 3_5_1]]      ).to(lowerCAmelCase      )
  									__lowercase=    model(
  									    input_ids=lowerCAmelCase   ,       attention_mask=lowerCAmelCase   ,       encoder_outputs=lowerCAmelCase   ,       decoder_input_ids=lowerCAmelCase      )
  									__lowercase=    output[0]
  									__lowercase=    torch.Size((1, 1_4, 2_5_0_0_1_2)      )
  									self.assertEqual(output_predited_logis.shape   ,       lowerCAmelCase      )
  									# compare the actual values for a slice.
  									__lowercase=    torch.tensor(
  									    [[[-9.22_53, -9.71_73, -6.35_29], [-7.67_01, -9.01_45, -1.93_82], [-8.01_95, -7.00_04, -0.15_23]]]      ).to(lowerCAmelCase      )
  
  									self.assertTrue(torch.allclose(output_predited_logis[:, :3, :3]   ,       lowerCAmelCase   ,       atol=1E-4      )      )
  
  
  
  
  
  
  
  							@slow
  							def     _A (self      ):
  									__lowercase=    XLMProphetNetForConditionalGeneration.from_pretrained(
  									    'microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'      )
  									model.to(lowerCAmelCase      )
  									__lowercase=    5_1_2
  
  									__lowercase=    XLMProphetNetTokenizer.from_pretrained('microsoft/xprophetnet-large-wiki100-cased-xglue-ntg'      )
  
  									__lowercase=    (
  									    'Microsoft Corporation intends to officially end free support for the Windows 7 operating system after'
  									    ' January 14, 2020, according to the official portal of the organization. From that day, users of this'
  									    ' system will not be able to receive security updates, which could make their computers vulnerable to'
  									    ' cyber attacks.'
  									)
  									__lowercase=    (
  									    'орпорация Microsoft намерена официально прекратить бесплатную поддержку операционной системы Windows 7'
  									    ' после 14 января 2020 года, сообщается на официальном портале организации . С указанного дня пользователи'
  									    ' этой системы не смогут получать обновления безопасности, из-за чего их компьютеры могут стать уязвимыми'
  									    ' к кибератакам.'
  									)
  									__lowercase=    (
  									    '根据该组织的官方门户网站，微软公司打算在2020年1月14日之后正式终止对Windows 7操作系统的免费支持。从那时起，该系统的用户将无法接收安全更新，这可能会使他们的计算机容易受到网络攻击。'
  									)
  
  									__lowercase=    tokenizer(
  									    [EN_SENTENCE, RU_SENTENCE, ZH_SENTENCE]   ,       padding=lowerCAmelCase   ,       max_length=2_5_5   ,       return_tensors='pt'      ).input_ids
  									__lowercase=    input_ids.to(lowerCAmelCase      )
  
  									__lowercase=    model.generate(
  									    lowerCAmelCase   ,       num_beams=1_0   ,       length_penalty=1.0   ,       no_repeat_ngram_size=3   ,       early_stopping=lowerCAmelCase      )
  									__lowercase=    [tokenizer.decode(lowerCAmelCase   ,       skip_special_tokens=lowerCAmelCase      ) for g in summary_ids]
  									__lowercase=    'Microsoft to end Windows 7 free support after January 14, 2020'
  									__lowercase=    'Microsoft намерена прекратить бесплатную поддержку Windows 7 после 14 января 2020 года'
  									__lowercase=    '微软打算终止对Windows 7操作系统的免费支持'
  									self.assertListEqual(
  									    [EXPECTED_TITLE_EN, EXPECTED_TITLE_RU, EXPECTED_TITLE_ZH]   ,       lowerCAmelCase   ,       )
  
  									__lowercase=    model.generate(
  									    lowerCAmelCase   ,       num_beams=1   ,       length_penalty=1.0   ,       no_repeat_ngram_size=3   ,       early_stopping=lowerCAmelCase      )
  									__lowercase=    [
  									    tokenizer.convert_ids_to_tokens(lowerCAmelCase   ,       skip_special_tokens=lowerCAmelCase      ) for g in summary_ids_beama
  									]
  									__lowercase=    '▁Microsoft ▁to ▁end ▁free ▁support ▁for ▁Windows ▁7'.split(' '      )
  									__lowercase=    '▁Microsoft ▁намерен а ▁прекрати ть ▁бес плат ную ▁поддержку ▁Windows ▁7 ▁после ▁14 ▁января ▁2020 ▁года'.split(
  									    ' '      )
  									__lowercase=    '微软 公司 打算 终止 对 Windows ▁7 操作 系统的 免费 支持'.split(' '      )
  									self.assertListEqual(
  									    [EXPECTED_TITLE_EN_BEAM1_TOK, EXPECTED_TITLE_RU_BEAM1_TOK, EXPECTED_TITLE_ZH_BEAM1_TOK]   ,       lowerCAmelCase   ,       )
  
  
  
  
  
  
  