Add tests which doesn't yet pass.

dart/tests/try/web/incremental_compilation_update_test.dart

 // Copyright (c) 2014, 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 trydart.incremental_compilation_update_test;
 
 import 'dart:html' hide
     Element;
 
 import 'dart:async' show
@@ skipping 140 matching lines @@
         const ProgramResult(
             """
 class C {
   m() {
     print('v1');
   }
 }
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
   instance.m();
 }
 """,
-            const <String> ['v1']),
+            const <String> ['instance is null', 'v1']),
         const ProgramResult(
             """
 class C {
   m() {
     print('v2');
   }
 }
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
   instance.m();
 }
 """,
             const <String> ['v2']),
     ],
 
     // Test that a stored instance tearoff changes behavior when updated.
     const <ProgramResult>[
         const ProgramResult(
             """
 class C {
   m() {
     print('v1');
   }
 }
 var closure;
 main() {
   if (closure == null) {
+    print('closure is null');
     closure = new C().m;
   }
   closure();
 }
 """,
-            const <String> ['v1']),
+            const <String> ['closure is null', 'v1']),
         const ProgramResult(
             """
 class C {
   m() {
     print('v2');
   }
 }
 var closure;
 main() {
   if (closure == null) {
+    print('closure is null');
     closure = new C().m;
   }
   closure();
 }
 """,
             const <String> ['v2']),
     ],
 
     // Test that deleting an instance method works.
     const <ProgramResult>[
         const ProgramResult(
             """
 class C {
   m() {
     print('v1');
   }
 }
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
   try {
     instance.m();
   } catch (e) {
-    print('v2');
+    print('threw');
   }
 }
 """,
-            const <String> ['v1']),
+            const <String> ['instance is null', 'v1']),
         const ProgramResult(
             """
 class C {
 }
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
   try {
     instance.m();
   } catch (e) {
-    print('v2');
+    print('threw');
   }
 }
 """,
-            const <String> ['v2']),
+            const <String> ['threw']),
     ],
 
     // Test that deleting an instance method works, even when accessed through
     // super.
     const <ProgramResult>[
         const ProgramResult(
             """
 class A {
   m() {
     print('v2');
   }
 }
 class B extends A {
   m() {
     print('v1');
   }
 }
 class C extends B {
   m() {
     super.m();
   }
 }
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
   instance.m();
 }
 """,
-            const <String> ['v1']),
+            const <String> ['instance is null', 'v1']),
         const ProgramResult(
             """
 class A {
   m() {
     print('v2');
   }
 }
 class B extends A {
 }
 class C extends B {
   m() {
     super.m();
   }
 }
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
   instance.m();
 }
 """,
             const <String> ['v2']),
     ],
 
     // Test that deleting a top-level method works.
     const <ProgramResult>[
         const ProgramResult(
             """
 toplevel() {
   print('v1');
 }
 class C {
   m() {
     try {
       toplevel();
     } catch (e) {
-      print('v2');
+      print('threw');
     }
   }
 }
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
   instance.m();
 }
 """,
-            const <String> ['v1']),
+            const <String> ['instance is null', 'v1']),
         const ProgramResult(
             """
 class C {
   m() {
     try {
       toplevel();
     } catch (e) {
-      print('v2');
+      print('threw');
     }
   }
 }
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
   instance.m();
 }
 """,
-            const <String> ['v2']),
+            const <String> ['threw']),
     ],
 
     // Test that deleting a static method works.
     const <ProgramResult>[
         const ProgramResult(
             """
 class B {
   static staticMethod() {
     print('v1');
   }
 }
 class C {
   m() {
     try {
       B.staticMethod();
     } catch (e) {
-      print('v2');
+      print('threw');
     }
     try {
       // Ensure that noSuchMethod support is compiled. This test is not about
       // adding new classes.
       B.missingMethod();
       print('bad');
     } catch (e) {
     }
   }
 }
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
   instance.m();
 }
 """,
-            const <String> ['v1']),
+            const <String> ['instance is null', 'v1']),
         const ProgramResult(
             """
 class B {
 }
 class C {
   m() {
     try {
       B.staticMethod();
     } catch (e) {
-      print('v2');
+      print('threw');
     }
     try {
       // Ensure that noSuchMethod support is compiled. This test is not about
       // adding new classes.
       B.missingMethod();
       print('bad');
     } catch (e) {
     }
   }
 }
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
   instance.m();
 }
 """,
-            const <String> ['v2']),
+            const <String> ['threw']),
     ],
 
     // Test that a newly instantiated class is handled.
     const <ProgramResult>[
         const ProgramResult(
             """
 class A {
   m() {
     print('Called A.m');
   }
 }
 
 class B {
   m() {
     print('Called B.m');
   }
 }
 
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new A();
-//   } else {
-//     instance = new B();
   }
   instance.m();
 }
 """,
-            const <String>['Called A.m']),
+            const <String>['instance is null', 'Called A.m']),
         const ProgramResult(
             """
 class A {
   m() {
     print('Called A.m');
   }
 }
 
 class B {
   m() {
     print('Called B.m');
   }
 }
 
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new A();
   } else {
     instance = new B();
   }
   instance.m();
 }
 """,
             const <String>['Called B.m']),
     ],
 
