






import unittest

from transformers import AlbertConfig, is_torch_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
   import torch

   from transformers import (
       MODEL_FOR_PRETRAINING_MAPPING,
       AlbertForMaskedLM,
       AlbertForMultipleChoice,
       AlbertForPreTraining,
       AlbertForQuestionAnswering,
       AlbertForSequenceClassification,
       AlbertForTokenClassification,
       AlbertModel,
   )
   from transformers.models.albert.modeling_albert import ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST


class 			SCREAMING_SNAKE_CASE      :
     '''simple docstring'''


     def __init__(					self							:						Union[str, Any]       ,			UpperCAmelCase_							:						int       ,			UpperCAmelCase_							:						List[str]=13       ,			UpperCAmelCase_							:						List[str]=7       ,			UpperCAmelCase_							:						Optional[int]=True       ,			UpperCAmelCase_							:						Union[str, Any]=True       ,			UpperCAmelCase_							:						Any=True       ,			UpperCAmelCase_							:						List[Any]=True       ,			UpperCAmelCase_							:						Dict=99       ,			UpperCAmelCase_							:						Optional[int]=16       ,			UpperCAmelCase_							:						str=36       ,			UpperCAmelCase_							:						Optional[Any]=6       ,			UpperCAmelCase_							:						Union[str, Any]=6       ,			UpperCAmelCase_							:						List[Any]=6       ,			UpperCAmelCase_							:						Optional[int]=37       ,			UpperCAmelCase_							:						Union[str, Any]="gelu"       ,			UpperCAmelCase_							:						Optional[Any]=0.1       ,			UpperCAmelCase_							:						Optional[Any]=0.1       ,			UpperCAmelCase_							:						Tuple=512       ,			UpperCAmelCase_							:						Union[str, Any]=16       ,			UpperCAmelCase_							:						List[str]=2       ,			UpperCAmelCase_							:						Optional[int]=0.02       ,			UpperCAmelCase_							:						List[str]=3       ,			UpperCAmelCase_							:						Union[str, Any]=4       ,			UpperCAmelCase_							:						Tuple=None       ,			):
       SCREAMING_SNAKE_CASE							:   str						    =     parent
       SCREAMING_SNAKE_CASE							:   str						    =     batch_size
       SCREAMING_SNAKE_CASE							:   int						    =     seq_length
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     is_training
       SCREAMING_SNAKE_CASE							:   Tuple						    =     use_input_mask
       SCREAMING_SNAKE_CASE							:   Any						    =     use_token_type_ids
       SCREAMING_SNAKE_CASE							:   str						    =     use_labels
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     vocab_size
       SCREAMING_SNAKE_CASE							:   List[str]						    =     embedding_size
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     hidden_size
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     num_hidden_layers
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     num_hidden_groups
       SCREAMING_SNAKE_CASE							:   List[str]						    =     num_attention_heads
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     intermediate_size
       SCREAMING_SNAKE_CASE							:   Tuple						    =     hidden_act
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     hidden_dropout_prob
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     attention_probs_dropout_prob
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     max_position_embeddings
       SCREAMING_SNAKE_CASE							:   int						    =     type_vocab_size
       SCREAMING_SNAKE_CASE							:   Tuple						    =     type_sequence_label_size
       SCREAMING_SNAKE_CASE							:   Dict						    =     initializer_range
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     num_labels
       SCREAMING_SNAKE_CASE							:   Dict						    =     num_choices
       SCREAMING_SNAKE_CASE							:   List[str]						    =     scope


     def 					_A							(					self							:						Dict   ):
       SCREAMING_SNAKE_CASE							:   Any						    =     ids_tensor([self.batch_size, self.seq_length]       ,			self.vocab_size   )

       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     None
       if self.use_input_mask:
         SCREAMING_SNAKE_CASE							:   Optional[int]						    =     random_attention_mask([self.batch_size, self.seq_length]   )

       SCREAMING_SNAKE_CASE							:   int						    =     None
       if self.use_token_type_ids:
         SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     ids_tensor([self.batch_size, self.seq_length]       ,			self.type_vocab_size   )

       SCREAMING_SNAKE_CASE							:   Tuple						    =     None
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     None
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     None
       if self.use_labels:
         SCREAMING_SNAKE_CASE							:   Dict						    =     ids_tensor([self.batch_size]       ,			self.type_sequence_label_size   )
         SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     ids_tensor([self.batch_size, self.seq_length]       ,			self.num_labels   )
         SCREAMING_SNAKE_CASE							:   int						    =     ids_tensor([self.batch_size]       ,			self.num_choices   )

       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     self.get_config()

       return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels


     def 					_A							(					self							:						Any   ):
       return AlbertConfig(
           vocab_size=self.vocab_size       ,			hidden_size=self.hidden_size       ,			num_hidden_layers=self.num_hidden_layers       ,			num_attention_heads=self.num_attention_heads       ,			intermediate_size=self.intermediate_size       ,			hidden_act=self.hidden_act       ,			hidden_dropout_prob=self.hidden_dropout_prob       ,			attention_probs_dropout_prob=self.attention_probs_dropout_prob       ,			max_position_embeddings=self.max_position_embeddings       ,			type_vocab_size=self.type_vocab_size       ,			initializer_range=self.initializer_range       ,			num_hidden_groups=self.num_hidden_groups       ,			)


     def 					_A							(					self							:						Union[str, Any]       ,			UpperCAmelCase_							:						Tuple       ,			UpperCAmelCase_							:						Tuple       ,			UpperCAmelCase_							:						str       ,			UpperCAmelCase_							:						Optional[int]       ,			UpperCAmelCase_							:						Tuple       ,			UpperCAmelCase_							:						List[str]       ,			UpperCAmelCase_							:						Union[str, Any]   ):
       SCREAMING_SNAKE_CASE							:   List[str]						    =     AlbertModel(config=UpperCAmelCase_   )
       model.to(UpperCAmelCase_   )
       model.eval()
       SCREAMING_SNAKE_CASE							:   Dict						    =     model(UpperCAmelCase_       ,			attention_mask=UpperCAmelCase_       ,			token_type_ids=UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     model(UpperCAmelCase_       ,			token_type_ids=UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   Any						    =     model(UpperCAmelCase_   )
       self.parent.assertEqual(result.last_hidden_state.shape       ,			(self.batch_size, self.seq_length, self.hidden_size)   )
       self.parent.assertEqual(result.pooler_output.shape       ,			(self.batch_size, self.hidden_size)   )


     def 					_A							(					self							:						Any       ,			UpperCAmelCase_							:						List[str]       ,			UpperCAmelCase_							:						str       ,			UpperCAmelCase_							:						Union[str, Any]       ,			UpperCAmelCase_							:						str       ,			UpperCAmelCase_							:						Optional[int]       ,			UpperCAmelCase_							:						Tuple       ,			UpperCAmelCase_							:						List[str]   ):
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     AlbertForPreTraining(config=UpperCAmelCase_   )
       model.to(UpperCAmelCase_   )
       model.eval()
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     model(
           UpperCAmelCase_       ,			attention_mask=UpperCAmelCase_       ,			token_type_ids=UpperCAmelCase_       ,			labels=UpperCAmelCase_       ,			sentence_order_label=UpperCAmelCase_       ,			)
       self.parent.assertEqual(result.prediction_logits.shape       ,			(self.batch_size, self.seq_length, self.vocab_size)   )
       self.parent.assertEqual(result.sop_logits.shape       ,			(self.batch_size, config.num_labels)   )


     def 					_A							(					self							:						Dict       ,			UpperCAmelCase_							:						str       ,			UpperCAmelCase_							:						int       ,			UpperCAmelCase_							:						Any       ,			UpperCAmelCase_							:						List[Any]       ,			UpperCAmelCase_							:						Any       ,			UpperCAmelCase_							:						Tuple       ,			UpperCAmelCase_							:						str   ):
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     AlbertForMaskedLM(config=UpperCAmelCase_   )
       model.to(UpperCAmelCase_   )
       model.eval()
       SCREAMING_SNAKE_CASE							:   str						    =     model(UpperCAmelCase_       ,			attention_mask=UpperCAmelCase_       ,			token_type_ids=UpperCAmelCase_       ,			labels=UpperCAmelCase_   )
       self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.seq_length, self.vocab_size)   )


     def 					_A							(					self							:						Any       ,			UpperCAmelCase_							:						Optional[Any]       ,			UpperCAmelCase_							:						int       ,			UpperCAmelCase_							:						Tuple       ,			UpperCAmelCase_							:						int       ,			UpperCAmelCase_							:						List[str]       ,			UpperCAmelCase_							:						Union[str, Any]       ,			UpperCAmelCase_							:						Any   ):
       SCREAMING_SNAKE_CASE							:   List[str]						    =     AlbertForQuestionAnswering(config=UpperCAmelCase_   )
       model.to(UpperCAmelCase_   )
       model.eval()
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     model(
           UpperCAmelCase_       ,			attention_mask=UpperCAmelCase_       ,			token_type_ids=UpperCAmelCase_       ,			start_positions=UpperCAmelCase_       ,			end_positions=UpperCAmelCase_       ,			)
       self.parent.assertEqual(result.start_logits.shape       ,			(self.batch_size, self.seq_length)   )
       self.parent.assertEqual(result.end_logits.shape       ,			(self.batch_size, self.seq_length)   )


     def 					_A							(					self							:						Union[str, Any]       ,			UpperCAmelCase_							:						Union[str, Any]       ,			UpperCAmelCase_							:						int       ,			UpperCAmelCase_							:						Optional[Any]       ,			UpperCAmelCase_							:						Any       ,			UpperCAmelCase_							:						Optional[int]       ,			UpperCAmelCase_							:						str       ,			UpperCAmelCase_							:						Any   ):
       SCREAMING_SNAKE_CASE							:   int						    =     self.num_labels
       SCREAMING_SNAKE_CASE							:   Any						    =     AlbertForSequenceClassification(UpperCAmelCase_   )
       model.to(UpperCAmelCase_   )
       model.eval()
       SCREAMING_SNAKE_CASE							:   str						    =     model(UpperCAmelCase_       ,			attention_mask=UpperCAmelCase_       ,			token_type_ids=UpperCAmelCase_       ,			labels=UpperCAmelCase_   )
       self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.num_labels)   )


     def 					_A							(					self							:						Union[str, Any]       ,			UpperCAmelCase_							:						int       ,			UpperCAmelCase_							:						Optional[Any]       ,			UpperCAmelCase_							:						Any       ,			UpperCAmelCase_							:						List[str]       ,			UpperCAmelCase_							:						Any       ,			UpperCAmelCase_							:						Optional[Any]       ,			UpperCAmelCase_							:						Any   ):
       SCREAMING_SNAKE_CASE							:   int						    =     self.num_labels
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     AlbertForTokenClassification(config=UpperCAmelCase_   )
       model.to(UpperCAmelCase_   )
       model.eval()
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     model(UpperCAmelCase_       ,			attention_mask=UpperCAmelCase_       ,			token_type_ids=UpperCAmelCase_       ,			labels=UpperCAmelCase_   )
       self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.seq_length, self.num_labels)   )


     def 					_A							(					self							:						str       ,			UpperCAmelCase_							:						Optional[Any]       ,			UpperCAmelCase_							:						Any       ,			UpperCAmelCase_							:						Optional[Any]       ,			UpperCAmelCase_							:						Tuple       ,			UpperCAmelCase_							:						Any       ,			UpperCAmelCase_							:						List[Any]       ,			UpperCAmelCase_							:						Union[str, Any]   ):
       SCREAMING_SNAKE_CASE							:   Dict						    =     self.num_choices
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     AlbertForMultipleChoice(config=UpperCAmelCase_   )
       model.to(UpperCAmelCase_   )
       model.eval()
       SCREAMING_SNAKE_CASE							:   int						    =     input_ids.unsqueeze(1   ).expand(-1       ,			self.num_choices       ,			-1   ).contiguous()
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     token_type_ids.unsqueeze(1   ).expand(-1       ,			self.num_choices       ,			-1   ).contiguous()
       SCREAMING_SNAKE_CASE							:   Dict						    =     input_mask.unsqueeze(1   ).expand(-1       ,			self.num_choices       ,			-1   ).contiguous()
       SCREAMING_SNAKE_CASE							:   int						    =     model(
           UpperCAmelCase_       ,			attention_mask=UpperCAmelCase_       ,			token_type_ids=UpperCAmelCase_       ,			labels=UpperCAmelCase_       ,			)
       self.parent.assertEqual(result.logits.shape       ,			(self.batch_size, self.num_choices)   )






     def 					_A							(					self							:						Union[str, Any]   ):
       SCREAMING_SNAKE_CASE							:   Dict						    =     self.prepare_config_and_inputs()
       (
           (
           SCREAMING_SNAKE_CASE
       )    ,	(
           SCREAMING_SNAKE_CASE
       )    ,	(
           SCREAMING_SNAKE_CASE
       )    ,	(
           SCREAMING_SNAKE_CASE
       )    ,	(
           SCREAMING_SNAKE_CASE
       )    ,	(
           SCREAMING_SNAKE_CASE
       )    ,	(
           SCREAMING_SNAKE_CASE
       )    ,	
       )							:   Tuple						    =     config_and_inputs
       SCREAMING_SNAKE_CASE							:   Dict						    =     {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
       return config, inputs_dict





@require_torch
class 			SCREAMING_SNAKE_CASE      (      lowerCAmelCase   ,		lowerCAmelCase   ,		unittest.TestCase       ):
     '''simple docstring'''


     UpperCamelCase_				:		str								=						(
         (
             AlbertModel,
             AlbertForPreTraining,
             AlbertForMaskedLM,
             AlbertForMultipleChoice,
             AlbertForSequenceClassification,
             AlbertForTokenClassification,
             AlbertForQuestionAnswering,
         )
         if is_torch_available()
         else ()
     )
     UpperCamelCase_				:		List[Any]								=						(
         {
             '''feature-extraction''': AlbertModel,
             '''fill-mask''': AlbertForMaskedLM,
             '''question-answering''': AlbertForQuestionAnswering,
             '''text-classification''': AlbertForSequenceClassification,
             '''token-classification''': AlbertForTokenClassification,
             '''zero-shot''': AlbertForSequenceClassification,
         }
         if is_torch_available()
         else {}
     )
     UpperCamelCase_				:		Dict								=						True


     def 					_A							(					self							:						int       ,			UpperCAmelCase_							:						Dict       ,			UpperCAmelCase_							:						str       ,			UpperCAmelCase_							:						Optional[int]=False   ):
       SCREAMING_SNAKE_CASE							:   Dict						    =     super()._prepare_for_class(UpperCAmelCase_       ,			UpperCAmelCase_       ,			return_labels=UpperCAmelCase_   )

       if return_labels:
         if model_class in get_values(UpperCAmelCase_   ):
           SCREAMING_SNAKE_CASE							:   Any						    =     torch.zeros(
               (self.model_tester.batch_size, self.model_tester.seq_length)       ,			dtype=torch.long       ,			device=UpperCAmelCase_   )
           SCREAMING_SNAKE_CASE							:   Dict						    =     torch.zeros(
               self.model_tester.batch_size       ,			dtype=torch.long       ,			device=UpperCAmelCase_   )
       return inputs_dict


     def 					_A							(					self							:						str   ):
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     AlbertModelTester(self   )
       SCREAMING_SNAKE_CASE							:   str						    =     ConfigTester(self       ,			config_class=UpperCAmelCase_       ,			hidden_size=37   )


     def 					_A							(					self							:						Any   ):
       self.config_tester.run_common_tests()


     def 					_A							(					self							:						Tuple   ):
       SCREAMING_SNAKE_CASE							:   Dict						    =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*UpperCAmelCase_   )


     def 					_A							(					self							:						Tuple   ):
       SCREAMING_SNAKE_CASE							:   int						    =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_pretraining(*UpperCAmelCase_   )


     def 					_A							(					self							:						List[Any]   ):
       SCREAMING_SNAKE_CASE							:   Optional[Any]						    =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_lm(*UpperCAmelCase_   )


     def 					_A							(					self							:						Dict   ):
       SCREAMING_SNAKE_CASE							:   Tuple						    =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_multiple_choice(*UpperCAmelCase_   )


     def 					_A							(					self							:						Union[str, Any]   ):
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_question_answering(*UpperCAmelCase_   )


     def 					_A							(					self							:						Optional[Any]   ):
       SCREAMING_SNAKE_CASE							:   str						    =     self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_sequence_classification(*UpperCAmelCase_   )


     def 					_A							(					self							:						int   ):
       SCREAMING_SNAKE_CASE							:   str						    =     self.model_tester.prepare_config_and_inputs()
       for type in ["absolute", "relative_key", "relative_key_query"]:
         SCREAMING_SNAKE_CASE							:   int						    =     type
         self.model_tester.create_and_check_model(*UpperCAmelCase_   )






     @slow
     def 					_A							(					self							:						Optional[int]   ):
       for model_name in ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
         SCREAMING_SNAKE_CASE							:   Dict						    =     AlbertModel.from_pretrained(UpperCAmelCase_   )
         self.assertIsNotNone(UpperCAmelCase_   )





