Add location information to watchers to make them more debuggable.

test/watcher_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.
 
 /** Tests for the watcher library. */
 library watcher_test;
 
 import 'dart:collection';
 import 'package:unittest/compact_vm_config.dart';
 import 'package:unittest/unittest.dart';
 import 'package:web_ui/watcher.dart';
+import 'package:logging/logging.dart';
+import 'package:stack_trace/stack_trace.dart';
 
 main() {
   useCompactVMConfiguration();
 
   group('core', () {
     test('simple watcher ', () {
       int x = 0;
       int valueSeen = null;
       var stop = watch(() => x, expectAsync1((_) { valueSeen = x; }));
       x = 22;
@@ skipping 75 matching lines @@
       x = 12;
       dispatch();
       expect(oldValue, 1);
       expect(newValue, 12);
       x = 14;
       dispatch();
       expect(oldValue, 12);
       expect(newValue, 14);
       stop();
     });
+
+    test('loop is detected', () {
+      int x = 0;
+      var oldValue;
+      var newValue;
+      var stop = watch(() => x, expectAsync1((e) {
+        x++;
+        oldValue = e.oldValue;
+        newValue = e.newValue;
+      }, count: maxNumIterations));
+      var subscription = Logger.root.onRecord.listen(expectAsync1((record) {
+        expect(record.message, startsWith('Possible loop in watchers'));
+      }));
+      x = 1;
+      dispatch();
+      expect(oldValue, maxNumIterations - 1);
+      expect(newValue, maxNumIterations);
+      stop();
+      subscription.cancel();
+    });
+
+    group('loops can be debugged', () {
+      var messages;
+      var subscription;
+      setUp(() {
+        verboseDebugMessages = true;
+        messages = [];
+        subscription = Logger.root.onRecord.listen((record) {
+          messages.add(record.message);
+        });
+      });
+
+      tearDown(() {
+        subscription.cancel();
+        verboseDebugMessages = false;
+      });
+
+      test('no debug name', () {
+        int x = 0;
+        var oldValue;
+        var newValue;
+        // Note: the next line number (151) is recorded in the debug messages
+        var stop = watch(() => x, expectAsync1((e) {
+          x++;
+          oldValue = e.oldValue;
+          newValue = e.newValue;
+        }, count: maxNumIterations));
+        x = 1;
+        dispatch();
+        expect(oldValue, maxNumIterations - 1);
+        expect(newValue, maxNumIterations);
+        expect(messages.length, maxNumIterations + 1);
+
+        // First message contains details of the definition of a callback:
+        var first = messages.first;
+        expect(first, contains('defined at'));
+        expect(first, contains('watcher_test.dart:151:25'));
+
+        // The id is based on some global numbering, read the id, and see that
+        // it is mentioned on every other message:
+        var regExp = new RegExp('(\\(id: #[0-9]*\\))');
+        var match = regExp.firstMatch(first);
+        expect(match, isNotNull);
+        var id = match.group(1);
+        for (int i = 1; i < maxNumIterations - 1; i++) {
+          expect(messages[i], 'watcher updated: <unnamed> $id');
+        }
+        expect(messages.last, startsWith('Possible loop in watchers'));
+        stop();
+      });
+
+      test('debug name provided', () {
+        readCurrentStackTrace = () {
+          try { throw "" ; } catch (e, trace) {
+            return new Trace.from(trace).terse.toString();
+          }
+        };
+        var messages = [];
+        var subscription = Logger.root.onRecord.listen((record) {
+          messages.add(record.message);
+        });
+        int x = 0;
+        var oldValue;
+        var newValue;
+        // Note: the next line number (194) is recorded in the debug messages
+        var stop = watch(() => x, expectAsync1((e) {
+          x++;
+          oldValue = e.oldValue;
+          newValue = e.newValue;
+        }, count: maxNumIterations), 'my-debug-name');
+        x = 1;
+        dispatch();
+        expect(oldValue, maxNumIterations - 1);
+        expect(newValue, maxNumIterations);
+        expect(messages.length, maxNumIterations + 1);
+
+        // First message contains details of the definition of a callback:
+        var first = messages.first;
+        expect(first, contains('defined at'));
+        expect(first, contains('watcher_test.dart 194:25'));
+
+        // The id is based on some global numbering, read the id, and see that
+        // it is mentioned on every other message:
+        var regExp = new RegExp('my-debug-name (\\(id: #[0-9]*\\))');
+        var match = regExp.firstMatch(first);
+        expect(match, isNotNull);
+        var id = match.group(1);
+        for (int i = 1; i < maxNumIterations - 1; i++) {
+          expect(messages[i], 'watcher updated: my-debug-name $id');
+        }
+        expect(messages.last, startsWith('Possible loop in watchers'));
+        stop();
+      });
+    });
   });
 
   group('fields', () {
     test('watch changes to shallow fields', () {
       B b = new B(3);
       int value = null;
       var stop = watch(() => b.c,
         expectAsync1((_) { value = b.c; }, count: 2));
       b.c = 5;
       dispatch();
@@ skipping 240 matching lines @@
 }
 
 class A {
   B b = new B(3);
 }
 
 class B {
   int c;
   B(this.c);
 }