first version of a logging library.

tests/lib/logging/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('../../../lib/logging/logging.dart');
+#import('../../../lib/unittest/unittest.dart');

[Jennifer Messerly, 2012/06/29 03:47:45]

do "package:" imports work yet?

[Siggi Cherem (dart-lang), 2012/06/29 18:34:48]

not until we rearrange the external repo & the SDK to have a package's directory

+
+main() {
+  test('level comparison is a valid comparator', () {
+    var level1 = const Level('NOT_REAL1', 253);
+    expect(level1 == level1);

[Jennifer Messerly, 2012/06/29 03:47:45]

use equals matcher?

+    expect(level1 <= level1);
+    expect(level1 >= level1);

[Jennifer Messerly, 2012/06/29 03:47:45]

add lessThan, lessThanOrEqual matchers?

(is there any reason to prefer matchers over direct operator calls for cases
like this?)

[gram, 2012/06/29 16:38:25]

Matchers will give better error messages.

[Siggi Cherem (dart-lang), 2012/06/29 18:34:48]

Unfortunately those matchers are smart and first check for == and then for <, so
they wont really test that <= is implemented correctly.

+    expect(level1 < level1, isFalse);
+    expect(level1 > level1, isFalse);
+
+    var level2 = const Level('NOT_REAL2', 455);
+    expect(level1 <= level2);
+    expect(level1 < level2);
+    expect(level2 >= level1);
+    expect(level2 > level1);

[Jennifer Messerly, 2012/06/29 03:47:45]

another test idea:

test('same value but different name not equal', () {
  var level1 = const Level('NOT_REAL1', 253);
  var level2 = const Level('NOT_REAL_EITHER', 253);
  expect(level2 != level1);
  // It's like comparing NaNs!
  expect(level2 < level1, isFalse);
  expect(level2 <= level1, isFalse);
  expect(level2 > level1, isFalse);
  expect(level2 >= level1, isFalse);
});

[gram, 2012/06/29 16:38:25]

I wonder - if the value is the same but the names are different, shouldn't they
still test as equal?

[Jennifer Messerly, 2012/06/29 17:37:13]

Yeah, I thought so too. But the code for the == seemed to explicitly check for
===.

Whatever the behavior is, it seems like a case worth testing :)

Oh! Another test: different instances (!==) but same name and value.

[Siggi Cherem (dart-lang), 2012/06/29 18:34:48]

changed the behavior to be == in value only. Added a test for it.

+  });
+
+  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++) {
+        expect(levels[i] < levels[j]);
+      }
+    }

[Jennifer Messerly, 2012/06/29 03:47:45]

another test:
#import('dart:coreimpl');

  // test they're comparable
  var map = new SplayTreeMap();
  for (var level in levels) {
    map[level] = level;
  }
  levels = map.getValues();
  for (int i = 1; i < levels.length; i++) {
    expect(levels[i - 1] < levels[i]);
  }

[Siggi Cherem (dart-lang), 2012/06/29 18:34:48]

added a test, but using simple list sorting instead...

