Removed unnecessary (non-gitpython) tests and fixed flake80.3.3

2 files changed, 1 insertions, 190 deletions

diff --git a/git/test/lib/__init__.py b/git/test/lib/__init__.py
index 033a1104..87e26752 100644
--- a/git/test/lib/__init__.py
+++ b/git/test/lib/__init__.py
@@ -4,6 +4,7 @@
 # This module is part of GitPython and is released under
 # the BSD License: http://www.opensource.org/licenses/bsd-license.php
 
+# flake8: noqa
 import inspect
 from .asserts import *
 from .helper import *
diff --git a/git/test/performance/test_utils.py b/git/test/performance/test_utils.py
deleted file mode 100644
index af8e8047..00000000
--- a/git/test/performance/test_utils.py
+++ /dev/null
@@ -1,190 +0,0 @@
-"""Performance of utilities"""
-from __future__ import print_function
-from time import time
-import sys
-
-from .lib import (
-    TestBigRepoR
-)
-
-
-class TestUtilPerformance(TestBigRepoR):
-
-    def test_access(self):
-        # compare dict vs. slot access
-        class Slotty(object):
-            __slots__ = "attr"
-
-            def __init__(self):
-                self.attr = 1
-
-        class Dicty(object):
-
-            def __init__(self):
-                self.attr = 1
-
-        class BigSlotty(object):
-            __slots__ = ('attr', ) + tuple('abcdefghijk')
-
-            def __init__(self):
-                for attr in self.__slots__:
-                    setattr(self, attr, 1)
-
-        class BigDicty(object):
-
-            def __init__(self):
-                for attr in BigSlotty.__slots__:
-                    setattr(self, attr, 1)
-
-        ni = 1000000
-        for cls in (Slotty, Dicty, BigSlotty, BigDicty):
-            cli = cls()
-            st = time()
-            for i in xrange(ni):
-                cli.attr
-            # END for each access
-            elapsed = time() - st
-            print("Accessed %s.attr %i times in %s s ( %f acc / s)"
-                  % (cls.__name__, ni, elapsed, ni / elapsed), file=sys.stderr)
-        # END for each class type
-
-        # check num of sequence-acceses
-        for cls in (list, tuple):
-            x = 10
-            st = time()
-            s = cls(range(x))
-            for i in xrange(ni):
-                s[0]
-                s[1]
-                s[2]
-            # END for
-            elapsed = time() - st
-            na = ni * 3
-            print("Accessed %s[x] %i times in %s s ( %f acc / s)"
-                  % (cls.__name__, na, elapsed, na / elapsed), file=sys.stderr)
-        # END for each sequence
-
-    def test_instantiation(self):
-        ni = 100000
-        max_num_items = 4
-        for mni in range(max_num_items + 1):
-            for cls in (tuple, list):
-                st = time()
-                for i in xrange(ni):
-                    if mni == 0:
-                        cls()
-                    elif mni == 1:
-                        cls((1,))
-                    elif mni == 2:
-                        cls((1, 2))
-                    elif mni == 3:
-                        cls((1, 2, 3))
-                    elif mni == 4:
-                        cls((1, 2, 3, 4))
-                    else:
-                        cls(x for x in xrange(mni))
-                    # END handle empty cls
-                # END for each item
-                elapsed = time() - st
-                print("Created %i %ss of size %i in %f s ( %f inst / s)"
-                      % (ni, cls.__name__, mni, elapsed, ni / elapsed), file=sys.stderr)
-            # END for each type
-        # END for each item count
-
-        # tuple and tuple direct
-        st = time()
-        for i in xrange(ni):
-            (1, 2, 3, 4)
-        # END for each item
-        elapsed = time() - st
-        print("Created %i tuples (1,2,3,4) in %f s ( %f tuples / s)"
-              % (ni, elapsed, ni / elapsed), file=sys.stderr)
-
-        st = time()
-        for i in xrange(ni):
-            tuple((1, 2, 3, 4))
-        # END for each item
-        elapsed = time() - st
-        print("Created %i tuples tuple((1,2,3,4)) in %f s ( %f tuples / s)"
-              % (ni, elapsed, ni / elapsed), file=sys.stderr)
-
-    def test_unpacking_vs_indexing(self):
-        ni = 1000000
-        list_items = [1, 2, 3, 4]
-        tuple_items = (1, 2, 3, 4)
-
-        for sequence in (list_items, tuple_items):
-            st = time()
-            for i in xrange(ni):
-                one, two, three, four = sequence
-            # END for eac iteration
-            elapsed = time() - st
-            print("Unpacked %i %ss of size %i in %f s ( %f acc / s)"
-                  % (ni, type(sequence).__name__, len(sequence), elapsed, ni / elapsed), file=sys.stderr)
-
-            st = time()
-            for i in xrange(ni):
-                one, two, three, four = sequence[0], sequence[1], sequence[2], sequence[3]
-            # END for eac iteration
-            elapsed = time() - st
-            print("Unpacked %i %ss of size %i individually in %f s ( %f acc / s)"
-                  % (ni, type(sequence).__name__, len(sequence), elapsed, ni / elapsed), file=sys.stderr)
-
-            st = time()
-            for i in xrange(ni):
-                one, two = sequence[0], sequence[1]
-            # END for eac iteration
-            elapsed = time() - st
-            print("Unpacked %i %ss of size %i individually (2 of 4) in %f s ( %f acc / s)"
-                  % (ni, type(sequence).__name__, len(sequence), elapsed, ni / elapsed), file=sys.stderr)
-        # END for each sequence
-
-    def test_large_list_vs_iteration(self):
-        # what costs more: alloc/realloc of lists, or the cpu strain of iterators ?
-        def slow_iter(ni):
-            for i in xrange(ni):
-                yield i
-        # END slow iter - be closer to the real world
-
-        # alloc doesn't play a role here it seems
-        for ni in (500, 1000, 10000, 20000, 40000):
-            st = time()
-            for i in list(xrange(ni)):
-                i
-            # END for each item
-            elapsed = time() - st
-            print("Iterated %i items from list in %f s ( %f acc / s)"
-                  % (ni, elapsed, ni / elapsed), file=sys.stderr)
-
-            st = time()
-            for i in slow_iter(ni):
-                i
-            # END for each item
-            elapsed = time() - st
-            print("Iterated %i items from iterator in %f s ( %f acc / s)"
-                  % (ni, elapsed, ni / elapsed), file=sys.stderr)
-        # END for each number of iterations
-
-    def test_type_vs_inst_class(self):
-        class NewType(object):
-            pass
-
-        # lets see which way is faster
-        inst = NewType()
-
-        ni = 1000000
-        st = time()
-        for i in xrange(ni):
-            inst.__class__()
-        # END for each item
-        elapsed = time() - st
-        print("Created %i items using inst.__class__ in %f s ( %f items / s)"
-              % (ni, elapsed, ni / elapsed), file=sys.stderr)
-
-        st = time()
-        for i in xrange(ni):
-            type(inst)()
-        # END for each item
-        elapsed = time() - st
-        print("Created %i items using type(inst)() in %f s ( %f items / s)"
-              % (ni, elapsed, ni / elapsed), file=sys.stderr)