Initial set of improvementes merged into master, including a class hierarchy redesign and performance improvements

Merge commit 'origin/improvements'

* commit 'origin/improvements': (38 commits)
  test_performance: module containing benchmarks to get an idea of the achieved throughput
  Removed plenty of mocked tree tests as they cannot work anymore with persistent commands that require stdin AND binary data - not even an adapter would help here. These tests will have to be replaced.
  tree: now reads tress directly by parsing the binary data, allowing it to safe possibly hundreds of command calls
  Refs are now truly dynamic - this costs a little bit of (persistent command) work, but assures refs behave as expected
  persistent command signature changed to also return the hexsha from a possible input ref - the objects pointed to by refs are now baked on demand - perhaps it should change to always be re-retrieved using a property as it is relatively fast - this way refs can always be cached
  test_blob: removed many redundant tests that would fail now as the mock cannot handle the complexity of the command backend
  Implemented git command facility to keep persistent commands for fast object information retrieval
  test: Added time-consuming test which could also be a benchmark in fact - currently it cause hundreds of command invocations which is slow
  cmd: added option to return the process directly, allowing to read the output directly from the output stream
  added Iterable interface to Ref type
  renamed find_all to list_all, changed commit to use iterable interface in preparation for command changes
  Added base for all iteratable objects
  unified name of utils module, recently it was named util and utils in different packages
  tree: renamed content_from_string to _from_string to make it private. Removed tests that were testing that method
  tree: now behaves like a list with string indexing functionality - using a dict as cache is a problem as the tree is ordered, added blobs, trees and traverse method
  test_base: Improved basic object creation as well as set hash tests
  repo.active_branch now returns a Head object, not a string
  IndexObjects are now checking their slots to raise a proper error message in case someone tries to access an unset path or mode - this information cannot be retrieved afterwards as IndexObject information is kept in the object that pointed at them. To find this information, one would have to search all objects which is not feasible
  refs now take repo as first argument and derive from LazyMixin to allow them to dynamically retrieve their objects
  renamed from_string and list_from_string to _from_string and _list_from_string to indicate their new status as private method, adjusted all callers respectively
  ...

20 files changed, 827 insertions, 851 deletions

diff --git a/test/fixtures/diff_mode_only b/test/fixtures/diff_mode_only
index 6fc18f69..6fc18f69 100644..100755
--- a/test/fixtures/diff_mode_only
+++ b/test/fixtures/diff_mode_only
diff --git a/test/fixtures/for_each_ref b/test/fixtures/for_each_ref
deleted file mode 100644
index e56f5262..00000000
--- a/test/fixtures/for_each_ref
+++ /dev/null
diff --git a/test/fixtures/for_each_ref_tags b/test/fixtures/for_each_ref_tags
deleted file mode 100644
index c4df85c6..00000000
--- a/test/fixtures/for_each_ref_tags
+++ /dev/null
diff --git a/test/fixtures/for_each_ref_with_path_component b/test/fixtures/for_each_ref_with_path_component
index 717c4203..e723b4ae 100644
--- a/test/fixtures/for_each_ref_with_path_component
+++ b/test/fixtures/for_each_ref_with_path_component
diff --git a/test/git/test_actor.py b/test/git/test_actor.py
index 862010fc..b7c2af7c 100644
--- a/test/git/test_actor.py
+++ b/test/git/test_actor.py
@@ -9,20 +9,20 @@ from test.testlib import *
 from git import *
 
 class TestActor(object):
-    def test_from_string_should_separate_name_and_email(self):
-        a = Actor.from_string("Michael Trier <mtrier@example.com>")
-        assert_equal("Michael Trier", a.name)
-        assert_equal("mtrier@example.com", a.email)
+	def test_from_string_should_separate_name_and_email(self):
+		a = Actor._from_string("Michael Trier <mtrier@example.com>")
+		assert_equal("Michael Trier", a.name)
+		assert_equal("mtrier@example.com", a.email)
 
-    def test_from_string_should_handle_just_name(self):
-        a = Actor.from_string("Michael Trier")
-        assert_equal("Michael Trier", a.name)
-        assert_equal(None, a.email)
+	def test_from_string_should_handle_just_name(self):
+		a = Actor._from_string("Michael Trier")
+		assert_equal("Michael Trier", a.name)
+		assert_equal(None, a.email)
 
-    def test_should_display_representation(self):
-        a = Actor.from_string("Michael Trier <mtrier@example.com>")
-        assert_equal('<git.Actor "Michael Trier <mtrier@example.com>">', repr(a))
+	def test_should_display_representation(self):
+		a = Actor._from_string("Michael Trier <mtrier@example.com>")
+		assert_equal('<git.Actor "Michael Trier <mtrier@example.com>">', repr(a))
 
-    def test_str_should_alias_name(self):
-        a = Actor.from_string("Michael Trier <mtrier@example.com>")
-        assert_equal(a.name, str(a))
\ No newline at end of file
+	def test_str_should_alias_name(self):
+		a = Actor._from_string("Michael Trier <mtrier@example.com>")
+		assert_equal(a.name, str(a))
\ No newline at end of file
diff --git a/test/git/test_base.py b/test/git/test_base.py
new file mode 100644
index 00000000..402cdba3
--- /dev/null
+++ b/test/git/test_base.py
@@ -0,0 +1,93 @@
+# test_base.py
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under
+# the BSD License: http://www.opensource.org/licenses/bsd-license.php
+
+import time
+from test.testlib import *
+from git import *
+import git.objects.base as base
+import git.refs as refs
+from itertools import chain
+from git.objects.utils import get_object_type_by_name
+
+class TestBase(object):
+	
+	type_tuples = (  ("blob", "8741fc1d09d61f02ffd8cded15ff603eff1ec070"), 
+					 ("tree", "3a6a5e3eeed3723c09f1ef0399f81ed6b8d82e79"),
+					 ("commit", "4251bd59fb8e11e40c40548cba38180a9536118c"),
+					 ("tag", "e56a60e8e9cd333cfba0140a77cd12b0d9398f10") ) 
+	
+	def setup(self):
+		self.repo = Repo(GIT_REPO)
+		
+	def test_base_object(self):	
+		# test interface of base object classes
+		types = (Blob, Tree, Commit, TagObject)
+		assert len(types) == len(self.type_tuples)
+		
+		s = set()
+		num_objs = 0
+		num_index_objs = 0
+		for obj_type, (typename, hexsha) in zip(types, self.type_tuples):
+			item = obj_type(self.repo,hexsha)
+			num_objs += 1
+			assert item.id == hexsha
+			assert item.type == typename
+			assert item.size
+			assert item.data
+			assert item == item
+			assert not item != item
+			assert str(item) == item.id
+			assert repr(item)
+			s.add(item)
+			
+			if isinstance(item, base.IndexObject):
+				num_index_objs += 1
+				if hasattr(item,'path'):						# never runs here
+					assert not item.path.startswith("/")		# must be relative
+					assert isinstance(item.mode, int)
+			# END index object check
+		# END for each object type to create
+		
+		# each has a unique sha
+		assert len(s) == num_objs
+		assert len(s|s) == num_objs
+		assert num_index_objs == 2
+		
+		
+	def test_tags(self):
+		# tag refs can point to tag objects or to commits
+		s = set()
+		ref_count = 0
+		for ref in chain(self.repo.tags, self.repo.heads):
+			ref_count += 1
+			assert isinstance(ref, refs.Ref)
+			assert str(ref) == ref.name
+			assert repr(ref)
+			assert ref == ref
+			assert not ref != ref
+			s.add(ref)
+		# END for each ref
+		assert len(s) == ref_count
+		assert len(s|s) == ref_count
+		
+	def test_heads(self):
+		# see how it dynmically updates its object
+		for head in self.repo.heads:
+			head.name
+			head.path
+			prev_object = head.object
+			cur_object = head.object
+			assert prev_object == cur_object		# represent the same git object
+			assert prev_object is not cur_object	# but are different instances
+		# END for each head
+		
+	def test_get_object_type_by_name(self):
+		for tname in base.Object.TYPES:
+			assert base.Object in get_object_type_by_name(tname).mro()
+		# END for each known type 
+		
+		assert_raises( ValueError, get_object_type_by_name, "doesntexist" )
+
diff --git a/test/git/test_blob.py b/test/git/test_blob.py
index 5bd74ff7..266f3a23 100644
--- a/test/git/test_blob.py
+++ b/test/git/test_blob.py
@@ -9,89 +9,25 @@ from test.testlib import *
 from git import *
 
 class TestBlob(object):
-    def setup(self):
-        self.repo = Repo(GIT_REPO)
-    
-    @patch_object(Git, '_call_process')
-    def test_should_return_blob_contents(self, git):
-        git.return_value = fixture('cat_file_blob')
-        blob = Blob(self.repo, **{'id': 'abc'})
-        assert_equal("Hello world", blob.data)
-        assert_true(git.called)
-        assert_equal(git.call_args, (('cat_file', 'abc'), {'p': True, 'with_raw_output': True}))
-
-    @patch_object(Git, '_call_process')
-    def test_should_return_blob_contents_with_newline(self, git):
-        git.return_value = fixture('cat_file_blob_nl')
-        blob = Blob(self.repo, **{'id': 'abc'})
-        assert_equal("Hello world\n", blob.data)
-        assert_true(git.called)
-        assert_equal(git.call_args, (('cat_file', 'abc'), {'p': True, 'with_raw_output': True}))
-    
-    @patch_object(Git, '_call_process')
-    def test_should_cache_data(self, git):
-        git.return_value = fixture('cat_file_blob')
-        blob = Blob(self.repo, **{'id': 'abc'})
-        blob.data
-        blob.data
-        assert_true(git.called)
-        assert_equal(git.call_count, 1)
-        assert_equal(git.call_args, (('cat_file', 'abc'), {'p': True, 'with_raw_output': True}))
-
-    @patch_object(Git, '_call_process')
-    def test_should_return_file_size(self, git):
-        git.return_value = fixture('cat_file_blob_size')
-        blob = Blob(self.repo, **{'id': 'abc'})
-        assert_equal(11, blob.size)
-        assert_true(git.called)
-        assert_equal(git.call_args, (('cat_file', 'abc'), {'s': True}))
-
-    @patch_object(Git, '_call_process')
-    def test_should_cache_file_size(self, git):
-        git.return_value = fixture('cat_file_blob_size')
-        blob = Blob(self.repo, **{'id': 'abc'})
-        assert_equal(11, blob.size)
-        assert_equal(11, blob.size)
-        assert_true(git.called)
-        assert_equal(git.call_count, 1)
-        assert_equal(git.call_args, (('cat_file', 'abc'), {'s': True}))
-  
-    def test_mime_type_should_return_mime_type_for_known_types(self):
-        blob = Blob(self.repo, **{'id': 'abc', 'name': 'foo.png'})
-        assert_equal("image/png", blob.mime_type)
-  
-    def test_mime_type_should_return_text_plain_for_unknown_types(self):
-        blob = Blob(self.repo, **{'id': 'abc'})
-        assert_equal("text/plain", blob.mime_type)
+	def setup(self):
+		self.repo = Repo(GIT_REPO)
+	
+	def test_should_cache_data(self):
+		bid = 'a802c139d4767c89dcad79d836d05f7004d39aac'
+		blob = Blob(self.repo, bid)
+		blob.data
+		assert blob.data
+		blob.size
+		blob.size
+		
+	def test_mime_type_should_return_mime_type_for_known_types(self):
+		blob = Blob(self.repo, **{'id': 'abc', 'path': 'foo.png'})
+		assert_equal("image/png", blob.mime_type)
   
