| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | |
| 2 // for details. All rights reserved. Use of this source code is governed by a | |
| 3 // BSD-style license that can be found in the LICENSE file. | |
| 4 | |
| 5 | |
| 6 library logging_test; | |
| 7 | |
| 8 import 'package:logging/logging.dart'; | |
| 9 import 'package:unittest/unittest.dart'; | |
| 10 | |
| 11 main() { | |
| 12 test('level comparison is a valid comparator', () { | |
| 13 var level1 = const Level('NOT_REAL1', 253); | |
| 14 expect(level1 == level1, isTrue); | |
| 15 expect(level1 <= level1, isTrue); | |
| 16 expect(level1 >= level1, isTrue); | |
| 17 expect(level1 < level1, isFalse); | |
| 18 expect(level1 > level1, isFalse); | |
| 19 | |
| 20 var level2 = const Level('NOT_REAL2', 455); | |
| 21 expect(level1 <= level2, isTrue); | |
| 22 expect(level1 < level2, isTrue); | |
| 23 expect(level2 >= level1, isTrue); | |
| 24 expect(level2 > level1, isTrue); | |
| 25 | |
| 26 var level3 = const Level('NOT_REAL3', 253); | |
| 27 expect(level1, isNot(same(level3))); // different instances | |
| 28 expect(level1, equals(level3)); // same value. | |
| 29 }); | |
| 30 | |
| 31 test('default levels are in order', () { | |
| 32 final levels = Level.LEVELS; | |
| 33 | |
| 34 for (int i = 0; i < levels.length; i++) { | |
| 35 for (int j = i + 1; j < levels.length; j++) { | |
| 36 expect(levels[i] < levels[j], isTrue); | |
| 37 } | |
| 38 } | |
| 39 }); | |
| 40 | |
| 41 test('levels are comparable', () { | |
| 42 final unsorted = [ | |
| 43 Level.INFO, Level.CONFIG, Level.FINE, Level.SHOUT, Level.OFF, | |
| 44 Level.FINER, Level.ALL, Level.WARNING, Level.FINEST, Level.SEVERE, | |
| 45 ]; | |
| 46 | |
| 47 final sorted = Level.LEVELS; | |
| 48 | |
| 49 expect(unsorted, isNot(orderedEquals(sorted))); | |
| 50 | |
| 51 unsorted.sort(); | |
| 52 expect(unsorted, orderedEquals(sorted)); | |
| 53 }); | |
| 54 | |
| 55 test('levels are hashable', () { | |
| 56 var map = new Map<Level, String>(); | |
| 57 map[Level.INFO] = 'info'; | |
| 58 map[Level.SHOUT] = 'shout'; | |
| 59 expect(map[Level.INFO], same('info')); | |
| 60 expect(map[Level.SHOUT], same('shout')); | |
| 61 }); | |
| 62 | |
| 63 test('logger name cannot start with a "." ', () { | |
| 64 expect(() => new Logger('.c'), throwsArgumentError); | |
| 65 }); | |
| 66 | |
| 67 test('logger naming is hierarchical', () { | |
| 68 Logger c = new Logger('a.b.c'); | |
| 69 expect(c.name, equals('c')); | |
| 70 expect(c.parent.name, equals('b')); | |
| 71 expect(c.parent.parent.name, equals('a')); | |
| 72 expect(c.parent.parent.parent.name, equals('')); | |
| 73 expect(c.parent.parent.parent.parent, isNull); | |
| 74 }); | |
| 75 | |
| 76 test('logger full name', () { | |
| 77 Logger c = new Logger('a.b.c'); | |
| 78 expect(c.fullName, equals('a.b.c')); | |
| 79 expect(c.parent.fullName, equals('a.b')); | |
| 80 expect(c.parent.parent.fullName, equals('a')); | |
| 81 expect(c.parent.parent.parent.fullName, equals('')); | |
| 82 expect(c.parent.parent.parent.parent, isNull); | |
| 83 }); | |
| 84 | |
| 85 test('logger parent-child links are correct', () { | |
| 86 Logger a = new Logger('a'); | |
| 87 Logger b = new Logger('a.b'); | |
| 88 Logger c = new Logger('a.c'); | |
| 89 expect(a, same(b.parent)); | |
| 90 expect(a, same(c.parent)); | |
| 91 expect(a.children['b'], same(b)); | |
| 92 expect(a.children['c'], same(c)); | |
| 93 }); | |
| 94 | |
| 95 test('loggers are singletons', () { | |
| 96 Logger a1 = new Logger('a'); | |
| 97 Logger a2 = new Logger('a'); | |
| 98 Logger b = new Logger('a.b'); | |
| 99 Logger root = Logger.root; | |
| 100 expect(a1, same(a2)); | |
| 101 expect(a1, same(b.parent)); | |
| 102 expect(root, same(a1.parent)); | |
| 103 expect(root, same(new Logger(''))); | |
| 104 }); | |
| 105 | |
| 106 test('cannot directly manipulate Logger.children', () { | |
| 107 var loggerAB = new Logger('a.b'); | |
| 108 var loggerA = loggerAB.parent; | |
| 109 | |
| 110 expect(loggerA.children['b'], same(loggerAB), reason: 'can read Children'); | |
| 111 | |
| 112 expect(() { | |
| 113 loggerAB.children['test'] = null; | |
| 114 }, throwsUnsupportedError, reason: 'Children is read-only'); | |
| 115 }); | |
| 116 | |
| 117 test('stackTrace gets throw to LogRecord', () { | |
| 118 Logger.root.level = Level.INFO; | |
| 119 | |
| 120 var records = new List<LogRecord>(); | |
| 121 | |
| 122 var sub = Logger.root.onRecord.listen(records.add); | |
| 123 | |
| 124 try { | |
| 125 throw new UnsupportedError('test exception'); | |
| 126 } catch(error, stack) { | |
| 127 Logger.root.log(Level.SEVERE, 'severe', error, stack); | |
| 128 Logger.root.warning('warning', error, stack); | |
| 129 } | |
| 130 | |
| 131 Logger.root.log(Level.SHOUT, 'shout'); | |
| 132 | |
| 133 sub.cancel(); | |
| 134 | |
| 135 expect(records, hasLength(3)); | |
| 136 | |
| 137 var severe = records[0]; | |
| 138 expect(severe.message, 'severe'); | |
| 139 expect(severe.error is UnsupportedError, isTrue); | |
| 140 expect(severe.stackTrace is StackTrace, isTrue); | |
| 141 | |
| 142 var warning = records[1]; | |
| 143 expect(warning.message, 'warning'); | |
| 144 expect(warning.error is UnsupportedError, isTrue); | |
| 145 expect(warning.stackTrace is StackTrace, isTrue); | |
| 146 | |
| 147 var shout = records[2]; | |
| 148 expect(shout.message, 'shout'); | |
| 149 expect(shout.error, isNull); | |
| 150 expect(shout.stackTrace, isNull); | |
| 151 }); | |
| 152 | |
| 153 group('mutating levels', () { | |
| 154 Logger root = Logger.root; | |
| 155 Logger a = new Logger('a'); | |
| 156 Logger b = new Logger('a.b'); | |
| 157 Logger c = new Logger('a.b.c'); | |
| 158 Logger d = new Logger('a.b.c.d'); | |
| 159 Logger e = new Logger('a.b.c.d.e'); | |
| 160 | |
| 161 setUp(() { | |
| 162 hierarchicalLoggingEnabled = true; | |
| 163 root.level = Level.INFO; | |
| 164 a.level = null; | |
| 165 b.level = null; | |
| 166 c.level = null; | |
| 167 d.level = null; | |
| 168 e.level = null; | |
| 169 root.clearListeners(); | |
| 170 a.clearListeners(); | |
| 171 b.clearListeners(); | |
| 172 c.clearListeners(); | |
| 173 d.clearListeners(); | |
| 174 e.clearListeners(); | |
| 175 hierarchicalLoggingEnabled = false; | |
| 176 root.level = Level.INFO; | |
| 177 }); | |
| 178 | |
| 179 test('cannot set level if hierarchy is disabled', () { | |
| 180 expect(() {a.level = Level.FINE;}, throwsUnsupportedError); | |
| 181 }); | |
| 182 | |
| 183 test('loggers effective level - no hierarchy', () { | |
| 184 expect(root.level, equals(Level.INFO)); | |
| 185 expect(a.level, equals(Level.INFO)); | |
| 186 expect(b.level, equals(Level.INFO)); | |
| 187 | |
| 188 root.level = Level.SHOUT; | |
| 189 | |
| 190 expect(root.level, equals(Level.SHOUT)); | |
| 191 expect(a.level, equals(Level.SHOUT)); | |
| 192 expect(b.level, equals(Level.SHOUT)); | |
| 193 }); | |
| 194 | |
| 195 test('loggers effective level - with hierarchy', () { | |
| 196 hierarchicalLoggingEnabled = true; | |
| 197 expect(root.level, equals(Level.INFO)); | |
| 198 expect(a.level, equals(Level.INFO)); | |
| 199 expect(b.level, equals(Level.INFO)); | |
| 200 expect(c.level, equals(Level.INFO)); | |
| 201 | |
| 202 root.level = Level.SHOUT; | |
| 203 b.level = Level.FINE; | |
| 204 | |
| 205 expect(root.level, equals(Level.SHOUT)); | |
| 206 expect(a.level, equals(Level.SHOUT)); | |
| 207 expect(b.level, equals(Level.FINE)); | |
| 208 expect(c.level, equals(Level.FINE)); | |
| 209 }); | |
| 210 | |
| 211 test('isLoggable is appropriate', () { | |
| 212 hierarchicalLoggingEnabled = true; | |
| 213 root.level = Level.SEVERE; | |
| 214 c.level = Level.ALL; | |
| 215 e.level = Level.OFF; | |
| 216 | |
| 217 expect(root.isLoggable(Level.SHOUT), isTrue); | |
| 218 expect(root.isLoggable(Level.SEVERE), isTrue); | |
| 219 expect(root.isLoggable(Level.WARNING), isFalse); | |
| 220 expect(c.isLoggable(Level.FINEST), isTrue); | |
| 221 expect(c.isLoggable(Level.FINE), isTrue); | |
| 222 expect(e.isLoggable(Level.SHOUT), isFalse); | |
| 223 }); | |
| 224 | |
| 225 test('add/remove handlers - no hierarchy', () { | |
| 226 int calls = 0; | |
| 227 var handler = (_) { calls++; }; | |
| 228 final sub = c.onRecord.listen(handler); | |
| 229 root.info("foo"); | |
| 230 root.info("foo"); | |
| 231 expect(calls, equals(2)); | |
| 232 sub.cancel(); | |
| 233 root.info("foo"); | |
| 234 expect(calls, equals(2)); | |
| 235 }); | |
| 236 | |
| 237 test('add/remove handlers - with hierarchy', () { | |
| 238 hierarchicalLoggingEnabled = true; | |
| 239 int calls = 0; | |
| 240 var handler = (_) { calls++; }; | |
| 241 c.onRecord.listen(handler); | |
| 242 root.info("foo"); | |
| 243 root.info("foo"); | |
| 244 expect(calls, equals(0)); | |
| 245 }); | |
| 246 | |
| 247 test('logging methods store appropriate level', () { | |
| 248 root.level = Level.ALL; | |
| 249 var rootMessages = []; | |
| 250 root.onRecord.listen((record) { | |
| 251 rootMessages.add('${record.level}: ${record.message}'); | |
| 252 }); | |
| 253 | |
| 254 root.finest('1'); | |
| 255 root.finer('2'); | |
| 256 root.fine('3'); | |
| 257 root.config('4'); | |
| 258 root.info('5'); | |
| 259 root.warning('6'); | |
| 260 root.severe('7'); | |
| 261 root.shout('8'); | |
| 262 | |
| 263 expect(rootMessages, equals([ | |
| 264 'FINEST: 1', | |
| 265 'FINER: 2', | |
| 266 'FINE: 3', | |
| 267 'CONFIG: 4', | |
| 268 'INFO: 5', | |
| 269 'WARNING: 6', | |
| 270 'SEVERE: 7', | |
| 271 'SHOUT: 8'])); | |
| 272 }); | |
| 273 | |
| 274 test('logging methods store exception', () { | |
| 275 root.level = Level.ALL; | |
| 276 var rootMessages = []; | |
| 277 root.onRecord.listen((r) { | |
| 278 rootMessages.add('${r.level}: ${r.message} ${r.error}'); | |
| 279 }); | |
| 280 | |
| 281 root.finest('1'); | |
| 282 root.finer('2'); | |
| 283 root.fine('3'); | |
| 284 root.config('4'); | |
| 285 root.info('5'); | |
| 286 root.warning('6'); | |
| 287 root.severe('7'); | |
| 288 root.shout('8'); | |
| 289 root.finest('1', 'a'); | |
| 290 root.finer('2', 'b'); | |
| 291 root.fine('3', ['c']); | |
| 292 root.config('4', 'd'); | |
| 293 root.info('5', 'e'); | |
| 294 root.warning('6', 'f'); | |
| 295 root.severe('7', 'g'); | |
| 296 root.shout('8', 'h'); | |
| 297 | |
| 298 expect(rootMessages, equals([ | |
| 299 'FINEST: 1 null', | |
| 300 'FINER: 2 null', | |
| 301 'FINE: 3 null', | |
| 302 'CONFIG: 4 null', | |
| 303 'INFO: 5 null', | |
| 304 'WARNING: 6 null', | |
| 305 'SEVERE: 7 null', | |
| 306 'SHOUT: 8 null', | |
| 307 'FINEST: 1 a', | |
| 308 'FINER: 2 b', | |
| 309 'FINE: 3 [c]', | |
| 310 'CONFIG: 4 d', | |
| 311 'INFO: 5 e', | |
| 312 'WARNING: 6 f', | |
| 313 'SEVERE: 7 g', | |
| 314 'SHOUT: 8 h'])); | |
| 315 }); | |
| 316 | |
| 317 test('message logging - no hierarchy', () { | |
| 318 root.level = Level.WARNING; | |
| 319 var rootMessages = []; | |
| 320 var aMessages = []; | |
| 321 var cMessages = []; | |
| 322 c.onRecord.listen((record) { | |
| 323 cMessages.add('${record.level}: ${record.message}'); | |
| 324 }); | |
| 325 a.onRecord.listen((record) { | |
| 326 aMessages.add('${record.level}: ${record.message}'); | |
| 327 }); | |
| 328 root.onRecord.listen((record) { | |
| 329 rootMessages.add('${record.level}: ${record.message}'); | |
| 330 }); | |
| 331 | |
| 332 root.info('1'); | |
| 333 root.fine('2'); | |
| 334 root.shout('3'); | |
| 335 | |
| 336 b.info('4'); | |
| 337 b.severe('5'); | |
| 338 b.warning('6'); | |
| 339 b.fine('7'); | |
| 340 | |
| 341 c.fine('8'); | |
| 342 c.warning('9'); | |
| 343 c.shout('10'); | |
| 344 | |
| 345 expect(rootMessages, equals([ | |
| 346 // 'INFO: 1' is not loggable | |
| 347 // 'FINE: 2' is not loggable | |
| 348 'SHOUT: 3', | |
| 349 // 'INFO: 4' is not loggable | |
| 350 'SEVERE: 5', | |
| 351 'WARNING: 6', | |
| 352 // 'FINE: 7' is not loggable | |
| 353 // 'FINE: 8' is not loggable | |
| 354 'WARNING: 9', | |
| 355 'SHOUT: 10'])); | |
| 356 | |
| 357 // no hierarchy means we all hear the same thing. | |
| 358 expect(aMessages, equals(rootMessages)); | |
| 359 expect(cMessages, equals(rootMessages)); | |
| 360 }); | |
| 361 | |
| 362 test('message logging - with hierarchy', () { | |
| 363 hierarchicalLoggingEnabled = true; | |
| 364 | |
| 365 b.level = Level.WARNING; | |
| 366 | |
| 367 var rootMessages = []; | |
| 368 var aMessages = []; | |
| 369 var cMessages = []; | |
| 370 c.onRecord.listen((record) { | |
| 371 cMessages.add('${record.level}: ${record.message}'); | |
| 372 }); | |
| 373 a.onRecord.listen((record) { | |
| 374 aMessages.add('${record.level}: ${record.message}'); | |
| 375 }); | |
| 376 root.onRecord.listen((record) { | |
| 377 rootMessages.add('${record.level}: ${record.message}'); | |
| 378 }); | |
| 379 | |
| 380 root.info('1'); | |
| 381 root.fine('2'); | |
| 382 root.shout('3'); | |
| 383 | |
| 384 b.info('4'); | |
| 385 b.severe('5'); | |
| 386 b.warning('6'); | |
| 387 b.fine('7'); | |
| 388 | |
| 389 c.fine('8'); | |
| 390 c.warning('9'); | |
| 391 c.shout('10'); | |
| 392 | |
| 393 expect(rootMessages, equals([ | |
| 394 'INFO: 1', | |
| 395 // 'FINE: 2' is not loggable | |
| 396 'SHOUT: 3', | |
| 397 // 'INFO: 4' is not loggable | |
| 398 'SEVERE: 5', | |
| 399 'WARNING: 6', | |
| 400 // 'FINE: 7' is not loggable | |
| 401 // 'FINE: 8' is not loggable | |
| 402 'WARNING: 9', | |
| 403 'SHOUT: 10'])); | |
| 404 | |
| 405 expect(aMessages, equals([ | |
| 406 // 1,2 and 3 are lower in the hierarchy | |
| 407 // 'INFO: 4' is not loggable | |
| 408 'SEVERE: 5', | |
| 409 'WARNING: 6', | |
| 410 // 'FINE: 7' is not loggable | |
| 411 // 'FINE: 8' is not loggable | |
| 412 'WARNING: 9', | |
| 413 'SHOUT: 10'])); | |
| 414 | |
| 415 expect(cMessages, equals([ | |
| 416 // 1 - 7 are lower in the hierarchy | |
| 417 // 'FINE: 8' is not loggable | |
| 418 'WARNING: 9', | |
| 419 'SHOUT: 10'])); | |
| 420 }); | |
| 421 | |
| 422 test('message logging - lazy functions', () { | |
| 423 root.level = Level.INFO; | |
| 424 var messages = []; | |
| 425 root.onRecord.listen((record) { | |
| 426 messages.add('${record.level}: ${record.message}'); | |
| 427 }); | |
| 428 | |
| 429 var callCount = 0; | |
| 430 var myClosure = () => "${++callCount}"; | |
| 431 | |
| 432 root.info(myClosure); | |
| 433 root.finer(myClosure); // Should not get evaluated. | |
| 434 root.warning(myClosure); | |
| 435 | |
| 436 expect(messages, equals([ | |
| 437 'INFO: 1', | |
| 438 'WARNING: 2',])); | |
| 439 }); | |
| 440 | |
| 441 test('message logging - calls toString', () { | |
| 442 root.level = Level.INFO; | |
| 443 var messages = []; | |
| 444 root.onRecord.listen((record) { | |
| 445 messages.add('${record.level}: ${record.message}'); | |
| 446 }); | |
| 447 | |
| 448 root.info(5); | |
| 449 root.info(false); | |
| 450 root.info([1, 2, 3]); | |
| 451 root.info(() => 10); | |
| 452 | |
| 453 expect(messages, equals([ | |
| 454 'INFO: 5', | |
| 455 'INFO: false', | |
| 456 'INFO: [1, 2, 3]', | |
| 457 'INFO: 10',])); | |
| 458 }); | |
| 459 }); | |
| 460 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 814113004:
Pull args, intl, logging, shelf, and source_maps out of the SDK. (Closed)
Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart