


# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
snake_case				:    List[str]       				=     abspath(join(dirname(__file__), '''src'''))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='''ignore''', category=FutureWarning)
def 				__lowerCamelCase						( UpperCAmelCase_						:		str						):




      """simple docstring"""





      config.addinivalue_line(
          '''markers''' ,  '''is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested'''						)
      config.addinivalue_line(
          '''markers''' ,  '''is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested'''						)
      config.addinivalue_line('''markers''' ,  '''is_pipeline_test: mark test to run only when pipelines are tested'''						)
      config.addinivalue_line('''markers''' ,  '''is_staging_test: mark test to run only in the staging environment'''						)
      config.addinivalue_line('''markers''' ,  '''accelerate_tests: mark test that require accelerate'''						)
      config.addinivalue_line('''markers''' ,  '''tool_tests: mark the tool tests that are run on their specific schedule'''						)
def 				__lowerCamelCase						( UpperCAmelCase_						:		List[Any]						):




      """simple docstring"""





      from transformers.testing_utils import pytest_addoption_shared

      pytest_addoption_shared(UpperCAmelCase_						)
def 				__lowerCamelCase						( UpperCAmelCase_						:		Dict						):




      """simple docstring"""





      from transformers.testing_utils import pytest_terminal_summary_main

      a						:Union[str, Any] 							=       terminalreporter.config.getoption('''--make-reports'''						)
      if make_reports:
            pytest_terminal_summary_main(UpperCAmelCase_ ,  id=UpperCAmelCase_						)
def 				__lowerCamelCase						( UpperCAmelCase_						:		int ,  UpperCAmelCase_						:		int						):




      """simple docstring"""





      if exitstatus == 5:
            a						:Union[str, Any] 							=       0


# Doctest custom flag to ignore output.
snake_case				:    str       				=     doctest.register_optionflag('''IGNORE_RESULT''')

snake_case				:    Tuple       				=     doctest.OutputChecker







class 		_snake_case  (      _snake_case							):




 def        SCREAMING_SNAKE_CASE__				(		self					,  _lowerCamelCase					,  _lowerCamelCase					,  _lowerCamelCase    ):
       if IGNORE_RESULT & optionflags:
             return True
       return OutputChecker.check_output(self					,  _lowerCamelCase					,  _lowerCamelCase					,  _lowerCamelCase    )







snake_case				:    int       				=     CustomOutputChecker
snake_case				:    Union[str, Any]       				=     HfDoctestModule






snake_case				:    Any       				=     HfDocTestParser







'''simple docstring'''




import pytest

import datasets.config
from datasets.utils.info_utils import is_small_dataset







@pytest.mark.parametrize('''dataset_size'''		,				[None, 400 * 2**20, 600 * 2**20]						)
@pytest.mark.parametrize('''input_in_memory_max_size'''		,				['''default''', 0, 100 * 2**20, 900 * 2**20]						)
def 		lowerCAmelCase_				(   snake_case__		,				snake_case__		,				snake_case__						):




    '''simple docstring'''



    if input_in_memory_max_size != "default":
        monkeypatch.setattr(datasets.config		,				'''IN_MEMORY_MAX_SIZE'''		,				snake_case__						)
    A       :   Dict					=						datasets.config.IN_MEMORY_MAX_SIZE
    if input_in_memory_max_size == "default":
        assert in_memory_max_size == 0
    else:
        assert in_memory_max_size == input_in_memory_max_size
    if dataset_size and in_memory_max_size:
        A       :   Dict					=						dataset_size < in_memory_max_size
    else:
        A       :   Tuple					=						False
    A       :   int					=						is_small_dataset(snake_case__						)
    assert result == expected