-    @patch_object(Git, '_call_process')
-    def test_should_display_blame_information(self, git):
-        git.return_value = fixture('blame')
-        b = Blob.blame(self.repo, 'master', 'lib/git.py')
-        assert_equal(13, len(b))
-        assert_equal( 2, len(b[0]) )
-        # assert_equal(25, reduce(lambda acc, x: acc + len(x[-1]), b))
-        assert_equal(hash(b[0][0]), hash(b[9][0]))
-        c = b[0][0]
-        assert_true(git.called)
-        assert_equal(git.call_args, (('blame', 'master', '--', 'lib/git.py'), {'p': True}))
-        
-        assert_equal('634396b2f541a9f2d58b00be1a07f0c358b999b3', c.id)
-        assert_equal('Tom Preston-Werner', c.author.name)
-        assert_equal('tom@mojombo.com', c.author.email)
-        assert_equal(time.gmtime(1191997100), c.authored_date)
-        assert_equal('Tom Preston-Werner', c.committer.name)
-        assert_equal('tom@mojombo.com', c.committer.email)
-        assert_equal(time.gmtime(1191997100), c.committed_date)
-        assert_equal('initial grit setup', c.message)
-        
-        # test the 'lines per commit' entries
-        tlist = b[0][1]
-        assert_true( tlist )
-        assert_true( isinstance( tlist[0], basestring ) )
-        assert_true( len( tlist ) < sum( len(t) for t in tlist ) )				 # test for single-char bug
-        
+	def test_mime_type_should_return_text_plain_for_unknown_types(self):
+		blob = Blob(self.repo, **{'id': 'abc','path': 'something'})
+		assert_equal("text/plain", blob.mime_type)
   
-    def test_should_return_appropriate_representation(self):
-        blob = Blob(self.repo, **{'id': 'abc'})
-        assert_equal('<git.Blob "abc">', repr(blob))
+	def test_should_return_appropriate_representation(self):
+		blob = Blob(self.repo, **{'id': 'abc'})
+		assert_equal('<git.Blob "abc">', repr(blob))
diff --git a/test/git/test_commit.py b/test/git/test_commit.py
index d6bd6120..a95fb675 100644
--- a/test/git/test_commit.py
+++ b/test/git/test_commit.py
@@ -8,241 +8,225 @@ from test.testlib import *
 from git import *
 
 class TestCommit(object):
-    def setup(self):
-        self.repo = Repo(GIT_REPO)
+	def setup(self):
+		self.repo = Repo(GIT_REPO)
 
-    @patch_object(Git, '_call_process')
-    def test_bake(self, git):
-        git.return_value = fixture('rev_list_single')
+	def test_bake(self):
 
-        commit = Commit(self.repo, **{'id': '4c8124ffcf4039d292442eeccabdeca5af5c5017'})
-        commit.author # bake
+		commit = Commit(self.repo, **{'id': '2454ae89983a4496a445ce347d7a41c0bb0ea7ae'})
+		commit.author # bake
 
-        assert_equal("Tom Preston-Werner", commit.author.name)
-        assert_equal("tom@mojombo.com", commit.author.email)
+		assert_equal("Sebastian Thiel", commit.author.name)
+		assert_equal("byronimo@gmail.com", commit.author.email)
 
-        assert_true(git.called)
-        assert_equal(git.call_args, (('rev_list', '4c8124ffcf4039d292442eeccabdeca5af5c5017', '--', ''), {'pretty': 'raw', 'max_count': 1}))
 
-    @patch_object(Git, '_call_process')
-    def test_id_abbrev(self, git):
-        git.return_value = fixture('rev_list_commit_idabbrev')
-        assert_equal('80f136f', self.repo.commit('80f136f500dfdb8c3e8abf4ae716f875f0a1b57f').id_abbrev)
+	@patch_object(Git, '_call_process')
+	def test_diff(self, git):
+		git.return_value = fixture('diff_p')
 
-    @patch_object(Git, '_call_process')
-    def test_diff(self, git):
-        git.return_value = fixture('diff_p')
+		diffs = Commit.diff(self.repo, 'master')
 
-        diffs = Commit.diff(self.repo, 'master')
+		assert_equal(15, len(diffs))
+		
+		diff = diffs[0]
+		assert_equal('.gitignore', diff.a_blob.path)
+		assert_equal('.gitignore', diff.b_blob.path)
+		assert_equal('4ebc8aea50e0a67e000ba29a30809d0a7b9b2666', diff.a_blob.id)
+		assert_equal('2dd02534615434d88c51307beb0f0092f21fd103', diff.b_blob.id)
+		
+		assert_mode_644(diff.b_blob.mode)
+		
+		assert_equal(False, diff.new_file)
+		assert_equal(False, diff.deleted_file)
+		assert_equal("--- a/.gitignore\n+++ b/.gitignore\n@@ -1 +1,2 @@\n coverage\n+pkg", diff.diff)
 
