"""simple docstring"""
import json
import os
import unittest

from transformers.models.roc_bert.tokenization_roc_bert import (
    VOCAB_FILES_NAMES,
    RoCBertBasicTokenizer,
    RoCBertTokenizer,
    RoCBertWordpieceTokenizer,
    _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        __snake_case	(					__lowerCAmelCase	,				unittest.TestCase    ):
      a__				=		RoCBertTokenizer
      a__				=		None
      a__				=		False
      a__				=		True
      a__				=		filter_non_english



      def   lowerCamelCase_       (						self)     ->      Tuple:





        '''simple docstring'''





        super().setUp()

        a__:					Dict      							=     ['[UNK]', '[CLS]', '[SEP]', '[PAD]', '[MASK]', '你', '好', '是', '谁', 'a', 'b', 'c', 'd']
        a__:					Dict      							=     {}
        a__:					Any      							=     {}
        for i, value in enumerate(lowercase):
          a__:					Optional[Any]      							=     i
          a__:					Tuple      							=     i
        a__:					Any      							=     os.path.join(self.tmpdirname   ,      VOCAB_FILES_NAMES['vocab_file'])
        a__:					Tuple      							=     os.path.join(self.tmpdirname   ,      VOCAB_FILES_NAMES['word_shape_file'])
        a__:					int      							=     os.path.join(self.tmpdirname   ,      VOCAB_FILES_NAMES['word_pronunciation_file'])
        with open(self.vocab_file   ,      'w'   ,      encoding='utf-8') as vocab_writer:
          vocab_writer.write(''.join([x + '\n' for x in vocab_tokens]))
        with open(self.word_shape_file   ,      'w'   ,      encoding='utf-8') as word_shape_writer:
          json.dump(lowercase   ,      lowercase   ,      ensure_ascii=lowercase)
        with open(self.word_pronunciation_file   ,      'w'   ,      encoding='utf-8') as word_pronunciation_writer:
          json.dump(lowercase   ,      lowercase   ,      ensure_ascii=lowercase)



      def   lowerCamelCase_       (						self)     ->      int:





        '''simple docstring'''





        a__:					Any      							=     self.tokenizer_class(self.vocab_file   ,      self.word_shape_file   ,      self.word_pronunciation_file)

        a__:					List[Any]      							=     tokenizer.tokenize('你好[SEP]你是谁')
        self.assertListEqual(lowercase   ,      ['你', '好', '[SEP]', '你', '是', '谁'])
        self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase)   ,      [5, 6, 2, 5, 7, 8])
        self.assertListEqual(tokenizer.convert_tokens_to_shape_ids(lowercase)   ,      [5, 6, 2, 5, 7, 8])
        self.assertListEqual(tokenizer.convert_tokens_to_pronunciation_ids(lowercase)   ,      [5, 6, 2, 5, 7, 8])



      def   lowerCamelCase_       (						self)     ->      Any:





        '''simple docstring'''





        a__:					Union[str, Any]      							=     RoCBertBasicTokenizer()

        self.assertListEqual(tokenizer.tokenize('ah\u535A\u63A8zz')   ,      ['ah', '\u535A', '\u63A8', 'zz'])



      def   lowerCamelCase_       (						self)     ->      Any:





        '''simple docstring'''





        a__:					List[str]      							=     RoCBertBasicTokenizer(do_lower_case=lowercase)

        self.assertListEqual(
            tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  ')   ,      ['hello', '!', 'how', 'are', 'you', '?'])
        self.assertListEqual(tokenizer.tokenize('H\u00E9llo')   ,      ['hello'])



      def   lowerCamelCase_       (						self)     ->      str:





        '''simple docstring'''





        a__:					List[Any]      							=     RoCBertBasicTokenizer(do_lower_case=lowercase   ,      strip_accents=lowercase)

        self.assertListEqual(
            tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  ')   ,      ['hällo', '!', 'how', 'are', 'you', '?'])
        self.assertListEqual(tokenizer.tokenize('H\u00E9llo')   ,      ['h\u00E9llo'])



      def   lowerCamelCase_       (						self)     ->      int:





        '''simple docstring'''





        a__:					Optional[int]      							=     RoCBertBasicTokenizer(do_lower_case=lowercase   ,      strip_accents=lowercase)

        self.assertListEqual(
            tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  ')   ,      ['hallo', '!', 'how', 'are', 'you', '?'])
        self.assertListEqual(tokenizer.tokenize('H\u00E9llo')   ,      ['hello'])



      def   lowerCamelCase_       (						self)     ->      Optional[int]:





        '''simple docstring'''





        a__:					List[Any]      							=     RoCBertBasicTokenizer(do_lower_case=lowercase)

        self.assertListEqual(
            tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  ')   ,      ['hallo', '!', 'how', 'are', 'you', '?'])
        self.assertListEqual(tokenizer.tokenize('H\u00E9llo')   ,      ['hello'])



      def   lowerCamelCase_       (						self)     ->      List[str]:





        '''simple docstring'''





        a__:					List[Any]      							=     RoCBertBasicTokenizer(do_lower_case=lowercase)

        self.assertListEqual(
            tokenizer.tokenize(' \tHeLLo!how  \n Are yoU?  ')   ,      ['HeLLo', '!', 'how', 'Are', 'yoU', '?'])



      def   lowerCamelCase_       (						self)     ->      Dict:





        '''simple docstring'''





        a__:					List[Any]      							=     RoCBertBasicTokenizer(do_lower_case=lowercase   ,      strip_accents=lowercase)

        self.assertListEqual(
            tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  ')   ,      ['HäLLo', '!', 'how', 'Are', 'yoU', '?'])



      def   lowerCamelCase_       (						self)     ->      Optional[Any]:





        '''simple docstring'''





        a__:					List[str]      							=     RoCBertBasicTokenizer(do_lower_case=lowercase   ,      strip_accents=lowercase)

        self.assertListEqual(
            tokenizer.tokenize(' \tHäLLo!how  \n Are yoU?  ')   ,      ['HaLLo', '!', 'how', 'Are', 'yoU', '?'])



      def   lowerCamelCase_       (						self)     ->      Optional[int]:





        '''simple docstring'''





        a__:					Optional[Any]      							=     RoCBertBasicTokenizer(do_lower_case=lowercase   ,      never_split=['[UNK]'])

        self.assertListEqual(
            tokenizer.tokenize(' \tHeLLo!how  \n Are yoU? [UNK]')   ,      ['HeLLo', '!', 'how', 'Are', 'yoU', '?', '[UNK]'])



      def   lowerCamelCase_       (						self)     ->      Union[str, Any]:





        '''simple docstring'''





        a__:					Dict      							=     ['[UNK]', '[CLS]', '[SEP]', 'want', '##want', '##ed', 'wa', 'un', 'runn', '##ing']

        a__:					Optional[int]      							=     {}
        for i, token in enumerate(lowercase):
          a__:					Any      							=     i
        a__:					Dict      							=     RoCBertWordpieceTokenizer(vocab=lowercase   ,      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   lowerCamelCase_       (						self)     ->      Tuple:





        '''simple docstring'''





        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   lowerCamelCase_       (						self)     ->      Union[str, Any]:





        '''simple docstring'''





        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   lowerCamelCase_       (						self)     ->      Tuple:





        '''simple docstring'''





        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   lowerCamelCase_       (						self)     ->      Any:





        '''simple docstring'''





        a__:					str      							=     self.get_tokenizer()

        # Example taken from the issue https://github.com/huggingface/tokenizers/issues/340
        self.assertListEqual([tokenizer.tokenize(lowercase) for t in ['Test', '\xad', 'test']]   ,      [['[UNK]'], [], ['[UNK]']])

        if self.test_rust_tokenizer:
          a__:					Dict      							=     self.get_rust_tokenizer()
          self.assertListEqual(
              [rust_tokenizer.tokenize(lowercase) for t in ['Test', '\xad', 'test']]   ,      [['[UNK]'], [], ['[UNK]']])



      def   lowerCamelCase_       (						self)     ->      Any:





        '''simple docstring'''





        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
          with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'):
            a__:					str      							=     self.rust_tokenizer_class.from_pretrained(lowercase   ,      **lowercase)

            a__:					List[Any]      							=     f'A, naïve {tokenizer_r.mask_token} AllenNLP sentence.'
            a__:					Optional[Any]      							=     tokenizer_r.encode_plus(
                lowercase   ,      return_attention_mask=lowercase   ,      return_token_type_ids=lowercase   ,      return_offsets_mapping=lowercase   ,      add_special_tokens=lowercase   ,      )

            a__:					str      							=     tokenizer_r.do_lower_case if hasattr(lowercase   ,      'do_lower_case') else False
            a__:					List[Any]      							=     (
                [
                    ((0, 0), tokenizer_r.cls_token),
                    ((0, 1), 'A'),
                    ((1, 2), ','),
                    ((3, 5), 'na'),
                    ((5, 6), '##ï'),
                    ((6, 8), '##ve'),
                    ((9, 15), tokenizer_r.mask_token),
                    ((16, 21), 'Allen'),
                    ((21, 23), '##NL'),
                    ((23, 24), '##P'),
                    ((25, 33), 'sentence'),
                    ((33, 34), '.'),
                    ((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, 15), tokenizer_r.mask_token),
                    ((16, 21), 'allen'),
                    ((21, 23), '##nl'),
                    ((23, 24), '##p'),
                    ((25, 33), 'sentence'),
                    ((33, 34), '.'),
                    ((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   lowerCamelCase_       (						self)     ->      Optional[int]:





        '''simple docstring'''





        a__:					int      							=     ['的', '人', '有']
        a__:					str      							=     ''.join(lowercase)
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
          with self.subTest(f'{tokenizer.__class__.__name__} ({pretrained_name})'):
            a__:					Optional[int]      							=     True
            a__:					Optional[Any]      							=     self.tokenizer_class.from_pretrained(lowercase   ,      **lowercase)
            a__:					List[str]      							=     self.rust_tokenizer_class.from_pretrained(lowercase   ,      **lowercase)

            a__:					Union[str, Any]      							=     tokenizer_p.encode(lowercase   ,      add_special_tokens=lowercase)
            a__:					str      							=     tokenizer_r.encode(lowercase   ,      add_special_tokens=lowercase)

            a__:					Dict      							=     tokenizer_r.convert_ids_to_tokens(lowercase)
            a__:					List[Any]      							=     tokenizer_p.convert_ids_to_tokens(lowercase)

            # it is expected that each Chinese character is not preceded by "##"
            self.assertListEqual(lowercase   ,      lowercase)
            self.assertListEqual(lowercase   ,      lowercase)

            a__:					Optional[int]      							=     False
            a__:					str      							=     self.rust_tokenizer_class.from_pretrained(lowercase   ,      **lowercase)
            a__:					List[Any]      							=     self.tokenizer_class.from_pretrained(lowercase   ,      **lowercase)

            a__:					int      							=     tokenizer_r.encode(lowercase   ,      add_special_tokens=lowercase)
            a__:					Optional[int]      							=     tokenizer_p.encode(lowercase   ,      add_special_tokens=lowercase)

            a__:					Any      							=     tokenizer_r.convert_ids_to_tokens(lowercase)
            a__:					Any      							=     tokenizer_p.convert_ids_to_tokens(lowercase)

            # it is expected that only the first Chinese character is not preceded by "##".
            a__:					Any      							=     [
                f'##{token}' if idx != 0 else token for idx, token in enumerate(lowercase)
            ]
            self.assertListEqual(lowercase   ,      lowercase)
            self.assertListEqual(lowercase   ,      lowercase)



      @slow
      def   lowerCamelCase_       (						self)     ->      Optional[int]:





        '''simple docstring'''





        a__:					Dict      							=     self.tokenizer_class(self.vocab_file   ,      self.word_shape_file   ,      self.word_pronunciation_file)

        a__:					Any      							=     tokenizer.encode('你好'   ,      add_special_tokens=lowercase)
        a__:					List[Any]      							=     tokenizer.encode('你是谁'   ,      add_special_tokens=lowercase)

        a__:					Optional[int]      							=     tokenizer.build_inputs_with_special_tokens(lowercase)
        a__:					Optional[Any]      							=     tokenizer.build_inputs_with_special_tokens(lowercase   ,      lowercase)

        assert encoded_sentence == [1] + text + [2]
        assert encoded_pair == [1] + text + [2] + text_a + [2]



      def   lowerCamelCase_       (						self)     ->      int:





        '''simple docstring'''





        a__:					str      							=     self.get_tokenizers(do_lower_case=lowercase)
        for tokenizer in tokenizers:
          with self.subTest(f'{tokenizer.__class__.__name__}'):
            a__:					List[Any]      							=     '你好，你是谁'
            a__:					Optional[Any]      							=     tokenizer.tokenize(lowercase)
            a__:					Any      							=     tokenizer.convert_tokens_to_ids(lowercase)
            a__:					int      							=     tokenizer.convert_tokens_to_shape_ids(lowercase)
            a__:					str      							=     tokenizer.convert_tokens_to_pronunciation_ids(lowercase)
            a__:					Tuple      							=     tokenizer.prepare_for_model(
                lowercase   ,      lowercase   ,      lowercase   ,      add_special_tokens=lowercase)

            a__:					List[str]      							=     tokenizer.encode_plus(lowercase   ,      add_special_tokens=lowercase)

            self.assertEqual(lowercase   ,      lowercase)



"""simple docstring"""
import json
import os
import unittest

from transformers import DebertaTokenizer, DebertaTokenizerFast
from transformers.models.deberta.tokenization_deberta import VOCAB_FILES_NAMES
from transformers.testing_utils import slow

from ...test_tokenization_common import TokenizerTesterMixin




class        __snake_case	(					__lowerCAmelCase	,				unittest.TestCase    ):
      a__				=		DebertaTokenizer
      a__				=		True
      a__				=		DebertaTokenizerFast



      def   lowerCamelCase_       (						self)     ->      str:





        '''simple docstring'''





        super().setUp()

        # Adapted from Sennrich et al. 2015 and https://github.com/rsennrich/subword-nmt
        a__:					List[str]      							=     [
            'l',
            'o',
            'w',
            'e',
            'r',
            's',
            't',
            'i',
            'd',
            'n',
            '\u0120',
            '\u0120l',
            '\u0120n',
            '\u0120lo',
            '\u0120low',
            'er',
            '\u0120lowest',
            '\u0120newer',
            '\u0120wider',
            '[UNK]',
        ]
        a__:					List[str]      							=     dict(zip(lowercase   ,      range(len(lowercase))))
        a__:					Any      							=     ['#version: 0.2', '\u0120 l', '\u0120l o', '\u0120lo w', 'e r', '']
        a__:					Optional[Any]      							=     {'unk_token': '[UNK]'}

        a__:					Any      							=     os.path.join(self.tmpdirname   ,      VOCAB_FILES_NAMES['vocab_file'])
        a__:					Dict      							=     os.path.join(self.tmpdirname   ,      VOCAB_FILES_NAMES['merges_file'])
        with open(self.vocab_file   ,      'w'   ,      encoding='utf-8') as fp:
          fp.write(json.dumps(lowercase) + '\n')
        with open(self.merges_file   ,      'w'   ,      encoding='utf-8') as fp:
          fp.write('\n'.join(lowercase))



      def   lowerCamelCase_       (						self   ,      **lowercase)     ->      int:





        '''simple docstring'''





        kwargs.update(self.special_tokens_map)
        return self.tokenizer_class.from_pretrained(self.tmpdirname   ,      **lowercase)



      def   lowerCamelCase_       (						self   ,      lowercase)     ->      Dict:





        '''simple docstring'''





        a__:					Tuple      							=     'lower newer'
        a__:					int      							=     'lower newer'
        return input_text, output_text



      def   lowerCamelCase_       (						self)     ->      Optional[int]:





        '''simple docstring'''





        a__:					Optional[int]      							=     self.get_tokenizer()
        a__:					List[Any]      							=     'lower newer'
        a__:					Optional[int]      							=     ['l', 'o', 'w', 'er', '\u0120', 'n', 'e', 'w', 'er']
        a__:					Optional[Any]      							=     tokenizer.tokenize(lowercase)
        self.assertListEqual(lowercase   ,      lowercase)

        a__:					int      							=     tokens + [tokenizer.unk_token]
        a__:					Optional[int]      							=     [0, 1, 2, 15, 10, 9, 3, 2, 15, 19]
        self.assertListEqual(tokenizer.convert_tokens_to_ids(lowercase)   ,      lowercase)



      def   lowerCamelCase_       (						self)     ->      List[str]:





        '''simple docstring'''





        a__:					int      							=     self.get_tokenizer()
        a__:					Any      							=     tokenizer('Hello'   ,      'World')
        a__:					Optional[Any]      							=     [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]
        self.assertListEqual(tokd['token_type_ids']   ,      lowercase)



      @slow
      def   lowerCamelCase_       (						self)     ->      int:





        '''simple docstring'''





        a__:					Dict      							=     self.tokenizer_class.from_pretrained('microsoft/deberta-base')

        a__:					Union[str, Any]      							=     tokenizer.encode('sequence builders'   ,      add_special_tokens=lowercase)
        a__:					Optional[Any]      							=     tokenizer.encode('multi-sequence build'   ,      add_special_tokens=lowercase)

        a__:					List[str]      							=     tokenizer.encode(
            'sequence builders'   ,      add_special_tokens=lowercase   ,      add_prefix_space=lowercase)
        a__:					Any      							=     tokenizer.encode(
            'sequence builders'   ,      'multi-sequence build'   ,      add_special_tokens=lowercase   ,      add_prefix_space=lowercase)

        a__:					Optional[int]      							=     tokenizer.build_inputs_with_special_tokens(lowercase)
        a__:					Union[str, Any]      							=     tokenizer.build_inputs_with_special_tokens(lowercase   ,      lowercase)

        assert encoded_sentence == encoded_text_from_decode
        assert encoded_pair == encoded_pair_from_decode



      @slow
      def   lowerCamelCase_       (						self)     ->      Any:





        '''simple docstring'''





        a__:					List[Any]      							=     [self.tokenizer_class]
        if self.test_rust_tokenizer:
          tokenizer_classes.append(self.rust_tokenizer_class)

        for tokenizer_class in tokenizer_classes:
          a__:					int      							=     tokenizer_class.from_pretrained('microsoft/deberta-base')

          a__:					List[str]      							=     [
              'ALBERT: A Lite BERT for Self-supervised Learning of Language Representations',
              'ALBERT incorporates two parameter reduction techniques',
              'The first one is a factorized embedding parameterization. By decomposing the large vocabulary'
              ' embedding matrix into two small matrices, we separate the size of the hidden layers from the size of'
              ' vocabulary embedding.',
          ]

          a__:					Dict      							=     tokenizer(lowercase   ,      padding=lowercase)
          a__:					Union[str, Any]      							=     [tokenizer.decode(lowercase   ,      skip_special_tokens=lowercase) for seq in encoding['input_ids']]

          # fmt: off
          a__:					Any      							=     {
              'input_ids': [
                  [1, 21_18, 1_11_26, 5_65, 35, 83, 2_51_91, 1_63, 1_88_54, 13, 1_21_56, 12, 1_61_01, 2_53_76, 1_38_07, 9, 2_22_05, 2_78_93, 16_35, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                  [1, 21_18, 1_11_26, 5_65, 2_45_36, 80, 4_37_97, 48_78, 73_73, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                  [1, 1_33, 78, 65, 16, 10, 37_24, 15_38, 3_31_83, 1_13_03, 4_37_97, 19_38, 4, 8_70, 2_41_65, 2_91_05, 5, 7_39, 3_26_44, 3_31_83, 1_13_03, 3_61_73, 88, 80, 6_50, 78_21, 4_59_40, 6, 52, 25_59, 5, 18_36, 9, 5, 73_97, 1_31_71, 31, 5, 18_36, 9, 3_26_44, 3_31_83, 1_13_03, 4, 2]
              ],
              'token_type_ids': [
                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                  [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
              ],
              'attention_mask': [
                  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
                  [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]
              ]
          }
          # fmt: on

          a__:					str      							=     [
              'ALBERT: A Lite BERT for Self-supervised Learning of Language Representations',
              'ALBERT incorporates two parameter reduction techniques',
              'The first one is a factorized embedding parameterization. By decomposing the large vocabulary'
              ' embedding matrix into two small matrices, we separate the size of the hidden layers from the size of'
              ' vocabulary embedding.',
          ]

          self.assertDictEqual(encoding.data   ,      lowercase)

          for expected, decoded in zip(lowercase   ,      lowercase):
            self.assertEqual(lowercase   ,      lowercase)