@@ skipping 30 matching lines @@
   }
 }
 
 class B extends A {
   get name => 'B.m';
 }
 
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new A();
-//   } else {
-//     instance = new B();
   }
   instance.m();
 }
 """,
-            const <String>['Called A.m']),
+            const <String>['instance is null', 'Called A.m']),
         const ProgramResult(
             r"""
 class A {
   get name => 'A.m';
 
   m() {
     print('Called $name');
   }
 }
 
 class B extends A {
   get name => 'B.m';
 }
 
 var instance;
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new A();
   } else {
     instance = new B();
   }
   instance.m();
 }
 """,
             const <String>['Called B.m']),
     ],
 
@@ skipping 41 matching lines @@
     ],
 
     // Test that top-level functions can be added.
     const <ProgramResult>[
         const ProgramResult(
             r"""
 main() {
   try {
     foo();
   } catch(e) {
-    print('v1');
+    print('threw');
   }
 }
 """,
-            const <String>['v1']),
+            const <String>['threw']),
         const ProgramResult(
             r"""
 foo() {
   print('v2');
 }
 
 main() {
   try {
     foo();
   } catch(e) {
-    print('v1');
+    print('threw');
   }
 }
 """,
             const <String>['v2']),
     ],
 
     // Test that static methods can be added.
     const <ProgramResult>[
         const ProgramResult(
             r"""
 class C {
 }
 
 main() {
   try {
     C.foo();
   } catch(e) {
-    print('v1');
+    print('threw');
   }
 }
 """,
-            const <String>['v1']),
+            const <String>['threw']),
         const ProgramResult(
             r"""
 class C {
   static foo() {
     print('v2');
   }
 }
 
 main() {
   try {
     C.foo();
   } catch(e) {
-    print('v1');
+    print('threw');
   }
 }
 """,
             const <String>['v2']),
     ],
 
     // Test that instance methods can be added.
     const <ProgramResult>[
         const ProgramResult(
             r"""
 class C {
 }
 
 var instance;
 
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
 
   try {
     instance.foo();
   } catch(e) {
-    print('v1');
+    print('threw');
   }
 }
 """,
-            const <String>['v1']),
+            const <String>['instance is null', 'threw']),
         const ProgramResult(
             r"""
 class C {
   foo() {
     print('v2');
   }
 }
 
 var instance;
 
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
 
   try {
     instance.foo();
   } catch(e) {
-    print('v1');
+    print('threw');
   }
 }
 """,
             const <String>['v2']),
     ],
 
     // Test that top-level functions can have signature changed.
     const <ProgramResult>[
         const ProgramResult(
             r"""