-        assert_equal(15, len(diffs))
-
-        assert_equal('.gitignore', diffs[0].a_blob.name)
-        assert_equal('.gitignore', diffs[0].b_blob.name)
-        assert_equal('4ebc8aea50e0a67e000ba29a30809d0a7b9b2666', diffs[0].a_blob.id)
-        assert_equal('2dd02534615434d88c51307beb0f0092f21fd103', diffs[0].b_blob.id)
-        assert_equal('100644', diffs[0].b_blob.mode)
-        assert_equal(False, diffs[0].new_file)
-        assert_equal(False, diffs[0].deleted_file)
-        assert_equal("--- a/.gitignore\n+++ b/.gitignore\n@@ -1 +1,2 @@\n coverage\n+pkg", diffs[0].diff)
-
-        assert_equal('lib/grit/actor.rb', diffs[5].b_blob.name)
-        assert_equal(None, diffs[5].a_blob)
-        assert_equal('f733bce6b57c0e5e353206e692b0e3105c2527f4', diffs[5].b_blob.id)
-        assert_equal( None, diffs[5].a_mode )
-        assert_equal(True, diffs[5].new_file)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('diff', '-M', 'master'), {'full_index': True}))
-
-    @patch_object(Git, '_call_process')
-    def test_diff_with_rename(self, git):
-        git.return_value = fixture('diff_rename')
-
-        diffs = Commit.diff(self.repo, 'rename')
-
-        assert_equal(1, len(diffs))
-
-        diff = diffs[0]
-        assert_true(diff.renamed)
-        assert_equal(diff.rename_from, 'AUTHORS')
-        assert_equal(diff.rename_to, 'CONTRIBUTORS')
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('diff', '-M', 'rename'), {'full_index': True}))
-
-    @patch_object(Git, '_call_process')
-    def test_diff_with_two_commits(self, git):
-        git.return_value = fixture('diff_2')
-
-        diffs = Commit.diff(self.repo, '59ddc32', '13d27d5')
-
-        assert_equal(3, len(diffs))
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('diff', '-M', '59ddc32', '13d27d5'), {'full_index': True}))
-
-    @patch_object(Git, '_call_process')
-    def test_diff_with_files(self, git):
-        git.return_value = fixture('diff_f')
-
-        diffs = Commit.diff(self.repo, '59ddc32', ['lib'])
-
-        assert_equal(1, len(diffs))
-        assert_equal('lib/grit/diff.rb', diffs[0].a_blob.name)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('diff', '-M', '59ddc32', '--', 'lib'), {'full_index': True}))
-
-    @patch_object(Git, '_call_process')
-    def test_diff_with_two_commits_and_files(self, git):
-        git.return_value = fixture('diff_2f')
-
-        diffs = Commit.diff(self.repo, '59ddc32', '13d27d5', ['lib'])
-
-        assert_equal(1, len(diffs))
-        assert_equal('lib/grit/commit.rb', diffs[0].a_blob.name)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('diff', '-M', '59ddc32', '13d27d5', '--', 'lib'), {'full_index': True}))
-
-    @patch_object(Git, '_call_process')
-    def test_diffs(self, git):
-        git.return_value = fixture('diff_p')
-
-        commit = Commit(self.repo, id='91169e1f5fa4de2eaea3f176461f5dc784796769', parents=['038af8c329ef7c1bae4568b98bd5c58510465493'])
-        diffs = commit.diffs
-
-        assert_equal(15, len(diffs))
-
-        assert_equal('.gitignore', diffs[0].a_blob.name)
-        assert_equal('.gitignore', diffs[0].b_blob.name)
-        assert_equal('4ebc8aea50e0a67e000ba29a30809d0a7b9b2666', diffs[0].a_blob.id)
-        assert_equal('2dd02534615434d88c51307beb0f0092f21fd103', diffs[0].b_blob.id)
-        assert_equal('100644', diffs[0].b_blob.mode)
-        assert_equal(False, diffs[0].new_file)
-        assert_equal(False, diffs[0].deleted_file)
-        assert_equal("--- a/.gitignore\n+++ b/.gitignore\n@@ -1 +1,2 @@\n coverage\n+pkg", diffs[0].diff)
-
-        assert_equal('lib/grit/actor.rb', diffs[5].b_blob.name)
-        assert_equal(None, diffs[5].a_blob)
-        assert_equal('f733bce6b57c0e5e353206e692b0e3105c2527f4', diffs[5].b_blob.id)
-        assert_equal(True, diffs[5].new_file)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('diff', '-M',
-                                              '038af8c329ef7c1bae4568b98bd5c58510465493',
-                                              '91169e1f5fa4de2eaea3f176461f5dc784796769',
-                                      ), {'full_index': True}))
-
-    @patch_object(Git, '_call_process')
-    def test_diffs_on_initial_import(self, git):
-        git.return_value = fixture('diff_i')
-
-        commit = Commit(self.repo, id='634396b2f541a9f2d58b00be1a07f0c358b999b3')
-        commit.__bake_it__()
-        diffs = commit.diffs
-
-        assert_equal(10, len(diffs))
-
-        assert_equal('History.txt', diffs[0].b_blob.name)
-        assert_equal(None, diffs[0].a_blob)
-        assert_equal('100644', diffs[0].b_blob.mode)
-        assert_equal('81d2c27608b352814cbe979a6acd678d30219678', diffs[0].b_blob.id)
-        assert_equal(True, diffs[0].new_file)
-        assert_equal(False, diffs[0].deleted_file)
-        assert_equal("--- /dev/null\n+++ b/History.txt\n@@ -0,0 +1,5 @@\n+== 1.0.0 / 2007-10-09\n+\n+* 1 major enhancement\n+  * Birthday!\n+", diffs[0].diff)
-
-        assert_equal('lib/grit.rb', diffs[5].b_blob.name)
-        assert_equal(None, diffs[5].a_blob)
-        assert_equal('32cec87d1e78946a827ddf6a8776be4d81dcf1d1', diffs[5].b_blob.id)
-        assert_equal(True, diffs[5].new_file)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('show', '634396b2f541a9f2d58b00be1a07f0c358b999b3', '-M'), {'full_index': True, 'pretty': 'raw'}))
-
-    @patch_object(Git, '_call_process')
-    def test_diffs_on_initial_import_with_empty_commit(self, git):
-        git.return_value = fixture('show_empty_commit')
-
-        commit = Commit(self.repo, id='634396b2f541a9f2d58b00be1a07f0c358b999b3')
-        diffs = commit.diffs
-
-        assert_equal([], diffs)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('show', '634396b2f541a9f2d58b00be1a07f0c358b999b3', '-M'), {'full_index': True, 'pretty': 'raw'}))
-
-    @patch_object(Git, '_call_process')
-    def test_diffs_with_mode_only_change(self, git):
-        git.return_value = fixture('diff_mode_only')
-
-        commit = Commit(self.repo, id='91169e1f5fa4de2eaea3f176461f5dc784796769')
-        commit.__bake_it__()
-        diffs = commit.diffs
-
-        # in case of mode-only changes, there is no blob
-        assert_equal(23, len(diffs))
-        assert_equal(None, diffs[0].a_blob)
-        assert_equal(None, diffs[0].b_blob)
-        assert_equal('100644', diffs[0].a_mode)
-        assert_equal('100755', diffs[0].b_mode)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('show', '91169e1f5fa4de2eaea3f176461f5dc784796769', '-M'), {'full_index': True, 'pretty': 'raw'}))
-
-    @patch_object(Git, '_call_process')
-    def test_stats(self, git):
-        git.return_value = fixture('diff_tree_numstat_root')
-
-        commit = Commit(self.repo, id='634396b2f541a9f2d58b00be1a07f0c358b999b3')
-        commit.__bake_it__()
-        stats = commit.stats
-
-        keys = stats.files.keys()
-        keys.sort()
-        assert_equal(["a.txt", "b.txt"], keys)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('diff_tree', '634396b2f541a9f2d58b00be1a07f0c358b999b3', '--'), {'numstat': True, 'root': True }))
-
-    @patch_object(Git, '_call_process')
-    def test_rev_list_bisect_all(self, git):
-        """
-        'git rev-list --bisect-all' returns additional information
-        in the commit header.  This test ensures that we properly parse it.
-        """
-
-        git.return_value = fixture('rev_list_bisect_all')
-
-        revs = self.repo.git.rev_list('HEAD',
-                                      pretty='raw',
-                                      first_parent=True,
-                                      bisect_all=True)
-        assert_true(git.called)
-
-        commits = Commit.list_from_string(self.repo, revs)
-        expected_ids = (
-            'cf37099ea8d1d8c7fbf9b6d12d7ec0249d3acb8b',
-            '33ebe7acec14b25c5f84f35a664803fcab2f7781',
-            'a6604a00a652e754cb8b6b0b9f194f839fc38d7c',
-            '8df638c22c75ddc9a43ecdde90c0c9939f5009e7',
-            'c231551328faa864848bde6ff8127f59c9566e90',
-        )
-        for sha1, commit in zip(expected_ids, commits):
-            assert_equal(sha1, commit.id)
-
-    def test_str(self):
-        commit = Commit(self.repo, id='abc')
-        assert_equal ("abc", str(commit))
-
-    def test_repr(self):
-        commit = Commit(self.repo, id='abc')
-        assert_equal('<git.Commit "abc">', repr(commit))
-
-    def test_equality(self):
-        commit1 = Commit(self.repo, id='abc')
-        commit2 = Commit(self.repo, id='abc')
-        commit3 = Commit(self.repo, id='zyx')
-        assert_equal(commit1, commit2)
-        assert_not_equal(commit2, commit3)
+		diff = diffs[5]
+		assert_equal('lib/grit/actor.rb', diff.b_blob.path)
+		assert_equal(None, diff.a_blob)
+		assert_equal('f733bce6b57c0e5e353206e692b0e3105c2527f4', diff.b_blob.id)
+		assert_equal( None, diff.a_mode )
+		assert_equal(True, diff.new_file)
+
+		assert_true(git.called)
+		assert_equal(git.call_args, (('diff', '-M', 'master'), {'full_index': True}))
+
+	@patch_object(Git, '_call_process')
+	def test_diff_with_rename(self, git):
+		git.return_value = fixture('diff_rename')
+
+		diffs = Commit.diff(self.repo, 'rename')
+
+		assert_equal(1, len(diffs))
+
+		diff = diffs[0]
+		assert_true(diff.renamed)
+		assert_equal(diff.rename_from, 'AUTHORS')
+		assert_equal(diff.rename_to, 'CONTRIBUTORS')
+
+		assert_true(git.called)
+		assert_equal(git.call_args, (('diff', '-M', 'rename'), {'full_index': True}))
+
+	@patch_object(Git, '_call_process')
+	def test_diff_with_two_commits(self, git):
+		git.return_value = fixture('diff_2')
+
+		diffs = Commit.diff(self.repo, '59ddc32', '13d27d5')
+
+		assert_equal(3, len(diffs))
+
+		assert_true(git.called)
+		assert_equal(git.call_args, (('diff', '-M', '59ddc32', '13d27d5'), {'full_index': True}))
+
+	@patch_object(Git, '_call_process')
+	def test_diff_with_files(self, git):
+		git.return_value = fixture('diff_f')
+
+		diffs = Commit.diff(self.repo, '59ddc32', ['lib'])
+
+		assert_equal(1, len(diffs))
+		assert_equal('lib/grit/diff.rb', diffs[0].a_blob.path)
+
+		assert_true(git.called)
+		assert_equal(git.call_args, (('diff', '-M', '59ddc32', '--', 'lib'), {'full_index': True}))
+
+	@patch_object(Git, '_call_process')
+	def test_diff_with_two_commits_and_files(self, git):
+		git.return_value = fixture('diff_2f')
+
+		diffs = Commit.diff(self.repo, '59ddc32', '13d27d5', ['lib'])
+
+		assert_equal(1, len(diffs))
+		assert_equal('lib/grit/commit.rb', diffs[0].a_blob.path)
+
+		assert_true(git.called)
+		assert_equal(git.call_args, (('diff', '-M', '59ddc32', '13d27d5', '--', 'lib'), {'full_index': True}))
+
+	@patch_object(Git, '_call_process')
+	def test_diffs(self, git):
+		git.return_value = fixture('diff_p')
+
+		commit = Commit(self.repo, id='91169e1f5fa4de2eaea3f176461f5dc784796769', parents=['038af8c329ef7c1bae4568b98bd5c58510465493'])
+		diffs = commit.diffs
+
+		assert_equal(15, len(diffs))
+
+		diff = diffs[0]
+		assert_equal('.gitignore', diff.a_blob.path)
+		assert_equal('.gitignore', diff.b_blob.path)
+		assert_equal('4ebc8aea50e0a67e000ba29a30809d0a7b9b2666', diff.a_blob.id)
+		assert_equal('2dd02534615434d88c51307beb0f0092f21fd103', diff.b_blob.id)
+		assert_mode_644(diff.b_blob.mode)
+		assert_equal(False, diff.new_file)
+		assert_equal(False, diff.deleted_file)
+		assert_equal("--- a/.gitignore\n+++ b/.gitignore\n@@ -1 +1,2 @@\n coverage\n+pkg", diff.diff)
+
+		diff = diffs[5]
+		assert_equal('lib/grit/actor.rb', diff.b_blob.path)
+		assert_equal(None, diff.a_blob)
+		assert_equal('f733bce6b57c0e5e353206e692b0e3105c2527f4', diff.b_blob.id)
+		assert_equal(True, diff.new_file)
+
+		assert_true(git.called)
+		assert_equal(git.call_args, (('diff', '-M',
+											  '038af8c329ef7c1bae4568b98bd5c58510465493',
+											  '91169e1f5fa4de2eaea3f176461f5dc784796769',
+									  ), {'full_index': True}))
+
+	def test_diffs_on_initial_import(self):
+		commit = Commit(self.repo, '33ebe7acec14b25c5f84f35a664803fcab2f7781')
+		
+		for diff in commit.diffs:
+			assert isinstance(diff, Diff)
+			assert isinstance(diff.a_blob, Blob) or isinstance(diff.b_blob, Blob)
+			
+			if diff.a_mode is not None:
+				assert isinstance(diff.a_mode, int)
+			if diff.b_mode is not None:
+				isinstance(diff.b_mode, int)
+			
+			assert diff.diff is not None 	# can be empty
+			
+			if diff.renamed:
+				assert diff.rename_from and diff.rename_to and diff.rename_from != diff.rename_to
+			if diff.a_blob is None:
+				assert diff.new_file and isinstance(diff.new_file, bool)
+			if diff.b_blob is None:
+				assert diff.deleted_file and isinstance(diff.deleted_file, bool)
+		# END for each diff in initial import commit
+
+	def test_diffs_on_initial_import_without_parents(self):
+		commit = Commit(self.repo, id='33ebe7acec14b25c5f84f35a664803fcab2f7781')
+		diffs = commit.diffs
+		assert diffs
+
+	def test_diffs_with_mode_only_change(self):
+		commit = Commit(self.repo, id='ccde80b7a3037a004a7807a6b79916ce2a1e9729')
+		diffs = commit.diffs
+
+		# in case of mode-only changes, there is no blob
+		assert_equal(1, len(diffs))
+		assert_equal(None, diffs[0].a_blob)
+		assert_equal(None, diffs[0].b_blob)
+		assert_mode_644(diffs[0].a_mode)
+		assert_mode_755(diffs[0].b_mode)
+
+	def test_stats(self):
+		commit = Commit(self.repo, id='33ebe7acec14b25c5f84f35a664803fcab2f7781')
+		stats = commit.stats
+		
+		def check_entries(d):
+			assert isinstance(d, dict)
+			for key in ("insertions", "deletions", "lines"):
+				assert key in d
+		# END assertion helper 
+		assert stats.files 
+		assert stats.total
+		
+		check_entries(stats.total) 
+		assert "files" in stats.total
+		
+		for filepath, d in stats.files.items():
+			check_entries(d)
+		# END for each stated file
+		
+	@patch_object(Git, '_call_process')
+	def test_rev_list_bisect_all(self, git):
+		"""
+		'git rev-list --bisect-all' returns additional information
+		in the commit header.  This test ensures that we properly parse it.
+		"""
+
+		git.return_value = fixture('rev_list_bisect_all')
+
+		revs = self.repo.git.rev_list('HEAD',
+									  pretty='raw',
+									  first_parent=True,
+									  bisect_all=True)
+		assert_true(git.called)
+
+		commits = Commit._iter_from_process_or_stream(self.repo, ListProcessAdapter(revs))
+		expected_ids = (
+			'cf37099ea8d1d8c7fbf9b6d12d7ec0249d3acb8b',
+			'33ebe7acec14b25c5f84f35a664803fcab2f7781',
+			'a6604a00a652e754cb8b6b0b9f194f839fc38d7c',
+			'8df638c22c75ddc9a43ecdde90c0c9939f5009e7',
+			'c231551328faa864848bde6ff8127f59c9566e90',
+		)
+		for sha1, commit in zip(expected_ids, commits):
+			assert_equal(sha1, commit.id)
+
+	def test_str(self):
+		commit = Commit(self.repo, id='abc')
+		assert_equal ("abc", str(commit))
+
+	def test_repr(self):
+		commit = Commit(self.repo, id='abc')
+		assert_equal('<git.Commit "abc">', repr(commit))
+
+	def test_equality(self):
+		commit1 = Commit(self.repo, id='abc')
+		commit2 = Commit(self.repo, id='abc')
+		commit3 = Commit(self.repo, id='zyx')
+		assert_equal(commit1, commit2)
+		assert_not_equal(commit2, commit3)
+		
diff --git a/test/git/test_diff.py b/test/git/test_diff.py
index 65a27e98..b2339455 100644
--- a/test/git/test_diff.py
+++ b/test/git/test_diff.py
@@ -8,23 +8,23 @@ from test.testlib import *
 from git import *
 
 class TestDiff(object):
