






'''simple docstring'''





import unittest

from transformers import MPNetConfig, is_torch_available
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 (
			    MPNetForMaskedLM,
			    MPNetForMultipleChoice,
			    MPNetForQuestionAnswering,
			    MPNetForSequenceClassification,
			    MPNetForTokenClassification,
			    MPNetModel,
			)



class   lowerCAmelCase__ :

			def __init__(					self					:		List[str]     ,		UpperCamelCase_					:		int     ,		UpperCamelCase_					:		Dict=13     ,		UpperCamelCase_					:		Union[str, Any]=7     ,		UpperCamelCase_					:		Optional[int]=True     ,		UpperCamelCase_					:		Any=True     ,		UpperCamelCase_					:		int=False     ,		UpperCamelCase_					:		Tuple=True     ,		UpperCamelCase_					:		List[str]=99     ,		UpperCamelCase_					:		List[Any]=64     ,		UpperCamelCase_					:		str=5     ,		UpperCamelCase_					:		Optional[int]=4     ,		UpperCamelCase_					:		List[Any]=64     ,		UpperCamelCase_					:		List[str]="gelu"     ,		UpperCamelCase_					:		Tuple=0.1     ,		UpperCamelCase_					:		int=0.1     ,		UpperCamelCase_					:		List[Any]=512     ,		UpperCamelCase_					:		Any=16     ,		UpperCamelCase_					:		int=2     ,		UpperCamelCase_					:		Tuple=0.02     ,		UpperCamelCase_					:		Tuple=3     ,		UpperCamelCase_					:		List[str]=4     ,		UpperCamelCase_					:		Dict=None     ,		) ->  int:







				"""simple docstring"""






				lowerCamelCase_					:  str						=    parent
				lowerCamelCase_					:  int						=    batch_size
				lowerCamelCase_					:  Any						=    seq_length
				lowerCamelCase_					:  Any						=    is_training
				lowerCamelCase_					:  Optional[int]						=    use_input_mask
				lowerCamelCase_					:  Dict						=    use_token_type_ids
				lowerCamelCase_					:  List[Any]						=    use_labels
				lowerCamelCase_					:  str						=    vocab_size
				lowerCamelCase_					:  List[str]						=    hidden_size
				lowerCamelCase_					:  List[str]						=    num_hidden_layers
				lowerCamelCase_					:  Dict						=    num_attention_heads
				lowerCamelCase_					:  Dict						=    intermediate_size
				lowerCamelCase_					:  int						=    hidden_act
				lowerCamelCase_					:  str						=    hidden_dropout_prob
				lowerCamelCase_					:  int						=    attention_probs_dropout_prob
				lowerCamelCase_					:  List[str]						=    max_position_embeddings
				lowerCamelCase_					:  Union[str, Any]						=    type_vocab_size
				lowerCamelCase_					:  str						=    type_sequence_label_size
				lowerCamelCase_					:  Union[str, Any]						=    initializer_range
				lowerCamelCase_					:  str						=    num_labels
				lowerCamelCase_					:  Optional[Any]						=    num_choices
				lowerCamelCase_					:  Any						=    scope

			def 						__UpperCamelCase				(					self					:		List[str]	) ->  int:







				"""simple docstring"""






				return MPNetConfig.from_pretrained('''microsoft/mpnet-base'''	)

			def 						__UpperCamelCase				(					self					:		Any	) ->  str:







				"""simple docstring"""






				lowerCamelCase_					:  Optional[int]						=    ids_tensor([self.batch_size, self.seq_length]     ,		self.vocab_size	)

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

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

				lowerCamelCase_					:  List[str]						=    self.get_config()
				return config, input_ids, input_mask, sequence_labels, token_labels, choice_labels

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







				"""simple docstring"""






				return MPNetConfig(
				    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     ,		initializer_range=self.initializer_range     ,		)

			def 						__UpperCamelCase				(					self					:		str     ,		UpperCamelCase_					:		Optional[Any]     ,		UpperCamelCase_					:		Any     ,		UpperCamelCase_					:		Optional[Any]     ,		UpperCamelCase_					:		List[Any]     ,		UpperCamelCase_					:		Optional[int]     ,		UpperCamelCase_					:		List[Any]	) ->  Dict:







				"""simple docstring"""






				lowerCamelCase_					:  Any						=    MPNetModel(config=UpperCamelCase_	)
				model.to(UpperCamelCase_	)
				model.eval()
				lowerCamelCase_					:  Any						=    model(UpperCamelCase_     ,		UpperCamelCase_	)
				lowerCamelCase_					:  Optional[int]						=    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 						__UpperCamelCase				(					self					:		Dict     ,		UpperCamelCase_					:		Optional[int]     ,		UpperCamelCase_					:		str     ,		UpperCamelCase_					:		Optional[int]     ,		UpperCamelCase_					:		Tuple     ,		UpperCamelCase_					:		Any     ,		UpperCamelCase_					:		Dict	) ->  Dict:







				"""simple docstring"""






				lowerCamelCase_					:  int						=    MPNetForQuestionAnswering(config=UpperCamelCase_	)
				model.to(UpperCamelCase_	)
				model.eval()
				lowerCamelCase_					:  List[str]						=    model(
				    UpperCamelCase_     ,		attention_mask=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 						__UpperCamelCase				(					self					:		Tuple     ,		UpperCamelCase_					:		List[str]     ,		UpperCamelCase_					:		int     ,		UpperCamelCase_					:		Optional[Any]     ,		UpperCamelCase_					:		Optional[Any]     ,		UpperCamelCase_					:		List[Any]     ,		UpperCamelCase_					:		Union[str, Any]	) ->  int:







				"""simple docstring"""






				lowerCamelCase_					:  int						=    self.num_labels
				lowerCamelCase_					:  Any						=    MPNetForSequenceClassification(UpperCamelCase_	)
				model.to(UpperCamelCase_	)
				model.eval()
				lowerCamelCase_					:  Optional[Any]						=    model(UpperCamelCase_     ,		attention_mask=UpperCamelCase_     ,		labels=UpperCamelCase_	)
				self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.num_labels)	)

			def 						__UpperCamelCase				(					self					:		Any     ,		UpperCamelCase_					:		List[Any]     ,		UpperCamelCase_					:		Dict     ,		UpperCamelCase_					:		Tuple     ,		UpperCamelCase_					:		Optional[int]     ,		UpperCamelCase_					:		str     ,		UpperCamelCase_					:		Union[str, Any]	) ->  int:







				"""simple docstring"""






				lowerCamelCase_					:  Union[str, Any]						=    self.num_choices
				lowerCamelCase_					:  List[str]						=    MPNetForMultipleChoice(config=UpperCamelCase_	)
				model.to(UpperCamelCase_	)
				model.eval()
				lowerCamelCase_					:  str						=    input_ids.unsqueeze(1	).expand(-1     ,		self.num_choices     ,		-1	).contiguous()
				lowerCamelCase_					:  Optional[int]						=    input_mask.unsqueeze(1	).expand(-1     ,		self.num_choices     ,		-1	).contiguous()
				lowerCamelCase_					:  str						=    model(
				    UpperCamelCase_     ,		attention_mask=UpperCamelCase_     ,		labels=UpperCamelCase_     ,		)
				self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.num_choices)	)

			def 						__UpperCamelCase				(					self					:		Optional[Any]     ,		UpperCamelCase_					:		Union[str, Any]     ,		UpperCamelCase_					:		Optional[Any]     ,		UpperCamelCase_					:		List[str]     ,		UpperCamelCase_					:		Optional[Any]     ,		UpperCamelCase_					:		Union[str, Any]     ,		UpperCamelCase_					:		Tuple	) ->  Dict:







				"""simple docstring"""






				lowerCamelCase_					:  str						=    self.num_labels
				lowerCamelCase_					:  Dict						=    MPNetForTokenClassification(config=UpperCamelCase_	)
				model.to(UpperCamelCase_	)
				model.eval()
				lowerCamelCase_					:  Union[str, Any]						=    model(UpperCamelCase_     ,		attention_mask=UpperCamelCase_     ,		labels=UpperCamelCase_	)
				self.parent.assertEqual(result.logits.shape     ,		(self.batch_size, self.seq_length, self.num_labels)	)





			def 						__UpperCamelCase				(					self					:		Dict	) ->  Any:







				"""simple docstring"""






				lowerCamelCase_					:  List[str]						=    self.prepare_config_and_inputs()
				((lowerCamelCase_)	,				(lowerCamelCase_)	,				(lowerCamelCase_)	,				(lowerCamelCase_)	,				(lowerCamelCase_)	,				(lowerCamelCase_))					:  List[Any]						=    config_and_inputs
				lowerCamelCase_					:  int						=    {'''input_ids''': input_ids, '''attention_mask''': input_mask}
				return config, inputs_dict






