xref: /third_party/python/Lib/test/test_logging.py

192         # Logging levels in a flat logger namespace.
458     # Skip the logger name group.
466     def log_at_all_levels(self, logger):
468             logger.log(lvl, self.next_message())
471         # Filter at logger level.
502         #  filter object on the logger itself.
1105     # Do not bother with a logger name group.
1387     # config7 adds a compiler logger, and uses kwargs instead of args.
1476             logger = logging.getLogger()
1478             logger.info(self.next_message())
1480             logger.error(self.next_message())
1484             # Original logger output is empty.
1494             logger = logging.getLogger()
1496             logger.info(self.next_message())
1498             logger.error(self.next_message())
1502             # Original logger output is empty.
1509             logger = logging.getLogger("compiler.parser")
1511             logger.info(self.next_message())
1512             logger.error(self.next_message())
1517             # Original logger output is empty.
1532             logger = logging.getLogger()
1540             # Original logger output is empty
1552             logger = logging.getLogger("compiler.parser")
1560             logger.info(self.next_message())
1561             logger.error(self.next_message())
1568             # Original logger output is empty.
1572             logger = logging.getLogger("compiler.parser")
1573             self.assertFalse(logger.disabled)
1575             logger.info(self.next_message())
1576             logger.error(self.next_message())
1577             logger = logging.getLogger("compiler.lexer")
1579             logger.info(self.next_message())
1580             logger.error(self.next_message())
1589             # Original logger output is empty.
1617         logger = logging.getLogger('some_pristine_logger')
1618         self.assertFalse(logger.disabled)
1620         self.assertTrue(logger.disabled)
1622         self.assertFalse(logger.disabled)
1794         logger = logging.getLogger("tcp")
1795         logger.error("spam")
1797         logger.debug("eggs")
1903         logger = logging.getLogger("udp")
1904         logger.error("spam")
1907         logger.error("eggs")
1982         logger = logging.getLogger("slh")
1983         logger.error("sp\xe4m")
1988         logger.error("sp\xe4m")
1993         logger.error("sp\xe4m")
1998         logger = logging.getLogger("slh")
2001         logger.error("sp\xe4m")
2065         logger = logging.getLogger("http")
2102                 logger.error(msg)
2120     """Test memory persistence of logger objects."""
2228             logger = logging.getLogger("py.warnings")
2229             logger.addHandler(h)
2231             logger.removeHandler(h)
2251             logger = logging.getLogger("py.warnings")
2252             self.assertEqual(logger.handlers, [])
2255             self.assertEqual(len(logger.handlers), 1)
2256             self.assertIsInstance(logger.handlers[0], logging.NullHandler)
2410     # As config1 but with a misspelt level on a logger
3021             logger = logging.getLogger()
3023             logger.info(self.next_message())
3025             logger.error(self.next_message())
3029             # Original logger output is empty.
3036             logger = logging.getLogger("compiler.parser")
3038             logger.info(self.next_message())
3039             logger.error(self.next_message())
3044             # Original logger output is empty.
3067             #logger = logging.getLogger()
3075             # Original logger output is empty
3082             #logger = logging.getLogger()
3090             # Original logger output is empty
3102             logger = logging.getLogger("compiler.parser")
3104             logger.info(self.next_message())
3105             logger.error(self.next_message())
3110             # Original logger output is empty.
3114             logger = logging.getLogger("compiler.parser")
3115             self.assertTrue(logger.disabled)
3116             logger = logging.getLogger("compiler.lexer")
3118             logger.info(self.next_message())
3119             logger.error(self.next_message())
3124             # Original logger output is empty.
3131             logger = logging.getLogger("compiler.parser")
3133             logger.info(self.next_message())
3134             logger.error(self.next_message())
3139             # Original logger output is empty.
3143             logger = logging.getLogger("compiler.parser")
3144             self.assertFalse(logger.disabled)
3146             logger.info(self.next_message())
3147             logger.error(self.next_message())
3148             logger = logging.getLogger("compiler.lexer")
3150             logger.info(self.next_message())
3151             logger.error(self.next_message())
3158             # Original logger output is empty.
3164             logger = logging.getLogger("compiler.parser")
3172             logger.info(self.next_message())
3173             logger.error(self.next_message())
3180             # Original logger output is empty.
3184             logger = logging.getLogger("compiler.parser")
3185             self.assertFalse(logger.disabled)
3187             logger.info(self.next_message())
3188             logger.error(self.next_message())
3189             logger = logging.getLogger("compiler.lexer")
3191             logger.info(self.next_message())
3192             logger.error(self.next_message())
3201             # Original logger output is empty.
3207             logger = logging.getLogger("compiler.parser")
3208             # Nothing will be output since both handler and logger are set to WARNING
3209             logger.info(self.next_message())
3213             logger.info(self.next_message())
3217             logger.info(self.next_message())
3225             logger = logging.getLogger("compiler.parser")
3226             logger.warning(self.next_message())
3227             logger = logging.getLogger('compiler')
3229             logger.warning(self.next_message())
3230             logger = logging.getLogger('compiler.lexer')
3232             logger.warning(self.next_message())
3233             logger = logging.getLogger("compiler.parser.codegen")
3235             logger.error(self.next_message())
3321             logger = logging.getLogger("compiler.parser")
3322             logger.warning(self.next_message())
3323             logger = logging.getLogger('compiler')
3325             logger.warning(self.next_message())
3326             logger = logging.getLogger('compiler.lexer')
3328             logger.warning(self.next_message())
3329             logger = logging.getLogger("compiler.parser.codegen")
3331             logger.error(self.next_message())
3341             logger = logging.getLogger("compiler.parser")
3343             logger.info(self.next_message())
3344             logger.error(self.next_message())
3349             # Original logger output is empty.
3361         logger = logging.getLogger("compiler.parser")
3369             logger.info(self.next_message())
3370             logger.error(self.next_message())
3372         # Original logger output has the stuff we logged.
3383             logger = logging.getLogger("compiler.parser")
3385             logger.info(self.next_message())
3386             logger.error(self.next_message())
3391         # Original logger output still has the stuff we logged before.
3401             logger = logging.getLogger("compiler.parser")
3403             logger.info(self.next_message())
3404             logger.error(self.next_message())
3409         # Original logger output still has the stuff we logged before.
3561         logger = logging.getLogger('a')
3562         self.assertFalse(logger.disabled)
3564         self.assertFalse(logger.disabled)
3567         self.assertTrue(logger.disabled)
3571         self.assertFalse(logger.disabled)
3584         logger = man.getLogger('test')
3585         logger.warning('should appear in logged')
3653     # Do not bother with a logger name group.
3775             Creates a logger with a QueueHandler that logs to a queue read by a
3779             logger = logging.getLogger('test_logger_with_id_%s' % ident)
3780             logger.setLevel(logging.DEBUG)
3782             logger.addHandler(handler)
3786             logger.info('one')
3787             logger.info('two')
3788             logger.info('three')
3789             logger.info('four')
3790             logger.info('five')
3793             logger.removeHandler(handler)
4232                 msg = 'No handlers could be found for logger "root"\n'
4453         logger = logging.getLogger('just_some_logger')
4457         logger.addHandler(h)
4459             logger.setLevel(logging.DEBUG)
4460             logger.debug("hello")
4466             logger.setLevel(logging.INFO)
4467             logger.debug("hello")
4470             logger.removeHandler(h)
4980         self.logger = logging.root
4981         self.logger.addHandler(self.recording)
4982         self.addCleanup(self.logger.removeHandler, self.recording)
4990         self.adapter = logging.LoggerAdapter(logger=self.logger, extra=None)
5033         old_disable = self.adapter.logger.manager.disable
5034         self.adapter.logger.manager.disable = 33
5035         self.addCleanup(setattr, self.adapter.logger.manager, 'disable',
5042         for handler in self.logger.handlers:
5043             self.logger.removeHandler(handler)
5045         self.assertFalse(self.logger.hasHandlers())
5056         adapter = Adapter(logger=self.logger, extra=None)
5057         adapter_adapter = Adapter(logger=adapter, extra=None)
5068         self.assertIs(self.logger.manager, orig_manager)
5074             self.assertIs(self.logger.manager, temp_manager)
5079         self.assertIs(self.logger.manager, orig_manager)
5087         self.logger = logging.Logger(name='blah')
5088         self.logger.addHandler(self.recording)
5089         self.addCleanup(self.logger.removeHandler, self.recording)
5096             self.logger.setLevel, None)
5099             self.logger.setLevel, (0, 0))
5108             self.logger.exception(msg, self.recording)
5120             self.assertRaises(TypeError, self.logger.log, '10', 'test message')
5124             self.logger.log('10', 'test message')  # no exception happens
5131         self.logger.findCaller(stack_info=True)
5138         trigger = self.logger.warning
5169         trigger = self.logger.warning
5184             self.assertRaises(KeyError, self.logger.makeRecord, name, level,
5193         result = self.logger.makeRecord(name, level, fn, lno, msg, args,
5198         self.assertTrue(self.logger.hasHandlers())
5200         for handler in self.logger.handlers:
5201             self.logger.removeHandler(handler)
5202         self.assertFalse(self.logger.hasHandlers())
5210         old_disable = self.logger.manager.disable
5211         self.logger.manager.disable = 23
5212         self.addCleanup(setattr, self.logger.manager, 'disable', old_disable)
5213         self.assertFalse(self.logger.isEnabledFor(22))
5216         old_disabled = self.logger.disabled
5217         old_disable = self.logger.manager.disable
5219         self.logger.disabled = True
5220         self.logger.manager.disable = 21
5222         self.addCleanup(setattr, self.logger, 'disabled', old_disabled)
5223         self.addCleanup(setattr, self.logger.manager, 'disable', old_disable)
5225         self.assertFalse(self.logger.isEnabledFor(22))
5247                 logger = logging.getLogger(name)
5248                 s = pickle.dumps(logger, proto)
5250                 self.assertIs(unpickled, logger)
5257         # Set root logger level and ensure cache is empty
5274         # Set parent logger level and ensure caches are emptied
5279         # Ensure logger2 uses parent logger's effective level

Indexes created Thu Nov 07 10:32:03 CST 2024