-    def setup(self):
-        self.repo = Repo(GIT_REPO)
+	def setup(self):
+		self.repo = Repo(GIT_REPO)
 
-    def test_list_from_string_new_mode(self):
-        output = fixture('diff_new_mode')
-        diffs = Diff.list_from_string(self.repo, output)
-        assert_equal(1, len(diffs))
-        assert_equal(10, len(diffs[0].diff.splitlines()))
+	def test_list_from_string_new_mode(self):
+		output = fixture('diff_new_mode')
+		diffs = Diff._list_from_string(self.repo, output)
+		assert_equal(1, len(diffs))
+		assert_equal(10, len(diffs[0].diff.splitlines()))
 
-    def test_diff_with_rename(self):
-        output = fixture('diff_rename')
-        diffs = Diff.list_from_string(self.repo, output)
+	def test_diff_with_rename(self):
+		output = fixture('diff_rename')
+		diffs = Diff._list_from_string(self.repo, output)
 
-        assert_equal(1, len(diffs))
+		assert_equal(1, len(diffs))
 
-        diff = diffs[0]
-        assert_true(diff.renamed)
-        assert_equal(diff.rename_from, 'AUTHORS')
-        assert_equal(diff.rename_to, 'CONTRIBUTORS')
+		diff = diffs[0]
+		assert_true(diff.renamed)
+		assert_equal(diff.rename_from, 'AUTHORS')
+		assert_equal(diff.rename_to, 'CONTRIBUTORS')
 
diff --git a/test/git/test_git.py b/test/git/test_git.py
index 6e28f4c0..1f44aebc 100644
--- a/test/git/test_git.py
+++ b/test/git/test_git.py
@@ -9,50 +9,81 @@ from test.testlib import *
 from git import Git, GitCommandError
 
 class TestGit(object):
-    def setup(self):
-        base = os.path.join(os.path.dirname(__file__), "../..")
-        self.git = Git(base)
-
-    @patch_object(Git, 'execute')
-    def test_call_process_calls_execute(self, git):
-        git.return_value = ''
-        self.git.version()
-        assert_true(git.called)
-        assert_equal(git.call_args, ((['git', 'version'],), {}))
-
-    @raises(GitCommandError)
-    def test_it_raises_errors(self):
-        self.git.this_does_not_exist()
-
-
-    def test_it_transforms_kwargs_into_git_command_arguments(self):
-        assert_equal(["-s"], self.git.transform_kwargs(**{'s': True}))
-        assert_equal(["-s5"], self.git.transform_kwargs(**{'s': 5}))
-
-        assert_equal(["--max-count"], self.git.transform_kwargs(**{'max_count': True}))
-        assert_equal(["--max-count=5"], self.git.transform_kwargs(**{'max_count': 5}))
-
-        assert_equal(["-s", "-t"], self.git.transform_kwargs(**{'s': True, 't': True}))
-
-    def test_it_executes_git_to_shell_and_returns_result(self):
-        assert_match('^git version [\d\.]{2}.*$', self.git.execute(["git","version"]))
-
-    def test_it_accepts_stdin(self):
-        filename = fixture_path("cat_file_blob")
-        fh = open(filename, 'r')
-        assert_equal("70c379b63ffa0795fdbfbc128e5a2818397b7ef8",
-                     self.git.hash_object(istream=fh, stdin=True))
-        fh.close()
-
-    def test_it_handles_large_input(self):
-        if sys.platform == 'win32':
-            output = self.git.execute(["type", "C:\WINDOWS\system32\cmd.exe"])
-        else:
-            output = self.git.execute(["cat", "/bin/bash"])
-        assert_true(len(output) > 4096) # at least 4k
-
-    @patch_object(Git, 'execute')
-    def test_it_ignores_false_kwargs(self, git):
-        # this_should_not_be_ignored=False implies it *should* be ignored
-        output = self.git.version(pass_this_kwarg=False)
-        assert_true("pass_this_kwarg" not in git.call_args[1])
+	def setup(self):
+		self.git = Git(GIT_REPO)
+
+	@patch_object(Git, 'execute')
+	def test_call_process_calls_execute(self, git):
+		git.return_value = ''
+		self.git.version()
+		assert_true(git.called)
+		assert_equal(git.call_args, ((['git', 'version'],), {}))
+
+	@raises(GitCommandError)
+	def test_it_raises_errors(self):
+		self.git.this_does_not_exist()
+
+
+	def test_it_transforms_kwargs_into_git_command_arguments(self):
+		assert_equal(["-s"], self.git.transform_kwargs(**{'s': True}))
+		assert_equal(["-s5"], self.git.transform_kwargs(**{'s': 5}))
+
+		assert_equal(["--max-count"], self.git.transform_kwargs(**{'max_count': True}))
+		assert_equal(["--max-count=5"], self.git.transform_kwargs(**{'max_count': 5}))
+
+		assert_equal(["-s", "-t"], self.git.transform_kwargs(**{'s': True, 't': True}))
+
+	def test_it_executes_git_to_shell_and_returns_result(self):
+		assert_match('^git version [\d\.]{2}.*$', self.git.execute(["git","version"]))
+
+	def test_it_accepts_stdin(self):
+		filename = fixture_path("cat_file_blob")
+		fh = open(filename, 'r')
+		assert_equal("70c379b63ffa0795fdbfbc128e5a2818397b7ef8",
+					 self.git.hash_object(istream=fh, stdin=True))
+		fh.close()
+
+	def test_it_handles_large_input(self):
+		if sys.platform == 'win32':
+			output = self.git.execute(["type", "C:\WINDOWS\system32\cmd.exe"])
+		else:
+			output = self.git.execute(["cat", "/bin/bash"])
+		assert_true(len(output) > 4096) # at least 4k
+
+	@patch_object(Git, 'execute')
+	def test_it_ignores_false_kwargs(self, git):
+		# this_should_not_be_ignored=False implies it *should* be ignored
+		output = self.git.version(pass_this_kwarg=False)
+		assert_true("pass_this_kwarg" not in git.call_args[1])
+		
+	def test_persistent_cat_file_command(self):
+		# read header only
+		import subprocess as sp
+		hexsha = "b2339455342180c7cc1e9bba3e9f181f7baa5167"
+		g = self.git.cat_file(batch_check=True, istream=sp.PIPE,as_process=True)
+		g.stdin.write("b2339455342180c7cc1e9bba3e9f181f7baa5167\n")
+		g.stdin.flush()
+		obj_info = g.stdout.readline()
+		
+		# read header + data
+		g = self.git.cat_file(batch=True, istream=sp.PIPE,as_process=True)
+		g.stdin.write("b2339455342180c7cc1e9bba3e9f181f7baa5167\n")
+		g.stdin.flush()
+		obj_info_two = g.stdout.readline()
+		assert obj_info == obj_info_two
+		
+		# read data - have to read it in one large chunk
+		size = int(obj_info.split()[2])
+		data = g.stdout.read(size)
+		terminating_newline = g.stdout.read(1)
+		
+		# now we should be able to read a new object
+		g.stdin.write("b2339455342180c7cc1e9bba3e9f181f7baa5167\n")
+		g.stdin.flush()
+		assert g.stdout.readline() == obj_info
+		
+		
+		# same can be achived using the respective command functions
+		hexsha, typename, size =  self.git.get_object_header(hexsha)
+		hexsha, typename_two, size_two, data = self.git.get_object_data(hexsha)
+		assert typename == typename_two and size == size_two
diff --git a/test/git/test_head.py b/test/git/test_head.py
index e3408974..b8380838 100644
--- a/test/git/test_head.py
+++ b/test/git/test_head.py
@@ -8,25 +8,19 @@ from test.testlib import *
 from git import *
 
 class TestHead(object):
