port Node.bind to bd0a0591920da9091b326627a46a104a92c7efe7

pkg/template_binding/test/template_element_test.dart

 // Copyright (c) 2013, 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 template_binding.test.template_element_test;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:html';
 import 'dart:math' as math;
@@ skipping 137 matching lines @@
     expect(div.nodes[1].text, '1');
     expect(div.nodes[2].text, '2');
     expect(div.nodes[3].text, '3');
   });
 
   observeTest('TextTemplateWithNullStringBinding', () {
     var div = createTestHtml('<template bind={{}}>a{{b}}c</template>');
     var model = toObservable({'b': 'B'});
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'aBc');
 
     model['b'] = 'b';
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.last.text, 'abc');
 
     model['b'] = null;
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.last.text, 'ac');
 
     model = null;
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     // setting model isn't observable.
     expect(div.nodes.last.text, 'ac');
   });
 
   observeTest('TextTemplateWithBindingPath', () {
     var div = createTestHtml(
         '<template bind="{{ data }}">a{{b}}c</template>');
     var model = toObservable({ 'data': {'b': 'B'} });
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'aBc');
 
     model['data']['b'] = 'b';
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.last.text, 'abc');
 
     model['data'] = toObservable({'b': 'X'});
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.last.text, 'aXc');
 
     model['data'] = null;
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.last.text, 'ac');
   });
 
   observeTest('TextTemplateWithBindingAndConditional', () {
     var div = createTestHtml(
         '<template bind="{{}}" if="{{ d }}">a{{b}}c</template>');
     var model = toObservable({'b': 'B', 'd': 1});
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'aBc');
 
     model['b'] = 'b';
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.last.text, 'abc');
 
     // TODO(jmesserly): MDV set this to empty string and relies on JS conversion
     // rules. Is that intended?
     // See https://github.com/toolkitchen/mdv/issues/59
     model['d'] = null;
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
 
     model['d'] = 'here';
     model['b'] = 'd';
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'adc');
   });
 
   observeTest('TemplateWithTextBinding2', () {
     var div = createTestHtml(
         '<template bind="{{ b }}">a{{value}}c</template>');
     expect(div.nodes.length, 1);
     var model = toObservable({'b': {'value': 'B'}});
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.nodes.last.text, 'aBc');
 
     model['b'] = toObservable({'value': 'b'});
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.last.text, 'abc');
   });
 
   observeTest('TemplateWithAttributeBinding', () {
     var div = createTestHtml(
         '<template bind="{{}}">'
         '<div foo="a{{b}}c"></div>'
         '</template>');
     var model = toObservable({'b': 'B'});
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.nodes.last.attributes['foo'], 'aBc');
 
     model['b'] = 'b';
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.last.attributes['foo'], 'abc');
 
     model['b'] = 'X';
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.last.attributes['foo'], 'aXc');
   });
 
   observeTest('TemplateWithConditionalBinding', () {
     var div = createTestHtml(
         '<template bind="{{}}">'
         '<div foo?="{{b}}"></div>'
         '</template>');
     var model = toObservable({'b': 'b'});
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.nodes.last.attributes['foo'], '');
     expect(div.nodes.last.attributes, isNot(contains('foo?')));
 
     model['b'] = null;
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.last.attributes, isNot(contains('foo')));
   });
 
   observeTest('Repeat', () {
     var div = createTestHtml(
         '<template repeat="{{}}"">text</template>');
 
     var model = toObservable([0, 1, 2]);
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 4);
 
     model.length = 1;
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
 
     model.addAll(toObservable([3, 4]));
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 4);
 
     model.removeRange(1, 2);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 3);
   });
 
   observeTest('Repeat - Reuse Instances', () {
     var div = createTestHtml('<template repeat>{{ val }}</template>');
 
     var model = toObservable([
       {'val': 10},
       {'val': 5},
       {'val': 2},
       {'val': 8},
       {'val': 1}
     ]);
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 6);
     var template = div.firstChild;
 
     addExpandos(template.nextNode);
     checkExpandos(template.nextNode);
 
     model.sort((a, b) => a['val'] - b['val']);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     checkExpandos(template.nextNode);
 
     model = toObservable(model.reversed);
     recursivelySetTemplateModel(div, model);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     checkExpandos(template.nextNode);
 
     for (var item in model) {
       item['val'] += 1;
     }
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes[1].text, "11");
     expect(div.nodes[2].text, "9");
     expect(div.nodes[3].text, "6");
     expect(div.nodes[4].text, "3");
     expect(div.nodes[5].text, "2");
   });
 
   observeTest('Bind - Reuse Instance', () {
     var div = createTestHtml(
         '<template bind="{{ foo }}">{{ bar }}</template>');
 
     var model = toObservable({ 'foo': { 'bar': 5 }});
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     var template = div.firstChild;
 
     addExpandos(template.nextNode);
     checkExpandos(template.nextNode);
 
     model = toObservable({'foo': model['foo']});
     recursivelySetTemplateModel(div, model);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     checkExpandos(template.nextNode);
   });
 
   observeTest('Repeat-Empty', () {
     var div = createTestHtml(
         '<template repeat>text</template>');
 
     var model = toObservable([0, 1, 2]);
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 4);
 
     model.length = 1;
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
 
     model.addAll(toObservable([3, 4]));
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 4);
 
     model.removeRange(1, 2);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 3);
   });
 
   observeTest('Removal from iteration needs to unbind', () {
     var div = createTestHtml(
         '<template repeat="{{}}"><a>{{v}}</a></template>');
     var model = toObservable([{'v': 0}, {'v': 1}, {'v': 2}, {'v': 3},
         {'v': 4}]);
     recursivelySetTemplateModel(div, model);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
 
     var nodes = div.nodes.skip(1).toList();
     var vs = model.toList();
 
     for (var i = 0; i < 5; i++) {
       expect(nodes[i].text, '$i');
     }
 
     model.length = 3;
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     for (var i = 0; i < 5; i++) {
       expect(nodes[i].text, '$i');
     }
 
     vs[3]['v'] = 33;
     vs[4]['v'] = 44;
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     for (var i = 0; i < 5; i++) {
       expect(nodes[i].text, '$i');
     }
   });
 
   observeTest('DOM Stability on Iteration', () {
     var div = createTestHtml(
         '<template repeat="{{}}">{{}}</template>');
     var model = toObservable([1, 2, 3, 4, 5]);
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
 
     // Note: the node at index 0 is the <template>.
     var nodes = div.nodes.toList();
     expect(nodes.length, 6, reason: 'list has 5 items');
 
     model.removeAt(0);
     model.removeLast();
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 4, reason: 'list has 3 items');
     expect(identical(div.nodes[1], nodes[2]), true, reason: '2 not removed');
     expect(identical(div.nodes[2], nodes[3]), true, reason: '3 not removed');
     expect(identical(div.nodes[3], nodes[4]), true, reason: '4 not removed');
 
     model.insert(0, 5);
     model[2] = 6;
     model.add(7);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
 
     expect(div.nodes.length, 6, reason: 'list has 5 items');
     expect(nodes.contains(div.nodes[1]), false, reason: '5 is a new node');
     expect(identical(div.nodes[2], nodes[2]), true);
     expect(nodes.contains(div.nodes[3]), false, reason: '6 is a new node');
     expect(identical(div.nodes[4], nodes[4]), true);
     expect(nodes.contains(div.nodes[5]), false, reason: '7 is a new node');
 
     nodes = div.nodes.toList();
 
     model.insert(2, 8);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
 
     expect(div.nodes.length, 7, reason: 'list has 6 items');
     expect(identical(div.nodes[1], nodes[1]), true);
     expect(identical(div.nodes[2], nodes[2]), true);
     expect(nodes.contains(div.nodes[3]), false, reason: '8 is a new node');
     expect(identical(div.nodes[4], nodes[3]), true);
     expect(identical(div.nodes[5], nodes[4]), true);
     expect(identical(div.nodes[6], nodes[5]), true);
   });
 
   observeTest('Repeat2', () {
     var div = createTestHtml(
         '<template repeat="{{}}">{{value}}</template>');
     expect(div.nodes.length, 1);
 
     var model = toObservable([
       {'value': 0},
       {'value': 1},
       {'value': 2}
     ]);
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 4);
     expect(div.nodes[1].text, '0');
     expect(div.nodes[2].text, '1');
     expect(div.nodes[3].text, '2');
 
     model[1]['value'] = 'One';
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 4);
     expect(div.nodes[1].text, '0');
     expect(div.nodes[2].text, 'One');
     expect(div.nodes[3].text, '2');
 
     model.replaceRange(0, 1, toObservable([{'value': 'Zero'}]));
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 4);
     expect(div.nodes[1].text, 'Zero');
     expect(div.nodes[2].text, 'One');
     expect(div.nodes[3].text, '2');
   });
 
   observeTest('TemplateWithInputValue', () {
     var div = createTestHtml(
         '<template bind="{{}}">'
         '<input value="{{x}}">'
         '</template>');
     var model = toObservable({'x': 'hi'});
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.nodes.last.value, 'hi');
 
     model['x'] = 'bye';
     expect(div.nodes.last.value, 'hi');
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.last.value, 'bye');
 
     div.nodes.last.value = 'hello';
     dispatchEvent('input', div.nodes.last);
     expect(model['x'], 'hello');
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.last.value, 'hello');
   });
 
 //////////////////////////////////////////////////////////////////////////////
 
   observeTest('Decorated', () {
     var div = createTestHtml(
         '<template bind="{{ XX }}" id="t1">'
           '<p>Crew member: {{name}}, Job title: {{title}}</p>'
         '</template>'
         '<template bind="{{ XY }}" id="t2" ref="t1"></template>');
 
     var model = toObservable({
       'XX': {'name': 'Leela', 'title': 'Captain'},
       'XY': {'name': 'Fry', 'title': 'Delivery boy'},
       'XZ': {'name': 'Zoidberg', 'title': 'Doctor'}
     });
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
 
     var t1 = document.getElementById('t1');
     var instance = t1.nextElementSibling;
     expect(instance.text, 'Crew member: Leela, Job title: Captain');
 
     var t2 = document.getElementById('t2');
     instance = t2.nextElementSibling;
     expect(instance.text, 'Crew member: Fry, Job title: Delivery boy');
 
     expect(div.children.length, 4);
@@ skipping 12 matching lines @@
 
     t.remove();
   });
 
 
   observeTest('Bind', () {
     var div = createTestHtml('<template bind="{{}}">Hi {{ name }}</template>');
     var model = toObservable({'name': 'Leela'});
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes[1].text, 'Hi Leela');
   });
 
   observeTest('BindImperative', () {
     var div = createTestHtml(
         '<template>'
           'Hi {{ name }}'
         '</template>');
     var t = div.nodes.first;
 
     var model = toObservable({'name': 'Leela'});
     nodeBind(t).bind('bind', model, '');
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes[1].text, 'Hi Leela');
   });
 
   observeTest('BindPlaceHolderHasNewLine', () {
     var div = createTestHtml(
         '<template bind="{{}}">Hi {{\nname\n}}</template>');
     var model = toObservable({'name': 'Leela'});
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes[1].text, 'Hi Leela');
   });
 
   observeTest('BindWithRef', () {
     var id = 't${new math.Random().nextDouble()}';
     var div = createTestHtml(
         '<template id="$id">'
           'Hi {{ name }}'
         '</template>'
         '<template ref="$id" bind="{{}}"></template>');
 
     var t1 = div.nodes.first;
     var t2 = div.nodes[1];
 
     expect(templateBind(t2).ref, t1);
 
     var model = toObservable({'name': 'Fry'});
     recursivelySetTemplateModel(div, model);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(t2.nextNode.text, 'Hi Fry');
   });
 
   observeTest('BindChanged', () {
     var model = toObservable({
       'XX': {'name': 'Leela', 'title': 'Captain'},
       'XY': {'name': 'Fry', 'title': 'Delivery boy'},
       'XZ': {'name': 'Zoidberg', 'title': 'Doctor'}
     });
 
     var div = createTestHtml(
         '<template bind="{{ XX }}">Hi {{ name }}</template>');
 
     recursivelySetTemplateModel(div, model);
 
     var t = div.nodes.first;
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
 
     expect(div.nodes.length, 2);
     expect(t.nextNode.text, 'Hi Leela');
 
     nodeBind(t).bind('bind', model, 'XZ');
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
 
     expect(div.nodes.length, 2);
     expect(t.nextNode.text, 'Hi Zoidberg');
   });
 
   assertNodesAre(div, [arguments]) {
     var expectedLength = arguments.length;
     expect(div.nodes.length, expectedLength + 1);
 
     for (var i = 0; i < arguments.length; i++) {
       var targetNode = div.nodes[i + 1];
       expect(targetNode.text, arguments[i]);
     }
   }
 
   observeTest('Repeat3', () {
     var div = createTestHtml(
         '<template repeat="{{ contacts }}">Hi {{ name }}</template>');
     var t = div.nodes.first;
 
     var m = toObservable({
       'contacts': [
         {'name': 'Raf'},
         {'name': 'Arv'},
         {'name': 'Neal'}
       ]
     });
 
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal']);
 
     m['contacts'].add(toObservable({'name': 'Alex'}));
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal', 'Hi Alex']);
 
     m['contacts'].replaceRange(0, 2,
         toObservable([{'name': 'Rafael'}, {'name': 'Erik'}]));
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Rafael', 'Hi Erik', 'Hi Neal', 'Hi Alex']);
 
     m['contacts'].removeRange(1, 3);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Rafael', 'Hi Alex']);
 
     m['contacts'].insertAll(1,
         toObservable([{'name': 'Erik'}, {'name': 'Dimitri'}]));
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Rafael', 'Hi Erik', 'Hi Dimitri', 'Hi Alex']);
 
     m['contacts'].replaceRange(0, 1,
         toObservable([{'name': 'Tab'}, {'name': 'Neal'}]));
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Tab', 'Hi Neal', 'Hi Erik', 'Hi Dimitri',
         'Hi Alex']);
 
     m['contacts'] = toObservable([{'name': 'Alex'}]);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Alex']);
 
     m['contacts'].length = 0;
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, []);
   });
 
   observeTest('RepeatModelSet', () {
     var div = createTestHtml(
         '<template repeat="{{ contacts }}">'
           'Hi {{ name }}'
         '</template>');
     var m = toObservable({
       'contacts': [
         {'name': 'Raf'},
         {'name': 'Arv'},
         {'name': 'Neal'}
       ]
     });
     recursivelySetTemplateModel(div, m);
 
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     var t = div.nodes.first;
 
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal']);
   });
 
   observeTest('RepeatEmptyPath', () {
     var div = createTestHtml(
         '<template repeat="{{}}">Hi {{ name }}</template>');
     var t = div.nodes.first;
 
     var m = toObservable([
       {'name': 'Raf'},
       {'name': 'Arv'},
       {'name': 'Neal'}
     ]);
     recursivelySetTemplateModel(div, m);
 
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal']);
 
     m.add(toObservable({'name': 'Alex'}));
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal', 'Hi Alex']);
 
     m.replaceRange(0, 2, toObservable([{'name': 'Rafael'}, {'name': 'Erik'}]));
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Rafael', 'Hi Erik', 'Hi Neal', 'Hi Alex']);
 
     m.removeRange(1, 3);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Rafael', 'Hi Alex']);
 
     m.insertAll(1, toObservable([{'name': 'Erik'}, {'name': 'Dimitri'}]));
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Rafael', 'Hi Erik', 'Hi Dimitri', 'Hi Alex']);
 
     m.replaceRange(0, 1, toObservable([{'name': 'Tab'}, {'name': 'Neal'}]));
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Tab', 'Hi Neal', 'Hi Erik', 'Hi Dimitri',
         'Hi Alex']);
 
     m.length = 0;
     m.add(toObservable({'name': 'Alex'}));
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Alex']);
   });
 
   observeTest('RepeatNullModel', () {
     var div = createTestHtml(
         '<template repeat="{{}}">Hi {{ name }}</template>');
     var t = div.nodes.first;
 
     var m = null;
     recursivelySetTemplateModel(div, m);
 
     expect(div.nodes.length, 1);
 
     t.attributes['iterate'] = '';
     m = toObservable({});
     recursivelySetTemplateModel(div, m);
 
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
   });
 
   observeTest('RepeatReuse', () {
     var div = createTestHtml(
         '<template repeat="{{}}">Hi {{ name }}</template>');
     var t = div.nodes.first;
 
     var m = toObservable([
       {'name': 'Raf'},
       {'name': 'Arv'},
       {'name': 'Neal'}
     ]);
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     assertNodesAre(div, ['Hi Raf', 'Hi Arv', 'Hi Neal']);
     var node1 = div.nodes[1];
     var node2 = div.nodes[2];
     var node3 = div.nodes[3];
 
     m.replaceRange(1, 2, toObservable([{'name': 'Erik'}]));
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Raf', 'Hi Erik', 'Hi Neal']);
     expect(div.nodes[1], node1,
         reason: 'model[0] did not change so the node should not have changed');
     expect(div.nodes[2], isNot(equals(node2)),
         reason: 'Should not reuse when replacing');
     expect(div.nodes[3], node3,
         reason: 'model[2] did not change so the node should not have changed');
 
     node2 = div.nodes[2];
     m.insert(0, toObservable({'name': 'Alex'}));
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     assertNodesAre(div, ['Hi Alex', 'Hi Raf', 'Hi Erik', 'Hi Neal']);
   });
 
   observeTest('TwoLevelsDeepBug', () {
     var div = createTestHtml(
       '<template bind="{{}}"><span><span>{{ foo }}</span></span></template>');
 
     var model = toObservable({'foo': 'bar'});
     recursivelySetTemplateModel(div, model);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
 
     expect(div.nodes[1].nodes[0].nodes[0].text, 'bar');
   });
 
   observeTest('Checked', () {
     var div = createTestHtml(
         '<template>'
           '<input type="checkbox" checked="{{a}}">'
         '</template>');
     var t = div.nodes.first;
     var m = toObservable({
       'a': true
     });
     nodeBind(t).bind('bind', m, '');
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     var instanceInput = t.nextNode;
     expect(instanceInput.checked, true);
 
     instanceInput.click();
     expect(instanceInput.checked, false);
 
     instanceInput.click();
     expect(instanceInput.checked, true);
   });
 
   nestedHelper(s, start) {
     var div = createTestHtml(s);
 
     var m = toObservable({
       'a': {
         'b': 1,
         'c': {'d': 2}
       },
     });
 
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     var i = start;
     expect(div.nodes[i++].text, '1');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, '2');
 
     m['a']['b'] = 11;
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     expect(div.nodes[start].text, '11');
 
     m['a']['c'] = toObservable({'d': 22});
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     expect(div.nodes[start + 2].text, '22');
   }
 
   observeTest('Nested', () {
     nestedHelper(
         '<template bind="{{a}}">'
           '{{b}}'
           '<template bind="{{c}}">'
             '{{d}}'
           '</template>'
@@ skipping 19 matching lines @@
           'c': {'d': 11}
         },
         {
           'b': 2,
           'c': {'d': 22}
         }
       ]
     });
 
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     var i = start;
     expect(div.nodes[i++].text, '1');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, '11');
     expect(div.nodes[i++].text, '2');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, '22');
 
     m['a'][1] = toObservable({
       'b': 3,
       'c': {'d': 33}
     });
 
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     expect(div.nodes[start + 3].text, '3');
     expect(div.nodes[start + 5].text, '33');
   }
 
   observeTest('NestedRepeatBind', () {
     nestedIterateInstantiateHelper(
         '<template repeat="{{a}}">'
           '{{b}}'
           '<template bind="{{c}}">'
             '{{d}}'
@@ skipping 22 matching lines @@
           'c': [{'d': 11}, {'d': 12}]
         },
         {
           'b': 2,
           'c': [{'d': 21}, {'d': 22}]
         }
       ]
     });
 
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     var i = start;
     expect(div.nodes[i++].text, '1');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, '11');
     expect(div.nodes[i++].text, '12');
     expect(div.nodes[i++].text, '2');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, '21');
     expect(div.nodes[i++].text, '22');
 
     m['a'][1] = toObservable({
       'b': 3,
       'c': [{'d': 31}, {'d': 32}, {'d': 33}]
     });
 
     i = start + 4;
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     expect(div.nodes[start + 4].text, '3');
     expect(div.nodes[start + 6].text, '31');
     expect(div.nodes[start + 7].text, '32');
     expect(div.nodes[start + 8].text, '33');
   }
 
   observeTest('NestedRepeatBind', () {
     nestedIterateIterateHelper(
         '<template repeat="{{a}}">'
           '{{b}}'
@@ skipping 39 matching lines @@
           }
         ]
       },
       {
         'name': 'Item 2',
         'items': []
       },
     ]);
 
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     var i = 1;
     expect(div.nodes[i++].text, 'Item 1');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, 'Item 1.1');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, 'Item 1.1.1');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, 'Item 1.2');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, 'Item 2');
 
     m[0] = toObservable({'name': 'Item 1 changed'});
 
     i = 1;
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     expect(div.nodes[i++].text, 'Item 1 changed');
     expect(div.nodes[i++].tagName, 'TEMPLATE');
     expect(div.nodes[i++].text, 'Item 2');
   });
 
   observeTest('Attribute Template Option/Optgroup', () {
     var div = createTestHtml(
         '<template bind>'
           '<select selectedIndex="{{ selected }}">'
             '<optgroup template repeat="{{ groups }}" label="{{ name }}">'
               '<option template repeat="{{ items }}">{{ val }}</option>'
             '</optgroup>'
           '</select>'
         '</template>');
 
     var m = toObservable({
       'selected': 1,
       'groups': [{
         'name': 'one', 'items': [{ 'val': 0 }, { 'val': 1 }]
       }],
     });
 
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     var select = div.nodes[0].nextNode;
     expect(select.nodes.length, 2);
 
     scheduleMicrotask(expectAsync0(() {
       scheduleMicrotask(expectAsync0(() {
         // TODO(jmesserly): this should be called sooner.
         expect(select.selectedIndex, 1);
       }));
     }));
@@ skipping 20 matching lines @@
             '</tr>'
           '</template>'
         '</tbody></table>');
 
     var m = toObservable([
       [{ 'val': 0 }, { 'val': 1 }],
       [{ 'val': 2 }, { 'val': 3 }]
     ]);
 
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     var tbody = div.nodes[0].nodes[0];
 
     // 1 for the <tr template>, 2 * (1 tr)
     expect(tbody.nodes.length, 3);
 
     // 1 for the <td template>, 2 * (1 td)
     expect(tbody.nodes[1].nodes.length, 3);
 
     expect(tbody.nodes[1].nodes[1].text, '0');
@@ skipping 16 matching lines @@
             '<td template repeat="{{}}" class="{{ val }}">{{ val }}</td>'
           '</tr>'
         '</tbody></table>');
 
     var m = toObservable([
       [{ 'val': 0 }, { 'val': 1 }],
       [{ 'val': 2 }, { 'val': 3 }]
     ]);
 
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     var i = 1;
     var tbody = div.nodes[0].nodes[0];
 
     // 1 for the <tr template>, 2 * (1 tr)
     expect(tbody.nodes.length, 3);
 
     // 1 for the <td template>, 2 * (1 td)
     expect(tbody.nodes[1].nodes.length, 3);
     expect(tbody.nodes[1].nodes[1].text, '0');
