Update the Angular/DI tests to latest from github.

third_party/pkg/angular/lib/core/interpolate.dart

 part of angular.core;
 
-String _startSymbol = '{{';
-String _endSymbol = '}}';
-int _startSymbolLength = _startSymbol.length;
-int _endSymbolLength = _endSymbol.length;
-
 class Interpolation {
   final String template;
   final List<String> seperators;
-  final List<Getter> watchExpressions;
+  final List<String> expressions;
   Function setter = (_) => _;
 
-  Interpolation(this.template, this.seperators, this.watchExpressions);
+  Interpolation(this.template, this.seperators, this.expressions);
 
-  String call(List parts, [_, __]) {
+  String call(List parts, [_]) {
+    if (parts == null) return seperators.join('');
     var str = [];
-    for(var i = 0, ii = parts.length; i < ii; i++) {
+    for (var i = 0; i < parts.length; i++) {
       str.add(seperators[i]);
       var value = parts[i];
       str.add(value == null ? '' : '$value');
     }
     str.add(seperators.last);
     return setter(str.join(''));
   }
 }
 
 /**
@@ skipping 12 matching lines @@
   Interpolate(this._parse);
 
   /**
    * Compiles markup text into interpolation function.
    *
    * - `text`: The markup text to interpolate in form `foo {{expr}} bar`.
    * - `mustHaveExpression`: if set to true then the interpolation string must
    *      have embedded expression in order to return an interpolation function.
    *      Strings with no embedded expression will return null for the
    *      interpolation function.
+   * - `startSymbol`: The symbol to start interpolation. '{{' by default.
+   * - `endSymbol`: The symbol to end interpolation. '}}' by default.
    */
-  Interpolation call(String template, [bool mustHaveExpression = false]) {
+  Interpolation call(String template, [bool mustHaveExpression = false,
+      String startSymbol = '{{', String endSymbol = '}}']) {
+    int startSymbolLength = startSymbol.length;
+    int endSymbolLength = endSymbol.length;
     int startIndex;
     int endIndex;
     int index = 0;
     int length = template.length;
     bool hasInterpolation = false;
     bool shouldAddSeparator = true;
     String exp;
     List<String> separators = [];
-    List<Getter> watchExpressions = [];
+    List<String> expressions = [];
 
     while(index < length) {
-      if ( ((startIndex = template.indexOf(_startSymbol, index)) != -1) &&
-           ((endIndex = template.indexOf(_endSymbol, startIndex + _startSymbolLength)) != -1) ) {
+      if ( ((startIndex = template.indexOf(startSymbol, index)) != -1) &&
+           ((endIndex = template.indexOf(endSymbol, startIndex + startSymbolLength)) != -1) ) {
         separators.add(template.substring(index, startIndex));
-        exp = template.substring(startIndex + _startSymbolLength, endIndex);
-        Expression expression = _parse(exp);
-        watchExpressions.add(expression.eval);
-        index = endIndex + _endSymbolLength;
+        exp = template.substring(startIndex + startSymbolLength, endIndex);
+        expressions.add(exp);
+        index = endIndex + endSymbolLength;
         hasInterpolation = true;
       } else {
         // we did not find anything, so we have to add the remainder to the chunks array
         separators.add(template.substring(index));
         shouldAddSeparator = false;
         break;
       }
     }
     if (shouldAddSeparator) {
       separators.add('');
     }
-    if (!mustHaveExpression  || hasInterpolation) {
-      return new Interpolation(template, separators, watchExpressions);
-    }
+    return (!mustHaveExpression || hasInterpolation)
+        ? new Interpolation(template, separators, expressions)
+        : null;
   }
 }