'''simple docstring'''






from datasets.utils.patching import _PatchedModuleObj, patch_submodule

from . import _test_patching






def    __UpperCAmelCase			(  ):
   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

   _UpperCAmelCase							:	str							=   "__test_patch_submodule_mock__"
   with patch_submodule(_test_patching,					"os.path.join",					snake_case_							):
      # 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    __UpperCAmelCase			(  ):
   assert _test_patching.open is open

   _UpperCAmelCase							:	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",					snake_case_							):
      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    __UpperCAmelCase			(  ):
   # pandas.read_csv is not present in _test_patching
   _UpperCAmelCase							:	str							=   "__test_patch_submodule_missing_mock__"
   with patch_submodule(_test_patching,					"pandas.read_csv",					snake_case_							):
      pass






def    __UpperCAmelCase			(  ):
   # builtin should always be mocked even if they're not in the globals
   # in case they're loaded at one point
   _UpperCAmelCase							:	Union[str, Any]							=   "__test_patch_submodule_missing_builtin_mock__"
   # _test_patching doesn't have "len" in its globals
   assert getattr(_test_patching,					"len",					snake_case_							) is None
   with patch_submodule(_test_patching,					"len",					snake_case_							):
      assert _test_patching.len is mock
   assert _test_patching.len is len






def    __UpperCAmelCase			(  ):
   _UpperCAmelCase							:	str							=   "__test_patch_submodule_start_and_stop_mock__"
   _UpperCAmelCase							:	int							=   patch_submodule(_test_patching,					"open",					snake_case_							)
   assert _test_patching.open is open
   patch.start()
   assert _test_patching.open is mock
   patch.stop()
   assert _test_patching.open is open






def    __UpperCAmelCase			(  ):
   from os import rename as original_rename
   from os.path import dirname as original_dirname
   from os.path import join as original_join

   _UpperCAmelCase							:	List[Any]							=   "__test_patch_submodule_successive_join__"
   _UpperCAmelCase							:	List[Any]							=   "__test_patch_submodule_successive_dirname__"
   _UpperCAmelCase							:	Union[str, Any]							=   "__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",					snake_case_							):
      with patch_submodule(_test_patching,					"os.rename",					snake_case_							):
         with patch_submodule(_test_patching,					"os.path.dirname",					snake_case_							):
            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",					snake_case_							):
      with patch_submodule(_test_patching,					"os.path.join",					snake_case_							):
         with patch_submodule(_test_patching,					"os.path.dirname",					snake_case_							):
            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    __UpperCAmelCase			(  ):
   _UpperCAmelCase							:	List[str]							=   "__test_patch_submodule_doesnt_exist_mock__"
   with patch_submodule(_test_patching,					"__module_that_doesn_exist__.__attribute_that_doesn_exist__",					snake_case_							):
      pass
   with patch_submodule(_test_patching,					"os.__attribute_that_doesn_exist__",					snake_case_							):
      pass






def lowerCamelCase__    (							snake_case_	:  int       )      ->				int:
   if not isinstance(snake_case_       ,      snake_case_       ) or number < 0:
      raise ValueError('''Input must be a non-negative integer'''       )

   __snake_case							       =   0
   while number:
      # This way we arrive at next set bit (next 1) instead of looping
      # through each bit and checking for 1s hence the
      # loop won't run 32 times it will only run the number of `1` times
      number &= number - 1
      count += 1
   return count


if __name__ == "__main__":
    import doctest

    doctest.testmod()

