diff --git a/tests/test_nested.py b/tests/test_nested.py
index bce97af9..bb49ebe1 100644
--- a/tests/test_nested.py
+++ b/tests/test_nested.py
@@ -9,10 +9,12 @@
 test dill's ability to handle nested functions
 """
 
+import os
+import math
+
 import dill as pickle
 pickle.settings['recurse'] = True
-import math
-#import pickle
+
 
 # the nested function: pickle should fail here, but dill is ok.
 def adder(augend):
@@ -22,6 +24,7 @@ def inner(addend):
         return addend + augend + zero[0]
     return inner
 
+
 # rewrite the nested function using a class: standard pickle should work here.
 class cadder(object):
     def __init__(self, augend):
@@ -31,6 +34,7 @@ def __init__(self, augend):
     def __call__(self, addend):
         return addend + self.augend + self.zero[0]
 
+
 # rewrite again, but as an old-style class
 class c2adder:
     def __init__(self, augend):
@@ -40,22 +44,22 @@ def __init__(self, augend):
     def __call__(self, addend):
         return addend + self.augend + self.zero[0]
 
-# some basic stuff
-a = [0, 1, 2]
 
 # some basic class stuff
 class basic(object):
     pass
 
+
 class basic2:
     pass
 
 
-if __name__ == '__main__':
-    x = 5
-    y = 1
+x = 5
+y = 1
+
 
-    # pickled basic stuff
+def test_basic():
+    a = [0, 1, 2]
     pa = pickle.dumps(a)
     pmath = pickle.dumps(math) #XXX: FAILS in pickle
     pmap = pickle.dumps(map)
@@ -65,46 +69,49 @@ class basic2:
     lmap = pickle.loads(pmap)
     assert list(map(math.sin, a)) == list(lmap(lmath.sin, la))
 
-    # pickled basic class stuff
+
+def test_basic_class():
     pbasic2 = pickle.dumps(basic2)
     _pbasic2 = pickle.loads(pbasic2)()
     pbasic = pickle.dumps(basic)
     _pbasic = pickle.loads(pbasic)()
 
-    # pickled c2adder
+
+def test_c2adder():
     pc2adder = pickle.dumps(c2adder)
     pc2add5 = pickle.loads(pc2adder)(x)
     assert pc2add5(y) == x+y
 
-    # pickled cadder
+
+def test_pickled_cadder():
     pcadder = pickle.dumps(cadder)
     pcadd5 = pickle.loads(pcadder)(x)
     assert pcadd5(y) == x+y
 
-    # raw adder and inner
+
+def test_raw_adder_and_inner():
     add5 = adder(x)
     assert add5(y) == x+y
 
-    # pickled adder
+
+def test_pickled_adder():
     padder = pickle.dumps(adder)
     padd5 = pickle.loads(padder)(x)
     assert padd5(y) == x+y
 
-    # pickled inner
+
+def test_pickled_inner():
+    add5 = adder(x)
     pinner = pickle.dumps(add5) #XXX: FAILS in pickle
     p5add = pickle.loads(pinner)
     assert p5add(y) == x+y
 
-    # testing moduledict where not __main__
+
+def test_moduledict_where_not_main():
     try:
-            import test_moduledict
-            error = None
+        from . import test_moduledict
     except:
-            import sys
-            error = sys.exc_info()[1]
-    assert error is None
-    # clean up
-    import os
+        import test_moduledict
     name = 'test_moduledict.py'
     if os.path.exists(name) and os.path.exists(name+'c'):
         os.remove(name+'c')
@@ -117,4 +124,12 @@ class basic2:
         os.removedirs("__pycache__")
 
 
-# EOF
+if __name__ == '__main__':
+    test_basic()
+    test_basic_class()
+    test_c2adder()
+    test_pickled_cadder()
+    test_raw_adder_and_inner()
+    test_pickled_adder()
+    test_pickled_inner()
+    test_moduledict_where_not_main()