


from __future__ import annotations

import unittest

from transformers import AutoTokenizer, GPTJConfig, is_tf_available
from transformers.testing_utils import require_tf, slow, tooslow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin
from ...utils.test_modeling_tf_core import TFCoreModelTesterMixin


if is_tf_available():
	import tensorflow as tf

	from transformers.models.gptj.modeling_tf_gptj import (
	    TFGPTJForCausalLM,
	    TFGPTJForQuestionAnswering,
	    TFGPTJForSequenceClassification,
	    TFGPTJModel,
	    shape_list,
	)





class        lowercase_				:






							"""simple docstring"""







							def __init__(   self			,    _UpperCAmelCase		):







													"""simple docstring"""


													a_					=		parent
													a_					=		13
													a_					=		7
													a_					=		True
													a_					=		True
													a_					=		True
													a_					=		True
													a_					=		True
													a_					=		99
													a_					=		32
													a_					=		4
													a_					=		2
													a_					=		4
													a_					=		37
													a_					=		"""gelu"""
													a_					=		0.1
													a_					=		0.1
													a_					=		512
													a_					=		16
													a_					=		2
													a_					=		0.0_2
													a_					=		3
													a_					=		4
													a_					=		None
													a_					=		self.vocab_size - 1
													a_					=		self.vocab_size - 1
													a_					=		self.vocab_size - 1


							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		ids_tensor([self.batch_size, self.seq_length]			,    self.vocab_size		)

													a_					=		None
													if self.use_input_mask:
																			a_					=		random_attention_mask([self.batch_size, self.seq_length]		)

													a_					=		None
													if self.use_token_type_ids:
																			a_					=		ids_tensor([self.batch_size, self.seq_length]			,    self.type_vocab_size		)

													a_					=		None
													if self.use_mc_token_ids:
																			a_					=		ids_tensor([self.batch_size, self.num_choices]			,    self.seq_length		)

													a_					=		None
													a_					=		None
													a_					=		None
													if self.use_labels:
																			a_					=		ids_tensor([self.batch_size]			,    self.type_sequence_label_size		)
																			a_					=		ids_tensor([self.batch_size, self.seq_length]			,    self.num_labels		)
																			a_					=		ids_tensor([self.batch_size]			,    self.num_choices		)

													a_					=		GPTJConfig(
													    vocab_size=self.vocab_size			,    n_embd=self.hidden_size			,    n_layer=self.num_hidden_layers			,    n_head=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			,    n_positions=self.max_position_embeddings			,    type_vocab_size=self.type_vocab_size			,    initializer_range=self.initializer_range			,    bos_token_id=self.bos_token_id			,    eos_token_id=self.eos_token_id			,    pad_token_id=self.pad_token_id			,    rotary_dim=self.rotary_dim			,    return_dict=_UpperCAmelCase			,    )

													a_					=		ids_tensor([self.num_hidden_layers, self.num_attention_heads]			,    2		)

													return (
													    config,
													    input_ids,
													    input_mask,
													    head_mask,
													    token_type_ids,
													    mc_token_ids,
													    sequence_labels,
													    token_labels,
													    choice_labels,
													)


							def 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    *_UpperCAmelCase		):







													"""simple docstring"""


													a_					=		TFGPTJModel(config=_UpperCAmelCase		)
													a_					=		{
													    """input_ids""": input_ids,
													    """attention_mask""": input_mask,
													    """token_type_ids""": token_type_ids,
													}
													a_					=		model(_UpperCAmelCase		)

													a_					=		[input_ids, None, input_mask]  # None is the input for 'past'
													a_					=		model(_UpperCAmelCase		)

													a_					=		model(_UpperCAmelCase		)

													self.parent.assertEqual(result.last_hidden_state.shape			,    (self.batch_size, self.seq_length, self.hidden_size)		)


							def 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    *_UpperCAmelCase		):







													"""simple docstring"""


													a_					=		TFGPTJModel(config=_UpperCAmelCase		)

													# first forward pass
													a_					=		model(_UpperCAmelCase			,    token_type_ids=_UpperCAmelCase			,    use_cache=_UpperCAmelCase		)
													a_					=		model(_UpperCAmelCase			,    token_type_ids=_UpperCAmelCase		)
													a_					=		model(_UpperCAmelCase			,    token_type_ids=_UpperCAmelCase			,    use_cache=_UpperCAmelCase		)

													self.parent.assertTrue(len(_UpperCAmelCase		) == len(_UpperCAmelCase		)		)
													self.parent.assertTrue(len(_UpperCAmelCase		) == len(_UpperCAmelCase		) + 1		)

													a_			,   a_					=		outputs.to_tuple()

													# create hypothetical next token and extent to next_input_ids
													a_					=		ids_tensor((self.batch_size, 1)			,    config.vocab_size		)
													a_					=		ids_tensor([self.batch_size, 1]			,    self.type_vocab_size		)

													# append to next input_ids and token_type_ids
													a_					=		tf.concat([input_ids, next_tokens]			,    axis=-1		)
													a_					=		tf.concat([token_type_ids, next_token_types]			,    axis=-1		)

													a_					=		model(_UpperCAmelCase			,    token_type_ids=_UpperCAmelCase		)["""last_hidden_state"""]
													a_					=		model(_UpperCAmelCase			,    token_type_ids=_UpperCAmelCase			,    past_key_values=_UpperCAmelCase		)[
													    """last_hidden_state"""
													]

													# select random slice
													a_					=		int(ids_tensor((1,)			,    shape_list(_UpperCAmelCase		)[-1]		)		)
													a_					=		output_from_no_past[:, -1, random_slice_idx]
													a_					=		output_from_past[:, 0, random_slice_idx]

													# test that outputs are equal for slice
													tf.debugging.assert_near(_UpperCAmelCase			,    _UpperCAmelCase			,    rtol=1e-6		)


							def 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    *_UpperCAmelCase		):







													"""simple docstring"""


													a_					=		TFGPTJModel(config=_UpperCAmelCase		)

													# create attention mask
													a_					=		self.seq_length // 2
													a_					=		tf.ones((self.batch_size, half_seq_length)			,    dtype=tf.intaa		)
													a_					=		tf.zeros((self.batch_size, self.seq_length - half_seq_length)			,    dtype=tf.intaa		)
													a_					=		tf.concat([attn_mask_begin, attn_mask_end]			,    axis=1		)

													# first forward pass
													a_			,   a_					=		model(_UpperCAmelCase			,    attention_mask=_UpperCAmelCase		).to_tuple()

													# create hypothetical next token and extent to next_input_ids
													a_					=		ids_tensor((self.batch_size, 1)			,    config.vocab_size		)

													# change a random masked slice from input_ids
													a_					=		ids_tensor((1,)			,    _UpperCAmelCase		).numpy() + 1
													a_					=		ids_tensor((self.batch_size, self.seq_length)			,    config.vocab_size		)
													a_					=		tf.range(self.seq_length		) == (self.seq_length - random_seq_idx_to_change)
													a_					=		tf.transpose(
													    tf.broadcast_to(tf.expand_dims(_UpperCAmelCase			,    -1		)			,    (self.seq_length, self.batch_size)		)		)
													a_					=		tf.where(_UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase		)

													# append to next input_ids and attn_mask
													a_					=		tf.concat([input_ids, next_tokens]			,    axis=-1		)
													a_					=		tf.concat([attn_mask, tf.ones((shape_list(_UpperCAmelCase		)[0], 1)			,    dtype=tf.intaa		)]			,    axis=1		)

													# get two different outputs
													a_					=		model(_UpperCAmelCase			,    attention_mask=_UpperCAmelCase		)["""last_hidden_state"""]
													a_					=		model(_UpperCAmelCase			,    past_key_values=_UpperCAmelCase			,    attention_mask=_UpperCAmelCase		)[
													    """last_hidden_state"""
													]

													# select random slice
													a_					=		int(ids_tensor((1,)			,    shape_list(_UpperCAmelCase		)[-1]		)		)
													a_					=		output_from_no_past[:, -1, random_slice_idx]
													a_					=		output_from_past[:, 0, random_slice_idx]

													# test that outputs are equal for slice
													tf.debugging.assert_near(_UpperCAmelCase			,    _UpperCAmelCase			,    rtol=1e-1_2		)


							def 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    *_UpperCAmelCase		):







													"""simple docstring"""


													a_					=		TFGPTJModel(config=_UpperCAmelCase		)

													a_					=		input_ids[:1, :]
													a_					=		input_mask[:1, :]
													a_					=		token_type_ids[:1, :]
													a_					=		1

													# first forward pass
													a_					=		model(_UpperCAmelCase			,    attention_mask=_UpperCAmelCase			,    token_type_ids=_UpperCAmelCase			,    use_cache=_UpperCAmelCase		)

													a_			,   a_					=		outputs.to_tuple()

													# create hypothetical next token and extent to next_input_ids
													a_					=		ids_tensor((self.batch_size, 3)			,    config.vocab_size		)
													a_					=		ids_tensor((self.batch_size, 3)			,    2		)
													a_					=		ids_tensor((self.batch_size, 3)			,    self.type_vocab_size		)

													# append to next input_ids and token_type_ids
													a_					=		tf.concat([input_ids, next_tokens]			,    axis=-1		)
													a_					=		tf.concat([input_mask, next_attn_mask]			,    axis=-1		)
													a_					=		tf.concat([token_type_ids, next_token_types]			,    axis=-1		)

													a_					=		model(
													    _UpperCAmelCase			,    token_type_ids=_UpperCAmelCase			,    attention_mask=_UpperCAmelCase		)["""last_hidden_state"""]
													a_					=		model(
													    _UpperCAmelCase			,    token_type_ids=_UpperCAmelCase			,    attention_mask=_UpperCAmelCase			,    past_key_values=_UpperCAmelCase			,    )["""last_hidden_state"""]
													self.parent.assertTrue(output_from_past.shape[1] == next_tokens.shape[1]		)

													# select random slice
													a_					=		int(ids_tensor((1,)			,    shape_list(_UpperCAmelCase		)[-1]		)		)
													a_					=		output_from_no_past[:, -3:, random_slice_idx]
													a_					=		output_from_past[:, :, random_slice_idx]

													# test that outputs are equal for slice
													tf.debugging.assert_near(_UpperCAmelCase			,    _UpperCAmelCase			,    rtol=1e-3		)


							def 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    *_UpperCAmelCase		):







													"""simple docstring"""


													a_					=		TFGPTJForCausalLM(config=_UpperCAmelCase		)
													a_					=		{
													    """input_ids""": input_ids,
													    """attention_mask""": input_mask,
													    """token_type_ids""": token_type_ids,
													}
													a_					=		model(_UpperCAmelCase		)
													self.parent.assertEqual(result.logits.shape			,    (self.batch_size, self.seq_length, self.vocab_size)		)






							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		self.prepare_config_and_inputs()

													(
													    (
													    a_
													)			,   (
													    a_
													)			,   (
													    a_
													)			,   (
													    a_
													)			,   (
													    a_
													)			,   (
													    a_
													)			,   (
													    a_
													)			,   (
													    a_
													)			,   (
													    a_
													)			,   
													)					=		config_and_inputs

													a_					=		{
													    """input_ids""": input_ids,
													    """token_type_ids""": token_type_ids,
													    """attention_mask""": input_mask,
													}
													return config, inputs_dict