+  });
+
+  test('logger naming is hierarchycal', () {

[gram, 2012/06/29 16:38:25]

hierarchical

[Siggi Cherem (dart-lang), 2012/06/29 18:34:48]

Done.

+    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);

[gram, 2012/06/29 16:38:25]

Can you explain the rationale why there are hierarchical names like this?

[gram, 2012/06/29 16:49:26]

I understand the intent I guess - it provides a way of controlling logging for a
subset of the logs that are grouped by function rather than by level. But it
seems quite complex, and I wonder if it would be simpler to just use a group
name (i.e. just one level of hierarchy), which could be implemented more simply.
For example, *nix logging systems do this (they have a log level and a log
'facility', which corresponds to a functional group).

[Siggi Cherem (dart-lang), 2012/06/29 18:34:48]

doing multilevel is something I have seen a lot in other logging libraries. I've
used this in the past to make an easy correlation of logs and the package/class
that is creating log entries. Then it is easy to filter log entries based on
classes, packages, subpackages, etc.

+  });
+
+  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);
+    expect(a == c.parent);
+    expect(a.children['b'] == b);
+    expect(a.children['c'] == 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(a1 === a2);
+    expect(a1 === b.parent);
+    expect(root === a1.parent);
+    expect(root === new Logger(''));
+  });
+
+  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(() {
+      Logger.enableHierarchyLogging = true;
+      root.level = Level.INFO;
+      a.level = null;
+      b.level = null;
+      c.level = null;
+      d.level = null;
+      e.level = null;
+      root.clearHandlers();
+      a.clearHandlers();
+      b.clearHandlers();
+      c.clearHandlers();
+      d.clearHandlers();
+      e.clearHandlers();
+      Logger.enableHierarchyLogging = false;
+      root.level = Level.INFO;
+    });
+
+    test('cannot set level if hierarchy is disabled', () {
+      expectThrow(() {a.level = Level.FINE;});
+    });
+
+    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));
+      expect(a.level, equals(Level.SHOUT));
+      expect(b.level, equals(Level.SHOUT));
+    });
+
+    test('loggers effective level - with hierarchy', () {
+      Logger.enableHierarchyLogging = true;
+      expect(root.level, equals(Level.INFO));
+      expect(a.level, equals(Level.INFO));
+      expect(b.level, equals(Level.INFO));
+      expect(c.level, equals(Level.INFO));
+
+      root.level = Level.SHOUT;
+      b.level = Level.FINE;
+
+      expect(root.level, equals(Level.SHOUT));
+      expect(a.level, equals(Level.SHOUT));
+      expect(b.level, equals(Level.FINE));
+      expect(c.level, equals(Level.FINE));
+    });
+
+    test('isLoggable is appropriate', () {
+      Logger.enableHierarchyLogging = true;
+      root.level = Level.SEVERE;
+      c.level = Level.ALL;
+      e.level = Level.OFF;
+
+      expect(root.isLoggable(Level.SHOUT));
+      expect(root.isLoggable(Level.SEVERE));
+      expect(!root.isLoggable(Level.WARNING));
+      expect(c.isLoggable(Level.FINEST));
+      expect(c.isLoggable(Level.FINE));
+      expect(!e.isLoggable(Level.SHOUT));
+    });
+
+    test('add/remove handlers - no hierarchy', () {
+      int calls = 0;
+      var handler = (_) { calls++; };
+      c.addHandler(handler);
+      root.info("foo");
+      root.info("foo");
+      expect(calls, equals(2));
+      c.removeHandler(handler);
+      root.info("foo");
+      expect(calls, equals(2));
+    });
+
+    test('add/remove handlers - with hierarchy', () {
+      Logger.enableHierarchyLogging = true;
+      int calls = 0;
+      var handler = (_) { calls++; };
+      c.addHandler(handler);
+      root.info("foo");
+      root.info("foo");
+      expect(calls, equals(0));
+    });
+
+    test('logging methods store appropriate level', () {
+      root.level = Level.ALL;
+      var rootMessages = [];
+      root.addHandler((record) {
+        rootMessages.add('${record.level}: ${record.message}');
+      });
+
+      root.finest('1');
+      root.finer('2');
+      root.fine('3');
+      root.config('4');
+      root.info('5');
+      root.warning('6');
+      root.severe('7');
+      root.shout('8');
+
+      expect(rootMessages, equals([
+        'FINEST: 1',
+        'FINER: 2',
+        'FINE: 3',
+        'CONFIG: 4',
+        'INFO: 5',
+        'WARNING: 6',
+        'SEVERE: 7',
+        'SHOUT: 8']));
+    });
+
+    test('message logging - no hierarchy', () {
+      root.level = Level.WARNING;
+      var rootMessages = [];
+      var aMessages = [];
+      var cMessages = [];
+      c.addHandler((record) {
+        cMessages.add('${record.level}: ${record.message}');
+      });
+      a.addHandler((record) {
+        aMessages.add('${record.level}: ${record.message}');
+      });
+      root.addHandler((record) {
+        rootMessages.add('${record.level}: ${record.message}');
+      });
+
+      root.info('1');
+      root.fine('2');
+      root.shout('3');
+
+      b.info('4');
+      b.severe('5');
+      b.warning('6');
+      b.fine('7');
+
+      c.fine('8');
+      c.warning('9');
+      c.shout('10');
+
+      expect(rootMessages, equals([
+            // 'INFO: 1' is not loggable
+            // 'FINE: 2' is not loggable
+            'SHOUT: 3',
+            // 'INFO: 4' is not loggable
+            'SEVERE: 5',
+            'WARNING: 6',
+            // 'FINE: 7' is not loggable
+            // 'FINE: 8' is not loggable
+            'WARNING: 9',
+            'SHOUT: 10']));
+
+      // no hierarchy means we all hear the same thing.
+      expect(aMessages, equals(rootMessages));
+      expect(cMessages, equals(rootMessages));
+    });
+
+    test('message logging - with hierarchy', () {
+      Logger.enableHierarchyLogging = true;
+
+      b.level = Level.WARNING;
+
+      var rootMessages = [];
+      var aMessages = [];
+      var cMessages = [];
+      c.addHandler((record) {
+        cMessages.add('${record.level}: ${record.message}');
+      });
+      a.addHandler((record) {
+        aMessages.add('${record.level}: ${record.message}');
+      });
+      root.addHandler((record) {
+        rootMessages.add('${record.level}: ${record.message}');
+      });
+
+      root.info('1');
+      root.fine('2');
+      root.shout('3');
+
+      b.info('4');
+      b.severe('5');
+      b.warning('6');
+      b.fine('7');
+
+      c.fine('8');
+      c.warning('9');
+      c.shout('10');
+
+      expect(rootMessages, equals([
+            'INFO: 1',
+            // 'FINE: 2' is not loggable
+            'SHOUT: 3',
+            // 'INFO: 4' is not loggable
+            'SEVERE: 5',
+            'WARNING: 6',
+            // 'FINE: 7' is not loggable
+            // 'FINE: 8' is not loggable
+            'WARNING: 9',
+            'SHOUT: 10']));
+
+      expect(aMessages, equals([
+            // 1,2 and 3 are lower in the hierarchy
+            // 'INFO: 4' is not loggable
+            'SEVERE: 5',
+            'WARNING: 6',
+            // 'FINE: 7' is not loggable
+            // 'FINE: 8' is not loggable
+            'WARNING: 9',
+            'SHOUT: 10']));
+
+      expect(cMessages, equals([
+            // 1 - 7 are lower in the hierarchy
+            // 'FINE: 8' is not loggable
+            'WARNING: 9',
+            'SHOUT: 10']));
+    });
+  });
+}