def __new__(cls, clsname, bases, dct):
     klass = type.__new__(cls, clsname, bases, dct)
     for app_name in set(settings.INSTALLED_APPS):
         name = app_name.split('.')[-1]
         setattr(klass, name, pytest.fixture(scope='session')(django_app(app_name)))
     for model in apps.get_models():
         name = model._meta.object_name
         setattr(klass, name, pytest.fixture(scope='session')(django_model(model)))
     return klass

    def decorator(func):
        step_func = func
        if step_type == GIVEN:
            if not hasattr(func, '_pytestfixturefunction'):
                # avoid overfixturing of a fixture
                func = pytest.fixture(func)
            step_func = lambda request: request.getfuncargvalue(func.func_name)

        step_func.__name__ = step_name
        setattr(get_caller_module(), step_name, pytest.fixture(lambda: step_func))
        return func

        def decorate(fn):
            name = fn.__name__
            self._factories[name] = fn
            # conn, teardown = self.connection_for(name)

            def wrapper(*args, **kw):
                # This check might be unnecessary
                assert self._current_connection == name
                return fn(*args, **kw)

            wrapper.__wrapped__ = fn
            pytest.fixture(scope="session")(wrapper)
            return wrapper

def given(name, fixture=None, converters=None, scope='function', target_fixture=None):
    """Given step decorator.

    :param name: Given step name.
    :param fixture: Optional name of the fixture to reuse.
    :param converters: Optional `dict` of the argument or parameter converters in form
                       {<param_name>: <converter function>}.
    :scope: Optional fixture scope
    :param target_fixture: Target fixture name to replace by steps definition function
    :raises: StepError in case of wrong configuration.
    :note: Can't be used as a decorator when the fixture is specified.
    """
    if fixture is not None:
        module = get_caller_module()

        def step_func(request):
            return request.getfuncargvalue(fixture)

        step_func.step_type = GIVEN
        step_func.converters = converters
        step_func.__name__ = name
        step_func.fixture = fixture
        func = pytest.fixture(scope=scope)(lambda: step_func)
        func.__doc__ = 'Alias for the "{0}" fixture.'.format(fixture)
        _, name = parse_line(name)
        contribute_to_module(module, get_step_fixture_name(name, GIVEN), func)
        return _not_a_fixture_decorator

    return _step_decorator(GIVEN, name, converters=converters, scope=scope, target_fixture=target_fixture)

    def simple_fixture(name, params, fmt=None):
        """Helper to create a pytest fixture using only name and params.

        Parameters
        ----------
        name : str
            Name of the parameters used for the ``ids`` argument
            to `pytest.fixture`.
        params : sequence
            Values to be taken as parameters in the fixture. They are
            used as ``params`` argument to `pytest.fixture`.
        fmt : str, optional
            Use this format string for the generation of the ``ids``.
            For each value, the id string is generated as::

                fmt.format(name=name, value=value)

            hence the format string must use ``{name}`` and ``{value}``.

            Default: ``" {name} = '{value}' "`` for string parameters,
            otherwise ``" {name} = {value} "``
        """
        if fmt is None:
            try:
                params[0] + ''
            except TypeError:
                # Not a string type
                fmt = " {name} = {value} "
            else:
                # String type
                fmt = " {name} = '{value}' "

        ids = [fmt.format(name=name, value=value) for value in params]
        wrapper = pytest.fixture(scope='module', ids=ids, params=params)
        return wrapper(lambda request: request.param)

    def decorator(func):

        step_func = func

        if step_type == GIVEN:
            if not hasattr(func, '_pytestfixturefunction'):
                # Avoid multiple wrapping a fixture
                func = pytest.fixture(func)
            step_func = lambda request: request.getfuncargvalue(func.__name__)
            step_func.__doc__ = func.__doc__

        step_func.__name__ = step_name

        @pytest.fixture
        def lazy_step_func():
            return step_func

        # Preserve a docstring
        lazy_step_func.__doc__ = func.__doc__

        contribute_to_module(
            get_caller_module(),
            step_name,
            lazy_step_func,
        )
        return func

