Exemple #1
0
    def test_time_with_3(self):

        #This test is somewhat time dependent.
        #I don't think it should ever fail, but if it does
        #try running it again and see if it works that time.

        sink = ListSink()
        logger = IndentLogger(sink)
        logs = sink.items

        with logger.time('a'):
            with logger.log('c'):
                time.sleep(0.05)
                with logger.time('d'):
                    logger.log('e')
                    time.sleep(0.05)
                with logger.time('d'):
                    logger.log('e')
                    time.sleep(0.05)
            logger.log('f')
        logger.log('g')

        self.assertEqual(8, len(logs))
        self.assertRegex(logs[0],
                         '^a \\(\\d+\\.\\d+ seconds\\) \\(completed\\)')
        self.assertEqual(logs[1], '  * c')
        self.assertRegex(
            logs[2], '^    > d \\(\\d+\\.\\d+ seconds\\) \\(completed\\)$')
        self.assertEqual(logs[3], '      - e')
        self.assertRegex(
            logs[4], '^    > d \\(\\d+\\.\\d+ seconds\\) \\(completed\\)$')
        self.assertEqual(logs[5], '      - e')
        self.assertEqual(logs[6], '  * f')
        self.assertEqual(logs[7], 'g')

        self.assertAlmostEqual(float(logs[0][3:7]), 0.15, 1)
        self.assertAlmostEqual(float(logs[2][9:13]), 0.05, 1)
        self.assertAlmostEqual(float(logs[4][9:13]), 0.05, 1)
Exemple #2
0
    def test_time_two_separate(self):

        #This test is somewhat time dependent.
        #I don't think it should ever fail, but if it does
        #try running it again and see if it works that time.

        sink = ListSink()
        logger = IndentLogger(sink)
        logs = sink.items

        with logger.time('a'):
            time.sleep(0.05)
            with logger.time('d'):
                logger.log('e')
                time.sleep(0.05)

        logger.log('g')

        with logger.time('a'):
            time.sleep(0.05)
            with logger.time('d'):
                logger.log('e')
                time.sleep(0.05)

        self.assertEqual(7, len(logs))
        self.assertRegex(logs[0], 'a \\(\\d+\\.\\d+ seconds\\)')
        self.assertRegex(logs[1], '  \\* d \\(\\d+\\.\\d+ seconds\\)')
        self.assertEqual(logs[2], '    > e')
        self.assertEqual(logs[3], 'g')
        self.assertRegex(logs[4], 'a \\(\\d+\\.\\d+ seconds\\)')
        self.assertRegex(logs[5], '  \\* d \\(\\d+\\.\\d+ seconds\\)')
        self.assertEqual(logs[6], '    > e')

        self.assertAlmostEqual(float(logs[0][3:7]), 0.10, 1)
        self.assertAlmostEqual(float(logs[1][7:11]), 0.05, 1)
        self.assertAlmostEqual(float(logs[4][3:7]), 0.10, 1)
        self.assertAlmostEqual(float(logs[5][7:11]), 0.05, 1)
Exemple #3
0
    def test_time_with_exception(self):

        sink = ListSink()
        logger = IndentLogger(sink)
        logs = sink.items

        try:
            with self.assertRaises(Exception) as e:
                with logger.time('a'):
                    logger.log('c')
                    logger.log('d')
                    raise Exception()
        except:
            pass

        self.assertEqual(3, len(logs))
        self.assertRegex(logs[0],
                         '^a \\(\\d+\\.\\d+ seconds\\) \\(exception\\)$')
        self.assertEqual(logs[1], '  * c')
        self.assertEqual(logs[2], '  * d')
Exemple #4
0
    def test_time_with_interrupt(self):

        #This test is somewhat time dependent.
        #I don't think it should ever fail, but if it does
        #try running it again and see if it works that time.

        sink = ListSink()
        logger = IndentLogger(sink)
        logs = sink.items

        try:
            with self.assertRaises(Exception) as e:
                with logger.time('a'):
                    logger.log('c')
                    logger.log('d')
                    raise KeyboardInterrupt()
        except:
            pass

        self.assertEqual(3, len(logs))
        self.assertRegex(logs[0],
                         '^a \\(\\d+\\.\\d+ seconds\\) \\(interrupt\\)$')
        self.assertEqual(logs[1], '  * c')
        self.assertEqual(logs[2], '  * d')