
"""simple docstring"""


import unittest

from transformers import ElectraConfig, 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, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch

							from transformers import (
							    MODEL_FOR_PRETRAINING_MAPPING,
							    ElectraForCausalLM,
							    ElectraForMaskedLM,
							    ElectraForMultipleChoice,
							    ElectraForPreTraining,
							    ElectraForQuestionAnswering,
							    ElectraForSequenceClassification,
							    ElectraForTokenClassification,
							    ElectraModel,
							)
							from transformers.models.electra.modeling_electra import ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST

class 					A_			:



							"""simple docstring"""






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





										"""simple docstring"""

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





							def    UpperCAmelCase__							(						self						:Optional[int] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =ids_tensor([self.batch_size, self.seq_length]  ,							self.vocab_size )

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

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

										lowerCamelCase__			:  Any  =None
										lowerCamelCase__			:  Optional[Any]  =None
										lowerCamelCase__			:  List[Any]  =None
										if self.use_labels:
													lowerCamelCase__			:  Dict  =ids_tensor([self.batch_size]  ,							self.type_sequence_label_size )
													lowerCamelCase__			:  List[str]  =ids_tensor([self.batch_size, self.seq_length]  ,							self.num_labels )
													lowerCamelCase__			:  List[Any]  =ids_tensor([self.batch_size]  ,							self.num_choices )
													lowerCamelCase__			:  Any  =ids_tensor([self.batch_size, self.seq_length]  ,							1 )

										lowerCamelCase__			:  List[Any]  =self.get_config()

										return (
										    config,
										    input_ids,
										    token_type_ids,
										    input_mask,
										    sequence_labels,
										    token_labels,
										    choice_labels,
										    fake_token_labels,
										)





							def    UpperCAmelCase__							(						self						:Optional[Any] ):





										"""simple docstring"""

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





							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										(
										    (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       
										)			:  List[str]  =self.prepare_config_and_inputs()

										lowerCamelCase__			:  Union[str, Any]  =True
										lowerCamelCase__			:  Optional[int]  =floats_tensor([self.batch_size, self.seq_length, self.hidden_size] )
										lowerCamelCase__			:  Dict  =ids_tensor([self.batch_size, self.seq_length]  ,							vocab_size=2 )

										return (
										    config,
										    input_ids,
										    token_type_ids,
										    input_mask,
										    sequence_labels,
										    token_labels,
										    choice_labels,
										    encoder_hidden_states,
										    encoder_attention_mask,
										)





							def    UpperCAmelCase__							(						self						:Optional[Any]  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:List[Any]  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:int  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:int  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:str  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Optional[Any]  =ElectraModel(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  int  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_ )
										lowerCamelCase__			:  Union[str, Any]  =model(lowerCamelCase_  ,							token_type_ids=lowerCamelCase_ )
										lowerCamelCase__			:  Optional[Any]  =model(lowerCamelCase_ )
										self.parent.assertEqual(result.last_hidden_state.shape  ,							(self.batch_size, self.seq_length, self.hidden_size) )





							def    UpperCAmelCase__							(						self						:Optional[Any]  ,							lowerCamelCase_						:Union[str, Any]  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:Union[str, Any]  ,							lowerCamelCase_						:List[Any]  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Union[str, Any]  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =True
										lowerCamelCase__			:  Any  =ElectraModel(lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Any  =model(
										    lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							encoder_hidden_states=lowerCamelCase_  ,							encoder_attention_mask=lowerCamelCase_  ,							)
										lowerCamelCase__			:  Union[str, Any]  =model(
										    lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							encoder_hidden_states=lowerCamelCase_  ,							)
										lowerCamelCase__			:  Dict  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_ )
										self.parent.assertEqual(result.last_hidden_state.shape  ,							(self.batch_size, self.seq_length, self.hidden_size) )





							def    UpperCAmelCase__							(						self						:Optional[Any]  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:int  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:Any  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  int  =ElectraForMaskedLM(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Union[str, Any]  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							labels=lowerCamelCase_ )
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.seq_length, self.vocab_size) )





							def    UpperCAmelCase__							(						self						:Tuple  ,							lowerCamelCase_						:int  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:List[Any]  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  List[Any]  =ElectraForCausalLM(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Any  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							labels=lowerCamelCase_ )
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.seq_length, self.vocab_size) )





							def    UpperCAmelCase__							(						self						:str  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:Tuple  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  List[Any]  =self.num_labels
										lowerCamelCase__			:  List[str]  =ElectraForTokenClassification(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Optional[int]  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							labels=lowerCamelCase_ )
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.seq_length, self.num_labels) )





							def    UpperCAmelCase__							(						self						:int  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:Union[str, Any]  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Optional[int]  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =self.num_labels
										lowerCamelCase__			:  str  =ElectraForPreTraining(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Any  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							labels=lowerCamelCase_ )
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.seq_length) )





							def    UpperCAmelCase__							(						self						:Union[str, Any]  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:Any  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:List[Any]  ,							lowerCamelCase_						:Optional[Any]  ,							lowerCamelCase_						:Tuple  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Tuple  =self.num_labels
										lowerCamelCase__			:  Optional[Any]  =ElectraForSequenceClassification(lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  Dict  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							labels=lowerCamelCase_ )
										self.parent.assertEqual(result.logits.shape  ,							(self.batch_size, self.num_labels) )





							def    UpperCAmelCase__							(						self						:List[str]  ,							lowerCamelCase_						:str  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Optional[int]  ,							lowerCamelCase_						:int  ,							lowerCamelCase_						:Dict  ,							):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =ElectraForQuestionAnswering(config=lowerCamelCase_ )
										model.to(lowerCamelCase_ )
										model.eval()
										lowerCamelCase__			:  int  =model(
										    lowerCamelCase_  ,							attention_mask=lowerCamelCase_  ,							token_type_ids=lowerCamelCase_  ,							start_positions=lowerCamelCase_  ,							end_positions=lowerCamelCase_  ,							)
										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						:List[Any]  ,							lowerCamelCase_						:Union[str, Any]  ,							lowerCamelCase_						:List[str]  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:Union[str, Any]  ,							lowerCamelCase_						:Union[str, Any]  ,							lowerCamelCase_						:List[Any]  ,							lowerCamelCase_						:List[Any]  ,							):





										"""simple docstring"""

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





							def    UpperCAmelCase__							(						self						:str ):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =self.prepare_config_and_inputs()
										(
										    (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       (
										    lowerCamelCase__
										) ,       
										)			:  List[str]  =config_and_inputs
										lowerCamelCase__			:  Optional[Any]  ={'input_ids': input_ids, 'token_type_ids': token_type_ids, 'attention_mask': input_mask}
										return config, inputs_dict






@require_torch
class 					A_			(  A__   ,      A__   ,      unittest.TestCase     ):



							"""simple docstring"""






							SCREAMING_SNAKE_CASE_			   =     (
							    (
							        ElectraModel,
							        ElectraForPreTraining,
							        ElectraForMaskedLM,
							        ElectraForCausalLM,
							        ElectraForMultipleChoice,
							        ElectraForTokenClassification,
							        ElectraForSequenceClassification,
							        ElectraForQuestionAnswering,
							    )
							    if is_torch_available()
							    else ()
							)
							SCREAMING_SNAKE_CASE_			   =     (
							    {
							        """feature-extraction""": ElectraModel,
							        """fill-mask""": ElectraForMaskedLM,
							        """question-answering""": ElectraForQuestionAnswering,
							        """text-classification""": ElectraForSequenceClassification,
							        """text-generation""": ElectraForCausalLM,
							        """token-classification""": ElectraForTokenClassification,
							        """zero-shot""": ElectraForSequenceClassification,
							    }
							    if is_torch_available()
							    else {}
							)
							SCREAMING_SNAKE_CASE_			   =     True





							def    UpperCAmelCase__							(						self						:List[Any]  ,							lowerCamelCase_						:Dict  ,							lowerCamelCase_						:Tuple  ,							lowerCamelCase_						:List[Any]=False ):





										"""simple docstring"""

										lowerCamelCase__			:  Dict  =super()._prepare_for_class(lowerCamelCase_  ,							lowerCamelCase_  ,							return_labels=lowerCamelCase_ )

										if return_labels:
													if model_class in get_values(lowerCamelCase_ ):
																lowerCamelCase__			:  int  =torch.zeros(
																    (self.model_tester.batch_size, self.model_tester.seq_length)  ,							dtype=torch.long  ,							device=lowerCamelCase_ )
										return inputs_dict





							def    UpperCAmelCase__							(						self						:Optional[int] ):





										"""simple docstring"""

										lowerCamelCase__			:  Any  =ElectraModelTester(self )
										lowerCamelCase__			:  Tuple  =ConfigTester(self  ,							config_class=lowerCamelCase_  ,							hidden_size=37 )





							def    UpperCAmelCase__							(						self						:str ):





										"""simple docstring"""

										self.config_tester.run_common_tests()





							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_model(*lowerCamelCase_ )





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





										"""simple docstring"""

										lowerCamelCase__			:  int  =self.model_tester.prepare_config_and_inputs_for_decoder()
										self.model_tester.create_and_check_electra_model_as_decoder(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:Tuple ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										for type in ["absolute", "relative_key", "relative_key_query"]:
													lowerCamelCase__			:  List[Any]  =type
													self.model_tester.create_and_check_electra_model(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_masked_lm(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_token_classification(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:Dict ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_pretraining(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:Dict ):





										"""simple docstring"""

										lowerCamelCase__			:  Any  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_sequence_classification(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:Any ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_question_answering(*lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_electra_for_multiple_choice(*lowerCamelCase_ )





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





										"""simple docstring"""

										for model_name in ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													lowerCamelCase__			:  List[str]  =ElectraModel.from_pretrained(lowerCamelCase_ )
													self.assertIsNotNone(lowerCamelCase_ )





							def    UpperCAmelCase__							(						self						:List[str] ):





										"""simple docstring"""

										lowerCamelCase__			:  str  =self.model_tester.prepare_config_and_inputs_for_decoder()
										self.model_tester.create_and_check_electra_for_causal_lm(*lowerCamelCase_ )






@require_torch
class 					A_			(  unittest.TestCase     ):



							"""simple docstring"""






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





										"""simple docstring"""

										lowerCamelCase__			:  int  =ElectraModel.from_pretrained('google/electra-small-discriminator' )
										lowerCamelCase__			:  Any  =torch.tensor([[0, 345, 232, 328, 740, 140, 1_695, 69, 6_078, 1_588, 2]] )
										lowerCamelCase__			:  Optional[Any]  =torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]] )
										lowerCamelCase__			:  Optional[int]  =model(lowerCamelCase_  ,							attention_mask=lowerCamelCase_ )[0]
										lowerCamelCase__			:  Tuple  =torch.Size((1, 11, 256) )
										self.assertEqual(output.shape  ,							lowerCamelCase_ )
										lowerCamelCase__			:  Any  =torch.tensor(
										    [[[0.44_71, 0.68_21, -0.32_65], [0.46_27, 0.52_55, -0.36_68], [0.45_32, 0.33_13, -0.43_44]]] )

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

"""simple docstring"""


import unittest
import warnings

from datasets.utils import experimental






@experimental
def      lowerCAmelCase_     (	)     ->Optional[Any]:
			return "success"

class 					A_			(  unittest.TestCase     ):



							"""simple docstring"""






							def    UpperCAmelCase__							(						self						:int ):





										"""simple docstring"""

										with warnings.catch_warnings(record=lowerCamelCase_ ) as w:
													warnings.simplefilter('always' )
													self.assertEqual(dummy_function()  ,							'success' )
										self.assertEqual(len(lowerCamelCase_ )  ,							1 )