


'''simple docstring'''







from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching






def       lowercase					():







       """simple docstring"""







       import os as original_os
       from os import path as original_path
       from os import rename as original_rename
       from os.path import dirname as original_dirname
       from os.path import join as original_join

       assert _test_patching.os is original_os
       assert _test_patching.path is original_path
       assert _test_patching.join is original_join

       assert _test_patching.renamed_os is original_os
       assert _test_patching.renamed_path is original_path
       assert _test_patching.renamed_join is original_join

       _lowerCAmelCase     :				str       =							'__test_patch_submodule_mock__'
       with patch_submodule(_test_patching ,    'os.path.join' ,    _A       ):
              # Every way to access os.path.join must be patched, and the rest must stay untouched

              # check os.path.join
              assert isinstance(_test_patching.os ,    _PatchedModuleObj       )
              assert isinstance(_test_patching.os.path ,    _PatchedModuleObj       )
              assert _test_patching.os.path.join is mock

              # check path.join
              assert isinstance(_test_patching.path ,    _PatchedModuleObj       )
              assert _test_patching.path.join is mock

              # check join
              assert _test_patching.join is mock

              # check that the other attributes are untouched
              assert _test_patching.os.rename is original_rename
              assert _test_patching.path.dirname is original_dirname
              assert _test_patching.os.path.dirname is original_dirname

              # Even renamed modules or objects must be patched

              # check renamed_os.path.join
              assert isinstance(_test_patching.renamed_os ,    _PatchedModuleObj       )
              assert isinstance(_test_patching.renamed_os.path ,    _PatchedModuleObj       )
              assert _test_patching.renamed_os.path.join is mock

              # check renamed_path.join
              assert isinstance(_test_patching.renamed_path ,    _PatchedModuleObj       )
              assert _test_patching.renamed_path.join is mock

              # check renamed_join
              assert _test_patching.renamed_join is mock

              # check that the other attributes are untouched
              assert _test_patching.renamed_os.rename is original_rename
              assert _test_patching.renamed_path.dirname is original_dirname
              assert _test_patching.renamed_os.path.dirname is original_dirname

       # check that everthing is back to normal when the patch is over

       assert _test_patching.os is original_os
       assert _test_patching.path is original_path
       assert _test_patching.join is original_join

       assert _test_patching.renamed_os is original_os
       assert _test_patching.renamed_path is original_path
       assert _test_patching.renamed_join is original_join






def       lowercase					():







       """simple docstring"""







       assert _test_patching.open is open

       _lowerCAmelCase     :				Union[str, Any]       =							'__test_patch_submodule_builtin_mock__'
       # _test_patching has "open" in its globals
       assert _test_patching.open is open
       with patch_submodule(_test_patching ,    'open' ,    _A       ):
              assert _test_patching.open is mock

       # check that everthing is back to normal when the patch is over

       assert _test_patching.open is open






def       lowercase					():







       """simple docstring"""







       _lowerCAmelCase     :				Any       =							'__test_patch_submodule_missing_mock__'
       with patch_submodule(_test_patching ,    'pandas.read_csv' ,    _A       ):
              pass






def       lowercase					():







       """simple docstring"""







       _lowerCAmelCase     :				List[str]       =							'__test_patch_submodule_missing_builtin_mock__'
       # _test_patching doesn't have "len" in its globals
       assert getattr(_test_patching ,    'len' ,    _A       ) is None
       with patch_submodule(_test_patching ,    'len' ,    _A       ):
              assert _test_patching.len is mock
       assert _test_patching.len is len






def       lowercase					():







       """simple docstring"""







       _lowerCAmelCase     :				int       =							'__test_patch_submodule_start_and_stop_mock__'
       _lowerCAmelCase     :				Optional[Any]       =							patch_submodule(_test_patching ,    'open' ,    _A       )
       assert _test_patching.open is open
       patch.start()
       assert _test_patching.open is mock
       patch.stop()
       assert _test_patching.open is open






def       lowercase					():







       """simple docstring"""







       from os import rename as original_rename
       from os.path import dirname as original_dirname
       from os.path import join as original_join

       _lowerCAmelCase     :				List[str]       =							'__test_patch_submodule_successive_join__'
       _lowerCAmelCase     :				Union[str, Any]       =							'__test_patch_submodule_successive_dirname__'
       _lowerCAmelCase     :				Tuple       =							'__test_patch_submodule_successive_rename__'
       assert _test_patching.os.path.join is original_join
       assert _test_patching.os.path.dirname is original_dirname
       assert _test_patching.os.rename is original_rename

       with patch_submodule(_test_patching ,    'os.path.join' ,    _A       ):
              with patch_submodule(_test_patching ,    'os.rename' ,    _A       ):
                     with patch_submodule(_test_patching ,    'os.path.dirname' ,    _A       ):
                            assert _test_patching.os.path.join is mock_join
                            assert _test_patching.os.path.dirname is mock_dirname
                            assert _test_patching.os.rename is mock_rename

    # try another order
       with patch_submodule(_test_patching ,    'os.rename' ,    _A       ):
              with patch_submodule(_test_patching ,    'os.path.join' ,    _A       ):
                     with patch_submodule(_test_patching ,    'os.path.dirname' ,    _A       ):
                            assert _test_patching.os.path.join is mock_join
                            assert _test_patching.os.path.dirname is mock_dirname
                            assert _test_patching.os.rename is mock_rename

       assert _test_patching.os.path.join is original_join
       assert _test_patching.os.path.dirname is original_dirname
       assert _test_patching.os.rename is original_rename






def       lowercase					():







       """simple docstring"""







       _lowerCAmelCase     :				Optional[Any]       =							'__test_patch_submodule_doesnt_exist_mock__'
       with patch_submodule(_test_patching ,    '__module_that_doesn_exist__.__attribute_that_doesn_exist__' ,    _A       ):
              pass
       with patch_submodule(_test_patching ,    'os.__attribute_that_doesn_exist__' ,    _A       ):
              pass





from unittest.mock import Mock, patch

from file_transfer.send_file import send_file
@patch("socket.socket"	)
@patch("builtins.open"	)
def 							UpperCamelCase_(					_A :Tuple					,  _A :str	)->		int:
			# ===== initialization =====
			UpperCamelCase__       =							Mock()
			UpperCamelCase__       =							conn, Mock()
			UpperCamelCase__       =							iter([1, None]	)
			UpperCamelCase__       =							lambda _A	: next(_A	)

			# ===== invoke =====
			send_file(filename="mytext.txt"					,  testing=_A	)

			# ===== ensurance =====
			sock.assert_called_once()
			sock.return_value.bind.assert_called_once()
			sock.return_value.listen.assert_called_once()
			sock.return_value.accept.assert_called_once()
			conn.recv.assert_called_once()

			file.return_value.__enter__.assert_called_once()
			file.return_value.__enter__.return_value.read.assert_called()

			conn.send.assert_called_once()
			conn.close.assert_called_once()
			sock.return_value.shutdown.assert_called_once()
			sock.return_value.close.assert_called_once()