@@ skipping 27 matching lines @@
         'items': [
           {
             'name': 'Item 1.1'
           }
         ]
       }
     ]);
 
     recursivelySetTemplateModel(div, m);
 
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     m.removeAt(0);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
   });
 
   observeTest('DeepNested', () {
     var div = createTestHtml(
       '<template bind="{{a}}">'
         '<p>'
           '<template bind="{{b}}">'
             '{{ c }}'
           '</template>'
         '</p>'
       '</template>');
 
     var m = toObservable({
       'a': {
         'b': {
           'c': 42
         }
       }
     });
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     expect(div.nodes[1].tagName, 'P');
     expect(div.nodes[1].nodes.first.tagName, 'TEMPLATE');
     expect(div.nodes[1].nodes[1].text, '42');
   });
 
   observeTest('TemplateContentRemoved', () {
     var div = createTestHtml('<template bind="{{}}">{{ }}</template>');
     var model = 42;
 
     recursivelySetTemplateModel(div, model);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes[1].text, '42');
     expect(div.nodes[0].text, '');
   });
 
   observeTest('TemplateContentRemovedEmptyArray', () {
     var div = createTestHtml('<template iterate>Remove me</template>');
     var model = toObservable([]);
 
     recursivelySetTemplateModel(div, model);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
     expect(div.nodes[0].text, '');
   });
 
   observeTest('TemplateContentRemovedNested', () {
     var div = createTestHtml(
         '<template bind="{{}}">'
           '{{ a }}'
           '<template bind="{{}}">'
             '{{ b }}'
           '</template>'
         '</template>');
 
     var model = toObservable({
       'a': 1,
       'b': 2
     });
     recursivelySetTemplateModel(div, model);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
 
     expect(div.nodes[0].text, '');
     expect(div.nodes[1].text, '1');
     expect(div.nodes[2].text, '');
     expect(div.nodes[3].text, '2');
   });
 
   observeTest('BindWithUndefinedModel', () {
     var div = createTestHtml(
         '<template bind="{{}}" if="{{}}">{{ a }}</template>');
 
     var model = toObservable({'a': 42});
     recursivelySetTemplateModel(div, model);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes[1].text, '42');
 
     model = null;
     recursivelySetTemplateModel(div, model);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 1);
 
     model = toObservable({'a': 42});
     recursivelySetTemplateModel(div, model);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(div.nodes[1].text, '42');
   });
 
   observeTest('BindNested', () {
     var div = createTestHtml(
         '<template bind="{{}}">'
           'Name: {{ name }}'
           '<template bind="{{wife}}" if="{{wife}}">'
             'Wife: {{ name }}'
           '</template>'
           '<template bind="{{child}}" if="{{child}}">'
             'Child: {{ name }}'
           '</template>'
         '</template>');
 
     var m = toObservable({
       'name': 'Hermes',
       'wife': {
         'name': 'LaBarbara'
       }
     });
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     expect(div.nodes.length, 5);
     expect(div.nodes[1].text, 'Name: Hermes');
     expect(div.nodes[3].text, 'Wife: LaBarbara');
 
     m['child'] = toObservable({'name': 'Dwight'});
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 6);
     expect(div.nodes[5].text, 'Child: Dwight');
 
     m.remove('wife');
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 5);
     expect(div.nodes[4].text, 'Child: Dwight');
   });
 
   observeTest('BindRecursive', () {
     var div = createTestHtml(
         '<template bind="{{}}" if="{{}}" id="t">'
           'Name: {{ name }}'
           '<template bind="{{friend}}" if="{{friend}}" ref="t"></template>'
         '</template>');
 
     var m = toObservable({
       'name': 'Fry',
       'friend': {
         'name': 'Bender'
       }
     });
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     expect(div.nodes.length, 5);
     expect(div.nodes[1].text, 'Name: Fry');
     expect(div.nodes[3].text, 'Name: Bender');
 
     m['friend']['friend'] = toObservable({'name': 'Leela'});
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 7);
     expect(div.nodes[5].text, 'Name: Leela');
 
     m['friend'] = toObservable({'name': 'Leela'});
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 5);
     expect(div.nodes[3].text, 'Name: Leela');
   });
 
   observeTest('Template - Self is terminator', () {
     var div = createTestHtml(
         '<template repeat>{{ foo }}'
           '<template bind></template>'
         '</template>');
 
@@ skipping 56 matching lines @@
     // binding keys.
     var m = toObservable({
       'a': [
         [],
         { 'b': [1,2,3,4] },
         // Note: this will use the Map "length" property, not the "length" key.
         {'length': 42, 'c': 123}
       ]
     });
     recursivelySetTemplateModel(div, m);
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
 
     expect(div.nodes.length, 2);
     expect(div.nodes[1].text, '3');
 
     nodeBind(template)
         ..unbind('bind')
         ..bind('repeat', m, 'a');
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 4);
     expect(div.nodes[1].text, '0');
     expect(div.nodes[2].text, '1');
     expect(div.nodes[3].text, '2');
 
     nodeBind(template).unbind('repeat');
     nodeBind(template).bind('bind', m, 'a.1.b');
 
-    deliverChanges(m);
+    performMicrotaskCheckpoint();
     expect(div.nodes.length, 2);
     expect(div.nodes[1].text, '4');
   });
 
   observeTest('ChangeRefId', () {
     var div = createTestHtml(
         '<template id="a">a:{{ }}</template>'
         '<template id="b">b:{{ }}</template>'
         '<template repeat="{{}}">'
           '<template ref="a" bind="{{}}"></template>'
         '</template>');
     var model = toObservable([]);
     recursivelySetTemplateModel(div, model);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
 
     expect(div.nodes.length, 3);
 
     document.getElementById('a').id = 'old-a';
     document.getElementById('b').id = 'a';
 
     model..add(1)..add(2);
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
 
     expect(div.nodes.length, 7);
     expect(div.nodes[4].text, 'b:1');
     expect(div.nodes[6].text, 'b:2');
   });
 
   observeTest('Content', () {
     var div = createTestHtml(
         '<template><a></a></template>'
         '<template><b></b></template>');
@@ skipping 35 matching lines @@
     expect(templateBind(templateB).content.ownerDocument,
         templateBind(templateA).content.ownerDocument);
   });
 
   observeTest('BindShadowDOM', () {
     if (ShadowRoot.supported) {
       var root = createShadowTestHtml(
           '<template bind="{{}}">Hi {{ name }}</template>');
       var model = toObservable({'name': 'Leela'});
       recursivelySetTemplateModel(root, model);
-      deliverChanges(model);
+      performMicrotaskCheckpoint();
       expect(root.nodes[1].text, 'Hi Leela');
     }
   });
 
   observeTest('BindShadowDOM createInstance', () {
     if (ShadowRoot.supported) {
       var model = toObservable({'name': 'Leela'});
       var template = new Element.html('<template>Hi {{ name }}</template>');
       var root = createShadowTestHtml('');
       root.nodes.add(templateBind(template).createInstance(model));
@@ skipping 30 matching lines @@
     var model = toObservable({
       'outer': {
         'inner': {
           'age': 42
         }
       }
     });
 
     recursivelySetTemplateModel(div, model, syntax);
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(syntax.count, 1);
 
     var inner = model['outer']['inner'];
     model['outer'] = null;
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(syntax.count, 1);
 
     model['outer'] = toObservable({'inner': {'age': 2}});
     syntax.expectedAge = 2;
 
-    deliverChanges(model);
+    performMicrotaskCheckpoint();
     expect(syntax.count, 2);
   });
 
   // https://github.com/toolkitchen/mdv/issues/8
   observeTest('DontCreateInstancesForAbandonedIterators', () {
     var div = createTestHtml(
       '<template bind="{{}} {{}}">'
         '<template bind="{{}}">Foo'
         '</template>'
       '</template>');
@@ skipping 68 matching lines @@
   int count = 0;
 
   getBinding(model, path, name, node) {
     if (name != 'text' || path != 'age')
       return;
 
     expect(model['age'], expectedAge);
     count++;
   }
 }
-
-/**
- * Verifies that the model is Observable, then calls
- * [performMicrotaskCheckpoint].
- */
-void deliverChanges(model) {
-  expectObservable(model);
-  performMicrotaskCheckpoint();
-}
-
-void expectObservable(model) {
-  if (model is! Observable) {
-    // This is here to eagerly catch a bug in the test; it means the test
-    // forgot a toObservable somewhere.
-    expect(identical(toObservable(model), model), true,
-        reason: 'model type "${model.runtimeType}" should be observable');
-    return;
-  }
-  if (model is ObservableList) {
-    for (var item in model) {
-      expectObservable(item);
-    }
-  } else if (model is ObservableMap) {
-    model.forEach((k, v) {
-      expectObservable(k);
-      expectObservable(v);
-    });
-  }
-}
-
-_deepToSymbol(value) {
-  if (value is Map) {
-    var result = new LinkedHashMap();
-    value.forEach((k, v) {
-      k = k is String ? new Symbol(k) : _deepToSymbol(k);
-      result[k] = _deepToSymbol(v);
-    });
-    return result;
-  }
-  if (value is Iterable) {
-    return value.map(_deepToSymbol).toList();
-  }
-  return value;
-}