Update MockSdk to be more consistent with the actual SDK, switch x_Driver tests to it.

pkg/analyzer/test/src/context/mock_sdk.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 analyzer.test.src.context.mock_sdk;
 
 import 'package:analyzer/file_system/file_system.dart' as resource;
 import 'package:analyzer/file_system/memory_file_system.dart' as resource;
 import 'package:analyzer/src/context/cache.dart';
 import 'package:analyzer/src/context/context.dart';
@@ skipping 48 matching lines @@
   factory Completer.sync() => new _SyncCompleter<T>();
   Future<T> get future;
   void complete([value]);
   void completeError(Object error, [StackTrace stackTrace]);
   bool get isCompleted;
 }
 ''',
     const <String, String>{
       '$sdkRoot/lib/async/stream.dart': r'''
 part of dart.async;
+
 class Stream<T> {
   Future<T> get first;
+  StreamSubscription<T> listen(void onData(T event),
+                               { Function onError,
+                                 void onDone(),
+                                 bool cancelOnError});
 }
+
+abstract class StreamSubscription<T> {
+  Future cancel();
+  void onData(void handleData(T data));
+  void onError(Function handleError);
+  void onDone(void handleDone());
+  void pause([Future resumeSignal]);
+  void resume();
+  bool get isPaused;
+  Future<E> asFuture<E>([E futureValue]);
+}
+
 abstract class StreamTransformer<S, T> {}
 '''
     });
 
 const _MockSdkLibrary _LIB_COLLECTION = const _MockSdkLibrary(
     'dart:collection',
     '$sdkRoot/lib/collection/collection.dart',
     '''
 library dart.collection;
 
@@ skipping 17 matching lines @@
     '$sdkRoot/lib/core/core.dart',
     '''
 library dart.core;
 
 import 'dart:async';
 
 class Object {
   bool operator ==(other) => identical(this, other);
   String toString() => 'a string';
   int get hashCode => 0;
+  Type get runtimeType => null;
+  dynamic noSuchMethod(Invocation invocation) => null;
 }
 
 class Function {}
 class StackTrace {}
-class Symbol {}
+
+class Symbol {
+  const factory Symbol(String name) {
+    return null;
+  }
+}
+
 class Type {}
 
 abstract class Comparable<T> {
   int compareTo(T other);
 }
 
 abstract class Pattern {}
 abstract class String implements Comparable<String>, Pattern {
   external factory String.fromCharCodes(Iterable<int> charCodes,
                                         [int start = 0, int end]);
   String operator +(String other) => null;
   bool get isEmpty => false;
   bool get isNotEmpty => false;
   int get length => 0;
   String substring(int len) => null;
+  String toLowerCase();
   String toUpperCase();
   List<int> get codeUnits;
 }
 abstract class RegExp implements Pattern {
   external factory RegExp(String source);
 }
 
-class bool extends Object {}
+class bool extends Object {
+  external const factory bool.fromEnvironment(String name,
+                                              {bool defaultValue: false});
+}
+
+abstract class Invocation {}
+
 abstract class num implements Comparable<num> {
   bool operator <(num other);
   bool operator <=(num other);
   bool operator >(num other);
   bool operator >=(num other);
   num operator +(num other);
   num operator -(num other);
   num operator *(num other);
   num operator /(num other);
   int operator ^(int other);
-  int operator &(int other);
   int operator |(int other);
   int operator <<(int other);
   int operator >>(int other);
   int operator ~/(num other);
   num operator %(num other);
   int operator ~();
+  num operator -();
   int toInt();
   double toDouble();
   num abs();
   int round();
 }
 abstract class int extends num {
+  external const factory int.fromEnvironment(String name, {int defaultValue});
+
+  bool get isNegative;
   bool get isEven => false;
+
+  int operator &(int other);
+  int operator |(int other);
+  int operator ^(int other);
+  int operator ~();
+  int operator <<(int shiftAmount);
+  int operator >>(int shiftAmount);
+
   int operator -();
+
   external static int parse(String source,
                             { int radix,
                               int onError(String source) });
 }
 
 abstract class double extends num {
   static const double NAN = 0.0 / 0.0;
   static const double INFINITY = 1.0 / 0.0;
   static const double NEGATIVE_INFINITY = -INFINITY;
   static const double MIN_POSITIVE = 5e-324;
@@ skipping 15 matching lines @@
   int truncate();
   double roundToDouble();
   double floorToDouble();
   double ceilToDouble();
   double truncateToDouble();
   external static double parse(String source,
                                [double onError(String source)]);
 }
 
 class DateTime extends Object {}
-class Null extends Object {}
+
+class Null extends Object {
+  factory Null._uninstantiable() {
+    throw new UnsupportedError('class Null cannot be instantiated');
+  }
+}
 
 class Deprecated extends Object {
   final String expires;
   const Deprecated(this.expires);
 }
 const Object deprecated = const Deprecated("next release");
 
 class Iterator<E> {
   bool moveNext();
   E get current;
@@ skipping 18 matching lines @@
   List();
   void add(E value) {}
   void addAll(Iterable<E> iterable) {}
   E operator [](int index) => null;
   void operator []=(int index, E value) {}
   Iterator<E> get iterator => null;
   void clear() {}
 
   bool get isEmpty => false;
   E get first => null;
+  E get last => null;
 
   Iterable/*<R>*/ map/*<R>*/(/*=R*/ f(E e)) => null;
 
   /*=R*/ fold/*<R>*/(/*=R*/ initialValue,
       /*=R*/ combine(/*=R*/ previousValue, E element)) => null;
 
 }
 
 class Map<K, V> extends Object {
-  Iterable<K> get keys => null;
   V operator [](K key) => null;
   void operator []=(K key, V value) {}
+  Iterable<K> get keys => null;
+  int get length;
+  Iterable<V> get values;
 }
 
 external bool identical(Object a, Object b);
 
 void print(Object object) {}
 
 class _Proxy { const _Proxy(); }
 const Object proxy = const _Proxy();
 
 class _Override { const _Override(); }
@@ skipping 17 matching lines @@
     '''
 library dart.html;
 class HtmlElement {}
 ''');
 
 const _MockSdkLibrary _LIB_HTML_DARTIUM = const _MockSdkLibrary(
     'dart:html',
     '$sdkRoot/lib/html/dartium/html_dartium.dart',
     '''
 library dart.html;
