Incremental compilation: test giving up.

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 1381 matching lines @@
 }
 
 main() {
   print(const C('v2').value);
 }
 """,
             const <String>['v2']),
     ],
 
     // Test that an instance field can be added to a compound declaration.
-    // TODO(ahe): Test doesn't pass.
     const <ProgramResult>[
         const ProgramResult(
             r"""
 class C {
   int x;
 }
 
 var instance;
 
 main() {
@@ skipping 10 matching lines @@
     print('[instance.x] threw');
   }
   try {
     print(instance.y);
   } catch (e) {
     print('[instance.y] threw');
   }
 }
 """,
             const <String>['[instance] is null', 'v1', '[instance.y] threw']),
-/*
+
         const ProgramResult(
             r"""
 class C {
   int x, y;
 }
 
 var instance;
 
 main() {
   if (instance == null) {
     print('[instance] is null');
     instance = new C();
     instance.x = 'v1';
   } else {
     instance.y = 'v2';
   }
   try {
     print(instance.x);
   } catch (e) {
     print('[instance.x] threw');
   }
   try {
     print(instance.y);
   } catch (e) {
     print('[instance.y] threw');
   }
 }
 """,
-            const <String>['v1', 'v2']),
-*/
+            const <String>['v1', 'v2'],
+            // TODO(ahe): Shouldn't throw.
+            compileUpdatesShouldThrow: true),
+
     ],
 
     // Test that an instance field can be removed from a compound declaration.
-    // TODO(ahe): Test doesn't pass.
     const <ProgramResult>[
         const ProgramResult(
             r"""
 class C {
   int x, y;
 }
 
 var instance;
 
 main() {
   if (instance == null) {
     print('[instance] is null');
     instance = new C();
     instance.x = 'v1';
     instance.y = 'v2';
   }
   try {
     print(instance.x);
   } catch (e) {
     print('[instance.x] threw');
   }
   try {
     print(instance.y);
   } catch (e) {
     print('[instance.y] threw');
   }
 }
 """,
             const <String>['[instance] is null', 'v1', 'v2']),
-/*
+
         const ProgramResult(
             r"""
 class C {
   int x;
 }
 
 var instance;
 
 main() {
   if (instance == null) {
     print('[instance] is null');
     instance = new C();
     instance.x = 'v1';
     instance.y = 'v2';
   }
   try {
     print(instance.x);
   } catch (e) {
     print('[instance.x] threw');
   }
   try {
     print(instance.y);
   } catch (e) {
     print('[instance.y] threw');
   }
 }
 """,
-            const <String>['v1', '[instance.y] threw']),
-*/
+            const <String>['v1', '[instance.y] threw'],
+            // TODO(ahe): Shouldn't throw.
+            compileUpdatesShouldThrow: true),
     ],
 
     // Test that a static field can be made an instance field.
     // TODO(ahe): Test doesn't pass.
     const <ProgramResult>[
         const ProgramResult(
             r"""
 class C {
   static int x;
 }
@@ skipping 14 matching lines @@
     print('[C.x] threw');
   }
   try {
     print(instance.x);
   } catch (e) {
     print('[instance.x] threw');
   }
 }
 """,
             const <String>['[instance] is null', 'v1', '[instance.x] threw']),
-/*
+
         const ProgramResult(
             r"""
 class C {
   int x;
 }
 
 var instance;
 
 main() {
   if (instance == null) {
     print('[instance] is null');
     instance = new C();
     C.x = 'v1';
   } else {
     instance.x = 'v2';
   }
   try {
     print(C.x);
   } catch (e) {
     print('[C.x] threw');
   }
   try {
     print(instance.x);
   } catch (e) {
     print('[instance.x] threw');
   }
 }
 """,
-            const <String>['[C.x] threw', 'v2']),
-*/
+            const <String>['[C.x] threw', 'v2'],
+            // TODO(ahe): Shouldn't throw.
+            compileUpdatesShouldThrow: true),
     ],
 
     // Test that instance field can be made static.
-    // TODO(ahe): Test doesn't pass.
     const <ProgramResult>[
         const ProgramResult(
             r"""
 class C {
   int x;
 }
 
 var instance;
 
 main() {
@@ skipping 10 matching lines @@
     print('[C.x] threw');
   }
   try {
     print(instance.x);
   } catch (e) {
     print('[instance.x] threw');
   }
 }
 """,
             const <String>['[instance] is null', '[C.x] threw', 'v1']),
-/*
+
         const ProgramResult(
             r"""
 class C {
   static int x;
 }
 
 var instance;
 
 main() {
   if (instance == null) {
     print('[instance] is null');
     instance = new C();
     instance.x = 'v1';
   } else {
     C.x = 'v2';
   }
   try {
     print(C.x);
   } catch (e) {
     print('[C.x] threw');
   }
   try {
     print(instance.x);
   } catch (e) {
     print('[instance.x] threw');
   }
 }
 """,
-            const <String>['v2', '[instance.x] threw']),
-*/
+            const <String>['v2', '[instance.x] threw'],
+            // TODO(ahe): Shouldn't throw.
+            compileUpdatesShouldThrow: true),
     ],
 
     // Test compound constants.
     const <ProgramResult>[
         const ProgramResult(
             r"""
 class A {
   final value;
   const A(this.value);
 
@@ skipping 93 matching lines @@
 
   summary = new SpanElement();
   document.body.append(new HeadingElement.h1()
       ..appendText("Incremental compiler tests")
       ..append(summary));
 
   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);