-    def setup(self):
-        self.repo = Repo(GIT_REPO)
+	def setup(self):
+		self.repo = Repo(GIT_REPO)
 
-    @patch_object(Git, '_call_process')
-    def test_repr(self, git):
-        git.return_value = fixture('for_each_ref')
-        
-        head = self.repo.heads[0]
-        
-        assert_equal('<git.Head "%s">' % head.name, repr(head))
-        
-        assert_true(git.called)
-        assert_equal(git.call_args, (('for_each_ref', 'refs/heads'), {'sort': 'committerdate', 'format': '%(refname)%00%(objectname)'}))
+	def test_base(self):
+		for head in self.repo.heads:
+			assert head.name
+			assert "refs/heads" in head.path
+		# END for each head
 
-    @patch_object(Git, '_call_process')
-    def test_ref_with_path_component(self, git):
-        git.return_value = fixture('for_each_ref_with_path_component')
-        head = self.repo.heads[0]
+	@patch_object(Git, '_call_process')
+	def test_ref_with_path_component(self, git):
+		git.return_value = fixture('for_each_ref_with_path_component')
+		head = self.repo.heads[0]
 
-        assert_equal('refactoring/feature1', head.name)
-        assert_true(git.called)
-        assert_equal(git.call_args, (('for_each_ref', 'refs/heads'), {'sort': 'committerdate', 'format': '%(refname)%00%(objectname)'}))
+		assert_equal('refactoring/feature1', head.name)
+		assert_true(git.called)
diff --git a/test/git/test_performance.py b/test/git/test_performance.py
new file mode 100644
index 00000000..96f13a2e
--- /dev/null
+++ b/test/git/test_performance.py
@@ -0,0 +1,38 @@
+# test_performance.py
+# Copyright (C) 2008, 2009 Michael Trier (mtrier@gmail.com) and contributors
+#
+# This module is part of GitPython and is released under
+# the BSD License: http://www.opensource.org/licenses/bsd-license.php
+
+from test.testlib import *
+from git import *
+from time import time
+
+class TestPerformance(object):
+	def setup(self):
+		self.repo = Repo(GIT_REPO)
+
+	def test_iteration(self):
+		num_objs = 0
+		num_commits = 0
+		
+		# find the first commit containing the given path - always do a full 
+		# iteration ( restricted to the path in question ), but in fact it should 
+		# return quite a lot of commits, we just take one and hence abort the operation
+		
+		st = time()
+		for c in self.repo.commits():
+			num_commits += 1
+			c.author
+			c.authored_date
+			c.committer
+			c.committed_date
+			c.message
+			for obj in c.tree.traverse():
+				obj.size
+				num_objs += 1
+			# END for each object
+		# END for each commit
+		elapsed_time = time() - st
+		print "Traversed %i Trees and a total of %i unchached objects in %s [s] ( %f objs/s )" % (num_commits, num_objs, elapsed_time, num_objs/elapsed_time) 
+		
diff --git a/test/git/test_repo.py b/test/git/test_repo.py
index a9d3beaf..e998ac6d 100644
--- a/test/git/test_repo.py
+++ b/test/git/test_repo.py
@@ -10,255 +10,237 @@ from test.testlib import *
 from git import *
 
 class TestRepo(object):
-    def setup(self):
-        self.repo = Repo(GIT_REPO)
-    
-    @raises(InvalidGitRepositoryError)
-    def test_new_should_raise_on_invalid_repo_location(self):
-        if sys.platform == "win32":
-            Repo("C:\\WINDOWS\\Temp")
-        else:
-            Repo("/tmp")
+	def setup(self):
+		self.repo = Repo(GIT_REPO)
+	
+	@raises(InvalidGitRepositoryError)
+	def test_new_should_raise_on_invalid_repo_location(self):
+		if sys.platform == "win32":
+			Repo("C:\\WINDOWS\\Temp")
+		else:
+			Repo("/tmp")
+
+	@raises(NoSuchPathError)
+	def test_new_should_raise_on_non_existant_path(self):
+		Repo("repos/foobar")
+
+	def test_description(self):
+		txt = "Test repository"
+		self.repo.description = txt
+		assert_equal(self.repo.description, txt)
+
+	def test_heads_should_return_array_of_head_objects(self):
+		for head in self.repo.heads:
+			assert_equal(Head, head.__class__)
+
+	def test_heads_should_populate_head_data(self):
+		for head in self.repo.heads:
+			assert head.name
+			assert isinstance(head.commit,Commit)
+		# END for each head 
+
+	@patch_object(Git, '_call_process')
+	def test_commits(self, git):
+		git.return_value = ListProcessAdapter(fixture('rev_list'))
+
+		commits = self.repo.commits('master', max_count=10)
+
+		c = commits[0]
+		assert_equal('4c8124ffcf4039d292442eeccabdeca5af5c5017', c.id)
+		assert_equal(["634396b2f541a9f2d58b00be1a07f0c358b999b3"], [p.id for p in c.parents])
+		assert_equal("672eca9b7f9e09c22dcb128c283e8c3c8d7697a4", c.tree.id)
+		assert_equal("Tom Preston-Werner", c.author.name)
+		assert_equal("tom@mojombo.com", c.author.email)
+		assert_equal(time.gmtime(1191999972), c.authored_date)
+		assert_equal("Tom Preston-Werner", c.committer.name)
+		assert_equal("tom@mojombo.com", c.committer.email)
+		assert_equal(time.gmtime(1191999972), c.committed_date)
+		assert_equal("implement Grit#heads", c.message)
+
+		c = commits[1]
+		assert_equal(tuple(), c.parents)
+
+		c = commits[2]
+		assert_equal(["6e64c55896aabb9a7d8e9f8f296f426d21a78c2c", "7f874954efb9ba35210445be456c74e037ba6af2"], map(lambda p: p.id, c.parents))
+		assert_equal("Merge branch 'site'", c.summary)
+
+		assert_true(git.called)
+
+	@patch_object(Git, '_call_process')
+	def test_commit_count(self, git):
+		git.return_value = fixture('rev_list_count')
+
+		assert_equal(655, self.repo.commit_count('master'))
+
+		assert_true(git.called)
+		assert_equal(git.call_args, (('rev_list', 'master', '--', ''), {}))
+
+	@patch_object(Git, '_call_process')
+	def test_commit(self, git):
+		git.return_value = ListProcessAdapter(fixture('rev_list_single'))
+
+		commit = self.repo.commit('4c8124ffcf4039d292442eeccabdeca5af5c5017')
+
+		assert_equal("4c8124ffcf4039d292442eeccabdeca5af5c5017", commit.id)
+
+		assert_true(git.called)
+		
+	@patch_object(Repo, '__init__')
+	@patch_object(Git, '_call_process')
+	def test_init_bare(self, git, repo):
+		git.return_value = True
+		repo.return_value = None
+
+		Repo.init_bare("repos/foo/bar.git")
+
+		assert_true(git.called)
+		assert_equal(git.call_args, (('init', '--bare'), {}))
+		assert_true(repo.called)
+		assert_equal(repo.call_args, (('repos/foo/bar.git',), {}))
+
+	@patch_object(Repo, '__init__')
+	@patch_object(Git, '_call_process')
+	def test_init_bare_with_options(self, git, repo):
+		git.return_value = True
+		repo.return_value = None
+
+		Repo.init_bare("repos/foo/bar.git", **{'template': "/baz/sweet"})
+
+		assert_true(git.called)
+		assert_equal(git.call_args, (('init', '--bare'), {'template': '/baz/sweet'}))
+		assert_true(repo.called)
+		assert_equal(repo.call_args, (('repos/foo/bar.git',), {}))
+
+	@patch_object(Repo, '__init__')
+	@patch_object(Git, '_call_process')
+	def test_fork_bare(self, git, repo):
+		git.return_value = None
+		repo.return_value = None
 
-    @raises(NoSuchPathError)
-    def test_new_should_raise_on_non_existant_path(self):
-        Repo("repos/foobar")
+		self.repo.fork_bare("repos/foo/bar.git")
 
-    def test_description(self):
-        txt = "Test repository"
-        self.repo.description = txt
-        assert_equal(self.repo.description, txt)
+		assert_true(git.called)
+		path = os.path.join(absolute_project_path(), '.git')
+		assert_equal(git.call_args, (('clone', path, 'repos/foo/bar.git'), {'bare': True}))
+		assert_true(repo.called)
 
-    def test_heads_should_return_array_of_head_objects(self):
-        for head in self.repo.heads:
-            assert_equal(Head, head.__class__)
+	@patch_object(Repo, '__init__')
+	@patch_object(Git, '_call_process')
+	def test_fork_bare_with_options(self, git, repo):
+		git.return_value = None
+		repo.return_value = None
 
