Add benchmark

Author: whtsky

dev-requirements.txt

@@ -1,4 +1,5 @@
 pytest
+pytest-benchmark
 coverage
 cython
 tox

tests/test_decode.py

@@ -10,52 +10,52 @@
 )
 
 
-def test_decode_str():
-    assert bdecode(b'6:WWWWWW') == b"WWWWWW"
+def test_decode_str(benchmark):
+    assert benchmark(bdecode, b'6:WWWWWW') == b"WWWWWW"
 
 
-def test_decode_int():
-    assert bdecode(b'i233e') == 233
+def test_decode_int(benchmark):
+    assert benchmark(bdecode, b'i233e') == 233
 
 
-def test_decode_large_int():
+def test_decode_large_int(benchmark):
     assert bdecode(b'i1455189890e') == 1455189890
     assert bdecode(b'i25735241490e') == 25735241490
-    assert bdecode(('i%de' % sys.maxsize).encode()) == sys.maxsize
+    assert benchmark(bdecode, ('i%de' % sys.maxsize).encode()) == sys.maxsize
 
 
-def test_decode_list():
-    assert bdecode(b'l1:a1:bi3ee') == [b'a', b'b', 3]
+def test_decode_list(benchmark):
+    assert benchmark(bdecode, b'l1:a1:bi3ee') == [b'a', b'b', 3]
 
 
-def test_decode_dict():
+def test_decode_dict(benchmark):
     od = dict()
     od[b'ka'] = b'va'
     od[b'kb'] = 2
-    assert bdecode(b'd2:ka2:va2:kbi2ee') == od
+    assert benchmark(bdecode, b'd2:ka2:va2:kbi2ee') == od
 
 
-def test_ordered_dict():
+def test_ordered_dict(benchmark):
     from bencoder import OrderedDict
-    rv = bdecode(b'd2:ka2:va2:kbi2ee')
+    rv = benchmark(bdecode, b'd2:ka2:va2:kbi2ee')
     assert isinstance(rv, OrderedDict)
     assert list(rv.keys()) == [b'ka', b'kb']
     assert list(bdecode(b'd2:kc2:va2:kei2ee').keys()) == [b'kc', b'ke']
     assert list(bdecode(b'd2:ke2:va2:kci2ee').keys()) == [b'ke', b'kc']
 
 
-def test_encode_complex():
+def test_encode_complex(benchmark):
     od = dict()
     od[b'KeyA'] = [b'listitemA', {b'k': b'v'}, 3]
     od[b'KeyB'] = {b'k': b'v'}
     od[b'KeyC'] = 3
     od[b'KeyD'] = b'AString'
     expected_result = b'd4:KeyAl9:listitemAd1:k1:vei3ee4:KeyBd1:k1:ve4:KeyCi3e4:KeyD7:AStringe'
-    assert bdecode(expected_result) == od
+    assert benchmark(bdecode, expected_result) == od
 
 
-def test_decode_debian_torrent():
+def test_decode_debian_torrent(benchmark):
     with open(TORRENT_PATH, "rb") as f:
-        torrent = bdecode(f.read())
+        torrent = benchmark(bdecode, f.read())
     assert torrent[b'announce'] == b'http://bttracker.debian.org:6969/announce'
     assert torrent[b'comment'] == b'"Debian CD from cdimage.debian.org"'

tests/test_encode.py

@@ -10,70 +10,73 @@
 )
 
 
-def test_encode_str():
-    assert bencode("WWWWWW") == b'6:WWWWWW'
+def test_encode_str(benchmark):
+    assert benchmark(bencode, "WWWWWW") == b'6:WWWWWW'
 
 
-def test_encode_int():
-    assert bencode(233) == b'i233e'
+def test_encode_int(benchmark):
+    assert benchmark(bencode, 233) == b'i233e'
 
 
-def test_encode_large_int():
+def test_encode_large_int(benchmark):
     assert bencode(1455189890) == b'i1455189890e'
     assert bencode(25735241490) == b'i25735241490e'
-    assert bencode(sys.maxsize) == ('i%de' % sys.maxsize).encode()
+    assert benchmark(bencode, sys.maxsize) == ('i%de' % sys.maxsize).encode()
 
 
-def test_encode_bytes():
+def test_encode_bytes(benchmark):
     b = b"TheseAreSomeBytes"
-    coded = bencode(b)
+    coded = benchmark(bencode, b)
     l = str(len(b)).encode()
     assert coded == l + b':' + b
 
 
-def test_encode_list():
-    assert bencode(['a', 'b', 3]) == b'l1:a1:bi3ee'
+def test_encode_list(benchmark):
+    assert benchmark(bencode, ['a', 'b', 3]) == b'l1:a1:bi3ee'
 
 
-def test_encode_tuple():
-    assert bencode(('a', 'b', 3)) == b'l1:a1:bi3ee'
+def test_encode_tuple(benchmark):
+    assert benchmark(bencode, ('a', 'b', 3)) == b'l1:a1:bi3ee'
 
 
-def test_encode_bool():
-    assert bencode(True) == bencode(1)
-    assert bencode(False) == bencode(0)
+def test_encode_true(benchmark):
+    assert benchmark(bencode, True) == bencode(1)
 
 
-def test_encode_dict():
+def test_encode_false(benchmark):
+    assert benchmark(bencode, False) == bencode(0)
+
+
+def test_encode_dict(benchmark):
     od = dict()
     od['ka'] = 'va'
     od['kb'] = 2
-    assert bencode(od) == b'd2:ka2:va2:kbi2ee'
+    assert benchmark(bencode, od) == b'd2:ka2:va2:kbi2ee'
 
 
-def test_encode_dict_subclass():
+def test_encode_dict_subclass(benchmark):
     class AAA(dict):
         pass
 
     od = dict()
     od['ka'] = 'va'
     od['kb'] = 2
-    assert bencode(od) == b'd2:ka2:va2:kbi2ee'
+    assert benchmark(bencode, od) == b'd2:ka2:va2:kbi2ee'
 
 
-def test_encode_complex():
+def test_encode_complex(benchmark):
     od = dict()
     od['KeyA'] = ['listitemA', {'k': 'v'}, 3]
     od['KeyB'] = {'k': 'v'}
     od['KeyC'] = 3
     od['KeyD'] = 'AString'
     expected_result = b'd4:KeyAl9:listitemAd1:k1:vei3ee4:KeyBd1:k1:ve4:KeyCi3e4:KeyD7:AStringe'
-    assert bencode(od) == expected_result
+    assert benchmark(bencode, od) == expected_result
 
 
-def test_infohash():
+def test_infohash(benchmark):
     import hashlib
     with open(TORRENT_PATH, "rb") as f:
         torrent = bdecode(f.read())
-    infohash = hashlib.sha1(bencode(torrent[b'info'])).hexdigest()
+    infohash = hashlib.sha1(benchmark(bencode, torrent[b'info'])).hexdigest()
     assert infohash == "4194e473d6c49630e1c6247d6716076809bb96ae"

tox.ini

@@ -11,11 +11,13 @@ deps =
   cython
   pytest
   coverage
+  pytest-benchmark
   codecov
 
 [testenv:pypy]
 skip_install = False
 deps =
   cython
   pytest
+  pytest-benchmark
 commands = py.test