+    String skipParameter = Uri.splitQueryString(window.location.search)['skip'];
+    if (skipParameter != null) {
+      skip = int.parse(skipParameter);
     }
+    String verboseParameter =
+        Uri.splitQueryString(window.location.search)['verbose'];
+    verboseStatus = verboseParameter != null;
   }
   testCount += skip;
 
   return asyncTest(() => Future.forEach(tests.skip(skip), compileAndRun)
       .then(updateSummary));
 }
 
 SpanElement summary;
 
 int testCount = 1;
 
+bool verboseStatus = false;
+
 void updateSummary(_) {
   summary.text = " (${testCount - 1}/${tests.length})";
 }
 
 Future compileAndRun(List<ProgramResult> programs) {
   updateSummary(null);
   var status = new DivElement();
   document.body.append(status);
 
   IFrameElement iframe =
@@ skipping 27 matching lines @@
 
           status.append(new HeadingElement.h2()..appendText("Update:"));
           status.append(numberedLines(program.code));
 
           WebInputProvider inputProvider =
               test.incrementalCompiler.inputProvider;
           Uri uri = test.scriptUri.resolve('?v${version++}');
           inputProvider.cachedSources[uri] = new Future.value(program.code);
           Future future = test.incrementalCompiler.compileUpdates(
               {test.scriptUri: uri}, logVerbose: logger, logTime: logger);
+          future = future.catchError((error, trace) {
+            String statusMessage;
+            Future result;
+            if (program.compileUpdatesShouldThrow) {
+              statusMessage = "Expected error in compileUpdates.";
+              result = null;
+            } else {
+              statusMessage = "Unexpected error in compileUpdates.";
+              result = new Future.error(error, trace);
+            }
+            status.append(new HeadingElement.h3()..appendText(statusMessage));
+            return result;
+          });
           return future.then((String update) {
+            if (program.compileUpdatesShouldThrow) {
+              Expect.isNull(update);
+              return null;
+            }
             print({'update': update});
             iframe.contentWindow.postMessage(['apply-update', update], '*');
 
             return listener.expect(
                 program.messagesWith('iframe-dart-updated-main-done'))
                 .then((_) {
                   return new SerializeScopeTestCase(
                       program.code, test.incrementalCompiler.mainApp,
                       test.incrementalCompiler.compiler).run();
                 });
           });
         });
       });
     });
   }).then((_) {
     status.style.color = 'limegreen';
 
     // Remove the iframe and status to work around a bug in test.dart
     // (https://code.google.com/p/dart/issues/detail?id=21691).
-    status.remove();
+    if (!verboseStatus) status.remove();
     iframe.remove();
   });
 }
 
 class SerializeScopeTestCase extends CompilerTestCase {
   final String scopeInfo;
 
   SerializeScopeTestCase(
       String source,
       LibraryElement library,
@@ skipping 51 matching lines @@
         ..classes.add("line");
     result.append(line);
   }
 
   return result;
 }
 
 
 StyleElement lineNumberStyle() {
   StyleElement style = new StyleElement()..appendText('''
-h2 {
+h2, h3 {
   color: black;
 }
 
 .output {
   padding: 0px;
   counter-reset: line-number;
   padding-bottom: 1em;
 }
 
 .line {
   white-space: pre-wrap;
   padding-left: 3.5em;
   margin-top: 0;
   margin-bottom: 0;
 }
 
 .line::before {
   counter-increment: line-number;
   content: counter(line-number) " ";
   position: absolute;
   left: 0px;
   width: 3em;
   text-align: right;
   background-color: lightgoldenrodyellow;
 }
 ''');
   style.type = 'text/css';
   return style;
 }