


from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import ResNetConfig
from transformers.testing_utils import require_tf, require_vision, slow
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
    import tensorflow as tf

    from transformers import TFResNetForImageClassification, TFResNetModel
    from transformers.models.resnet.modeling_tf_resnet import TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor



class 	__lowerCamelCase			:







       def __init__(			self: Dict,A_: List[str],A_: List[Any]=3,A_: Union[str, Any]=32,A_: List[str]=3,A_: List[str]=10,A_: Any=[10, 20, 30, 40],A_: List[str]=[1, 1, 2, 1],A_: Optional[int]=True,A_: Tuple=True,A_: str="relu",A_: Any=3,A_: Tuple=None,):






            '''simple docstring'''




            __UpperCamelCase =			parent
            __UpperCamelCase =			batch_size
            __UpperCamelCase =			image_size
            __UpperCamelCase =			num_channels
            __UpperCamelCase =			embeddings_size
            __UpperCamelCase =			hidden_sizes
            __UpperCamelCase =			depths
            __UpperCamelCase =			is_training
            __UpperCamelCase =			use_labels
            __UpperCamelCase =			hidden_act
            __UpperCamelCase =			num_labels
            __UpperCamelCase =			scope
            __UpperCamelCase =			len(A_					)







       def 		snake_case_	(			self: str					):






            '''simple docstring'''




            __UpperCamelCase =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

            __UpperCamelCase =			None
            if self.use_labels:
                 __UpperCamelCase =			ids_tensor([self.batch_size],self.num_labels					)

            __UpperCamelCase =			self.get_config()

            return config, pixel_values, labels







       def 		snake_case_	(			self: Dict					):






            '''simple docstring'''




            return ResNetConfig(
                num_channels=self.num_channels,embeddings_size=self.embeddings_size,hidden_sizes=self.hidden_sizes,depths=self.depths,hidden_act=self.hidden_act,num_labels=self.num_labels,image_size=self.image_size,)







       def 		snake_case_	(			self: str,A_: Union[str, Any],A_: int,A_: str					):






            '''simple docstring'''




            __UpperCamelCase =			TFResNetModel(config=A_					)
            __UpperCamelCase =			model(A_					)
            # expected last hidden states: B, C, H // 32, W // 32
            self.parent.assertEqual(
                result.last_hidden_state.shape,(self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32),)







       def 		snake_case_	(			self: Tuple,A_: Dict,A_: Union[str, Any],A_: Union[str, Any]					):






            '''simple docstring'''




            __UpperCamelCase =			self.num_labels
            __UpperCamelCase =			TFResNetForImageClassification(A_					)
            __UpperCamelCase =			model(A_,labels=A_					)
            self.parent.assertEqual(result.logits.shape,(self.batch_size, self.num_labels)					)







       def 		snake_case_	(			self: Union[str, Any]					):






            '''simple docstring'''




            __UpperCamelCase =			self.prepare_config_and_inputs()
            __UpperCamelCase,    __UpperCamelCase,    __UpperCamelCase =			config_and_inputs
            __UpperCamelCase =			{'pixel_values': pixel_values}
            return config, inputs_dict



