pkg/logging: added stackTrace support

pkg/logging/test/logging_test.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 
 library logging_test;
 
 import 'package:logging/logging.dart';
 import 'package:unittest/unittest.dart';
 
 main() {
   test('level comparison is a valid comparator', () {
     var level1 = const Level('NOT_REAL1', 253);
     expect(level1 == level1, isTrue);
     expect(level1 <= level1, isTrue);
     expect(level1 >= level1, isTrue);
     expect(level1 < level1, isFalse);
     expect(level1 > level1, isFalse);
 
     var level2 = const Level('NOT_REAL2', 455);
     expect(level1 <= level2, isTrue);
     expect(level1 < level2, isTrue);
     expect(level2 >= level1, isTrue);
     expect(level2 > level1, isTrue);
 
     var level3 = const Level('NOT_REAL3', 253);
-    expect(!identical(level1, level3), isTrue); // different instances
-    expect(level1 == level3, isTrue); // same value.
+    expect(level1, isNot(same(level3))); // different instances
+    expect(level1, equals(level3)); // same value.
   });
 
   test('default levels are in order', () {
     final levels = const [
         Level.ALL, Level.FINEST, Level.FINER, Level.FINE, Level.CONFIG,
         Level.INFO, Level.WARNING, Level.SEVERE, Level.SHOUT, Level.OFF
       ];
 
     for (int i = 0; i < levels.length; i++) {
       for (int j = i + 1; j < levels.length; j++) {
@@ skipping 14 matching lines @@
     expect(unsorted, isNot(orderedEquals(sorted)));
 
     unsorted.sort((a, b) => a.compareTo(b));
     expect(unsorted, orderedEquals(sorted));
   });
 
   test('levels are hashable', () {
     var map = new Map<Level, String>();
     map[Level.INFO] = 'info';
     map[Level.SHOUT] = 'shout';
-    expect(map[Level.INFO], equals('info'));
-    expect(map[Level.SHOUT], equals('shout'));
+    expect(map[Level.INFO], same('info'));
+    expect(map[Level.SHOUT], same('shout'));
   });
 
   test('logger name cannot start with a "." ', () {
     expect(() => new Logger('.c'), throws);
   });
 
   test('logger naming is hierarchical', () {
     Logger c = new Logger('a.b.c');
     expect(c.name, equals('c'));
     expect(c.parent.name, equals('b'));
     expect(c.parent.parent.name, equals('a'));
     expect(c.parent.parent.parent.name, equals(''));
     expect(c.parent.parent.parent.parent, isNull);
   });
 
   test('logger full name', () {
     Logger c = new Logger('a.b.c');
     expect(c.fullName, equals('a.b.c'));
     expect(c.parent.fullName, equals('a.b'));
     expect(c.parent.parent.fullName, equals('a'));
     expect(c.parent.parent.parent.fullName, equals(''));
     expect(c.parent.parent.parent.parent, isNull);
   });
 
   test('logger parent-child links are correct', () {
     Logger a = new Logger('a');
     Logger b = new Logger('a.b');
     Logger c = new Logger('a.c');
-    expect(a == b.parent, isTrue);
-    expect(a == c.parent, isTrue);
-    expect(a.children['b'] == b, isTrue);
-    expect(a.children['c'] == c, isTrue);
+    expect(a, same(b.parent));
+    expect(a, same(c.parent));
+    expect(a.children['b'], same(b));
+    expect(a.children['c'], same(c));
   });
 
   test('loggers are singletons', () {
     Logger a1 = new Logger('a');
     Logger a2 = new Logger('a');
     Logger b = new Logger('a.b');
     Logger root = Logger.root;
-    expect(identical(a1, a2), isTrue);
-    expect(identical(a1, b.parent), isTrue);
-    expect(identical(root, a1.parent), isTrue);
-    expect(identical(root, new Logger('')), isTrue);
+    expect(a1, same(a2));
+    expect(a1, same(b.parent));
+    expect(root, same(a1.parent));
+    expect(root, same(new Logger('')));
+  });
+
+  test('cannot directly manipulate Logger.children', () {
+    var loggerAB = new Logger('a.b');
+    var loggerA = loggerAB.parent;
+
+    expect(loggerA.children['b'], same(loggerAB), reason: 'can read Children');
+
+    expect(() {
+        loggerAB.children['test'] = null;
+    }, throwsUnsupportedError, reason: 'Children is read-only');
+  });
+
+  test('stackTrace gets throw to LogRecord', () {
+    Logger.root.level = Level.INFO;
+
+    var records = new List<LogRecord>();
+
+    var sub = Logger.root.onRecord.listen(records.add);
+
+    try {
+      throw new UnsupportedError('test exception');
+    } catch(error, stack) {
+      Logger.root.log(Level.SEVERE, 'severe', error, stack);
+      Logger.root.warning('warning', error, stack);
+    }
+
+    Logger.root.log(Level.SHOUT, 'shout');
+
+    sub.cancel();
+
+    expect(records, hasLength(3));
+
+    var severe = records[0];
+    expect(severe.message, 'severe');
+    expect(severe.error is UnsupportedError, isTrue);
+    expect(severe.stackTrace is StackTrace, isTrue);
+
+    var warning = records[1];
+    expect(warning.message, 'warning');
+    expect(warning.error is UnsupportedError, isTrue);
+    expect(warning.stackTrace is StackTrace, isTrue);
+
+    var shout = records[2];
+    expect(shout.message, 'shout');
+    expect(shout.error, isNull);
+    expect(shout.stackTrace, isNull);
   });
 
   group('mutating levels', () {
     Logger root = Logger.root;
     Logger a = new Logger('a');
     Logger b = new Logger('a.b');
     Logger c = new Logger('a.b.c');
     Logger d = new Logger('a.b.c.d');
     Logger e = new Logger('a.b.c.d.e');
 
     setUp(() {
       hierarchicalLoggingEnabled = true;
       root.level = Level.INFO;
       a.level = null;
       b.level = null;
       c.level = null;
       d.level = null;
       e.level = null;
       root.clearListeners();
       a.clearListeners();
       b.clearListeners();
       c.clearListeners();
       d.clearListeners();
       e.clearListeners();
       hierarchicalLoggingEnabled = false;
       root.level = Level.INFO;
     });
 
     test('cannot set level if hierarchy is disabled', () {
-      expect(() {a.level = Level.FINE;}, throws);
+      expect(() {a.level = Level.FINE;}, throwsUnsupportedError);
     });
 
     test('loggers effective level - no hierarchy', () {
       expect(root.level, equals(Level.INFO));
       expect(a.level, equals(Level.INFO));
       expect(b.level, equals(Level.INFO));
 
       root.level = Level.SHOUT;
 
       expect(root.level, equals(Level.SHOUT));
@@ skipping 21 matching lines @@
       hierarchicalLoggingEnabled = true;
       root.level = Level.SEVERE;
       c.level = Level.ALL;
       e.level = Level.OFF;
 
       expect(root.isLoggable(Level.SHOUT), isTrue);
       expect(root.isLoggable(Level.SEVERE), isTrue);
       expect(root.isLoggable(Level.WARNING), isFalse);
       expect(c.isLoggable(Level.FINEST), isTrue);
       expect(c.isLoggable(Level.FINE), isTrue);
-      expect(!e.isLoggable(Level.SHOUT), isTrue);
+      expect(e.isLoggable(Level.SHOUT), isFalse);
     });
 
     test('add/remove handlers - no hierarchy', () {
       int calls = 0;
       var handler = (_) { calls++; };
       final sub = c.onRecord.listen(handler);
       root.info("foo");
       root.info("foo");
       expect(calls, equals(2));
       sub.cancel();
@@ skipping 180 matching lines @@
             'SHOUT: 10']));
 
       expect(cMessages, equals([
             // 1 - 7 are lower in the hierarchy
             // 'FINE: 8' is not loggable
             'WARNING: 9',
             'SHOUT: 10']));
     });
   });
 }