-    @patch_object(Git, '_call_process')
-    def test_heads_should_populate_head_data(self, git):
-        git.return_value = fixture('for_each_ref')
+		self.repo.fork_bare("repos/foo/bar.git", **{'template': '/awesome'})
 
-        head = self.repo.heads[0]
-        assert_equal('master', head.name)
-        assert_equal('634396b2f541a9f2d58b00be1a07f0c358b999b3', head.commit.id)
+		assert_true(git.called)
+		path = os.path.join(absolute_project_path(), '.git')
+		assert_equal(git.call_args, (('clone', path, 'repos/foo/bar.git'),
+									  {'bare': True, 'template': '/awesome'}))
+		assert_true(repo.called)
 
-        assert_true(git.called)
-        assert_equal(git.call_args, (('for_each_ref', 'refs/heads'), {'sort': 'committerdate', 'format': '%(refname)%00%(objectname)'}))
+	@patch_object(Git, '_call_process')
+	def test_diff(self, git):
+		self.repo.diff('master^', 'master')
 
-    @patch_object(Git, '_call_process')
-    def test_commits(self, git):
-        git.return_value = fixture('rev_list')
+		assert_true(git.called)
+		assert_equal(git.call_args, (('diff', 'master^', 'master', '--'), {}))
 
-        commits = self.repo.commits('master', max_count=10)
+		self.repo.diff('master^', 'master', 'foo/bar')
 
-        c = commits[0]
-        assert_equal('4c8124ffcf4039d292442eeccabdeca5af5c5017', c.id)
-        assert_equal(["634396b2f541a9f2d58b00be1a07f0c358b999b3"], [p.id for p in c.parents])
-        assert_equal("672eca9b7f9e09c22dcb128c283e8c3c8d7697a4", c.tree.id)
-        assert_equal("Tom Preston-Werner", c.author.name)
-        assert_equal("tom@mojombo.com", c.author.email)
-        assert_equal(time.gmtime(1191999972), c.authored_date)
-        assert_equal("Tom Preston-Werner", c.committer.name)
-        assert_equal("tom@mojombo.com", c.committer.email)
-        assert_equal(time.gmtime(1191999972), c.committed_date)
-        assert_equal("implement Grit#heads", c.message)
+		assert_true(git.called)
+		assert_equal(git.call_args, (('diff', 'master^', 'master', '--', 'foo/bar'), {}))
 
-        c = commits[1]
-        assert_equal([], c.parents)
+		self.repo.diff('master^', 'master', 'foo/bar', 'foo/baz')
 
-        c = commits[2]
-        assert_equal(["6e64c55896aabb9a7d8e9f8f296f426d21a78c2c", "7f874954efb9ba35210445be456c74e037ba6af2"], map(lambda p: p.id, c.parents))
-        assert_equal("Merge branch 'site'", c.summary)
+		assert_true(git.called)
+		assert_equal(git.call_args, (('diff', 'master^', 'master', '--', 'foo/bar', 'foo/baz'), {}))
 
-        assert_true(git.called)
-        assert_equal(git.call_args, (('rev_list', 'master', '--', ''), {'skip': 0, 'pretty': 'raw', 'max_count': 10}))
+	@patch_object(Git, '_call_process')
+	def test_diff_with_parents(self, git):
+		git.return_value = fixture('diff_p')
 
-    @patch_object(Git, '_call_process')
-    def test_commit_count(self, git):
-        git.return_value = fixture('rev_list_count')
+		diffs = self.repo.commit_diff('master')
+		assert_equal(15, len(diffs))
+		assert_true(git.called)
 
-        assert_equal(655, self.repo.commit_count('master'))
+	def test_archive_tar(self):
+		assert self.repo.archive_tar()
 
-        assert_true(git.called)
-        assert_equal(git.call_args, (('rev_list', 'master', '--', ''), {}))
+	def test_archive_tar_gz(self):
+		assert self.repo.archive_tar_gz()
 
-    @patch_object(Git, '_call_process')
-    def test_commit(self, git):
-        git.return_value = fixture('rev_list_single')
+	@patch('git.utils.touch')
+	def test_enable_daemon_serve(self, touch):
+		self.repo.daemon_serve = False
+		assert_false(self.repo.daemon_serve)
 
-        commit = self.repo.commit('4c8124ffcf4039d292442eeccabdeca5af5c5017')
-
-        assert_equal("4c8124ffcf4039d292442eeccabdeca5af5c5017", commit.id)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('rev_list', '4c8124ffcf4039d292442eeccabdeca5af5c5017', '--', ''), {'pretty': 'raw', 'max_count': 1}))
-
-    @patch_object(Git, '_call_process')
-    def test_tree(self, git):
-        git.return_value = fixture('ls_tree_a')
-
-        tree = self.repo.tree('master')
-
-        assert_equal(4, len([c for c in tree.values() if isinstance(c, Blob)]))
-        assert_equal(3, len([c for c in tree.values() if isinstance(c, Tree)]))
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('ls_tree', 'master'), {}))
-
-    @patch_object(Git, '_call_process')
-    def test_blob(self, git):
-        git.return_value = fixture('cat_file_blob')
-
-        blob = self.repo.blob("abc")
-        assert_equal("Hello world", blob.data)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('cat_file', 'abc'), {'p': True, 'with_raw_output': True}))
-
-    @patch_object(Repo, '__init__')
-    @patch_object(Git, '_call_process')
-    def test_init_bare(self, git, repo):
-        git.return_value = True
-        repo.return_value = None
-
-        Repo.init_bare("repos/foo/bar.git")
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('init', '--bare'), {}))
-        assert_true(repo.called)
-        assert_equal(repo.call_args, (('repos/foo/bar.git',), {}))
-
-    @patch_object(Repo, '__init__')
-    @patch_object(Git, '_call_process')
-    def test_init_bare_with_options(self, git, repo):
-        git.return_value = True
-        repo.return_value = None
-
-        Repo.init_bare("repos/foo/bar.git", **{'template': "/baz/sweet"})
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('init', '--bare'), {'template': '/baz/sweet'}))
-        assert_true(repo.called)
-        assert_equal(repo.call_args, (('repos/foo/bar.git',), {}))
-
-    @patch_object(Repo, '__init__')
-    @patch_object(Git, '_call_process')
-    def test_fork_bare(self, git, repo):
-        git.return_value = None
-        repo.return_value = None
-
-        self.repo.fork_bare("repos/foo/bar.git")
-
-        assert_true(git.called)
-        path = os.path.join(absolute_project_path(), '.git')
-        assert_equal(git.call_args, (('clone', path, 'repos/foo/bar.git'), {'bare': True}))
-        assert_true(repo.called)
-
-    @patch_object(Repo, '__init__')
-    @patch_object(Git, '_call_process')
-    def test_fork_bare_with_options(self, git, repo):
-        git.return_value = None
-        repo.return_value = None
-
-        self.repo.fork_bare("repos/foo/bar.git", **{'template': '/awesome'})
-
-        assert_true(git.called)
-        path = os.path.join(absolute_project_path(), '.git')
-        assert_equal(git.call_args, (('clone', path, 'repos/foo/bar.git'),
-                                      {'bare': True, 'template': '/awesome'}))
-        assert_true(repo.called)
-
-    @patch_object(Git, '_call_process')
-    def test_diff(self, git):
-        self.repo.diff('master^', 'master')
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('diff', 'master^', 'master', '--'), {}))
-
-        self.repo.diff('master^', 'master', 'foo/bar')
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('diff', 'master^', 'master', '--', 'foo/bar'), {}))
-
-        self.repo.diff('master^', 'master', 'foo/bar', 'foo/baz')
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('diff', 'master^', 'master', '--', 'foo/bar', 'foo/baz'), {}))
-
-    @patch_object(Git, '_call_process')
-    def test_diff_with_parents(self, git):
-        git.return_value = fixture('diff_p')
-
-        diffs = self.repo.commit_diff('master')
-        assert_equal(15, len(diffs))
-        assert_true(git.called)
-
-    def test_archive_tar(self):
-        assert self.repo.archive_tar()
-
-    def test_archive_tar_gz(self):
-        assert self.repo.archive_tar_gz()
-
-    @patch('git.utils.touch')
-    def test_enable_daemon_serve(self, touch):
-        self.repo.daemon_serve = False
-        assert_false(self.repo.daemon_serve)
-
-    def test_disable_daemon_serve(self):
-        self.repo.daemon_serve = True
-        assert_true(self.repo.daemon_serve)
+	def test_disable_daemon_serve(self):
+		self.repo.daemon_serve = True
+		assert_true(self.repo.daemon_serve)
   