@require_tf
class 	__lowerCamelCase			(_a				,      _a				,      unittest.TestCase						):
       _lowercase											=     (TFResNetModel, TFResNetForImageClassification) if is_tf_available() else ()
       _lowercase											=     (
           {"""feature-extraction""": TFResNetModel, """image-classification""": TFResNetForImageClassification}
           if is_tf_available()
           else {}
       )

       _lowercase											=     False
       _lowercase											=     False
       _lowercase											=     False
       _lowercase											=     False
       _lowercase											=     False







       def 		snake_case_	(			self: List[str]					):






            '''simple docstring'''




            __UpperCamelCase =			TFResNetModelTester(self					)
            __UpperCamelCase =			ConfigTester(self,config_class=A_,has_text_modality=A_					)







       def 		snake_case_	(			self: Dict					):






            '''simple docstring'''




            self.create_and_test_config_common_properties()
            self.config_tester.create_and_test_config_to_json_string()
            self.config_tester.create_and_test_config_to_json_file()
            self.config_tester.create_and_test_config_from_and_save_pretrained()
            self.config_tester.create_and_test_config_with_num_labels()
            self.config_tester.check_config_can_be_init_without_params()
            self.config_tester.check_config_arguments_init()







       def 		snake_case_	(			self: Tuple					):






            '''simple docstring'''




            return







       @unittest.skip(reason='ResNet does not use inputs_embeds'					)
       def 		snake_case_	(			self: List[str]					):






            '''simple docstring'''




            pass







       @unittest.skip(reason='ResNet does not support input and output embeddings'					)
       def 		snake_case_	(			self: List[str]					):






            '''simple docstring'''




            pass







       def 		snake_case_	(			self: List[Any]					):






            '''simple docstring'''




            __UpperCamelCase,    __UpperCamelCase =			self.model_tester.prepare_config_and_inputs_for_common()

            for model_class in self.all_model_classes:
                 __UpperCamelCase =			model_class(A_					)
                 __UpperCamelCase =			inspect.signature(model.call					)
                 # signature.parameters is an OrderedDict => so arg_names order is deterministic
                 __UpperCamelCase =			[*signature.parameters.keys()]

                 __UpperCamelCase =			['pixel_values']
                 self.assertListEqual(arg_names[:1],A_					)







       def 		snake_case_	(			self: str					):






            '''simple docstring'''




            __UpperCamelCase =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_model(*A_					)







       def 		snake_case_	(			self: Dict					):






            '''simple docstring'''




            def check_hidden_states_output(A_: Union[str, Any],A_: Optional[Any],A_: Union[str, Any]					):
                 __UpperCamelCase =			model_class(A_					)
                 __UpperCamelCase =			model(**self._prepare_for_class(A_,A_					)					)

                 __UpperCamelCase =			outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

                 __UpperCamelCase =			self.model_tester.num_stages
                 self.assertEqual(len(A_					),expected_num_stages + 1					)

                 # ResNet's feature maps are of shape (batch_size, num_channels, height, width)
                 self.assertListEqual(
                     list(hidden_states[0].shape[-2:]					),[self.model_tester.image_size // 4, self.model_tester.image_size // 4],)

            __UpperCamelCase,    __UpperCamelCase =			self.model_tester.prepare_config_and_inputs_for_common()
            __UpperCamelCase =			['basic', 'bottleneck']
            for model_class in self.all_model_classes:
                 for layer_type in layers_type:
                      __UpperCamelCase =			layer_type
                      __UpperCamelCase =			True
                      check_hidden_states_output(A_,A_,A_					)

                      # check that output_hidden_states also work using config
                      del inputs_dict["output_hidden_states"]
                      __UpperCamelCase =			True

                      check_hidden_states_output(A_,A_,A_					)







       def 		snake_case_	(			self: str					):






            '''simple docstring'''




            __UpperCamelCase =			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_for_image_classification(*A_					)







       @slow
       def 		snake_case_	(			self: List[str]					):






            '''simple docstring'''




            for model_name in TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                 __UpperCamelCase =			TFResNetModel.from_pretrained(A_					)
                 self.assertIsNotNone(A_					)






def 		_A		(		)					-> List[Any]:


     """simple docstring"""


     __UpperCamelCase =			Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
     return image



@require_tf
@require_vision
class 	__lowerCamelCase			(unittest.TestCase						):







       @cached_property
       def 		snake_case_	(			self: List[str]					):






            '''simple docstring'''




            return (
                AutoImageProcessor.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)
                if is_vision_available()
                else None
            )







       @slow
       def 		snake_case_	(			self: Optional[Any]					):






            '''simple docstring'''




            __UpperCamelCase =			TFResNetForImageClassification.from_pretrained(TF_RESNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]					)

            __UpperCamelCase =			self.default_image_processor
            __UpperCamelCase =			prepare_img()
            __UpperCamelCase =			image_processor(images=A_,return_tensors='tf'					)

            # forward pass
            __UpperCamelCase =			model(**A_					)

            # verify the logits
            __UpperCamelCase =			tf.TensorShape((1, 1000)					)
            self.assertEqual(outputs.logits.shape,A_					)

            __UpperCamelCase =			tf.constant([-1_1.1_0_6_9, -9.7_8_7_7, -8.3_7_7_7]					)

            self.assertTrue(np.allclose(outputs.logits[0, :3].numpy(),A_,atol=1E-4					)					)









'''simple docstring'''




import unittest

from transformers import SPIECE_UNDERLINE, XLNetTokenizer, XLNetTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin


_SCREAMING_SNAKE_CASE							     =			get_tests_dir("fixtures/test_sentencepiece.model")
@require_sentencepiece
@require_tokenizers
class 			_lowerCAmelCase		(			A__							,     unittest.TestCase	):






     """simple docstring"""






     snake_case_						      =   XLNetTokenizer
     snake_case_						      =   XLNetTokenizerFast
     snake_case_						      =   True
     snake_case_						      =   True



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

        # We have a SentencePiece fixture for testing
        snake_case 						=   XLNetTokenizer(__snake_case   ,       keep_accents=__snake_case						)
        tokenizer.sanitize_special_tokens()
        tokenizer.save_pretrained(self.tmpdirname						)



     def      lowerCAmelCase			(   self							:			List[Any]						)->	str:
        snake_case 						=   """<s>"""
        snake_case 						=   1

        self.assertEqual(self.get_tokenizer()._convert_token_to_id(__snake_case						)   ,       __snake_case						)
        self.assertEqual(self.get_tokenizer()._convert_id_to_token(__snake_case						)   ,       __snake_case						)



     def      lowerCAmelCase			(   self							:			Tuple						)->	str:
        snake_case 						=   list(self.get_tokenizer().get_vocab().keys()						)

        self.assertEqual(vocab_keys[0]   ,       """<unk>"""						)
        self.assertEqual(vocab_keys[1]   ,       """<s>"""						)
        self.assertEqual(vocab_keys[-1]   ,       """<eod>"""						)
        self.assertEqual(len(__snake_case						)   ,       10_06						)



     def      lowerCAmelCase			(   self							:			Optional[Any]						)->	Tuple:
        self.assertEqual(self.get_tokenizer().vocab_size   ,       10_00						)



     def      lowerCAmelCase			(   self							:			List[str]						)->	int:
        snake_case 						=   XLNetTokenizer(__snake_case   ,       keep_accents=__snake_case						)

        snake_case 						=   tokenizer.tokenize("""This is a test"""						)
        self.assertListEqual(__snake_case   ,       ["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]						)

        self.assertListEqual(tokenizer.convert_tokens_to_ids(__snake_case						)   ,       [2_85, 46, 10, 1_70, 3_82]						)

        snake_case 						=   tokenizer.tokenize("""I was born in 92000, and this is falsé."""						)
        self.assertListEqual(
            __snake_case   ,       [
                SPIECE_UNDERLINE + """I""",
                SPIECE_UNDERLINE + """was""",
                SPIECE_UNDERLINE + """b""",
                """or""",
                """n""",
                SPIECE_UNDERLINE + """in""",
                SPIECE_UNDERLINE + """""",
                """9""",
                """2""",
                """0""",
                """0""",
                """0""",
                """,""",
                SPIECE_UNDERLINE + """and""",
                SPIECE_UNDERLINE + """this""",
                SPIECE_UNDERLINE + """is""",
                SPIECE_UNDERLINE + """f""",
                """al""",
                """s""",
                """é""",
                """.""",
            ]   ,       )
        snake_case 						=   tokenizer.convert_tokens_to_ids(__snake_case						)
        self.assertListEqual(__snake_case   ,       [8, 21, 84, 55, 24, 19, 7, 0, 6_02, 3_47, 3_47, 3_47, 3, 12, 66, 46, 72, 80, 6, 0, 4]						)

        snake_case 						=   tokenizer.convert_ids_to_tokens(__snake_case						)
        self.assertListEqual(
            __snake_case   ,       [
                SPIECE_UNDERLINE + """I""",
                SPIECE_UNDERLINE + """was""",
                SPIECE_UNDERLINE + """b""",
                """or""",
                """n""",
                SPIECE_UNDERLINE + """in""",
                SPIECE_UNDERLINE + """""",
                """<unk>""",
                """2""",
                """0""",
                """0""",
                """0""",
                """,""",
                SPIECE_UNDERLINE + """and""",
                SPIECE_UNDERLINE + """this""",
                SPIECE_UNDERLINE + """is""",
                SPIECE_UNDERLINE + """f""",
                """al""",
                """s""",
                """<unk>""",
                """.""",
            ]   ,       )



     def      lowerCAmelCase			(   self							:			str						)->	str:
        snake_case 						=   XLNetTokenizer(__snake_case   ,       do_lower_case=__snake_case						)
        snake_case 						=   tokenizer.tokenize("""I was born in 92000, and this is falsé."""						)
        self.assertListEqual(
            __snake_case   ,       [
                SPIECE_UNDERLINE + """""",
                """i""",
                SPIECE_UNDERLINE + """was""",
                SPIECE_UNDERLINE + """b""",
                """or""",
                """n""",
                SPIECE_UNDERLINE + """in""",
                SPIECE_UNDERLINE + """""",
                """9""",
                """2""",
                """0""",
                """0""",
                """0""",
                """,""",
                SPIECE_UNDERLINE + """and""",
                SPIECE_UNDERLINE + """this""",
                SPIECE_UNDERLINE + """is""",
                SPIECE_UNDERLINE + """f""",
                """al""",
                """se""",
                """.""",
            ]   ,       )
        self.assertListEqual(tokenizer.tokenize("""H\u00E9llo"""						)   ,       ["""▁he""", """ll""", """o"""]						)



     def      lowerCAmelCase			(   self							:			List[str]						)->	str:
        snake_case 						=   XLNetTokenizer(__snake_case   ,       do_lower_case=__snake_case						)
        snake_case 						=   tokenizer.tokenize("""I was born in 92000, and this is falsé."""						)
        self.assertListEqual(
            __snake_case   ,       [
                SPIECE_UNDERLINE + """I""",
                SPIECE_UNDERLINE + """was""",
                SPIECE_UNDERLINE + """b""",
                """or""",
                """n""",
                SPIECE_UNDERLINE + """in""",
                SPIECE_UNDERLINE + """""",
                """9""",
                """2""",
                """0""",
                """0""",
                """0""",
                """,""",
                SPIECE_UNDERLINE + """and""",
                SPIECE_UNDERLINE + """this""",
                SPIECE_UNDERLINE + """is""",
                SPIECE_UNDERLINE + """f""",
                """al""",
                """se""",
                """.""",
            ]   ,       )



     @slow
     def      lowerCAmelCase			(   self							:			Optional[Any]						)->	Dict:
        snake_case 						=   XLNetTokenizer.from_pretrained("""xlnet-base-cased"""						)

        snake_case 						=   tokenizer.encode("""sequence builders"""   ,       add_special_tokens=__snake_case						)
        snake_case 						=   tokenizer.encode("""multi-sequence build"""   ,       add_special_tokens=__snake_case						)

        snake_case 						=   tokenizer.build_inputs_with_special_tokens(__snake_case						)
        snake_case 						=   tokenizer.build_inputs_with_special_tokens(__snake_case   ,       __snake_case						)

        assert encoded_sentence == text + [4, 3]
        assert encoded_pair == text + [4] + text_a + [4, 3]



     @slow
     def      lowerCAmelCase			(   self							:			Optional[int]						)->	Union[str, Any]:
        # fmt: off
        snake_case 						=   {"""input_ids""": [[17, 2_14_42, 2_70, 17, 10, 1_46_45, 3_18, 34, 17, 45_46, 31_45, 7_87, 13, 77_52, 2_20_18, 23, 21, 17, 45_46, 31_45, 7_87, 13, 33_52, 1_44_31, 13, 55_00, 11, 11_76, 5_80, 13, 1_68_19, 47_97, 23, 17, 10, 1_71_35, 6_58, 19, 4_57, 79_32, 13, 1_84, 19, 31_54, 1_71_35, 64_68, 19, 14_04, 1_22_69, 19, 42_29, 53_56, 1_62_64, 46, 19, 17, 2_05_45, 1_03_95, 9, 9, 9, 11, 28, 64_21, 95_31, 2_07_29, 17, 10, 3_53, 1_70_22, 11, 21, 64_21, 95_31, 1_69_49, 17, 10, 1_15_09, 7_53, 11, 33, 95, 24_21, 73_85, 9_56, 1_44_31, 26_26, 25, 8_42, 73_85, 48_36, 21, 14_29, 22_72, 98_55, 31_20, 1_61, 2_47_38, 19, 1_32_03, 6_58, 2_18, 7_87, 21, 4_30, 1_84_82, 8_47, 26_37, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 3_22, 2_21_78, 27, 10_64, 22, 9_56, 13, 1_11_01, 14_29, 58_54, 2_43_13, 1_89_53, 40, 4_22, 2_43_66, 68, 17_58, 37, 1_04_83, 1_42_57, 31, 2_07, 2_63, 21, 2_03, 37_73, 25, 71, 97_35, 9, 4, 3], [5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 32, 20_49, 34_42, 17, 1_38_94, 33_80, 23, 95, 18, 1_76_34, 22_88, 9, 4, 3]], """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, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 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, 2], [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2]], """attention_mask""": [[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, 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, 1, 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, 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, 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], [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, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
        # fmt: on

        self.tokenizer_integration_test_util(
            expected_encoding=__snake_case   ,       model_name="""xlnet-base-cased"""   ,       revision="""c841166438c31ec7ca9a106dee7bb312b73ae511"""   ,       )

