Update dart2js_foreign suite as we now validate annotations.

dart/tests/compiler/dart2js_foreign/native_exceptions1_test.dart

 // Copyright (c) 2011, 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.
 
 // Test that hidden native exception classes can be marked as existing.
 //
 // To infer which native hidden types exist, we need
 //   (1) return types of native methods and getters
 //   (2) argument types of callbacks
 //   (3) exceptions thrown by the operation.
 //
 // (1) and (2) can be achieved by having nicely typed native methods, but there
 // is no place in the Dart language to communicate (3).  So we use the following
 // fake body technique.
 
+import 'native_metadata.dart';
 
 // The exception type.
-@native("*E")
+@Native("*E")
 class E {
   @native E._used();  // Bogus native constructor, called only from fake body.
 
   final int code;
 }
 
 // Type with exception-throwing methods.
-@native("*A")
+@Native("*A")
 class A {
   @native op(int x) {
     // Fake body calls constructor to mark the exception class (E) as used.
     throw new E._used();
   }
 }
 
 // This class is here just so that a dynamic context is polymorphic.
 class B {
   int get code => 666;
   op(String x) => 123;
 }
 
 @native makeA();
 
-@native("""
+@Native("""
 // Ensure we are not relying on global names 'A' and 'E'.
 A = null;
 E = null;
 """)
 void setup1();
 
-@native("""
+@Native("""
 // This code is all inside 'setup2' and so not accesible from the global scope.
 function E(x){ this.code = x; }
 
 function A(){}
 A.prototype.op = function (x) {
   if (x & 1) throw new E(100);
   return  x / 2;
 };
 makeA = function(){return new A};
 """)
@@ skipping 34 matching lines @@
   threw = false;
   try {
     var x = aa.op(51);
   } on E catch (e) {
     threw = true;
     Expect.equals(100, e.code);
     Expect.isTrue(e is E);
   }
   Expect.isTrue(threw);
 }