@require_torch
class 			SCREAMING_SNAKE_CASE      (      unittest.TestCase       ):
     '''simple docstring'''


     @slow
     def 					_A							(					self							:						List[Any]   ):
       SCREAMING_SNAKE_CASE							:   Optional[int]						    =     AlbertModel.from_pretrained("albert-base-v2"   )
       SCREAMING_SNAKE_CASE							:   Tuple						    =     torch.tensor([[0, 345, 232, 328, 740, 140, 1695, 69, 6078, 1588, 2]]   )
       SCREAMING_SNAKE_CASE							:   Union[str, Any]						    =     torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]   )
       with torch.no_grad():
         SCREAMING_SNAKE_CASE							:   Tuple						    =     model(UpperCAmelCase_       ,			attention_mask=UpperCAmelCase_   )[0]
       SCREAMING_SNAKE_CASE							:   str						    =     torch.Size((1, 11, 768)   )
       self.assertEqual(output.shape       ,			UpperCAmelCase_   )
       SCREAMING_SNAKE_CASE							:   List[Any]						    =     torch.tensor(
           [[[-0.6_513, 1.5_035, -0.2_766], [-0.6_515, 1.5_046, -0.2_780], [-0.6_512, 1.5_049, -0.2_784]]]   )

       self.assertTrue(torch.allclose(output[:, 1:4, 1:4]       ,			UpperCAmelCase_       ,			atol=1E-4   )   )









