def _needs_client (_test, _class, _member, _session, _agent_or_none, _target_or_port_or_queue, _coder) :
	
	def _constructor (__context = None, * __metadata) :
		_client = _construct_wrapper (_class, __context, _session, _agent_or_none, _target_or_port_or_queue, _coder)
		return _client
	
	def _destructor (_client, __context = None, * __metadata) :
		return
	
	return testing.append_context_member_hook (_test, _member, _constructor, _destructor, _accepts_metadata = True)
def _needs_buffered_server (_test, _class, _member, _session, _agent, _target_or_port, _coder, _auto_register, _auto_unregister) :
	
	if _auto_unregister is None : _auto_unregister = _auto_register
	
	def _constructor (__context = None, * __metadata) :
		_server = _construct_wrapper (_class, __context, _session, _agent, _target_or_port, _coder)
		_register_server (_server, _auto_register)
		return _server
	
	def _destructor (_server, __context = None, * __metadata) :
		_unregister_server (_server, _auto_unregister)
		return
	
	return testing.append_context_member_hook (_test, _member, _constructor, _destructor, _accepts_metadata = True)
def needs_reactor (_test, member = 'reactor', threaded = True, auto_start = True, auto_stop = None) :
	
	if auto_stop is None : auto_stop = auto_start
	
	def _constructor () :
		_reactor = reactor.Reactor (threaded)
		if auto_start :
			_reactor.start ()
		return _reactor
	
	def _destructor (_reactor) :
		if auto_stop :
			_reactor.stop ()
		return
	
	return testing.append_context_member_hook (_test, member, _constructor, _destructor)
def _needs_client(
    _test, _class, _member, _session, _callback_agent, _callback_port, _coder, _auto_initialize, _auto_finalize
):

    if _auto_initialize is None:
        _auto_unregister = _auto_register

    def _constructor(__context=None, *__metadata):
        _client = _construct_wrapper(_class, __context, _session, _callback_agent, _callback_port, _coder)
        _initialize_rpc(_client, _auto_initialize)
        return _client

    def _destructor(_client, __context=None, *__metadata):
        _finalize_rpc(_client, _auto_finalize)
        return

    return testing.append_context_member_hook(_test, _member, _constructor, _destructor, _accepts_metadata=True)
def needs_session (_test, member = 'session', address = '127.0.0.1:27683', login = '******', password = '******', ssl = False, reactor_member = 'reactor', auto_open = True, auto_close = None) :
	
	if auto_close is None : auto_close = auto_open
	
	def _constructor (__context = None, ** __metadata) :
		_reactor = getattr (__context, reactor_member)
		_session = session.Session (_reactor, address, login, password, ssl)
		if auto_open :
			_outcome = _session.open_sync (1.0, Exception ())
			assert _outcome
		return _session
	
	def _destructor (_session, __context = None, ** __metadata) :
		if auto_close :
			_outcome = _session.close_sync (1.0, Exception ())
			assert _outcome
		return
	
	return testing.append_context_member_hook (_test, member, _constructor, _destructor, _accepts_metadata = True)
def _needs_echo_server(
    _test, _class, _member, _session, _agent, _target_or_port, _coder, _auto_initialize, _auto_finalize
):

    if _auto_initialize is None:
        _auto_unregister = _auto_register

    _callable = lambda _request: _request

    def _constructor(__context=None, *__metadata):
        _server = _construct_wrapper(_class, __context, _session, _agent, _target_or_port, _coder, _callable)
        _initialize_rpc(_server, _auto_initialize)
        return _server

    def _destructor(_server, __context=None, *__metadata):
        _finalize_rpc(_server, _auto_finalize)
        return

    return testing.append_context_member_hook(_test, _member, _constructor, _destructor, _accepts_metadata=True)
def needs_null_task (_test, something = object (), callback_member = 'callback') :
	
	return testing.append_context_member_hook (_test, callback_member, lambda : (lambda : None), None)
def needs_json_coder (_test, member = 'coder') :
	
	return testing.append_context_member_hook (_test, member, coders.JsonCoder, None)
def needs_message_objects (_test, member = 'objects', count = 4) :
	
	_constructor = lambda : [_generate_message_object () for _index in xrange (count)]
	
	return testing.append_context_member_hook (_test, member, _constructor, None)
def needs_message_object (_test, member = 'object') :
	
	return testing.append_context_member_hook (_test, member, _generate_message_object, None)
def needs_pickle_coder (_test, member = 'coder') :
	
	return testing.append_context_member_hook (_test, member, coders.PickleCoder, None)
def needs_port_identifier (_test, member = 'port', identifier = None) :
	
	_constructor = lambda : identifier if identifier is not None else uuid.uuid4 () .hex
	
	return testing.append_context_member_hook (_test, member, _constructor, None)
def needs_target_identifier (_test, member = 'target', identifier = None, length = 8, part_length = 8) :
	
	_constructor = lambda : identifier if identifier is not None else [uuid.uuid4 () .hex [:part_length] for _index in xrange (length)]
	
	return testing.append_context_member_hook (_test, member, _constructor, None)
def needs_message (_test, member = 'message') :
	
	return testing.append_context_member_hook (_test, member, generate_message, None)
def needs_null_handler (_test, member = 'handler') :
	
	_handler = lambda _session, _endpoint, _message : None
	
	return testing.append_context_member_hook (_test, member, lambda : _handler, None)