@require_torch
class   lowerCAmelCase__ ( __UpperCamelCase						,__UpperCamelCase						,unittest.TestCase  ):
			A     				= (
			    (
			        MPNetForMaskedLM,
			        MPNetForMultipleChoice,
			        MPNetForQuestionAnswering,
			        MPNetForSequenceClassification,
			        MPNetForTokenClassification,
			        MPNetModel,
			    )
			    if is_torch_available()
			    else ()
			)
			A     				= (
			    {
			        'feature-extraction': MPNetModel,
			        'fill-mask': MPNetForMaskedLM,
			        'question-answering': MPNetForQuestionAnswering,
			        'text-classification': MPNetForSequenceClassification,
			        'token-classification': MPNetForTokenClassification,
			        'zero-shot': MPNetForSequenceClassification,
			    }
			    if is_torch_available()
			    else {}
			)
			A     				= False
			A     				= True

			def 						__UpperCamelCase				(					self					:		Any	) ->  List[str]:







				"""simple docstring"""






				lowerCamelCase_					:  Optional[int]						=    MPNetModelTester(self	)
				lowerCamelCase_					:  str						=    ConfigTester(self     ,		config_class=UpperCamelCase_     ,		hidden_size=37	)

			def 						__UpperCamelCase				(					self					:		int	) ->  List[Any]:







				"""simple docstring"""






				self.config_tester.run_common_tests()

			def 						__UpperCamelCase				(					self					:		str	) ->  str:







				"""simple docstring"""






				lowerCamelCase_					:  List[str]						=    self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_mpnet_model(*UpperCamelCase_	)

			def 						__UpperCamelCase				(					self					:		Dict	) ->  Optional[Any]:







				"""simple docstring"""






				lowerCamelCase_					:  Tuple						=    self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_mpnet_for_sequence_classification(*UpperCamelCase_	)

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







				"""simple docstring"""






				lowerCamelCase_					:  List[Any]						=    self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_mpnet_for_multiple_choice(*UpperCamelCase_	)

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







				"""simple docstring"""






				lowerCamelCase_					:  Optional[Any]						=    self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_mpnet_for_token_classification(*UpperCamelCase_	)





			def 						__UpperCamelCase				(					self					:		Tuple	) ->  Dict:







				"""simple docstring"""






				lowerCamelCase_					:  Tuple						=    self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_mpnet_for_question_answering(*UpperCamelCase_	)