-    @patch_object(os.path, 'exists')
-    def test_alternates_no_file(self, os):
-        os.return_value = False
-        assert_equal([], self.repo.alternates)
-
-        assert_true(os.called)
-
-    @patch_object(os, 'remove')
-    def test_alternates_setter_empty(self, os):
-        self.repo.alternates = []
-        assert_true(os.called)
-
-    def test_repr(self):
-        path = os.path.join(os.path.abspath(GIT_REPO), '.git')
-        assert_equal('<git.Repo "%s">' % path, repr(self.repo))
-
-    @patch_object(Git, '_call_process')
-    def test_log(self, git):
-        git.return_value = fixture('rev_list')
-        assert_equal('4c8124ffcf4039d292442eeccabdeca5af5c5017', self.repo.log()[0].id)
-        assert_equal('ab25fd8483882c3bda8a458ad2965d2248654335', self.repo.log()[-1].id)
-        assert_true(git.called)
-        assert_equal(git.call_count, 2)
-        assert_equal(git.call_args, (('log', 'master', '--'), {'pretty': 'raw'}))
-
-    @patch_object(Git, '_call_process')
-    def test_log_with_path_and_options(self, git):
-        git.return_value = fixture('rev_list')
-        self.repo.log('master', 'file.rb', **{'max_count': 1})
-        assert_true(git.called)
-        assert_equal(git.call_args, (('log', 'master', '--', 'file.rb'), {'pretty': 'raw', 'max_count': 1}))
-
-    def test_is_dirty_with_bare_repository(self):
-        self.repo.bare = True
-        assert_false(self.repo.is_dirty)
-
-    @patch_object(Git, '_call_process')
-    def test_is_dirty_with_clean_working_dir(self, git):
-        self.repo.bare = False
-        git.return_value = ''
-        assert_false(self.repo.is_dirty)
-        assert_equal(git.call_args, (('diff', 'HEAD', '--'), {}))
-
-    @patch_object(Git, '_call_process')
-    def test_is_dirty_with_dirty_working_dir(self, git):
-        self.repo.bare = False
-        git.return_value = '''-aaa\n+bbb'''
-        assert_true(self.repo.is_dirty)
-        assert_equal(git.call_args, (('diff', 'HEAD', '--'), {}))
-
-    @patch_object(Git, '_call_process')
-    def test_active_branch(self, git):
-        git.return_value = 'refs/heads/major-refactoring'
-        assert_equal(self.repo.active_branch, 'major-refactoring')
-        assert_equal(git.call_args, (('symbolic_ref', 'HEAD'), {}))
+	@patch_object(os.path, 'exists')
+	def test_alternates_no_file(self, os):
+		os.return_value = False
+		assert_equal([], self.repo.alternates)
+
+		assert_true(os.called)
+
+	@patch_object(os, 'remove')
+	def test_alternates_setter_empty(self, os):
+		self.repo.alternates = []
+		assert_true(os.called)
+
+	def test_repr(self):
+		path = os.path.join(os.path.abspath(GIT_REPO), '.git')
+		assert_equal('<git.Repo "%s">' % path, repr(self.repo))
+
+	def test_is_dirty_with_bare_repository(self):
+		self.repo.bare = True
+		assert_false(self.repo.is_dirty)
+
+	@patch_object(Git, '_call_process')
+	def test_is_dirty_with_clean_working_dir(self, git):
+		self.repo.bare = False
+		git.return_value = ''
+		assert_false(self.repo.is_dirty)
+		assert_equal(git.call_args, (('diff', 'HEAD', '--'), {}))
+
+	@patch_object(Git, '_call_process')
+	def test_is_dirty_with_dirty_working_dir(self, git):
+		self.repo.bare = False
+		git.return_value = '''-aaa\n+bbb'''
+		assert_true(self.repo.is_dirty)
+		assert_equal(git.call_args, (('diff', 'HEAD', '--'), {}))
+
+	@patch_object(Git, '_call_process')
+	def test_active_branch(self, git):
+		git.return_value = 'refs/heads/major-refactoring'
+		assert_equal(self.repo.active_branch.name, 'major-refactoring')
+		assert_equal(git.call_args, (('symbolic_ref', 'HEAD'), {}))
+		
+	@patch_object(Git, '_call_process')
+	def test_should_display_blame_information(self, git):
+		git.return_value = fixture('blame')
+		b = self.repo.blame( 'master', 'lib/git.py')
+		assert_equal(13, len(b))
+		assert_equal( 2, len(b[0]) )
+		# assert_equal(25, reduce(lambda acc, x: acc + len(x[-1]), b))
+		assert_equal(hash(b[0][0]), hash(b[9][0]))
+		c = b[0][0]
+		assert_true(git.called)
+		assert_equal(git.call_args, (('blame', 'master', '--', 'lib/git.py'), {'p': True}))
+		
+		assert_equal('634396b2f541a9f2d58b00be1a07f0c358b999b3', c.id)
+		assert_equal('Tom Preston-Werner', c.author.name)
+		assert_equal('tom@mojombo.com', c.author.email)
+		assert_equal(time.gmtime(1191997100), c.authored_date)
+		assert_equal('Tom Preston-Werner', c.committer.name)
+		assert_equal('tom@mojombo.com', c.committer.email)
+		assert_equal(time.gmtime(1191997100), c.committed_date)
+		assert_equal('initial grit setup', c.message)
+		
+		# test the 'lines per commit' entries
+		tlist = b[0][1]
+		assert_true( tlist )
+		assert_true( isinstance( tlist[0], basestring ) )
+		assert_true( len( tlist ) < sum( len(t) for t in tlist ) )				 # test for single-char bug
diff --git a/test/git/test_stats.py b/test/git/test_stats.py
index b6f1b60e..706f29a4 100644
--- a/test/git/test_stats.py
+++ b/test/git/test_stats.py
@@ -8,20 +8,20 @@ from test.testlib import *
 from git import *
 
 class TestStats(object):
-    def setup(self):
-        self.repo = Repo(GIT_REPO)
-    
-    def test_list_from_string(self):
-        output = fixture('diff_numstat')
-        stats = Stats.list_from_string(self.repo, output)
-        
-        assert_equal(2, stats.total['files'])
-        assert_equal(52, stats.total['lines'])
-        assert_equal(29, stats.total['insertions'])
-        assert_equal(23, stats.total['deletions'])
-        
-        assert_equal(29, stats.files["a.txt"]['insertions'])
-        assert_equal(18, stats.files["a.txt"]['deletions'])
-        
-        assert_equal(0, stats.files["b.txt"]['insertions'])
-        assert_equal(5, stats.files["b.txt"]['deletions'])
+	def setup(self):
+		self.repo = Repo(GIT_REPO)
+	
+	def test__list_from_string(self):
+		output = fixture('diff_numstat')
+		stats = Stats._list_from_string(self.repo, output)
+		
+		assert_equal(2, stats.total['files'])
+		assert_equal(52, stats.total['lines'])
+		assert_equal(29, stats.total['insertions'])
+		assert_equal(23, stats.total['deletions'])
+		
+		assert_equal(29, stats.files["a.txt"]['insertions'])
+		assert_equal(18, stats.files["a.txt"]['deletions'])
+		
+		assert_equal(0, stats.files["b.txt"]['insertions'])
+		assert_equal(5, stats.files["b.txt"]['deletions'])
diff --git a/test/git/test_tag.py b/test/git/test_tag.py
index 732bbd45..2ebb860a 100644
--- a/test/git/test_tag.py
+++ b/test/git/test_tag.py
@@ -7,30 +7,29 @@
 from mock import *
 from test.testlib import *
 from git import *
+from git.objects.tag import TagObject
+import time
 
 class TestTag(object):
-    def setup(self):
-        self.repo = Repo(GIT_REPO)
+	def setup(self):
+		self.repo = Repo(GIT_REPO)
 
-    @patch_object(Git, '_call_process')
-    def test_list_from_string(self, git):
-        git.return_value = fixture('for_each_ref_tags')
-        
-        tags = self.repo.tags
-        
-        assert_equal(1, len(tags))
-        assert_equal('v0.7.1', tags[0].name)
-        assert_equal('634396b2f541a9f2d58b00be1a07f0c358b999b3', tags[0].commit.id)
-        
-        assert_true(git.called)
-        assert_equal(git.call_args, (('for_each_ref', 'refs/tags'), {'sort': 'committerdate', 'format': '%(refname)%00%(objectname)'}))
+	def test_tag_base(self):
+		tag_object_refs = list()
+		for tag in self.repo.tags:
+			assert "refs/tags" in tag.path
+			assert tag.name
+			assert isinstance( tag.commit, Commit )
+			if tag.tag is not None:
+				tag_object_refs.append( tag )
+				tagobj = tag.tag
+				assert isinstance( tagobj, TagObject ) 
+				assert tagobj.tag == tag.name
+				assert isinstance( tagobj.tagger, Actor )
+				assert isinstance( tagobj.tagged_date, time.struct_time )
+				assert tagobj.message
+			# END if we have a tag object
+		# END for tag in repo-tags
+		assert tag_object_refs
+		
 
-    @patch_object(Git, '_call_process')
-    def test_repr(self, git):
-        git.return_value = fixture('for_each_ref')
-        
-        tag = self.repo.tags[0]
-        assert_equal('<git.Tag "%s">' % tag.name, repr(tag))
-        
-        assert_true(git.called)
-        assert_equal(git.call_args, (('for_each_ref', 'refs/tags'), {'sort': 'committerdate', 'format': '%(refname)%00%(objectname)'}))
diff --git a/test/git/test_tree.py b/test/git/test_tree.py
index 947b0ffb..dafb6f3f 100644
--- a/test/git/test_tree.py
+++ b/test/git/test_tree.py
@@ -7,143 +7,38 @@
 from test.testlib import *
 from git import *
 
-class TestTree(object):
-    def setup(self):
-        self.repo = Repo(GIT_REPO)
-
-    @patch_object(Git, '_call_process')
-    def test_contents_should_cache(self, git):
-        git.return_value = fixture('ls_tree_a') + fixture('ls_tree_b')
-    
-        tree = self.repo.tree('master')
-
-        child = tree['grit']
-        child.items()
-        child.items()
-        
-        assert_true(git.called)
-        assert_equal(2, git.call_count)
-        assert_equal(git.call_args, (('ls_tree', '34868e6e7384cb5ee51c543a8187fdff2675b5a7'), {}))
-  
-    def test_content_from_string_tree_should_return_tree(self):
-        text = fixture('ls_tree_a').splitlines()[-1]
-        tree = Tree.content_from_string(None, text)
-
-        assert_equal(Tree, tree.__class__)
-        assert_equal("650fa3f0c17f1edb4ae53d8dcca4ac59d86e6c44", tree.id)
-        assert_equal("040000", tree.mode)
-        assert_equal("test", tree.name)
+class TestTree(TestCase):
+	
+	def setUp(self):
+		self.repo = Repo(GIT_REPO)
+
+	
+		
+	def test_traverse(self):
+		root = self.repo.tree()
+		num_recursive = 0
+		all_items = list()
+		for obj in root.traverse():
+			if "/" in obj.path:
+				num_recursive += 1
+				
+			assert isinstance(obj, (Blob, Tree))
+			all_items.append(obj)
+		# END for each object
+		# limit recursion level to 0 - should be same as default iteration
+		assert all_items
+		assert 'CHANGES' in root
+		assert len(list(root)) == len(list(root.traverse(max_depth=0)))
+		
+		# only choose trees
+		trees_only = lambda i: i.type == "tree"
+		trees = list(root.traverse(predicate = trees_only))
+		assert len(trees) == len(list( i for i in root.traverse() if trees_only(i) ))
+		
+		# trees and blobs
+		assert len(set(trees)|set(root.trees)) == len(trees)
+		assert len(set(b for b in root if isinstance(b, Blob)) | set(root.blobs)) == len( root.blobs )
   