-class HtmlElement {}
+
+abstract class HtmlElement {}
+
+abstract class CanvasElement extends HtmlElement {
+  Object getContext(String contextId, [Map attributes]);
+  CanvasRenderingContext2D get context2D;
+}
+
+abstract class class CanvasRenderingContext2D {}
+''');
+
+const _MockSdkLibrary _LIB_INTERCEPTORS = const _MockSdkLibrary(
+    'dart:_interceptors',
+    '$sdkRoot/lib/_internal/js_runtime/lib/interceptors.dart',
+    '''
+library dart._interceptors;
 ''');
 
 const _MockSdkLibrary _LIB_MATH = const _MockSdkLibrary(
     'dart:math',
     '$sdkRoot/lib/math/math.dart',
     '''
 library dart.math;
 
 const double E = 2.718281828459045;
 const double PI = 3.1415926535897932;
@@ skipping 14 matching lines @@
 
 const List<SdkLibrary> _LIBRARIES = const [
   _LIB_CORE,
   _LIB_ASYNC,
   _LIB_COLLECTION,
   _LIB_CONVERT,
   _LIB_FOREIGN_HELPER,
   _LIB_MATH,
   _LIB_HTML_DART2JS,
   _LIB_HTML_DARTIUM,
+  _LIB_INTERCEPTORS,
 ];
 
 class MockSdk implements DartSdk {
   static const Map<String, String> FULL_URI_MAP = const {
     "dart:core": "$sdkRoot/lib/core/core.dart",
     "dart:html": "$sdkRoot/lib/html/dartium/html_dartium.dart",
     "dart:async": "$sdkRoot/lib/async/async.dart",
     "dart:async/stream.dart": "$sdkRoot/lib/async/stream.dart",
     "dart:collection": "$sdkRoot/lib/collection/collection.dart",
     "dart:convert": "$sdkRoot/lib/convert/convert.dart",
     "dart:_foreign_helper": "$sdkRoot/lib/_foreign_helper/_foreign_helper.dart",
+    "dart:_interceptors":
+        "$sdkRoot/lib/_internal/js_runtime/lib/interceptors.dart",
     "dart:math": "$sdkRoot/lib/math/math.dart"
   };
 
   static const Map<String, String> NO_ASYNC_URI_MAP = const {
     "dart:core": "$sdkRoot/lib/core/core.dart",
   };
 
   final resource.MemoryResourceProvider provider;
 
   final Map<String, String> uriMap;
@@ skipping 196 matching lines @@
 
   @override
   AnalysisCache createCacheFromSourceFactory(SourceFactory factory) {
     if (factory == null) {
       return super.createCacheFromSourceFactory(factory);
     }
     return new AnalysisCache(
         <CachePartition>[AnalysisEngine.instance.partitionManager.forSdk(sdk)]);
   }
 }