@require_tf
class        lowercase_				( UpperCamelCase__			,UpperCamelCase__			,UpperCamelCase__			,unittest.TestCase):






							"""simple docstring"""







							snake_case_        =		(
							    (TFGPTJForCausalLM, TFGPTJForSequenceClassification, TFGPTJForQuestionAnswering, TFGPTJModel)
							    if is_tf_available()
							    else ()
							)

							snake_case_        =		(TFGPTJForCausalLM,) if is_tf_available() else ()
							snake_case_        =		(
							    {
							        '''feature-extraction''': TFGPTJModel,
							        '''question-answering''': TFGPTJForQuestionAnswering,
							        '''text-classification''': TFGPTJForSequenceClassification,
							        '''text-generation''': TFGPTJForCausalLM,
							        '''zero-shot''': TFGPTJForSequenceClassification,
							    }
							    if is_tf_available()
							    else {}
							)
							snake_case_        =		False
							snake_case_        =		False
							snake_case_        =		False
							snake_case_        =		False


							def 						lowercase__     (   self			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase			,    _UpperCAmelCase		):







													"""simple docstring"""


													if (
													    pipeline_test_casse_name == "QAPipelineTests"
													    and tokenizer_name is not None
													    and not tokenizer_name.endswith("""Fast"""		)
													):
																			# `QAPipelineTests` fails for a few models when the slower tokenizer are used.
																			# (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
																			# TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
																			return True

													return False


							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		TFGPTJModelTester(self		)
													a_					=		ConfigTester(self			,    config_class=_UpperCAmelCase			,    n_embd=37		)


							def 						lowercase__     (   self		):







													"""simple docstring"""


													self.config_tester.run_common_tests()


							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_gptj_model(*_UpperCAmelCase		)


							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_gptj_model_past(*_UpperCAmelCase		)


							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_gptj_model_attention_mask_past(*_UpperCAmelCase		)


							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_gptj_model_past_large_inputs(*_UpperCAmelCase		)


							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_gptj_lm_head_model(*_UpperCAmelCase		)


							@slow
							@unittest.skipIf(
							    not is_tf_available() or len(tf.config.list_physical_devices("""GPU"""		)		) > 0			,    """skip testing on GPU for now to avoid GPU OOM."""			,    )
							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		TFGPTJModel.from_pretrained("""EleutherAI/gpt-j-6B"""			,    from_pt=_UpperCAmelCase		)
													self.assertIsNotNone(_UpperCAmelCase		)






							@unittest.skip(reason="""Currently, model embeddings are going to undergo a major refactor."""		)
							def 						lowercase__     (   self		):







													"""simple docstring"""


													super().test_resize_token_embeddings()





