def testWeakref(self):
        from music21 import note

        n = note.Note()
        idStored = id(n)
        wn = common.wrapWeakref(n)
        n2 = common.unwrapWeakref(n)
        self.assertEqual(id(n), id(n2))

 def setContainer(self, container):
     # container is the Stream that contains
     if container is None:
         self._containerId = None
         self._container = None
     else:
         self._containerId = id(container)
         self._container = common.wrapWeakref(container)

 def client(self, client):
     # client is the Stream that this derivation lives on
     if client is None:
         self._clientId = None
         self._client = None
     else:
         self._clientId = id(client)
         self._client = common.wrapWeakref(client)

 def wrapWeakref(self):
     '''Wrap all stored objects with weakrefs.
     '''
     if not common.isWeakref(self._container):
         # update id in case it has changed
         self._containerId = id(self._container)
         post = common.wrapWeakref(self._container)
         self._container = post

    def add(self, spanner, component):
        """Add a spanner and one or more component references.

        The `spanner` is the object represent the connections, such as a Slur or GroupBracket.

        The `component` is one or more (a list) objects, such as Note or Part.
        
        If the spanner already exists, the component will be added to the components list.


        >>> from music21 import *
        >>> class TestMock(object): pass
        >>> tm1 = TestMock()
        >>> n1 = note.Note('c2')
        >>> n2 = note.Note('g3')
        >>> sp1 = Spanners()
        >>> sp1.add(tm1, [n1, n2])
        >>> len(sp1)
        1
        """
        idSpanner = id(spanner)
        if idSpanner not in self.keys():
            self._storage[idSpanner] = (common.wrapWeakref(spanner), [])
            self._idRef[idSpanner] = []  # just a list

        refPair = self._storage[idSpanner]
        idList = self._idRef[idSpanner]

        # presently this does not look for redundant entries
        # store component as weak ref
        if common.isListLike(component):
            bundle = component
        else:  # just append one
            bundle = [component]

        for sub in bundle:  # permit a lost of spanners
            refPair[1].append(common.wrapWeakref(sub))
            idList.append(id(sub))

 def client(self, client):
     # client is the Stream that this status lives on
     self._client = common.wrapWeakref(client)

 def __setstate__(self, state):
     SlottedObject.__setstate__(self, state)
     self._client = common.wrapWeakref(self._client)

 def __init__(self, parent, stateInfo):
     self.affectedTokens = []
     self.parent = common.wrapWeakref(parent)
     self.stateInfo = stateInfo

 def client(self, referent):
     self._client = common.wrapWeakref(referent)

 def __setstate__(self, state):
     common.SlottedObject.__setstate__(self, state)
     if WEAKREF_ACTIVE:
         self.siteWeakref = common.wrapWeakref(self.siteWeakref)

 def _setParent(self, parent):
     if parent is not None:
         if hasattr(parent, 'classes') and 'NotRest' in parent.classes:
             self._parent = common.wrapWeakref(parent)
     else:
         self._parent = None

 def element(self, expr):
     self._source = common.wrapWeakref(expr)

 def corpus(self, newCorpus):
     self._corpus = common.wrapWeakref(newCorpus)

 def _setAndWrapSite(self, site):
     if WEAKREF_ACTIVE:
         self.siteWeakref = common.wrapWeakref(site)
     else:
         self.siteWeakref = site

 def _setParent(self, parent):
     self._parent = common.wrapWeakref(parent)

 def client(self, client):
     if client is not None:
         if hasattr(client, 'classes') and 'NotRest' in client.classes:
             self._client = common.wrapWeakref(client)
     else:
         self._client = None

 def _setAndWrapSite(self, site):
     self.siteWeakref = common.wrapWeakref(site)