class Class(PyCollectorMixin, test.collect.Collector):

def __init__(self, name, parent=None):

    self.name = name 

    self.parent = parent

    self._config = getattr(parent, '_config', py.test.config)

    self.fspath = getattr(parent, 'fspath', None) 

def classnamefilter(self, name): 

    return name.startswith('Test')

def finishcapture(self): 

    return None # by default collectors don't capture output

def funcnamefilter(self, name): 

    return name.startswith('test') 

def join(self, name):

    assert name == '()'

    return self.Instance(name, self)

def listchain(self): 

    """ return list of all parent collectors up to ourself. """ 

    l = [self]

    while 1: 

        x = l[-1]

        if x.parent is not None: 

            l.append(x.parent) 

        else: 

            l.reverse() 

            return l 

def listnames(self): 

    return [x.name for x in self.listchain()]

def makeitem(self, name, obj, usefilters=True):

    if (not usefilters or self.classnamefilter(name)) and \

        py.std.inspect.isclass(obj):

        return self.Class(name, parent=self)

    elif (not usefilters or self.funcnamefilter(name)) and callable(obj): 

        if obj.func_code.co_flags & 32: # generator function 

            return self.Generator(name, parent=self)

        else: 

            return self.Function(name, parent=self)

def multijoin(self, namelist): 

    """ return a list of colitems for the given namelist. """ 

    return [self.join(name) for name in namelist]

def run(self): 

    if getattr(self.obj, 'disabled', 0):

        return []

    return ["()"]

def setup(self): 

    setup_class = getattr(self.obj, 'setup_class', None)

    if setup_class is not None: 

        setup_class = getattr(setup_class, 'im_func', setup_class) 

        setup_class(self.obj) 

def startcapture(self): 

    return None # by default collectors don't capture output

def teardown(self): 

    teardown_class = getattr(self.obj, 'teardown_class', None) 

    if teardown_class is not None: 

        teardown_class = getattr(teardown_class, 'im_func', teardown_class) 

        teardown_class(self.obj) 

def __cmp__(self, other): 

    s1 = self._getsortvalue()

    s2 = other._getsortvalue()

    #print "cmp", s1, s2

    return cmp(s1, s2) 

def __eq__(self, other): 

    # XXX a rather strict check for now to not confuse

    #     the SetupState.prepare() logic

    return self is other

def __hash__(self):

    return hash((self.name, self.parent))

def __ne__(self, other):

    return not self == other

def __repr__(self): 

    return "<%s %r>" %(self.__class__.__name__, self.name)