@require_tf
@tooslow
# Marked as @tooslow due to GPU OOM -- but still useful to run locally. Requires ~39GB of RAM.
class        lowercase_				( unittest.TestCase):






							"""simple docstring"""







							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		TFGPTJForCausalLM.from_pretrained("""EleutherAI/gpt-j-6B"""			,    from_pt=_UpperCAmelCase		)
													a_					=		tf.convert_to_tensor([[464, 3_290]]			,    dtype=tf.intaa		)  # The dog
													# fmt: off
													# The dog is a man's best friend. It is a loyal companion, and it is a friend
													a_					=		[464, 3_290, 318, 257, 582, 338, 1_266, 1_545, 13, 632, 318, 257, 9_112, 15_185, 11, 290, 340, 318, 257, 1_545]
													# fmt: on
													a_					=		model.generate(_UpperCAmelCase			,    do_sample=_UpperCAmelCase		)
													self.assertListEqual(output_ids[0].numpy().tolist()			,    _UpperCAmelCase		)


							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		AutoTokenizer.from_pretrained("""EleutherAI/gpt-j-6B"""			,    revision="""float16"""		)
													a_					=		TFGPTJForCausalLM.from_pretrained("""EleutherAI/gpt-j-6B"""			,    revision="""float16"""			,    from_pt=_UpperCAmelCase		)

													a_					=		tokenizer("""Today is a nice day and"""			,    return_tensors="""tf"""		)
													# forces the generation to happen on CPU, to avoid GPU-related quirks
													with tf.device(""":/CPU:0"""		):
																			a_					=		model.generate(**_UpperCAmelCase			,    do_sample=_UpperCAmelCase			,    seed=[42, 0]		)
													a_					=		tokenizer.decode(output_ids[0]			,    skip_special_tokens=_UpperCAmelCase		)

													a_					=		"""Today is a nice day and I’m going to go for a walk. I’"""
													self.assertEqual(_UpperCAmelCase			,    _UpperCAmelCase		)


							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		TFGPTJForCausalLM.from_pretrained("""EleutherAI/gpt-j-6B"""			,    revision="""float16"""			,    from_pt=_UpperCAmelCase		)
													a_					=		AutoTokenizer.from_pretrained("""EleutherAI/gpt-j-6B"""			,    revision="""float16"""		)

													a_					=		"""left"""

													# Define PAD Token = EOS Token = 50256
													a_					=		tokenizer.eos_token
													a_					=		model.config.eos_token_id

													# use different length sentences to test batching
													a_					=		[
													    """Hello, my dog is a little""",
													    """Today, I""",
													]
													a_					=		[
													    """Hello, my dog is a little over a year old and has been diagnosed with hip dysplasia""",
													    """Today, I’m going to be talking about a topic that’""",
													]
													return model, tokenizer, sentences, expected_output_sentences


							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_			,   a_			,   a_			,   a_					=		self._get_beam_search_test_objects()

													a_					=		tokenizer(_UpperCAmelCase			,    return_tensors="""tf"""			,    padding=_UpperCAmelCase		)
													a_					=		model.generate(**_UpperCAmelCase			,    do_sample=_UpperCAmelCase			,    num_beams=2		)
													a_					=		tokenizer.batch_decode(_UpperCAmelCase			,    skip_special_tokens=_UpperCAmelCase		)
													self.assertListEqual(_UpperCAmelCase			,    _UpperCAmelCase		)


							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_			,   a_			,   a_			,   a_					=		self._get_beam_search_test_objects()

													a_					=		tokenizer(_UpperCAmelCase			,    return_tensors="""tf"""			,    padding=_UpperCAmelCase		)
													a_					=		tokenizer(sentences[0]			,    return_tensors="""tf"""		)
													a_					=		model.generate(**_UpperCAmelCase			,    do_sample=_UpperCAmelCase			,    num_beams=2		)
													a_					=		(
													    shape_list(inputs_non_padded["""input_ids"""]		)[-1]
													    - tf.reduce_sum(tf.cast(inputs["""attention_mask"""][-1]			,    tf.intaa		)		).numpy()
													)
													a_					=		tokenizer(sentences[1]			,    return_tensors="""tf"""		)
													a_					=		model.generate(
													    **_UpperCAmelCase			,    do_sample=_UpperCAmelCase			,    num_beams=2			,    max_length=model.config.max_length - num_paddings		)
													a_					=		tokenizer.decode(output_non_padded[0]			,    skip_special_tokens=_UpperCAmelCase		)
													a_					=		tokenizer.decode(output_padded[0]			,    skip_special_tokens=_UpperCAmelCase		)
													self.assertListEqual(_UpperCAmelCase			,    [non_padded_sentence, padded_sentence]		)






							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_			,   a_			,   a_			,   a_					=		self._get_beam_search_test_objects()

													a_					=		tokenizer(_UpperCAmelCase			,    return_tensors="""tf"""			,    padding=_UpperCAmelCase		)
													a_					=		tf.function(model.generate			,    jit_compile=_UpperCAmelCase		)
													a_					=		xla_generate(**_UpperCAmelCase			,    do_sample=_UpperCAmelCase			,    num_beams=2		)
													a_					=		tokenizer.batch_decode(_UpperCAmelCase			,    skip_special_tokens=_UpperCAmelCase		)
													self.assertListEqual(_UpperCAmelCase			,    _UpperCAmelCase		)