import os
import unittest

from transformers import LxmertTokenizer, LxmertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin

@require_tokenizers
class 							UpperCAmelCase_						(     __lowercase							,			unittest.TestCase  ):
							"""simple docstring"""







							UpperCAmelCase__			:		Any             =       LxmertTokenizer
							UpperCAmelCase__			:		Optional[Any]             =       LxmertTokenizerFast
							UpperCAmelCase__			:		Any             =       True
							UpperCAmelCase__			:		Dict             =       True


							def 							__lowercase							(     self			)       ->       Union[str, Any]:
												super().setUp()

												_a      :       int   =						[
												    '''[UNK]''',
												    '''[CLS]''',
												    '''[SEP]''',
												    '''want''',
												    '''##want''',
												    '''##ed''',
												    '''wa''',
												    '''un''',
												    '''runn''',
												    '''##ing''',
												    ''',''',
												    '''low''',
												    '''lowest''',
												]
												_a      :       Any   =						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 							__lowercase							(     self			,				_a			)       ->       List[str]:
												_a      :       Tuple   =						'''UNwant\u00E9d,running'''
												_a      :       str   =						'''unwanted, running'''
												return input_text, output_text


							def 							__lowercase							(     self			)       ->       List[Any]:
												_a      :       str   =						self.tokenizer_class(self.vocab_file			)

												_a      :       str   =						tokenizer.tokenize('''UNwant\u00E9d,running'''			)
												self.assertListEqual(_a			,				['''un''', '''##want''', '''##ed''', ''',''', '''runn''', '''##ing''']			)
												self.assertListEqual(tokenizer.convert_tokens_to_ids(_a			)			,				[7, 4, 5, 1_0, 8, 9]			)




							def 							__lowercase							(     self			)       ->       List[Any]:
												if not self.test_rust_tokenizer:
																	return

												_a      :       Optional[Any]   =						self.get_tokenizer()
												_a      :       str   =						self.get_rust_tokenizer()

												_a      :       Optional[Any]   =						'''I was born in 92000, and this is falsé.'''

												_a      :       Optional[Any]   =						tokenizer.tokenize(_a			)
												_a      :       List[Any]   =						rust_tokenizer.tokenize(_a			)
												self.assertListEqual(_a			,				_a			)

												_a      :       List[Any]   =						tokenizer.encode(_a			,				add_special_tokens=_a			)
												_a      :       Any   =						rust_tokenizer.encode(_a			,				add_special_tokens=_a			)
												self.assertListEqual(_a			,				_a			)

												_a      :       Dict   =						self.get_rust_tokenizer()
												_a      :       Optional[int]   =						tokenizer.encode(_a			)
												_a      :       Dict   =						rust_tokenizer.encode(_a			)
												self.assertListEqual(_a			,				_a			)