@require_torch
class   lowerCAmelCase__ ( unittest.TestCase  ):

			@slow
			def 						__UpperCamelCase				(					self					:		List[Any]	) ->  List[Any]:







				"""simple docstring"""






				lowerCamelCase_					:  List[str]						=    MPNetModel.from_pretrained('''microsoft/mpnet-base'''	)
				lowerCamelCase_					:  List[Any]						=    torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]]	)
				lowerCamelCase_					:  Tuple						=    model(UpperCamelCase_	)[0]
				lowerCamelCase_					:  List[str]						=    torch.Size((1, 11, 768)	)
				self.assertEqual(output.shape     ,		UpperCamelCase_	)
				lowerCamelCase_					:  Optional[Any]						=    torch.tensor(
				    [[[-0.0550, 0.1943, -0.0740], [-0.0562, 0.2211, -0.0579], [-0.0437, 0.3337, -0.0641]]]	)
				# compare the actual values for a slice.
				self.assertTrue(torch.allclose(output[:, :3, :3]     ,		UpperCamelCase_     ,		atol=1e-4	)	)








import unittest

from transformers import BertGenerationTokenizer
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


__magic_name__  							=	'''▁'''

__magic_name__  							=	get_tests_dir('''fixtures/test_sentencepiece.model''')