-    def test_content_from_string_tree_should_return_blob(self):
-        text = fixture('ls_tree_b').split("\n")[0]
-        
-        tree = Tree.content_from_string(None, text)
-
-        assert_equal(Blob, tree.__class__)
-        assert_equal("aa94e396335d2957ca92606f909e53e7beaf3fbb", tree.id)
-        assert_equal("100644", tree.mode)
-        assert_equal("grit.rb", tree.name)
-  
-    def test_content_from_string_tree_should_return_commit(self):
-        text = fixture('ls_tree_commit').split("\n")[1]
-    
-        tree = Tree.content_from_string(None, text)
-        assert_none(tree)
-    
-    @raises(TypeError)
-    def test_content_from_string_invalid_type_should_raise(self):
-        Tree.content_from_string(None, "040000 bogus 650fa3f0c17f1edb4ae53d8dcca4ac59d86e6c44	test")
-
-    @patch_object(Blob, 'size')
-    @patch_object(Git, '_call_process')
-    def test_slash(self, git, blob):
-        git.return_value = fixture('ls_tree_a')
-        blob.return_value = 1
-        
-        tree = self.repo.tree('master')
-        
-        assert_equal('aa06ba24b4e3f463b3c4a85469d0fb9e5b421cf8', (tree/'lib').id)
-        assert_equal('8b1e02c0fb554eed2ce2ef737a68bb369d7527df', (tree/'README.txt').id)
-        
-        assert_true(git.called)
-        assert_equal(git.call_args, (('ls_tree', 'master'), {}))
-  
-    @patch_object(Blob, 'size')
-    @patch_object(Git, '_call_process')
-    def test_slash_with_zero_length_file(self, git, blob):
-        git.return_value = fixture('ls_tree_a')
-        blob.return_value = 0
-        
-        tree = self.repo.tree('master')
-        
-        assert_not_none(tree/'README.txt')
-        assert_equal('8b1e02c0fb554eed2ce2ef737a68bb369d7527df', (tree/'README.txt').id)
-        
-        assert_true(git.called)
-        assert_equal(git.call_args, (('ls_tree', 'master'), {}))
-  
-    @patch_object(Git, '_call_process')
-    def test_slash_with_commits(self, git):
-        git.return_value = fixture('ls_tree_commit')
-
-        tree = self.repo.tree('master')
-    
-        assert_none(tree/'bar')
-        assert_equal('2afb47bcedf21663580d5e6d2f406f08f3f65f19', (tree/'foo').id)
-        assert_equal('f623ee576a09ca491c4a27e48c0dfe04be5f4a2e', (tree/'baz').id)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('ls_tree', 'master'), {}))
-
-    @patch_object(Blob, 'size')
-    @patch_object(Git, '_call_process')
-    def test_dict(self, git, blob):
-        git.return_value = fixture('ls_tree_a')
-        blob.return_value = 1
-
-        tree = self.repo.tree('master')
-
-        assert_equal('aa06ba24b4e3f463b3c4a85469d0fb9e5b421cf8', tree['lib'].id)
-        assert_equal('8b1e02c0fb554eed2ce2ef737a68bb369d7527df', tree['README.txt'].id)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('ls_tree', 'master'), {}))
-
-    @patch_object(Blob, 'size')
-    @patch_object(Git, '_call_process')
-    def test_dict_with_zero_length_file(self, git, blob):
-        git.return_value = fixture('ls_tree_a')
-        blob.return_value = 0
-
-        tree = self.repo.tree('master')
-
-        assert_not_none(tree['README.txt'])
-        assert_equal('8b1e02c0fb554eed2ce2ef737a68bb369d7527df', tree['README.txt'].id)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('ls_tree', 'master'), {}))
-
-    @patch_object(Git, '_call_process')
-    def test_dict_with_commits(self, git):
-        git.return_value = fixture('ls_tree_commit')
-
-        tree = self.repo.tree('master')
-
-        assert_none(tree.get('bar'))
-        assert_equal('2afb47bcedf21663580d5e6d2f406f08f3f65f19', tree['foo'].id)
-        assert_equal('f623ee576a09ca491c4a27e48c0dfe04be5f4a2e', tree['baz'].id)
-
-        assert_true(git.called)
-        assert_equal(git.call_args, (('ls_tree', 'master'), {}))
-
-    @patch_object(Git, '_call_process')
-    @raises(KeyError)
-    def test_dict_with_non_existant_file(self, git):
-        git.return_value = fixture('ls_tree_commit')
-
-        tree = self.repo.tree('master')
-        tree['bar']
-
-    def test_repr(self):
-        tree = Tree(self.repo, id='abc')
-        assert_equal('<git.Tree "abc">', repr(tree))
+	def test_repr(self):
+		tree = Tree(self.repo, id='abc')
+		assert_equal('<git.Tree "abc">', repr(tree))
diff --git a/test/git/test_utils.py b/test/git/test_utils.py
index 327a07ed..2983a14a 100644
--- a/test/git/test_utils.py
+++ b/test/git/test_utils.py
@@ -9,13 +9,13 @@ from test.testlib import *
 from git import *
 
 class TestUtils(object):
-    def setup(self):
-        self.testdict = {
-            "string":   "42",
-            "int":      42,
-            "array":    [ 42 ],
-        }
+	def setup(self):
+		self.testdict = {
+			"string":	"42",
+			"int":		42,
+			"array":	[ 42 ],
+		}
 
-    def test_it_should_dashify(self):
-        assert_equal('this-is-my-argument', dashify('this_is_my_argument'))
-        assert_equal('foo', dashify('foo'))
+	def test_it_should_dashify(self):
+		assert_equal('this-is-my-argument', dashify('this_is_my_argument'))
+		assert_equal('foo', dashify('foo'))
diff --git a/test/testlib/__init__.py b/test/testlib/__init__.py
index 77512794..f364171b 100644
--- a/test/testlib/__init__.py
+++ b/test/testlib/__init__.py
@@ -8,6 +8,7 @@ import inspect
 from mock import *
 from asserts import *
 from helper import *
+from unittest import TestCase
 
 __all__ = [ name for name, obj in locals().items()
-            if not (name.startswith('_') or inspect.ismodule(obj)) ]
+			if not (name.startswith('_') or inspect.ismodule(obj)) ]
diff --git a/test/testlib/asserts.py b/test/testlib/asserts.py
index f66af122..46fcf20e 100644
--- a/test/testlib/asserts.py
+++ b/test/testlib/asserts.py
@@ -8,31 +8,43 @@ import re
 import unittest
 from nose import tools
 from nose.tools import *
+import stat
 
 __all__ = ['assert_instance_of', 'assert_not_instance_of', 
-           'assert_none', 'assert_not_none',
-           'assert_match', 'assert_not_match'] + tools.__all__
+		   'assert_none', 'assert_not_none',
+		   'assert_match', 'assert_not_match', 'assert_mode_644',
+		   'assert_mode_755'] + tools.__all__
 
 def assert_instance_of(expected, actual, msg=None):
-    """Verify that object is an instance of expected """
-    assert isinstance(actual, expected), msg
+	"""Verify that object is an instance of expected """
+	assert isinstance(actual, expected), msg
 
 def assert_not_instance_of(expected, actual, msg=None):
-    """Verify that object is not an instance of expected """
-    assert not isinstance(actual, expected, msg)
-    
+	"""Verify that object is not an instance of expected """
+	assert not isinstance(actual, expected, msg)
+	
 def assert_none(actual, msg=None):
-    """verify that item is None"""
-    assert_equal(None, actual, msg)
+	"""verify that item is None"""
+	assert actual is None, msg
 
 def assert_not_none(actual, msg=None):
-    """verify that item is None"""
-    assert_not_equal(None, actual, msg)
+	"""verify that item is None"""
+	assert actual is not None, msg
 
 def assert_match(pattern, string, msg=None):
-    """verify that the pattern matches the string"""
-    assert_not_none(re.search(pattern, string), msg)
+	"""verify that the pattern matches the string"""
+	assert_not_none(re.search(pattern, string), msg)
 
 def assert_not_match(pattern, string, msg=None):
-    """verify that the pattern does not match the string"""
-    assert_none(re.search(pattern, string), msg)
\ No newline at end of file
+	"""verify that the pattern does not match the string"""
+	assert_none(re.search(pattern, string), msg)
+	
+def assert_mode_644(mode):
+	"""Verify given mode is 644"""
+	assert (mode & stat.S_IROTH) and (mode & stat.S_IRGRP) 
+	assert (mode & stat.S_IWUSR) and (mode & stat.S_IRUSR) and not (mode & stat.S_IXUSR)
+
+def assert_mode_755(mode):
+	"""Verify given mode is 755"""
+	assert (mode & stat.S_IROTH) and (mode & stat.S_IRGRP) and (mode & stat.S_IXOTH) and (mode & stat.S_IXGRP)
+	assert (mode & stat.S_IWUSR) and (mode & stat.S_IRUSR) and (mode & stat.S_IXUSR)
\ No newline at end of file
diff --git a/test/testlib/helper.py b/test/testlib/helper.py
index ca262ee4..b66d3eaa 100644
--- a/test/testlib/helper.py
+++ b/test/testlib/helper.py
@@ -9,11 +9,22 @@ import os
 GIT_REPO = os.path.dirname(os.path.dirname(os.path.dirname(__file__)))
 
 def fixture_path(name):
-    test_dir = os.path.dirname(os.path.dirname(__file__))
-    return os.path.join(test_dir, "fixtures", name)
+	test_dir = os.path.dirname(os.path.dirname(__file__))
+	return os.path.join(test_dir, "fixtures", name)
 
 def fixture(name):
-    return open(fixture_path(name)).read()
+	return open(fixture_path(name)).read()
 
 def absolute_project_path():
-    return os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+	return os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
+	
+	
+class ListProcessAdapter(object):
+	"""Allows to use lists as Process object as returned by SubProcess.Popen.
+	Its tailored to work with the test system only"""
+	
+	def __init__(self, input_list_or_string):
+		l = input_list_or_string
+		if isinstance(l,basestring):
+			l = l.splitlines()
+		self.stdout = iter(l)