


'''simple docstring'''
import unittest

from transformers.utils.backbone_utils import (
    BackboneMixin,
    get_aligned_output_features_output_indices,
    verify_out_features_out_indices,
)






class        lowerCAmelCase_  (     unittest.TestCase	):






       def   UpperCamelCase						( self   )->      Optional[Any]:
            _A				=							['a', 'b', 'c']

            # Defaults to last layer if both are None
            _A		,				_A				=							get_aligned_output_features_output_indices(_UpperCamelCase			,     _UpperCamelCase			,     _UpperCamelCase   )
            self.assertEqual(_UpperCamelCase			,     ['c']   )
            self.assertEqual(_UpperCamelCase			,     [2]   )

            # Out indices set to match out features
            _A		,				_A				=							get_aligned_output_features_output_indices(['a', 'c']			,     _UpperCamelCase			,     _UpperCamelCase   )
            self.assertEqual(_UpperCamelCase			,     ['a', 'c']   )
            self.assertEqual(_UpperCamelCase			,     [0, 2]   )

            # Out features set to match out indices
            _A		,				_A				=							get_aligned_output_features_output_indices(_UpperCamelCase			,     [0, 2]			,     _UpperCamelCase   )
            self.assertEqual(_UpperCamelCase			,     ['a', 'c']   )
            self.assertEqual(_UpperCamelCase			,     [0, 2]   )

            # Out features selected from negative indices
            _A		,				_A				=							get_aligned_output_features_output_indices(_UpperCamelCase			,     [-3, -1]			,     _UpperCamelCase   )
            self.assertEqual(_UpperCamelCase			,     ['a', 'c']   )
            self.assertEqual(_UpperCamelCase			,     [-3, -1]   )






       def   UpperCamelCase						( self   )->      int:
            # Stage names must be set
            with self.assertRaises(_UpperCamelCase   ):
                 verify_out_features_out_indices(['a', 'b']			,     (0, 1)			,     _UpperCamelCase   )

            # Out features must be a list
            with self.assertRaises(_UpperCamelCase   ):
                 verify_out_features_out_indices(('a', 'b')			,     (0, 1)			,     ['a', 'b']   )

            # Out features must be a subset of stage names
            with self.assertRaises(_UpperCamelCase   ):
                 verify_out_features_out_indices(['a', 'b']			,     (0, 1)			,     ['a']   )

            # Out indices must be a list or tuple
            with self.assertRaises(_UpperCamelCase   ):
                 verify_out_features_out_indices(_UpperCamelCase			,     0			,     ['a', 'b']   )

            # Out indices must be a subset of stage names
            with self.assertRaises(_UpperCamelCase   ):
                 verify_out_features_out_indices(_UpperCamelCase			,     (0, 1)			,     ['a']   )

            # Out features and out indices must be the same length
            with self.assertRaises(_UpperCamelCase   ):
                 verify_out_features_out_indices(['a', 'b']			,     (0,)			,     ['a', 'b', 'c']   )

            # Out features should match out indices
            with self.assertRaises(_UpperCamelCase   ):
                 verify_out_features_out_indices(['a', 'b']			,     (0, 2)			,     ['a', 'b', 'c']   )

            # Out features and out indices should be in order
            with self.assertRaises(_UpperCamelCase   ):
                 verify_out_features_out_indices(['b', 'a']			,     (0, 1)			,     ['a', 'b']   )

            # Check passes with valid inputs
            verify_out_features_out_indices(['a', 'b', 'd']			,     (0, 1, -1)			,     ['a', 'b', 'c', 'd']   )






       def   UpperCamelCase						( self   )->      Tuple:
            _A				=							BackboneMixin()

            _A				=							['a', 'b', 'c']
            _A				=							['a', 'c']
            _A				=							[0, 2]

            # Check that the output features and indices are set correctly
            self.assertEqual(backbone.out_features			,     ['a', 'c']   )
            self.assertEqual(backbone.out_indices			,     [0, 2]   )

            # Check out features and indices are updated correctly
            _A				=							['a', 'b']
            self.assertEqual(backbone.out_features			,     ['a', 'b']   )
            self.assertEqual(backbone.out_indices			,     [0, 1]   )

            _A				=							[-3, -1]
            self.assertEqual(backbone.out_features			,     ['a', 'c']   )
            self.assertEqual(backbone.out_indices			,     [-3, -1]   )









'''simple docstring'''
# 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.
lowerCAmelCase						=					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					:       Optional[Any]		)					->	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					:       Tuple		)					->	List[str]:







     """simple docstring"""
     from transformers.testing_utils import pytest_addoption_shared

     pytest_addoption_shared(__UpperCamelCase		)

def 					lowerCamelCase_ ( __UpperCamelCase					:       Union[str, Any]		)					->	str:







     """simple docstring"""
     from transformers.testing_utils import pytest_terminal_summary_main

     _A				=							terminalreporter.config.getoption('--make-reports'		)
     if make_reports:
          pytest_terminal_summary_main(__UpperCamelCase							,    id=__UpperCamelCase		)

def 					lowerCamelCase_ ( __UpperCamelCase					:       str							,    __UpperCamelCase					:       List[str]		)					->	Optional[int]:







     """simple docstring"""
     # If no tests are collected, pytest exists with code 5, which makes the CI fail.
     if exitstatus == 5:
          _A				=							0


# Doctest custom flag to ignore output.
lowerCAmelCase						=					doctest.register_optionflag("""IGNORE_RESULT""")

lowerCAmelCase						=					doctest.OutputChecker






class        lowerCAmelCase_  (     UpperCAmelCase	):






       def   UpperCamelCase						( self			,     _UpperCamelCase			,     _UpperCamelCase			,     _UpperCamelCase   )->      Tuple:
            if IGNORE_RESULT & optionflags:
                 return True
            return OutputChecker.check_output(self			,     _UpperCamelCase			,     _UpperCamelCase			,     _UpperCamelCase   )






lowerCAmelCase						=					CustomOutputChecker
lowerCAmelCase						=					HfDoctestModule
lowerCAmelCase						=					HfDocTestParser





