



import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch
							from torch import nn

							from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
							from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor







class 							a_  :

						def __init__(    self	:List[Any]   ,						_lowercase	:Tuple   ,						_lowercase	:Optional[Any]=13   ,						_lowercase	:str=32   ,						_lowercase	:Optional[int]=2   ,						_lowercase	:Any=3   ,						_lowercase	:Optional[Any]=16   ,						_lowercase	:int=[1, 2, 1]   ,						_lowercase	:Optional[Any]=[2, 2, 4]   ,						_lowercase	:Any=2   ,						_lowercase	:List[str]=2.0   ,						_lowercase	:Union[str, Any]=True   ,						_lowercase	:Dict=0.0   ,						_lowercase	:Optional[Any]=0.0   ,						_lowercase	:str=0.1   ,						_lowercase	:Tuple="gelu"   ,						_lowercase	:List[Any]=False   ,						_lowercase	:Dict=True   ,						_lowercase	:str=0.02   ,						_lowercase	:Tuple=1E-5   ,						_lowercase	:str=True   ,						_lowercase	:List[str]=None   ,						_lowercase	:Optional[Any]=True   ,						_lowercase	:Optional[int]=10   ,						_lowercase	:List[str]=8   ,						_lowercase	:Dict=["stage1", "stage2"]   ,						_lowercase	:List[Any]=[1, 2]   ,						)		->					Tuple:
												UpperCAmelCase_     							=     parent
												UpperCAmelCase_     							=     batch_size
												UpperCAmelCase_     							=     image_size
												UpperCAmelCase_     							=     patch_size
												UpperCAmelCase_     							=     num_channels
												UpperCAmelCase_     							=     embed_dim
												UpperCAmelCase_     							=     depths
												UpperCAmelCase_     							=     num_heads
												UpperCAmelCase_     							=     window_size
												UpperCAmelCase_     							=     mlp_ratio
												UpperCAmelCase_     							=     qkv_bias
												UpperCAmelCase_     							=     hidden_dropout_prob
												UpperCAmelCase_     							=     attention_probs_dropout_prob
												UpperCAmelCase_     							=     drop_path_rate
												UpperCAmelCase_     							=     hidden_act
												UpperCAmelCase_     							=     use_absolute_embeddings
												UpperCAmelCase_     							=     patch_norm
												UpperCAmelCase_     							=     layer_norm_eps
												UpperCAmelCase_     							=     initializer_range
												UpperCAmelCase_     							=     is_training
												UpperCAmelCase_     							=     scope
												UpperCAmelCase_     							=     use_labels
												UpperCAmelCase_     							=     type_sequence_label_size
												UpperCAmelCase_     							=     encoder_stride
												UpperCAmelCase_     							=     out_features
												UpperCAmelCase_     							=     out_indices

						def 	__a       (    self	:Any)		->					Tuple:
												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.type_sequence_label_size)

												UpperCAmelCase_     							=     self.get_config()

												return config, pixel_values, labels

						def 	__a       (    self	:Any)		->					List[Any]:
												return SwinConfig(
												    image_size=self.image_size   ,						patch_size=self.patch_size   ,						num_channels=self.num_channels   ,						embed_dim=self.embed_dim   ,						depths=self.depths   ,						num_heads=self.num_heads   ,						window_size=self.window_size   ,						mlp_ratio=self.mlp_ratio   ,						qkv_bias=self.qkv_bias   ,						hidden_dropout_prob=self.hidden_dropout_prob   ,						attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,						drop_path_rate=self.drop_path_rate   ,						hidden_act=self.hidden_act   ,						use_absolute_embeddings=self.use_absolute_embeddings   ,						path_norm=self.patch_norm   ,						layer_norm_eps=self.layer_norm_eps   ,						initializer_range=self.initializer_range   ,						encoder_stride=self.encoder_stride   ,						out_features=self.out_features   ,						out_indices=self.out_indices   ,						)

						def 	__a       (    self	:Any   ,						_lowercase	:List[Any]   ,						_lowercase	:Tuple   ,						_lowercase	:List[Any])		->					Dict:
												UpperCAmelCase_     							=     SwinModel(config=_lowercase)
												model.to(_lowercase)
												model.eval()
												UpperCAmelCase_     							=     model(_lowercase)

												UpperCAmelCase_     							=     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths) - 1))
												UpperCAmelCase_     							=     int(config.embed_dim * 2 ** (len(config.depths) - 1))

												self.parent.assertEqual(result.last_hidden_state.shape   ,						(self.batch_size, expected_seq_len, expected_dim))

						def 	__a       (    self	:str   ,						_lowercase	:Union[str, Any]   ,						_lowercase	:Union[str, Any]   ,						_lowercase	:List[str])		->					List[str]:
												UpperCAmelCase_     							=     SwinBackbone(config=_lowercase)
												model.to(_lowercase)
												model.eval()
												UpperCAmelCase_     							=     model(_lowercase)

												# verify hidden states
												self.parent.assertEqual(len(result.feature_maps)   ,						len(config.out_features))
												self.parent.assertListEqual(list(result.feature_maps[0].shape)   ,						[self.batch_size, model.channels[0], 16, 16])

												# verify channels
												self.parent.assertEqual(len(model.channels)   ,						len(config.out_features))

												# verify backbone works with out_features=None
												UpperCAmelCase_     							=     None
												UpperCAmelCase_     							=     SwinBackbone(config=_lowercase)
												model.to(_lowercase)
												model.eval()
												UpperCAmelCase_     							=     model(_lowercase)

												# verify feature maps
												self.parent.assertEqual(len(result.feature_maps)   ,						1)
												self.parent.assertListEqual(list(result.feature_maps[0].shape)   ,						[self.batch_size, model.channels[-1], 4, 4])

												# verify channels
												self.parent.assertEqual(len(model.channels)   ,						1)

						def 	__a       (    self	:List[str]   ,						_lowercase	:List[str]   ,						_lowercase	:Union[str, Any]   ,						_lowercase	:Union[str, Any])		->					List[str]:
												UpperCAmelCase_     							=     SwinForMaskedImageModeling(config=_lowercase)
												model.to(_lowercase)
												model.eval()
												UpperCAmelCase_     							=     model(_lowercase)
												self.parent.assertEqual(
												    result.logits.shape   ,						(self.batch_size, self.num_channels, self.image_size, self.image_size))

												# test greyscale images
												UpperCAmelCase_     							=     1
												UpperCAmelCase_     							=     SwinForMaskedImageModeling(_lowercase)
												model.to(_lowercase)
												model.eval()

												UpperCAmelCase_     							=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
												UpperCAmelCase_     							=     model(_lowercase)
												self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, 1, self.image_size, self.image_size))

						def 	__a       (    self	:Tuple   ,						_lowercase	:str   ,						_lowercase	:int   ,						_lowercase	:Any)		->					Optional[Any]:
												UpperCAmelCase_     							=     self.type_sequence_label_size
												UpperCAmelCase_     							=     SwinForImageClassification(_lowercase)
												model.to(_lowercase)
												model.eval()
												UpperCAmelCase_     							=     model(_lowercase   ,						labels=_lowercase)
												self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.type_sequence_label_size))

												# test greyscale images
												UpperCAmelCase_     							=     1
												UpperCAmelCase_     							=     SwinForImageClassification(_lowercase)
												model.to(_lowercase)
												model.eval()

												UpperCAmelCase_     							=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size])
												UpperCAmelCase_     							=     model(_lowercase)
												self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.type_sequence_label_size))




						def 	__a       (    self	:int)		->					Optional[int]:
												UpperCAmelCase_     							=     self.prepare_config_and_inputs()
												(
												    (
												    UpperCAmelCase_
												)							,      (
												    UpperCAmelCase_
												)							,      (
												    UpperCAmelCase_
												)							,      
												)     							=     config_and_inputs
												UpperCAmelCase_     							=     {'''pixel_values''': pixel_values}
												return config, inputs_dict