@@ skipping 56 matching lines @@
 class C {
   foo() {
     print('v1');
   }
 }
 
 var instance;
 
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
 
   instance.foo();
 }
 """,
-            const <String>['v1']),
+            const <String>['instance is null', 'v1']),
         const ProgramResult(
             r"""
 class C {
   void foo() {
     print('v2');
   }
 }
 
 var instance;
 
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
 
   instance.foo();
 }
 """,
             const <String>['v2']),
     ],
 
     // Test that adding a class is supported.
@@ skipping 100 matching lines @@
 class C extends B {
   m() {
     super.m();
   }
 }
 
 var instance;
 
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
   instance.m();
 }
 """,
-            const <String>['v1']),
+            const <String>['instance is null', 'v1']),
         const ProgramResult(
             r"""
 class A {
   m() {
     print('v2');
   }
 }
 class B extends A {
   m() {
     print('v1');
   }
 }
 class C extends A {
   m() {
     super.m();
   }
 }
 
 var instance;
 
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new C();
   }
   instance.m();
 }
 """,
             const <String>['v2']),
     ],
 
     // Test adding a field to a class works.
     const <ProgramResult>[
         const ProgramResult(
             r"""
 class A {
 }
 
 var instance;
 
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new A();
   }
   try {
     instance.x = 'v2';
   } catch(e) {
     print('setter threw');
   }
   try {
     print(instance.x);
   } catch (e) {
     print('getter threw');
   }
 }
 """,
-            const <String>['setter threw', 'getter threw']),
+            const <String>['instance is null', 'setter threw', 'getter threw']),
         const ProgramResult(
             r"""
 class A {
   var x;
 }
 
 var instance;
 
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new A();
   }
   try {
     instance.x = 'v2';
   } catch(e) {
     print('setter threw');
   }
   try {
     print(instance.x);
   } catch (e) {
     print('getter threw');
   }
 }
 """,
             const <String>['v2']),
     ],
 
     // Test removing a field from a class works.
-    // TODO(ahe): The emitter still see the field, and we need to ensure that
-    // old names aren't used again.
     const <ProgramResult>[
         const ProgramResult(
             r"""
 class A {
   var x;
 }
 
 var instance;
 
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new A();
   }
   try {
     instance.x = 'v1';
   } catch(e) {
     print('setter threw');
   }
   try {
     print(instance.x);
   } catch (e) {
     print('getter threw');
   }
 }
 """,
-            const <String>['v1']),
+            const <String>['instance is null', 'v1']),
         const ProgramResult(
             r"""
 class A {
 }
 
 var instance;
 
 main() {
   if (instance == null) {
+    print('instance is null');
     instance = new A();
   }
   try {
     instance.x = 'v1';
   } catch(e) {
     print('setter threw');
   }
   try {
     print(instance.x);
   } catch (e) {
     print('getter threw');
   }
 }
 """,
             const <String>['setter threw', 'getter threw']),
     ],