import os
import unittest

from transformers import MPNetTokenizerFast
from transformers.models.mpnet.tokenization_mpnet import VOCAB_FILES_NAMES, MPNetTokenizer
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin





@require_tokenizers
class        lowercase_				( UpperCamelCase__			,unittest.TestCase):






							"""simple docstring"""







							snake_case_        =		MPNetTokenizer
							snake_case_        =		MPNetTokenizerFast
							snake_case_        =		True
							snake_case_        =		True


							def 						lowercase__     (   self		):







													"""simple docstring"""


													super().setUp()

													a_					=		[
													    """[UNK]""",
													    """[CLS]""",
													    """[SEP]""",
													    """[PAD]""",
													    """[MASK]""",
													    """want""",
													    """##want""",
													    """##ed""",
													    """wa""",
													    """un""",
													    """runn""",
													    """##ing""",
													    """,""",
													    """low""",
													    """lowest""",
													]
													a_					=		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			,    _UpperCAmelCase		):







													"""simple docstring"""


													a_					=		"""UNwant\u00E9d,running"""
													a_					=		"""unwanted, running"""
													return input_text, output_text


							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		self.tokenizer_class(self.vocab_file		)

													a_					=		tokenizer.tokenize("""UNwant\u00E9d,running"""		)
													self.assertListEqual(_UpperCAmelCase			,    ["""un""", """##want""", """##ed""", """,""", """runn""", """##ing"""]		)
													self.assertListEqual(tokenizer.convert_tokens_to_ids(_UpperCAmelCase		)			,    [9, 6, 7, 12, 10, 11]		)






							@slow
							def 						lowercase__     (   self		):







													"""simple docstring"""


													a_					=		self.tokenizer_class.from_pretrained("""microsoft/mpnet-base"""		)

													a_					=		tokenizer.encode("""sequence builders"""			,    add_special_tokens=_UpperCAmelCase		)
													a_					=		tokenizer.encode("""multi-sequence build"""			,    add_special_tokens=_UpperCAmelCase		)

													a_					=		tokenizer.build_inputs_with_special_tokens(_UpperCAmelCase		)
													a_					=		tokenizer.build_inputs_with_special_tokens(_UpperCAmelCase			,    _UpperCAmelCase		)

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