# Create tree and populates it with blobs

        commit_tree = self.parents[0] and repo[self.parents[0]._commit.tree] or\

            objects.Tree()

        for node in self.added + self.changed:

            # Compute subdirs if needed

            dirpath, nodename = posixpath.split(node.path)

            dirnames = dirpath and dirpath.split('/') or []

            parent = commit_tree

            ancestors = [('', parent)]

            # Tries to dig for the deepest existing tree

            while dirnames:

                curdir = dirnames.pop(0)

                try:

                    dir_id = parent[curdir][1]

                except KeyError:

                    # put curdir back into dirnames and stops

                    dirnames.insert(0, curdir)

                    break

                else:

                    # If found, updates parent

                    parent = self.repository._repo[dir_id]

                    ancestors.append((curdir, parent))

            # for dirnames (in reverse order) [this only applies for nodes from added]

            new_trees = []

            node_path = node.name.encode(ENCODING)

            if dirnames:

                # If there are trees which should be created we need to build

                # them now (in reverse order)

                reversed_dirnames = list(reversed(dirnames))

                curtree = objects.Tree()

                curtree[node_path] = node.mode, blob.id

                new_trees.append(curtree)

                for dirname in reversed_dirnames[:-1]:

                    newtree = objects.Tree()

                    #newtree.add(DIRMOD, dirname, curtree.id)

                    newtree[dirname] = DIRMOD, curtree.id

                    new_trees.append(newtree)

                    curtree = newtree

                parent[reversed_dirnames[-1]] = DIRMOD, curtree.id

            else:

                parent.add(name=node_path, mode=node.mode, hexsha=blob.id)

            new_trees.append(parent)

            # Update ancestors

            for parent, tree, path in reversed([(a[1], b[1], b[0]) for a, b in

                zip(ancestors, ancestors[1:])]):

                parent[path] = DIRMOD, tree.id

                object_store.add_object(tree)

    """

    This is a backend independent test case class which should be created

    with ``type`` method.

    It is required to set following attributes at subclass:

    - ``backend_alias``: alias of used backend (see ``vcs.BACKENDS``)

    - ``repo_path``: path to the repository which would be created for set of

      tests

    """

    def get_backend(self):

        return vcs.get_backend(self.backend_alias)

    def setUp(self):

        Backend = self.get_backend()

        self.repo_path = get_new_dir(str(time.time()))

        self.repo = Backend(self.repo_path, create=True)

        self.imc = self.repo.in_memory_changeset

        self.nodes = [

            FileNode('foobar', content='Foo & bar'),

            FileNode('foobar2', content='Foo & bar, doubled!'),

            FileNode('foo bar with spaces', content=''),

            FileNode('foo/bar/baz', content='Inside'),

        ]

    def test_add(self):

        rev_count = len(self.repo.revisions)

        to_add = [FileNode(node.path, content=node.content)

            for node in self.nodes]

        for node in to_add:

            self.imc.add(node)

        message = u'Added: %s' % ', '.join((node.path for node in self.nodes))

        author = unicode(self.__class__)

        changeset = self.imc.commit(message=message, author=author)

        newtip = self.repo.get_changeset()

        self.assertEqual(changeset, newtip)

        self.assertEqual(rev_count + 1, len(self.repo.revisions))

        self.assertEqual(newtip.message, message)

        self.assertEqual(newtip.author, author)

        self.assertTrue(not any((self.imc.added, self.imc.changed,

            self.imc.removed)))

        for node in to_add:

            self.assertEqual(newtip.get_node(node.path).content, node.content)

    def test_add_in_bulk(self):

        rev_count = len(self.repo.revisions)