+
+    // Test that named arguments can be called.
+    // TODO(ahe): This test doesn't pass yet, see expectation below.
+    const <ProgramResult>[
+        const ProgramResult(
+            r"""
+class C {
+  foo({a, named: 'v1', x}) {
+    print(named);
+  }
+}
+
+var instance;
+
+main() {
+  if (instance == null) {
+    print('instance is null');
+    instance = new C();
+  }
+  try {
+    instance.foo();
+  } catch (e) {
+    // TODO(ahe): This try/catch shouldn't be necessary.
+    print('threw');
+  }
+}
+""",
+            const <String>['instance is null', 'v1']),
+        const ProgramResult(
+            r"""
+class C {
+  foo({a, named: 'v1', x}) {
+    print(named);
+  }
+}
+
+var instance;
+
+main() {
+  if (instance == null) {
+    print('instance is null');
+    instance = new C();
+  }
+  try {
+    instance.foo(named: 'v2');
+  } catch (e) {
+    // TODO(ahe): This try/catch shouldn't be necessary.
+    print('threw');
+  }
+}
+""",
+            const <String>['threw']), // TODO(ahe): Expect 'v2'.
+    ],
+
+    // Test than named arguments can be called.
+    // TODO(ahe): This test doesn't pass yet, see expectation below.
+    const <ProgramResult>[
+        const ProgramResult(
+            r"""
+class C {
+  foo({a, named: 'v2', x}) {
+    print(named);
+  }
+}
+
+var instance;
+
+main() {
+  if (instance == null) {
+    print('instance is null');
+    instance = new C();
+  }
+  try {
+    instance.foo(named: 'v1');
+  } catch (e) {
+    // TODO(ahe): This try/catch shouldn't be necessary.
+    print('threw');
+  }
+}
+""",
+            const <String>['instance is null', 'v1']),
+        const ProgramResult(
+            r"""
+class C {
+  foo({a, named: 'v2', x}) {
+    print(named);
+  }
+}
+
+var instance;
+
+main() {
+  if (instance == null) {
+    print('instance is null');
+    instance = new C();
+  }
+  try {
+    instance.foo();
+  } catch (e) {
+    // TODO(ahe): This try/catch shouldn't be necessary.
+    print('threw');
+  }
+}
+""",
+            const <String>['threw']),
+    ],
+
+    // Test that an instance tear-off with named parameters can be called.
+    // TODO(ahe): This test doesn't pass yet, see expectation below.
+    const <ProgramResult>[
+        const ProgramResult(
+            r"""
+class C {
+  foo({a, named: 'v1', x}) {
+    print(named);
+  }
+}
+
+var closure;
+
+main() {
+  if (closure == null) {
+    print('closure is null');
+    closure = new C().foo;
+  }
+  try {
+    closure();
+  } catch (e) {
+    // TODO(ahe): This try/catch shouldn't be necessary.
+    print('threw');
+  }
+}
+""",
+            const <String>['closure is null', 'v1']),
+        const ProgramResult(
+            r"""
+class C {
+  foo({a, named: 'v1', x}) {
+    print(named);
+  }
+}
+
+var closure;
+
+main() {
+  if (closure == null) {
+    print('closure is null');
+    closure = new C().foo;
+  }
+  try {
+    closure(named: 'v2');
+  } catch (e) {
+    // TODO(ahe): This try/catch shouldn't be necessary.
+    print('threw');
+  }
+}
+""",
+            const <String>['threw']), // TODO(ahe): Expect 'v2'.
+    ],
+
+/*
+    // Test that a lazy static is supported.
+    // TODO(ahe): This test doesn't pass yet.
+    const <ProgramResult>[
+        const ProgramResult(
+            r"""
+var normal;
+
+foo() {
+  print(normal);
+}
+
+main() {
+  if (normal == null) {
+    normal = 'v1';
+  } else {
+    normal = '';
+  }
+  foo();
+}
+""",
+            const <String>['v1']),
+        const ProgramResult(
+            r"""
+var normal;
+
+var lazy = bar();
+
+foo() {
+  print(lazy);
+}
+
+bar() {
+  print('v2');
+  return 'lazy';
+}
+
+main() {
+  if (normal == null) {
+    normal = 'v1';
+  } else {
+    normal = '';
+  }
+  foo();
+}
+""",
+            const <String>['v2', 'lazy']),
+    ],
+*/
 ];
 
 void main() {
   listener.start();
 
   document.head.append(lineNumberStyle());
 
-  return asyncTest(() => Future.forEach(tests, compileAndRun));
+  String query = window.location.search;
+  int skip = 0;
+  if (query != null && query.length > 1) {
+    query = query.substring(1);
+    String skipParam = Uri.splitQueryString(window.location.search)['skip'];
+    if (skipParam != null) {
+      skip = int.parse(skipParam);
+    }
+  }
+
+  return asyncTest(() => Future.forEach(tests.skip(skip), compileAndRun));
 }
 
 int testCount = 1;
 
 Future compileAndRun(List<ProgramResult> programs) {
   var status = new DivElement();
   document.body.append(status);
 
   IFrameElement iframe =
       appendIFrame(
@@ skipping 146 matching lines @@
   position: absolute;
   left: 0px;
   width: 3em;
   text-align: right;
   background-color: lightgoldenrodyellow;
 }
 ''');
   style.type = 'text/css';
   return style;
 }