Modified unittest to use new argument syntax.

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');
 
 // TODO(rnystrom): Use "package:" import when test.dart supports it (#4968).
 #import('../lib/logging.dart');
 #import('../../../pkg/unittest/unittest.dart');
 
 main() {
   test('level comparison is a valid comparator', () {
     var level1 = const Level('NOT_REAL1', 253);
-    expect(level1 == level1);
-    expect(level1 <= level1);
-    expect(level1 >= level1);
+    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);
-    expect(level1 < level2);
-    expect(level2 >= level1);
-    expect(level2 > level1);
+    expect(level1 <= level2, isTrue);
+    expect(level1 < level2, isTrue);
+    expect(level2 >= level1, isTrue);
+    expect(level2 > level1, isTrue);
 
     var level3 = const Level('NOT_REAL3', 253);
-    expect(level1 !== level3); // different instances
-    expect(level1 == level3); // same value.
+    expect(level1 !== level3, isTrue); // different instances
+    expect(level1 == level3, isTrue); // 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++) {
-        expect(levels[i] < levels[j]);
+        expect(levels[i] < levels[j], isTrue);
       }
     }
   });
 
   test('levels are comparable', () {
     final unsorted = [
         Level.INFO, Level.CONFIG, Level.FINE, Level.SHOUT, Level.OFF,
         Level.FINER, Level.ALL, Level.WARNING, Level.FINEST,  Level.SEVERE,
       ];
     final sorted = const [
@@ skipping 33 matching lines @@
     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);
+    expect(a == b.parent, isTrue);
+    expect(a == c.parent, isTrue);
+    expect(a.children['b'] == b, isTrue);
+    expect(a.children['c'] == c, isTrue);
   });
 
   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(''));
+    expect(a1 === a2, isTrue);
+    expect(a1 === b.parent, isTrue);
+    expect(root === a1.parent, isTrue);
+    expect(root === new Logger(''), isTrue);
   });
 
   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');
 
@@ skipping 46 matching lines @@
       expect(b.level, equals(Level.FINE));
       expect(c.level, equals(Level.FINE));
     });
 
     test('isLoggable is appropriate', () {
       hierarchicalLoggingEnabled = 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));
+      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);
     });
 
     test('add/remove handlers - no hierarchy', () {
       int calls = 0;
       var handler = (_) { calls++; };
       c.on.record.add(handler);
       root.info("foo");
       root.info("foo");
       expect(calls, equals(2));
       c.on.record.remove(handler);
@@ skipping 137 matching lines @@
             'SHOUT: 10']));
 
       expect(cMessages, equals([
             // 1 - 7 are lower in the hierarchy
             // 'FINE: 8' is not loggable
             'WARNING: 9',
             'SHOUT: 10']));
     });
   });
 }