def given(name, fixture=None, converters=None):
    """Given step decorator.

    :param name: Given step name.
    :param fixture: Optional name of the fixture to reuse.
    :param converters: Optional `dict` of the argument or parameter converters in form
    {<param_name>: <converter function>}.

    :raises: StepError in case of wrong configuration.
    :note: Can't be used as a decorator when the fixture is specified.

    """

    if fixture is not None:
        module = get_caller_module()
        step_func = lambda request: request.getfuncargvalue(fixture)
        step_func.step_type = GIVEN
        step_func.converters = converters
        step_func.__name__ = name
        step_func.fixture = fixture
        func = pytest.fixture(lambda: step_func)
        func.__doc__ = 'Alias for the "{0}" fixture.'.format(fixture)
        contribute_to_module(module, remove_prefix(name), func)
        return _not_a_fixture_decorator

    return _step_decorator(GIVEN, name, converters=converters)

    def decorator(func):
        step_func = func

        if step_type == GIVEN:
            if not hasattr(func, "_pytestfixturefunction"):
                # Avoid multiple wrapping of a fixture
                func = pytest.fixture(func)
            step_func = lambda request: request.getfuncargvalue(func.__name__)
            step_func.__doc__ = func.__doc__
            step_func.fixture = func.__name__

        step_func.__name__ = force_encode(step_name)
        step_func.step_type = step_type
        step_func.converters = converters

        @pytest.fixture
        def lazy_step_func():
            return step_func

        # Preserve the docstring
        lazy_step_func.__doc__ = func.__doc__

        if pattern:
            lazy_step_func.pattern = pattern
        if converters:
            lazy_step_func.converters = converters

        contribute_to_module(get_caller_module(), step_name, lazy_step_func)
        return func

    def _make_fixture(cls, name):
        factory = getattr(cls, name + '_factory')

        def fixture(self):
            return factory.create()

        fixture.__name__ = name
        return pytest.fixture(fixture)

def _get_role_fixture(role_name):
    def fixture(testuser_id, webapp_without_login):
        with webapp_without_login.app.app_context():
            user = models.User.query.get(testuser_id)
            user.roles.append(models.Role.query.filter_by(name=role_name).one())
            models.db.session.commit()

    fixture.__name__ = "{}_role".format(role_name)
    return pytest.fixture(fixture)

def calc_motor_fixture(name):
    def get_motor(beacon):
        m = beacon.get(name)
        m.no_offset = False
        yield m
        m.stop()
        m.wait_move()
    get_motor.__name__ = name
    return pytest.fixture(get_motor)

def make_uri_fixture(name):
    """
    Create a pytest fixture named NAME that resolves
    to a URI object '<ex://NAME>'.
    """
    # noinspection PyShadowingNames
    def func(conn):
        return conn.createURI('ex://' + name)
    func.__name__ = name
    return pytest.fixture(func, name=name)

def instance_fixture(func):
    """
    Mark function as an instance fixture.

    It marks function as a fixture and also applies pytest.mark.instance_fixture
    """

    func = pytest.fixture(func)
    func = pytest.mark.instance_fixture(func)
    func.__is_instance_fixture = True
    return func

        def make_fixture(arg):
            args_attr = 'base_args__' + arg
            kwargs_attr = 'base_kwargs__' + arg

            def fixture(self, cls):
                args = getattr(self, args_attr)
                kwargs = getattr(self, kwargs_attr)
                return cls(*args, **kwargs)

            fixture.__name__ = arg
            return pytest.fixture(fixture)

