Lines Matching refs:self
53 def checkError(self, args, msg):
54 with support.captured_stderr() as err, self.assertRaises(SystemExit):
56 self.assertIn(msg, err.getvalue())
58 def test_help(self):
60 with self.subTest(opt=opt):
62 self.assertRaises(SystemExit):
64 self.assertIn('Run Python regression tests.', out.getvalue())
66 def test_timeout(self):
68 self.assertEqual(ns.timeout, 4.2)
69 self.checkError(['--timeout'], 'expected one argument')
70 self.checkError(['--timeout', 'foo'], 'invalid float value')
72 def test_wait(self):
74 self.assertTrue(ns.wait)
76 def test_worker_args(self):
78 self.assertEqual(ns.worker_args, '[[], {}]')
79 self.checkError(['--worker-args'], 'expected one argument')
81 def test_start(self):
83 with self.subTest(opt=opt):
85 self.assertEqual(ns.start, 'foo')
86 self.checkError([opt], 'expected one argument')
88 def test_verbose(self):
90 self.assertEqual(ns.verbose, 1)
92 self.assertEqual(ns.verbose, 3)
94 self.assertEqual(ns.verbose, 1)
96 self.assertEqual(ns.verbose, 3)
98 self.assertEqual(ns.verbose, 0)
100 def test_verbose2(self):
102 with self.subTest(opt=opt):
104 self.assertTrue(ns.verbose2)
106 def test_verbose3(self):
108 with self.subTest(opt=opt):
110 self.assertTrue(ns.verbose3)
112 def test_quiet(self):
114 with self.subTest(opt=opt):
116 self.assertTrue(ns.quiet)
117 self.assertEqual(ns.verbose, 0)
119 def test_slowest(self):
121 with self.subTest(opt=opt):
123 self.assertTrue(ns.print_slow)
125 def test_header(self):
127 self.assertTrue(ns.header)
130 self.assertTrue(ns.header)
132 def test_randomize(self):
134 with self.subTest(opt=opt):
136 self.assertTrue(ns.randomize)
138 def test_randseed(self):
140 self.assertEqual(ns.random_seed, 12345)
141 self.assertTrue(ns.randomize)
142 self.checkError(['--randseed'], 'expected one argument')
143 self.checkError(['--randseed', 'foo'], 'invalid int value')
145 def test_fromfile(self):
147 with self.subTest(opt=opt):
149 self.assertEqual(ns.fromfile, 'foo')
150 self.checkError([opt], 'expected one argument')
151 self.checkError([opt, 'foo', '-s'], "don't go together")
153 def test_exclude(self):
155 with self.subTest(opt=opt):
157 self.assertTrue(ns.exclude)
159 def test_single(self):
161 with self.subTest(opt=opt):
163 self.assertTrue(ns.single)
164 self.checkError([opt, '-f', 'foo'], "don't go together")
166 def test_ignore(self):
168 with self.subTest(opt=opt):
170 self.assertEqual(ns.ignore_tests, ['pattern'])
171 self.checkError([opt], 'expected one argument')
173 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
181 self.assertEqual(ns.ignore_tests,
184 def test_match(self):
186 with self.subTest(opt=opt):
188 self.assertEqual(ns.match_tests, ['pattern'])
189 self.checkError([opt], 'expected one argument')
193 self.assertEqual(ns.match_tests, ['pattern1', 'pattern2'])
195 self.addCleanup(os_helper.unlink, os_helper.TESTFN)
203 self.assertEqual(ns.match_tests,
206 def test_failfast(self):
208 with self.subTest(opt=opt):
210 self.assertTrue(ns.failfast)
212 self.assertTrue(ns.failfast)
213 self.checkError([opt], '-G/--failfast needs either -v or -W')
215 def test_use(self):
217 with self.subTest(opt=opt):
219 self.assertEqual(ns.use_resources, ['gui', 'network'])
222 self.assertEqual(ns.use_resources, ['network'])
227 self.assertEqual(ns.use_resources, expected)
228 self.checkError([opt], 'expected one argument')
229 self.checkError([opt, 'foo'], 'invalid resource')
233 self.assertEqual(ns.use_resources,
238 self.assertEqual(ns.use_resources, ['extralargefile'])
240 def test_memlimit(self):
242 with self.subTest(opt=opt):
244 self.assertEqual(ns.memlimit, '4G')
245 self.checkError([opt], 'expected one argument')
247 def test_testdir(self):
249 self.assertEqual(ns.testdir, os.path.join(os_helper.SAVEDCWD, 'foo'))
250 self.checkError(['--testdir'], 'expected one argument')
252 def test_runleaks(self):
254 with self.subTest(opt=opt):
256 self.assertTrue(ns.runleaks)
258 def test_huntrleaks(self):
260 with self.subTest(opt=opt):
262 self.assertEqual(ns.huntrleaks, (5, 4, 'reflog.txt'))
264 self.assertEqual(ns.huntrleaks, (6, 4, 'reflog.txt'))
266 self.assertEqual(ns.huntrleaks, (5, 3, 'reflog.txt'))
268 self.assertEqual(ns.huntrleaks, (6, 3, 'leaks.log'))
269 self.checkError([opt], 'expected one argument')
270 self.checkError([opt, '6'],
272 self.checkError([opt, 'foo:'], 'invalid huntrleaks value')
273 self.checkError([opt, '6:foo'], 'invalid huntrleaks value')
275 def test_multiprocess(self):
277 with self.subTest(opt=opt):
279 self.assertEqual(ns.use_mp, 2)
280 self.checkError([opt], 'expected one argument')
281 self.checkError([opt, 'foo'], 'invalid int value')
282 self.checkError([opt, '2', '-T'], "don't go together")
283 self.checkError([opt, '0', '-T'], "don't go together")
285 def test_coverage(self):
287 with self.subTest(opt=opt):
289 self.assertTrue(ns.trace)
291 def test_coverdir(self):
293 with self.subTest(opt=opt):
295 self.assertEqual(ns.coverdir,
297 self.checkError([opt], 'expected one argument')
299 def test_nocoverdir(self):
301 with self.subTest(opt=opt):
303 self.assertIsNone(ns.coverdir)
305 def test_threshold(self):
307 with self.subTest(opt=opt):
309 self.assertEqual(ns.threshold, 1000)
310 self.checkError([opt], 'expected one argument')
311 self.checkError([opt, 'foo'], 'invalid int value')
313 def test_nowindows(self):
315 with self.subTest(opt=opt):
318 self.assertTrue(ns.nowindows)
320 self.assertIn('the --nowindows (-n) option is deprecated', err)
322 def test_forever(self):
324 with self.subTest(opt=opt):
326 self.assertTrue(ns.forever)
328 def test_unrecognized_argument(self):
329 self.checkError(['--xxx'], 'usage:')
331 def test_long_option__partial(self):
333 self.assertTrue(ns.quiet)
334 self.assertEqual(ns.verbose, 0)
336 def test_two_options(self):
338 self.assertTrue(ns.quiet)
339 self.assertEqual(ns.verbose, 0)
340 self.assertTrue(ns.exclude)
342 def test_option_with_empty_string_value(self):
344 self.assertEqual(ns.start, '')
346 def test_arg(self):
348 self.assertEqual(ns.args, ['foo'])
350 def test_option_and_arg(self):
352 self.assertTrue(ns.quiet)
353 self.assertEqual(ns.verbose, 0)
354 self.assertEqual(ns.args, ['foo'])
356 def test_arg_option_arg(self):
358 self.assertEqual(ns.verbose, 1)
359 self.assertEqual(ns.args, ['test_unaryop', 'test_binop'])
361 def test_unknown_option(self):
362 self.checkError(['--unknown-option'],
371 def setUp(self):
372 self.testdir = os.path.realpath(os.path.dirname(__file__))
374 self.tmptestdir = tempfile.mkdtemp()
375 self.addCleanup(os_helper.rmtree, self.tmptestdir)
377 def create_test(self, name=None, code=None):
387 def test_empty_test(self):
393 name = self.TESTNAME_PREFIX + name
394 path = os.path.join(self.tmptestdir, name + '.py')
396 self.addCleanup(os_helper.unlink, path)
403 self.skipTest("cannot write %s: %s" % (path, exc))
407 def regex_search(self, regex, output):
410 self.fail("%r not found in %r" % (regex, output))
413 def check_line(self, output, regex):
415 self.assertRegex(output, regex)
417 def parse_executed_tests(self, output):
419 % (LOG_PREFIX, self.TESTNAME_REGEX))
423 def check_executed_tests(self, output, tests, skipped=(), failed=(),
441 executed = self.parse_executed_tests(output)
443 self.assertEqual(set(executed), set(tests), output)
445 self.assertEqual(executed, tests, output)
459 self.check_line(output, regex)
463 self.check_line(output, regex)
468 self.check_line(output, regex)
472 self.check_line(output, regex)
476 self.check_line(output, regex)
478 self.check_line(output, regex)
481 self.check_line(output, regex)
485 self.check_line(output, regex)
493 self.check_line(output, regex)
496 self.check_line(output, 'Test suite interrupted by signal SIGINT.')
512 self.check_line(output, 'Tests result: FAILURE')
515 self.check_line(output, 'Tests result: %s' % result)
517 def parse_random_seed(self, output):
518 match = self.regex_search(r'Using random seed ([0-9]+)', output)
520 self.assertTrue(0 <= randseed <= 10000000, randseed)
523 def run_command(self, args, input=None, exitcode=0, **kw):
548 self.fail(msg)
551 def run_python(self, args, **kw):
553 proc = self.run_command(args, **kw)
558 def test_finds_expected_number_of_tests(self):
563 output = self.run_python(args)
575 self.assertGreater(rough_number_of_tests_found,
589 def setUp(self):
593 self.tests = [self.create_test() for index in range(self.NTEST)]
595 self.python_args = ['-Wd', '-E', '-bb']
596 self.regrtest_args = ['-uall', '-rwW',
597 '--testdir=%s' % self.tmptestdir]
598 self.regrtest_args.extend(('--timeout', '3600', '-j4'))
600 self.regrtest_args.append('-n')
602 def check_output(self, output):
603 self.parse_random_seed(output)
604 self.check_executed_tests(output, self.tests, randomize=True)
606 def run_tests(self, args):
607 output = self.run_python(args)
608 self.check_output(output)
610 def test_script_regrtest(self):
612 script = os.path.join(self.testdir, 'regrtest.py')
614 args = [*self.python_args, script, *self.regrtest_args, *self.tests]
615 self.run_tests(args)
617 def test_module_test(self):
619 args = [*self.python_args, '-m', 'test',
620 *self.regrtest_args, *self.tests]
621 self.run_tests(args)
623 def test_module_regrtest(self):
625 args = [*self.python_args, '-m', 'test.regrtest',
626 *self.regrtest_args, *self.tests]
627 self.run_tests(args)
629 def test_module_autotest(self):
631 args = [*self.python_args, '-m', 'test.autotest',
632 *self.regrtest_args, *self.tests]
633 self.run_tests(args)
635 def test_module_from_test_autotest(self):
638 args = [*self.python_args, '-c', code,
639 *self.regrtest_args, *self.tests]
640 self.run_tests(args)
642 def test_script_autotest(self):
644 script = os.path.join(self.testdir, 'autotest.py')
645 args = [*self.python_args, script, *self.regrtest_args, *self.tests]
646 self.run_tests(args)
650 def test_tools_script_run_tests(self):
653 args = [script, *self.regrtest_args, *self.tests]
654 self.run_tests(args)
656 def run_batch(self, *args):
657 proc = self.run_command(args)
658 self.check_output(proc.stdout)
663 def test_tools_buildbot_test(self):
666 test_args = ['--testdir=%s' % self.tmptestdir]
675 self.run_batch(script, *test_args, *self.tests)
678 def test_pcbuild_rt(self):
682 self.skipTest(f'File "{script}" does not exist')
692 self.run_batch(script, *rt_args, *self.regrtest_args, *self.tests)
700 def run_tests(self, *testargs, **kw):
701 cmdargs = ['-m', 'test', '--testdir=%s' % self.tmptestdir, *testargs]
702 return self.run_python(cmdargs, **kw)
704 def test_failing_test(self):
710 def test_failing(self):
711 self.fail("bug")
713 test_ok = self.create_test('ok')
714 test_failing = self.create_test('failing', code=code)
717 output = self.run_tests(*tests, exitcode=2)
718 self.check_executed_tests(output, tests, failed=test_failing)
720 def test_resources(self):
728 def test_pass(self):
732 tests[resource] = self.create_test(resource, code)
736 output = self.run_tests('-u', 'all', *test_names)
737 self.check_executed_tests(output, test_names)
740 output = self.run_tests('-uaudio', *test_names)
741 self.check_executed_tests(output, test_names,
745 output = self.run_tests(*test_names)
746 self.check_executed_tests(output, test_names,
749 def test_random(self):
755 test = self.create_test('random', code)
758 output = self.run_tests('-r', test)
759 randseed = self.parse_random_seed(output)
760 match = self.regex_search(r'TESTRANDOM: ([0-9]+)', output)
764 output = self.run_tests('-r', '--randseed=%s' % randseed, test)
765 randseed2 = self.parse_random_seed(output)
766 self.assertEqual(randseed2, randseed)
768 match = self.regex_search(r'TESTRANDOM: ([0-9]+)', output)
770 self.assertEqual(test_random2, test_random)
772 def test_fromfile(self):
774 tests = [self.create_test() for index in range(5)]
780 self.addCleanup(os_helper.unlink, filename)
793 output = self.run_tests('--fromfile', filename)
794 self.check_executed_tests(output, tests)
801 output = self.run_tests('--fromfile', filename)
802 self.check_executed_tests(output, tests)
809 output = self.run_tests('--fromfile', filename)
810 self.check_executed_tests(output, tests)
817 output = self.run_tests('--fromfile', filename)
818 self.check_executed_tests(output, tests)
820 def test_interrupted(self):
822 test = self.create_test('sigint', code=code)
823 output = self.run_tests(test, exitcode=130)
824 self.check_executed_tests(output, test, omitted=test,
827 def test_slowest(self):
829 tests = [self.create_test() for index in range(3)]
830 output = self.run_tests("--slowest", *tests)
831 self.check_executed_tests(output, tests)
834 % (self.TESTNAME_REGEX, len(tests)))
835 self.check_line(output, regex)
837 def test_slowest_interrupted(self):
840 test = self.create_test("sigint", code=code)
843 with self.subTest(multiprocessing=multiprocessing):
848 output = self.run_tests(*args, exitcode=130)
849 self.check_executed_tests(output, test,
853 self.check_line(output, regex)
855 def test_coverage(self):
857 test = self.create_test('coverage')
858 output = self.run_tests("--coverage", test)
859 self.check_executed_tests(output, [test])
862 self.check_line(output, regex)
864 def test_wait(self):
866 test = self.create_test('wait')
867 output = self.run_tests("--wait", test, input='key')
868 self.check_line(output, 'Press any key to continue')
870 def test_forever(self):
877 def test_run(self):
883 self.fail("fail at the 3rd runs")
887 test = self.create_test('forever', code=code)
888 output = self.run_tests('--forever', test, exitcode=2)
889 self.check_executed_tests(output, [test]*3, failed=test)
891 def check_leak(self, code, what):
892 test = self.create_test('huntrleaks', code=code)
895 self.addCleanup(os_helper.unlink, filename)
896 output = self.run_tests('--huntrleaks', '3:3:', test,
899 self.check_executed_tests(output, [test], failed=test)
902 self.check_line(output, re.escape(line))
905 self.assertIn(line2, output)
909 self.assertIn(line2, reflog)
912 def test_huntrleaks(self):
920 def test_leak(self):
923 self.check_leak(code, 'references')
926 def test_huntrleaks_fd_leak(self):
933 def test_leak(self):
937 self.check_leak(code, 'file descriptors')
939 def test_list_tests(self):
941 tests = [self.create_test() for i in range(5)]
942 output = self.run_tests('--list-tests', *tests)
943 self.assertEqual(output.rstrip().splitlines(),
946 def test_list_cases(self):
952 def test_method1(self):
954 def test_method2(self):
957 testname = self.create_test(code=code)
962 output = self.run_tests('--list-cases', testname)
963 self.assertEqual(output.splitlines(), all_methods)
967 output = self.run_tests('--list-cases',
970 self.assertEqual(output.splitlines(), all_methods)
973 def test_crashed(self):
976 crash_test = self.create_test(name="crash", code=code)
979 output = self.run_tests("-j2", *tests, exitcode=2)
980 self.check_executed_tests(output, tests, failed=crash_test,
983 def parse_methods(self, output):
987 def test_ignorefile(self):
992 def test_method1(self):
994 def test_method2(self):
996 def test_method3(self):
998 def test_method4(self):
1003 testname = self.create_test(code=code)
1007 self.addCleanup(os_helper.unlink, filename)
1018 output = self.run_tests("-v", "--ignorefile", filename, testname)
1019 methods = self.parse_methods(output)
1021 self.assertEqual(methods, subset)
1023 def test_matchfile(self):
1028 def test_method1(self):
1030 def test_method2(self):
1032 def test_method3(self):
1034 def test_method4(self):
1039 testname = self.create_test(code=code)
1042 output = self.run_tests("-v", testname)
1043 methods = self.parse_methods(output)
1044 self.assertEqual(methods, all_methods)
1048 self.addCleanup(os_helper.unlink, filename)
1059 output = self.run_tests("-v", "--matchfile", filename, testname)
1060 methods = self.parse_methods(output)
1062 self.assertEqual(methods, subset)
1064 def test_env_changed(self):
1069 def test_env_changed(self):
1072 testname = self.create_test(code=code)
1075 output = self.run_tests(testname)
1076 self.check_executed_tests(output, [testname], env_changed=testname)
1079 output = self.run_tests("--fail-env-changed", testname, exitcode=3)
1080 self.check_executed_tests(output, [testname], env_changed=testname,
1083 def test_rerun_fail(self):
1089 def test_succeed(self):
1092 def test_fail_always(self):
1094 self.fail("bug")
1096 testname = self.create_test(code=code)
1098 output = self.run_tests("-w", testname, exitcode=2)
1099 self.check_executed_tests(output, [testname],
1102 def test_rerun_success(self):
1109 def test_succeed(self):
1112 def test_fail_once(self):
1115 self.fail("bug")
1117 testname = self.create_test(code=code)
1119 output = self.run_tests("-w", testname, exitcode=0)
1120 self.check_executed_tests(output, [testname],
1123 def test_rerun_setup_class_hook_failure(self):
1130 def setUpClass(self):
1133 def test_success(self):
1136 testname = self.create_test(code=code)
1138 output = self.run_tests("-w", testname, exitcode=EXITCODE_BAD_TEST)
1139 self.check_executed_tests(output, testname,
1143 def test_rerun_teardown_class_hook_failure(self):
1150 def tearDownClass(self):
1153 def test_success(self):
1156 testname = self.create_test(code=code)
1158 output = self.run_tests("-w", testname, exitcode=EXITCODE_BAD_TEST)
1159 self.check_executed_tests(output, testname,
1163 def test_rerun_setup_module_hook_failure(self):
1172 def test_success(self):
1175 testname = self.create_test(code=code)
1177 output = self.run_tests("-w", testname, exitcode=EXITCODE_BAD_TEST)
1178 self.check_executed_tests(output, testname,
1182 def test_rerun_teardown_module_hook_failure(self):
1191 def test_success(self):
1194 testname = self.create_test(code=code)
1196 output = self.run_tests("-w", testname, exitcode=EXITCODE_BAD_TEST)
1197 self.check_executed_tests(output, testname,
1201 def test_rerun_setup_hook_failure(self):
1207 def setUp(self):
1210 def test_success(self):
1213 testname = self.create_test(code=code)
1215 output = self.run_tests("-w", testname, exitcode=EXITCODE_BAD_TEST)
1216 self.check_executed_tests(output, testname,
1220 def test_rerun_teardown_hook_failure(self):
1226 def tearDown(self):
1229 def test_success(self):
1232 testname = self.create_test(code=code)
1234 output = self.run_tests("-w", testname, exitcode=EXITCODE_BAD_TEST)
1235 self.check_executed_tests(output, testname,
1239 def test_rerun_async_setup_hook_failure(self):
1245 async def asyncSetUp(self):
1248 async def test_success(self):
1251 testname = self.create_test(code=code)
1253 output = self.run_tests("-w", testname, exitcode=EXITCODE_BAD_TEST)
1254 self.check_executed_tests(output, testname,
1258 def test_rerun_async_teardown_hook_failure(self):
1264 async def asyncTearDown(self):
1267 async def test_success(self):
1270 testname = self.create_test(code=code)
1272 output = self.run_tests("-w", testname, exitcode=EXITCODE_BAD_TEST)
1273 self.check_executed_tests(output, testname,
1277 def test_no_tests_ran(self):
1282 def test_bug(self):
1285 testname = self.create_test(code=code)
1287 output = self.run_tests(testname, "-m", "nosuchtest", exitcode=0)
1288 self.check_executed_tests(output, [testname], no_test_ran=testname)
1290 def test_no_tests_ran_skip(self):
1295 def test_skipped(self):
1296 self.skipTest("because")
1298 testname = self.create_test(code=code)
1300 output = self.run_tests(testname, exitcode=0)
1301 self.check_executed_tests(output, [testname])
1303 def test_no_tests_ran_multiple_tests_nonexistent(self):
1308 def test_bug(self):
1311 testname = self.create_test(code=code)
1312 testname2 = self.create_test(code=code)
1314 output = self.run_tests(testname, testname2, "-m", "nosuchtest", exitcode=0)
1315 self.check_executed_tests(output, [testname, testname2],
1318 def test_no_test_ran_some_test_exist_some_not(self):
1323 def test_bug(self):
1326 testname = self.create_test(code=code)
1331 def test_other_bug(self):
1334 testname2 = self.create_test(code=other_code)
1336 output = self.run_tests(testname, testname2, "-m", "nosuchtest",
1338 self.check_executed_tests(output, [testname, testname2],
1342 def test_uncollectable(self):
1350 def __tp_del__(self):
1354 def test_garbage(self):
1360 testname = self.create_test(code=code)
1362 output = self.run_tests("--fail-env-changed", testname, exitcode=3)
1363 self.check_executed_tests(output, [testname],
1367 def test_multiprocessing_timeout(self):
1378 def test_sleep(self):
1386 testname = self.create_test(code=code)
1388 output = self.run_tests("-j2", "--timeout=1.0", testname, exitcode=2)
1389 self.check_executed_tests(output, [testname],
1391 self.assertRegex(output,
1394 def test_unraisable_exc(self):
1409 def test_unraisable_exc(self):
1416 self.assertEqual(stderr.getvalue(), '')
1418 testname = self.create_test(code=code)
1420 output = self.run_tests("--fail-env-changed", "-v", testname, exitcode=3)
1421 self.check_executed_tests(output, [testname],
1424 self.assertIn("Warning -- Unraisable exception", output)
1425 self.assertIn("Exception: weakref callback bug", output)
1427 def test_threading_excepthook(self):
1442 def test_threading_excepthook(self):
1447 self.assertEqual(stderr.getvalue(), '')
1449 testname = self.create_test(code=code)
1451 output = self.run_tests("--fail-env-changed", "-v", testname, exitcode=3)
1452 self.check_executed_tests(output, [testname],
1455 self.assertIn("Warning -- Uncaught thread exception", output)
1456 self.assertIn("Exception: bug in thread", output)
1458 def test_print_warning(self):
1473 def test_print_warning(self):
1479 testname = self.create_test(code=code)
1490 with self.subTest(option=option):
1492 output = self.run_tests(*cmd, exitcode=3)
1493 self.check_executed_tests(output, [testname],
1496 self.assertRegex(output, regex)
1498 def test_unicode_guard_env(self):
1500 self.assertIsNotNone(guard, f"{setup.UNICODE_GUARD_ENV} not set")
1504 self.skipTest("Modified guard")
1506 def test_cleanup(self):
1507 dirname = os.path.join(self.tmptestdir, "test_python_123")
1509 filename = os.path.join(self.tmptestdir, "test_python_456")
1514 '--tempdir=%s' % self.tmptestdir,
1516 self.run_python(cmdargs)
1519 self.assertFalse(os.path.exists(name), name)
1523 def test_format_duration(self):
1524 self.assertEqual(utils.format_duration(0),
1526 self.assertEqual(utils.format_duration(1e-9),
1528 self.assertEqual(utils.format_duration(10e-3),
1530 self.assertEqual(utils.format_duration(1.5),
1532 self.assertEqual(utils.format_duration(1),
1534 self.assertEqual(utils.format_duration(2 * 60),
1536 self.assertEqual(utils.format_duration(2 * 60 + 1),
1538 self.assertEqual(utils.format_duration(3 * 3600),
1540 self.assertEqual(utils.format_duration(3 * 3600 + 2 * 60 + 1),
1542 self.assertEqual(utils.format_duration(3 * 3600 + 1),