diff --git a/test/cancel.t b/test/cancel.t
index ea26a3ad..86c8a07a 100755
--- a/test/cancel.t
+++ b/test/cancel.t
@@ -26,30 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestCancel(TestCase):
     def setUp(self):
diff --git a/test/chart.t b/test/chart.t
index ed5e7a11..2dac660d 100755
--- a/test/chart.t
+++ b/test/chart.t
@@ -26,31 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
-
 
 class TestChart(TestCase):
     def setUp(self):
@@ -199,6 +183,7 @@ class TestChart(TestCase):
 
 """, out)
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/cli.t b/test/cli.t
index d8be80be..3924025d 100755
--- a/test/cli.t
+++ b/test/cli.t
@@ -26,32 +26,16 @@
 #
 ###############################################################################
 
-import sys
 import os
 import shutil
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
-
 
 class TestCLI(TestCase):
     def setUp(self):
@@ -59,15 +43,15 @@ class TestCLI(TestCase):
         self.t = Timew()
 
     def test_initial_call_of_timew(self):
-      """Verify that calling 'timew' the first time returns exit code 0"""
-      self.t.reset_env()
-      shutil.rmtree(self.t.env["TIMEWARRIORDB"])
+        """Verify that calling 'timew' the first time returns exit code 0"""
+        self.t.reset_env()
+        shutil.rmtree(self.t.env["TIMEWARRIORDB"])
 
-      code, out, err = self.t.runSuccess(":yes")
-      self.assertIn("Welcome to Timewarrior.\n", out)
+        code, out, err = self.t.runSuccess(":yes")
+        self.assertIn("Welcome to Timewarrior.\n", out)
 
-      assert os.path.isdir(self.t.env["TIMEWARRIORDB"])
-      assert os.path.exists(self.t.env["TIMEWARRIORDB"])
+        assert os.path.isdir(self.t.env["TIMEWARRIORDB"])
+        assert os.path.exists(self.t.env["TIMEWARRIORDB"])
 
     def test_TimeWarrior_without_command_without_active_time_tracking(self):
         """Call 'timew' without active time tracking"""
diff --git a/test/clock.t b/test/clock.t
index 69b7067f..f4d48b25 100755
--- a/test/clock.t
+++ b/test/clock.t
@@ -26,30 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestClock(TestCase):
     def setUp(self):
diff --git a/test/config.t b/test/config.t
index 99b4d283..51cd6adb 100755
--- a/test/config.t
+++ b/test/config.t
@@ -26,8 +26,8 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
 
 # Ensure python finds the local simpletap module
@@ -35,21 +35,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestConfig(TestCase):
     def setUp(self):
@@ -229,6 +214,7 @@ class TestConfig(TestCase):
         code, out, err = self.t("config number 5", input="yes\n")
         self.assertIn(" with a value of '5'?", out)
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/continue.t b/test/continue.t
index 78d995c0..f8db1063 100755
--- a/test/continue.t
+++ b/test/continue.t
@@ -26,9 +26,10 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
+
 from datetime import datetime, timedelta
 
 # Ensure python finds the local simpletap module
@@ -36,21 +37,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestContinue(TestCase):
     def setUp(self):
@@ -232,6 +218,7 @@ class TestContinue(TestCase):
         self.assertTrue('tags' in j[2])
         self.assertEqual(j[2]['tags'], ['FOO'])
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/delete.t b/test/delete.t
index 607cffb0..3588ec53 100755
--- a/test/delete.t
+++ b/test/delete.t
@@ -26,30 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestDelete(TestCase):
     def setUp(self):
@@ -96,7 +81,6 @@ class TestDelete(TestCase):
         j = self.t.export()
         self.assertEqual(len(j), 0)
 
-    # TI-58
     def test_delete_open_interval_straddling_lunch(self):
         """Delete a single open interval that straddles lunch, verify that is is gone"""
         self.t.config("exclusions.monday",    "12:00-13:00")
diff --git a/test/dom.t b/test/dom.t
index 94407c94..116cd6fe 100755
--- a/test/dom.t
+++ b/test/dom.t
@@ -26,30 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestDOM(TestCase):
     def setUp(self):
@@ -166,6 +151,7 @@ class TestDOM(TestCase):
         code, out, err = self.t("get dom.tracked.count")
         self.assertEqual('0\n', out)
 
+
 class TestDOMTracked(TestCase):
     @classmethod
     def setUpClass(cls):
@@ -247,6 +233,7 @@ class TestDOMTracked(TestCase):
         code, out, err = self.t("get dom.tracked.1.json")
         self.assertRegexpMatches(out, r'{"start":"\d{8}T\d{6}Z"}')
 
+
 class TestDOMRC(TestCase):
     def setUp(self):
         """Executed before each test in the class"""
@@ -260,6 +247,7 @@ class TestDOMRC(TestCase):
         """Test dom.rc.debug"""
         code, out, err = self.t("get dom.rc.debug")
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/export.t b/test/export.t
index 68149146..d5acff96 100755
--- a/test/export.t
+++ b/test/export.t
@@ -37,22 +37,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
-
 
 class TestExport(TestCase):
     def setUp(self):
diff --git a/test/extensions.t b/test/extensions.t
index eeccb835..f407ecab 100755
--- a/test/extensions.t
+++ b/test/extensions.t
@@ -26,32 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
-from basetest.utils import DEFAULT_EXTENSION_PATH
-import shutil
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestExtensions(TestCase):
     def setUp(self):
@@ -73,6 +56,7 @@ class TestExtensions(TestCase):
         code, out, err = self.t('report ext')
         self.assertIn('test works', out)
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/fill.t b/test/fill.t
index 32843881..3b75d725 100755
--- a/test/fill.t
+++ b/test/fill.t
@@ -26,30 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestFillHint(TestCase):
     def setUp(self):
@@ -112,6 +97,7 @@ class TestFillHint(TestCase):
         self.assertTrue('end' not in j[1])
         self.assertEqual(j[1]['tags'][0], 'two')
 
+
 class TestFillCommand(TestCase):
     def setUp(self):
         """Executed before each test in the class"""
@@ -144,6 +130,7 @@ class TestFillCommand(TestCase):
         self.tap(out)
         self.tap(err)
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/gaps.t b/test/gaps.t
index a74be52c..88c40276 100755
--- a/test/gaps.t
+++ b/test/gaps.t
@@ -26,30 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestGaps(TestCase):
     def setUp(self):
@@ -82,6 +67,7 @@ class TestGaps(TestCase):
         code, out, err = self.t("gaps 2016-05-27 - 2016-05-28")
         self.assertRegexpMatches(out, r'\s{30}5:00:00')
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/ids.t b/test/ids.t
index e87f832f..6c4f0d31 100755
--- a/test/ids.t
+++ b/test/ids.t
@@ -35,22 +35,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
-
 
 class TestIds(TestCase):
     def setUp(self):
diff --git a/test/join.t b/test/join.t
index 75ec60a7..68acf862 100755
--- a/test/join.t
+++ b/test/join.t
@@ -26,30 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestJoin(TestCase):
     def setUp(self):
@@ -72,6 +57,7 @@ class TestJoin(TestCase):
 
 # TODO Add :adjust tests.
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/lengthen.t b/test/lengthen.t
index 47f753ff..49ff8859 100755
--- a/test/lengthen.t
+++ b/test/lengthen.t
@@ -26,30 +26,17 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
+
 from datetime import datetime, timedelta
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestLengthen(TestCase):
     def setUp(self):
diff --git a/test/move.t b/test/move.t
index efd848cc..2e234bb4 100755
--- a/test/move.t
+++ b/test/move.t
@@ -26,31 +26,17 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
+
 from datetime import datetime, timedelta
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
-
 
 class TestMove(TestCase):
     def setUp(self):
@@ -225,6 +211,7 @@ class TestMove(TestCase):
 
 # TODO Add :adjust tests.
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/quiet.t b/test/quiet.t
index 60adae8b..5f9e08d3 100755
--- a/test/quiet.t
+++ b/test/quiet.t
@@ -26,30 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestQuietMode(TestCase):
     def setUp(self):
diff --git a/test/resize.t b/test/resize.t
index dd134075..3f22d283 100755
--- a/test/resize.t
+++ b/test/resize.t
@@ -26,30 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestResize(TestCase):
     def setUp(self):
@@ -68,6 +53,7 @@ class TestResize(TestCase):
         code, out, err = self.t.runError("resize @1 10mins")
         self.assertIn('Cannot resize open interval @1', err)
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/shorten.t b/test/shorten.t
index 977d17a8..3c7d3134 100755
--- a/test/shorten.t
+++ b/test/shorten.t
@@ -26,30 +26,17 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
+
 from datetime import datetime, timedelta
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestShorten(TestCase):
     def setUp(self):
@@ -140,6 +127,7 @@ class TestBug6(TestCase):
         code, out, err = self.t.runError("shorten @1 10mins")
         self.assertIn('Cannot shorten interval @1 by 0:10:00 because it is only 0:05:00 in length.', err)
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/split.t b/test/split.t
index d4a4a2eb..917a70b6 100755
--- a/test/split.t
+++ b/test/split.t
@@ -26,30 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestSplit(TestCase):
     def setUp(self):
@@ -98,6 +83,7 @@ class TestSplit(TestCase):
 
 # TODO Add :adjust tests.
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/start.t b/test/start.t
index 6e959e44..fe2ecccc 100755
--- a/test/start.t
+++ b/test/start.t
@@ -35,22 +35,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
-
 
 class TestStart(TestCase):
     def setUp(self):
@@ -114,7 +98,6 @@ class TestStart(TestCase):
         code, out, err = self.t("start foo bar")
         self.assertNotIn("Recorded bar foo", out)
 
-
     def test_single_interval_enclosing_exclusion(self):
         """Add one interval that encloseѕ an exclusion, and is therefore flattened"""
         self.t.config("exclusions.monday",    "<9:11:50 12:22:44-13:32:23 >18:05:11")
diff --git a/test/stop.t b/test/stop.t
index 262c001d..1c229fff 100755
--- a/test/stop.t
+++ b/test/stop.t
@@ -35,22 +35,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
-
 
 class TestStop(TestCase):
     def setUp(self):
diff --git a/test/summary.t b/test/summary.t
index 3622a7c3..8ca991d0 100755
--- a/test/summary.t
+++ b/test/summary.t
@@ -30,30 +30,13 @@ import os
 import sys
 import unittest
 
+from datetime import datetime, timedelta
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-from datetime import datetime, timedelta
-
-
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
-
 
 class TestSummary(TestCase):
     def setUp(self):
diff --git a/test/tag.t b/test/tag.t
index 793ca8c9..0b4cce45 100755
--- a/test/tag.t
+++ b/test/tag.t
@@ -26,30 +26,17 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
+
 from datetime import datetime, timedelta
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestTag(TestCase):
     def setUp(self):
@@ -136,7 +123,6 @@ class TestTag(TestCase):
         self.assertEqual(j[1]['tags'], ['foo'], 'tags of unmodified interval do not match')
 
 
-
 class TestUntag(TestCase):
     def setUp(self):
         """Executed before each test in the class"""
diff --git a/test/tags.t b/test/tags.t
index 2da6daa5..4a0e9908 100755
--- a/test/tags.t
+++ b/test/tags.t
@@ -26,30 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestTags(TestCase):
     def setUp(self):
@@ -110,6 +95,7 @@ class TestTags(TestCase):
 #        self.assertNotIn("Note: 'foo' is a new tag.", out)
 #        self.assertNotIn("Note: 'bar' is a new tag.", out)
 
+
 if __name__ == "__main__":
     from simpletap import TAPTestRunner
     unittest.main(testRunner=TAPTestRunner())
diff --git a/test/template.t b/test/template.t
index 20b9ae12..f917815f 100644
--- a/test/template.t
+++ b/test/template.t
@@ -26,10 +26,12 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
+
 from datetime import datetime
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
@@ -51,6 +53,7 @@ from basetest import Timew, TestCase
 #     self.assertNotRegexpMatches(text, pattern)
 #     self.tap("")
 
+
 class TestBugNumber(TestCase):
     @classmethod
     def setUpClass(cls):
diff --git a/test/track.t b/test/track.t
index 1e608c54..28cc8451 100755
--- a/test/track.t
+++ b/test/track.t
@@ -37,22 +37,6 @@ sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
-
 
 class TestTrack(TestCase):
     def setUp(self):
diff --git a/test/version.t b/test/version.t
index 7890caa8..becf37f1 100755
--- a/test/version.t
+++ b/test/version.t
@@ -26,31 +26,15 @@
 #
 ###############################################################################
 
-import sys
 import os
+import sys
 import unittest
-import re
+
 # Ensure python finds the local simpletap module
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from basetest import Timew, TestCase
-from basetest.utils import run_cmd_wait
 
-# Test methods available:
-#     self.assertEqual(a, b)
-#     self.assertNotEqual(a, b)
-#     self.assertTrue(x)
-#     self.assertFalse(x)
-#     self.assertIs(a, b)
-#     self.assertIsNot(substring, text)
-#     self.assertIsNone(x)
-#     self.assertIsNotNone(x)
-#     self.assertIn(substring, text)
-#     self.assertNotIn(substring, text
-#     self.assertRaises(e)
-#     self.assertRegexpMatches(text, pattern)
-#     self.assertNotRegexpMatches(text, pattern)
-#     self.tap("")
 
 class TestVersion(TestCase):
     def setUp(self):