@require_sentencepiece
class        _SCREAMING_SNAKE_CASE	(   __UpperCamelCase							,       unittest.TestCase			):
      _A    :		List[str]     						=  BertGenerationTokenizer
      _A    :		int     						=  False
      _A    :		Optional[Any]     						=  True
      def A_      (      self			):
          super().setUp()

          snake_case__    =					BertGenerationTokenizer(lowerCamelCase		,						keep_accents=lowerCamelCase			)
          tokenizer.save_pretrained(self.tmpdirname			)
      def A_      (      self			):
          snake_case__    =					"<s>"
          snake_case__    =					1

          self.assertEqual(self.get_tokenizer()._convert_token_to_id(lowerCamelCase			)		,						lowerCamelCase			)
          self.assertEqual(self.get_tokenizer()._convert_id_to_token(lowerCamelCase			)		,						lowerCamelCase			)
      def A_      (      self			):
          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]		,						"<pad>"			)
          self.assertEqual(len(lowerCamelCase			)		,						10_02			)
      def A_      (      self			):
          self.assertEqual(self.get_tokenizer().vocab_size		,						10_00			)
      def A_      (      self			):
          snake_case__    =					BertGenerationTokenizer(lowerCamelCase		,						keep_accents=lowerCamelCase			)

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

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

          snake_case__    =					tokenizer.tokenize("I was born in 92000, and this is falsé."			)
          self.assertListEqual(
              lowerCamelCase		,						[
                  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(lowerCamelCase			)
          self.assertListEqual(
              lowerCamelCase		,						[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(lowerCamelCase			)
          self.assertListEqual(
              lowerCamelCase		,						[
                  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>",
                  ".",
              ]		,						)
      @cached_property
      def A_      (      self			):
          return BertGenerationTokenizer.from_pretrained("google/bert_for_seq_generation_L-24_bbc_encoder"			)
      @slow
      def A_      (      self			):
          snake_case__    =					"Hello World!"
          snake_case__    =					[1_85_36, 22_60, 1_01]

          self.assertListEqual(lowerCamelCase		,						self.big_tokenizer.encode(lowerCamelCase			)			)
      @slow
      def A_      (      self			):
          snake_case__    =					(
              "This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"
              " add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth"
          )
          snake_case__    =					[
              8_71,
              4_19,
              3_58,
              9_46,
              9_91,
              25_21,
              4_52,
              3_58,
              13_57,
              3_87,
              77_51,
              35_36,
              1_12,
              9_85,
              4_56,
              1_26,
              8_65,
              9_38,
              54_00,
              57_34,
              4_58,
              13_68,
              4_67,
              7_86,
              24_62,
              52_46,
              11_59,
              6_33,
              8_65,
              45_19,
              4_57,
              5_82,
              8_52,
              25_57,
              4_27,
              9_16,
              5_08,
              4_05,
              3_43_24,
              4_97,
              3_91,
              4_08,
              1_13_42,
              12_44,
              3_85,
              1_00,
              9_38,
              9_85,
              4_56,
              5_74,
              3_62,
              1_25_97,
              32_00,
              31_29,
              11_72,
          ]

          self.assertListEqual(lowerCamelCase		,						self.big_tokenizer.encode(lowerCamelCase			)			)
      @require_torch
      @slow
      def A_      (      self			):
          import torch

          from transformers import BertGenerationConfig, BertGenerationEncoder

          # Build sequence
          snake_case__    =					list(self.big_tokenizer.get_vocab().keys()			)[:10]
          snake_case__    =					" ".join(lowerCamelCase			)
          snake_case__    =					self.big_tokenizer.encode_plus(lowerCamelCase		,						return_tensors="pt"		,						return_token_type_ids=lowerCamelCase			)
          snake_case__    =					self.big_tokenizer.batch_encode_plus(
              [sequence + " " + sequence]		,						return_tensors="pt"		,						return_token_type_ids=lowerCamelCase			)

          snake_case__    =					BertGenerationConfig()
          snake_case__    =					BertGenerationEncoder(lowerCamelCase			)

          assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

          with torch.no_grad():
              model(**lowerCamelCase			)
              model(**lowerCamelCase			)



      @slow
      def A_      (      self			):
          # fmt: off
          snake_case__    =					{"input_ids": [[3_92_86, 4_58, 3_63_35, 20_01, 4_56, 1_30_73, 1_32_66, 4_55, 1_13, 77_46, 17_41, 1_11_57, 3_91, 1_30_73, 1_32_66, 4_55, 1_13, 39_67, 3_54_12, 1_13, 49_36, 1_09, 38_70, 23_77, 1_13, 3_00_84, 4_57_20, 4_58, 1_34, 1_74_96, 1_12, 5_03, 1_16_72, 1_13, 1_18, 1_12, 56_65, 1_33_47, 3_86_87, 1_12, 14_96, 3_13_89, 1_12, 32_68, 4_72_64, 1_34, 9_62, 1_12, 1_63_77, 80_35, 2_31_30, 4_30, 1_21_69, 1_55_18, 2_85_92, 4_58, 1_46, 4_16_97, 1_09, 3_91, 1_21_69, 1_55_18, 1_66_89, 4_58, 1_46, 4_13_58, 1_09, 4_52, 7_26, 40_34, 1_11, 7_63, 3_54_12, 50_82, 3_88, 19_03, 1_11, 90_51, 3_91, 28_70, 4_89_18, 19_00, 11_23, 5_50, 9_98, 1_12, 95_86, 1_59_85, 4_55, 3_91, 4_10, 2_29_55, 3_76_36, 1_14], [4_48, 1_74_96, 4_19, 36_63, 3_85, 7_63, 1_13, 2_75_33, 28_70, 32_83, 1_30_43, 16_39, 2_47_13, 5_23, 6_56, 2_40_13, 1_85_50, 25_21, 5_17, 2_70_14, 2_12_44, 4_20, 12_12, 14_65, 3_91, 9_27, 48_33, 3_88, 5_78, 1_17_86, 1_14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [4_84, 21_69, 76_87, 2_19_32, 1_81_46, 7_26, 3_63, 1_70_32, 33_91, 1_14, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 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], [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]]}  # noqa: E501
          # fmt: on

          self.tokenizer_integration_test_util(
              expected_encoding=lowerCamelCase		,						model_name="google/bert_for_seq_generation_L-24_bbc_encoder"		,						revision="c817d1fd1be2ffa69431227a1fe320544943d4db"		,						)