@require_torch
class 							a_  (		_snake_case					, _snake_case					, unittest.TestCase				):
						UpperCamelCase__      :						Tuple				       =(
						    (
						        SwinModel,
						        SwinBackbone,
						        SwinForImageClassification,
						        SwinForMaskedImageModeling,
						    )
						    if is_torch_available()
						    else ()
						)
						UpperCamelCase__      :						Any				       =(
						    {"feature-extraction": SwinModel, "image-classification": SwinForImageClassification}
						    if is_torch_available()
						    else {}
						)
						UpperCamelCase__      :						str				       =True

						UpperCamelCase__      :						List[str]				       =False
						UpperCamelCase__      :						List[Any]				       =False
						UpperCamelCase__      :						Dict				       =False

						def 	__a       (    self	:Dict)		->					int:
												UpperCAmelCase_     							=     SwinModelTester(self)
												UpperCAmelCase_     							=     ConfigTester(self   ,						config_class=_lowercase   ,						embed_dim=37)

						def 	__a       (    self	:int)		->					str:
												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 	__a       (    self	:Tuple)		->					str:
												return

						def 	__a       (    self	:str)		->					int:
												UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_lowercase)

						@unittest.skip(reason='''Got `CUDA error: misaligned address` with PyTorch 2.0.0.''')
						def 	__a       (    self	:Optional[int])		->					Any:
												pass

						def 	__a       (    self	:List[str])		->					str:
												super().test_training_gradient_checkpointing()

						def 	__a       (    self	:Union[str, Any])		->					Optional[int]:
												UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_backbone(*_lowercase)

						def 	__a       (    self	:Tuple)		->					Optional[Any]:
												UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_image_modeling(*_lowercase)

						def 	__a       (    self	:str)		->					Tuple:
												UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*_lowercase)

						@unittest.skip(reason='''Swin does not use inputs_embeds''')
						def 	__a       (    self	:List[Any])		->					Optional[int]:
												pass

						@unittest.skip(reason='''Swin Transformer does not use feedforward chunking''')
						def 	__a       (    self	:Any)		->					Optional[Any]:
												pass

						def 	__a       (    self	:Optional[Any])		->					List[str]:
												UpperCAmelCase_							,      UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																		UpperCAmelCase_     							=     model_class(_lowercase)
																		self.assertIsInstance(model.get_input_embeddings()   ,						(nn.Module))
																		UpperCAmelCase_     							=     model.get_output_embeddings()
																		self.assertTrue(x is None or isinstance(_lowercase   ,						nn.Linear))

						def 	__a       (    self	:Union[str, Any])		->					Union[str, Any]:
												UpperCAmelCase_							,      UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs_for_common()

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

																		UpperCAmelCase_     							=     ['''pixel_values''']
																		self.assertListEqual(arg_names[:1]   ,						_lowercase)

						def 	__a       (    self	:Optional[Any])		->					List[str]:
												UpperCAmelCase_							,      UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs_for_common()
												UpperCAmelCase_     							=     True

												for model_class in self.all_model_classes:
																		UpperCAmelCase_     							=     True
																		UpperCAmelCase_     							=     False
																		UpperCAmelCase_     							=     True
																		UpperCAmelCase_     							=     model_class(_lowercase)
																		model.to(_lowercase)
																		model.eval()
																		with torch.no_grad():
																								UpperCAmelCase_     							=     model(**self._prepare_for_class(_lowercase   ,						_lowercase))
																		UpperCAmelCase_     							=     outputs.attentions
																		UpperCAmelCase_     							=     len(self.model_tester.depths)
																		self.assertEqual(len(_lowercase)   ,						_lowercase)

																		# check that output_attentions also work using config
																		del inputs_dict["output_attentions"]
																		UpperCAmelCase_     							=     True
																		UpperCAmelCase_     							=     config.window_size**2
																		UpperCAmelCase_     							=     model_class(_lowercase)
																		model.to(_lowercase)
																		model.eval()
																		with torch.no_grad():
																								UpperCAmelCase_     							=     model(**self._prepare_for_class(_lowercase   ,						_lowercase))
																		UpperCAmelCase_     							=     outputs.attentions
																		self.assertEqual(len(_lowercase)   ,						_lowercase)

																		self.assertListEqual(
																		    list(attentions[0].shape[-3:])   ,						[self.model_tester.num_heads[0], window_size_squared, window_size_squared]   ,						)
																		UpperCAmelCase_     							=     len(_lowercase)

																		# Check attention is always last and order is fine
																		UpperCAmelCase_     							=     True
																		UpperCAmelCase_     							=     True
																		UpperCAmelCase_     							=     model_class(_lowercase)
																		model.to(_lowercase)
																		model.eval()
																		with torch.no_grad():
																								UpperCAmelCase_     							=     model(**self._prepare_for_class(_lowercase   ,						_lowercase))

																		# also another +1 for reshaped_hidden_states
																		UpperCAmelCase_     							=     1 if model_class.__name__ == '''SwinBackbone''' else 2
																		self.assertEqual(out_len + added_hidden_states   ,						len(_lowercase))

																		UpperCAmelCase_     							=     outputs.attentions

																		self.assertEqual(len(_lowercase)   ,						_lowercase)

																		self.assertListEqual(
																		    list(self_attentions[0].shape[-3:])   ,						[self.model_tester.num_heads[0], window_size_squared, window_size_squared]   ,						)

						def 	__a       (    self	:str   ,						_lowercase	:List[Any]   ,						_lowercase	:Union[str, Any]   ,						_lowercase	:Any   ,						_lowercase	:Dict)		->					str:
												UpperCAmelCase_     							=     model_class(_lowercase)
												model.to(_lowercase)
												model.eval()

												with torch.no_grad():
																		UpperCAmelCase_     							=     model(**self._prepare_for_class(_lowercase   ,						_lowercase))

												UpperCAmelCase_     							=     outputs.hidden_states

												UpperCAmelCase_     							=     getattr(
												    self.model_tester   ,						'''expected_num_hidden_layers'''   ,						len(self.model_tester.depths) + 1)
												self.assertEqual(len(_lowercase)   ,						_lowercase)

												# Swin has a different seq_length
												UpperCAmelCase_     							=     (
												    config.patch_size
												    if isinstance(config.patch_size   ,						collections.abc.Iterable)
												    else (config.patch_size, config.patch_size)
												)

												UpperCAmelCase_     							=     (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

												self.assertListEqual(
												    list(hidden_states[0].shape[-2:])   ,						[num_patches, self.model_tester.embed_dim]   ,						)

												if not model_class.__name__ == "SwinBackbone":
																		UpperCAmelCase_     							=     outputs.reshaped_hidden_states
																		self.assertEqual(len(_lowercase)   ,						_lowercase)

																		UpperCAmelCase_							,      UpperCAmelCase_							,      UpperCAmelCase_							,      UpperCAmelCase_     							=     reshaped_hidden_states[0].shape
																		UpperCAmelCase_     							=     (
																		    reshaped_hidden_states[0].view(_lowercase   ,						_lowercase   ,						height * width).permute(0   ,						2   ,						1)
																		)
																		self.assertListEqual(
																		    list(reshaped_hidden_states.shape[-2:])   ,						[num_patches, self.model_tester.embed_dim]   ,						)

						def 	__a       (    self	:Optional[Any])		->					List[Any]:
												UpperCAmelCase_							,      UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs_for_common()

												UpperCAmelCase_     							=     (
												    self.model_tester.image_size
												    if isinstance(self.model_tester.image_size   ,						collections.abc.Iterable)
												    else (self.model_tester.image_size, self.model_tester.image_size)
												)

												for model_class in self.all_model_classes:
																		UpperCAmelCase_     							=     True
																		self.check_hidden_states_output(_lowercase   ,						_lowercase   ,						_lowercase   ,						_lowercase)

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

																		self.check_hidden_states_output(_lowercase   ,						_lowercase   ,						_lowercase   ,						_lowercase)

						def 	__a       (    self	:List[str])		->					int:
												UpperCAmelCase_							,      UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs_for_common()
												UpperCAmelCase_     							=     3

												UpperCAmelCase_     							=     (
												    self.model_tester.image_size
												    if isinstance(self.model_tester.image_size   ,						collections.abc.Iterable)
												    else (self.model_tester.image_size, self.model_tester.image_size)
												)
												UpperCAmelCase_     							=     (
												    config.patch_size
												    if isinstance(config.patch_size   ,						collections.abc.Iterable)
												    else (config.patch_size, config.patch_size)
												)

												UpperCAmelCase_     							=     image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
												UpperCAmelCase_     							=     image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

												for model_class in self.all_model_classes:
																		UpperCAmelCase_     							=     True
																		self.check_hidden_states_output(_lowercase   ,						_lowercase   ,						_lowercase   ,						(padded_height, padded_width))

																		# check that output_hidden_states also work using config
																		del inputs_dict["output_hidden_states"]
																		UpperCAmelCase_     							=     True
																		self.check_hidden_states_output(_lowercase   ,						_lowercase   ,						_lowercase   ,						(padded_height, padded_width))

						@slow
						def 	__a       (    self	:Optional[Any])		->					int:
												for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		UpperCAmelCase_     							=     SwinModel.from_pretrained(_lowercase)
																		self.assertIsNotNone(_lowercase)




						def 	__a       (    self	:Optional[int])		->					Any:
												UpperCAmelCase_							,      UpperCAmelCase_     							=     self.model_tester.prepare_config_and_inputs_for_common()

												UpperCAmelCase_     							=     _config_zero_init(_lowercase)
												for model_class in self.all_model_classes:
																		UpperCAmelCase_     							=     model_class(config=_lowercase)
																		for name, param in model.named_parameters():
																								if "embeddings" not in name and param.requires_grad:
																														self.assertIn(
																														    ((param.data.mean() * 1E9).round() / 1E9).item()   ,						[0.0, 1.0]   ,						msg=f"Parameter {name} of model {model_class} seems not properly initialized"   ,						)







@require_vision
@require_torch
class 							a_  (		unittest.TestCase				):

						@cached_property
						def 	__a       (    self	:List[str])		->					Union[str, Any]:
												return (
												    AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224''')
												    if is_vision_available()
												    else None
												)




						@slow
						def 	__a       (    self	:Tuple)		->					List[Any]:
												UpperCAmelCase_     							=     SwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224''').to(_lowercase)
												UpperCAmelCase_     							=     self.default_image_processor

												UpperCAmelCase_     							=     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''')
												UpperCAmelCase_     							=     image_processor(images=_lowercase   ,						return_tensors='''pt''').to(_lowercase)

												# forward pass
												with torch.no_grad():
																		UpperCAmelCase_     							=     model(**_lowercase)

												# verify the logits
												UpperCAmelCase_     							=     torch.Size((1, 1000))
												self.assertEqual(outputs.logits.shape   ,						_lowercase)
												UpperCAmelCase_     							=     torch.tensor([-0.0_948, -0.6_454, -0.0_921]).to(_lowercase)
												self.assertTrue(torch.allclose(outputs.logits[0, :3]   ,						_lowercase   ,						atol=1E-4))







@require_torch
class 							a_  (		unittest.TestCase					, _snake_case				):
						UpperCamelCase__      :						Union[str, Any]				       =(SwinBackbone,) if is_torch_available() else ()
						UpperCamelCase__      :						Tuple				       =SwinConfig

						def 	__a       (    self	:Optional[int])		->					str:
												UpperCAmelCase_     							=     SwinModelTester(self)











import unittest
from pathlib import Path

from transformers import is_vision_available, load_tool
from transformers.testing_utils import get_tests_dir

from .test_tools_common import ToolTesterMixin


if is_vision_available():
     from PIL import Image





class  __lowerCamelCase       (    unittest.TestCase	,				UpperCamelCase__    ):




    """simple docstring"""

    def    a      (       self     :     Any   )      ->       Tuple:
         lowerCAmelCase__		= load_tool("image-captioning"   )
         self.tool.setup()
         lowerCAmelCase__		= load_tool("image-captioning"   ,	remote=SCREAMING_SNAKE_CASE__   )


    def    a      (       self     :     int   )      ->       List[str]:
         lowerCAmelCase__		= Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO"   )   ) / "000000039769.png"   )
         lowerCAmelCase__		= self.tool(SCREAMING_SNAKE_CASE__   )
         self.assertEqual(SCREAMING_SNAKE_CASE__   ,	"two cats sleeping on a couch"   )


    def    a      (       self     :     List[str]   )      ->       int:
         lowerCAmelCase__		= Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO"   )   ) / "000000039769.png"   )
         lowerCAmelCase__		= self.remote_tool(SCREAMING_SNAKE_CASE__   )
         self.assertEqual(SCREAMING_SNAKE_CASE__   ,	"two cats sleeping on a couch"   )


    def    a      (       self     :     Any   )      ->       Any:
         lowerCAmelCase__		= Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO"   )   ) / "000000039769.png"   )
         lowerCAmelCase__		= self.tool(image=SCREAMING_SNAKE_CASE__   )
         self.assertEqual(SCREAMING_SNAKE_CASE__   ,	"two cats sleeping on a couch"   )


    def    a      (       self     :     Dict   )      ->       Any:
         lowerCAmelCase__		= Image.open(Path(get_tests_dir("fixtures/tests_samples/COCO"   )   ) / "000000039769.png"   )
         lowerCAmelCase__		= self.remote_tool(image=SCREAMING_SNAKE_CASE__   )
         self.assertEqual(SCREAMING_SNAKE_CASE__   ,	"two cats sleeping on a couch"   )