def fixture(scope="function", params=None, autouse=False, ids=None, name=None):
    """
    When running under pytest, this is the same as the pytest.fixture decorator.
    See https://docs.pytest.org/en/latest/reference.html#pytest-fixture
    """
    if _use_native_pytest:
        # XXX sorting of fixtures based on scope does not work, see
        # https://github.com/pytest-dev/pytest/issues/4143#issuecomment-431794076
        # When ran under pytest, use native functionality.
        return pytest.fixture(scope, params, autouse, ids, name)
    init_fallback_fixtures_once()
    return _fallback.fixture(scope, params, autouse, ids, name)

def setup_pytest_browser_fixture(BrowserClass):
    def browser(live_server, settings):
        # also require the live_server fixture from pytest-django
        # django runserver doesnt support https.
        # todo: can just replace live_server with own fixture that
        # runs the stunnel script instead
        # todo: or can do local setting imports and have a testing one?
        settings.SESSION_COOKIE_SECURE = False
        settings.CSRF_COOKIE_SECURE = False
        _browser = BrowserClass(host_address=live_server.url)
        yield _browser
        # use quit instead of close to release all resources
        _browser.quit()
    return pytest.fixture(browser)

def motor_fixture(name):
    def get_motor(beacon):
        m = beacon.get(name)
        yield m
        m.stop()
        m.wait_move()
        m.apply_config()
        m.controller.set_hw_limits(m, None, None)
        m.dial(0)
        m.position(0)
        for hook in m.motion_hooks:
            hook.nb_pre_move = 0
            hook.nb_post_move = 0
    get_motor.__name__ = name
    return pytest.fixture(get_motor)

def pytest_configure(config):
    # Enable stdout and stderr analysis, unless output capture is disabled
    if config.getoption('capture') != 'no':
        global check_test_output
        check_test_output = pytest.fixture(autouse=True)(check_test_output)

    # If we are running from the source directory, make sure that we load
    # modules from here
    basedir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
    if not config.getoption('installed'):
        llfuse_path = os.path.join(basedir, 'src')
        if (os.path.exists(os.path.join(basedir, 'setup.py')) and
            os.path.exists(os.path.join(basedir, 'src', 'llfuse.pyx'))):
            sys.path.insert(0, llfuse_path)

        # Make sure that called processes use the same path
        pp = os.environ.get('PYTHONPATH', None)
        if pp:
            pp = '%s:%s' % (llfuse_path, pp)
        else:
            pp = llfuse_path
        os.environ['PYTHONPATH'] = pp

    try:
        import faulthandler
    except ImportError:
        pass
    else:
        faulthandler.enable()

    # When running from VCS repo, enable all warnings
    if os.path.exists(os.path.join(basedir, 'MANIFEST.in')):
        import warnings
        warnings.resetwarnings()
        warnings.simplefilter('error')

    logdebug = config.getoption('logdebug')
    if logdebug:
        root_logger = logging.getLogger()
        formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(threadName)s '
                                      '%(funcName)s: %(message)s',
                                      datefmt="%H:%M:%S")
        handler = logging.StreamHandler(sys.stdout)
        handler.setLevel(logging.DEBUG)
        handler.setFormatter(formatter)
        root_logger.addHandler(handler)
        root_logger.setLevel(logging.DEBUG)

def given(name, fixture=None):
    """Given step decorator.

    :param name: Given step name.
    :param fixture: Optional name of the fixture to reuse.

    :raises: StepError in case of wrong configuration.
    :note: Can't be used as a decorator when the fixture is specified.
    """
    name = remove_prefix(name)
    if fixture is not None:
        module = get_caller_module()
        func = getattr(module, fixture, lambda request: request.getfuncargvalue(fixture))
        setattr(module, name, pytest.fixture(lambda: func))
        return _not_a_fixture_decorator

    return _step_decorator(GIVEN, name)

def model_fixture(func):
    """
    Marks function that returns a Model instance as a fixture

    Consider the example::

        @model_fixture
        def foo():
            return ...

    This is the same as::

        @pytest.fixture
        @pytest.mark.db
        def foo():
            return ...
    """
    return pytest.fixture(pytest.mark.db(func))