/**
  * Starts measuring
  */
 beginMeasure(): Promise<any> {
   return PromiseWrapper.all(this._metrics.map(metric => metric.beginMeasure()));
 }

 supports(promise): boolean { return PromiseWrapper.isPromise(promise); }

function AsyncParentLoader() {
  return PromiseWrapper.resolve(DummyParentComp);
}

 ref.spy('routerCanReuse').andCallFake((_) => PromiseWrapper.resolve(false));

 executeScript(script): Promise<string> { return PromiseWrapper.resolve('someUserAgent'); }

  _inlineImports(cssText: string, baseUrl: string, inlinedUrls: List<string>): Promise<string>|string {
    var partIndex = 0;
    var parts = StringWrapper.split(cssText, _importRe);

    if (parts.length === 1) {
      // no @import rule found, return the original css
      return cssText;
    }

    var promises = [];

    while (partIndex < parts.length - 1) {
      // prefix is the content before the @import rule
      var prefix = parts[partIndex];
      // rule is the parameter of the @import rule
      var rule = parts[partIndex + 1];
      var url = _extractUrl(rule);
      if (isPresent(url)) {
        url = this._urlResolver.resolve(baseUrl, url);
      }
      var mediaQuery = _extractMediaQuery(rule);
      var promise;

      if (isBlank(url)) {
        promise = PromiseWrapper.resolve(`/* Invalid import rule: "@import ${rule};" */`);
      } else if (ListWrapper.contains(inlinedUrls, url)) {
        // The current import rule has already been inlined, return the prefix only
        // Importing again might cause a circular dependency
        promise = PromiseWrapper.resolve(prefix);
      } else {
        ListWrapper.push(inlinedUrls, url);
        promise = PromiseWrapper.then(
          this._xhr.get(url),
          (css) => {
            // resolve nested @import rules
            css = this._inlineImports(css, url, inlinedUrls);
            if (PromiseWrapper.isPromise(css)) {
              // wait until nested @import are inlined
              return css.then((css) => {
                return prefix + this._transformImportedCss(css, mediaQuery, url) + '\n'
              }) ;
            } else {
              // there are no nested @import, return the css
              return prefix + this._transformImportedCss(css, mediaQuery, url) + '\n';
            }
          },
          (error) => `/* failed to import ${url} */\n`
        );
      }
      ListWrapper.push(promises, promise);
      partIndex += 2;
    }

    return PromiseWrapper.all(promises).then(function (cssParts) {
      var cssText = cssParts.join('');
      if (partIndex < parts.length) {
        // append then content located after the last @import rule
        cssText += parts[partIndex];
      }
      return cssText;
    });
  }

 reportSample(completeSample: MeasureValues[], validSample: MeasureValues[]): Promise<any[]> {
   return PromiseWrapper.all(
       this._reporters.map(reporter => reporter.reportSample(completeSample, validSample)));
 }

 routerOnActivate(next: ComponentInstruction, prev: ComponentInstruction): Promise<any> {
   completer = PromiseWrapper.completer();
   logHook('parent activate', next, prev);
   return completer.promise;
 }

 routerCanDeactivate(next: ComponentInstruction, prev: ComponentInstruction): Promise<boolean> {
   completer = PromiseWrapper.completer();
   logHook('routerCanDeactivate', next, prev);
   return completer.promise;
 }

 reportSample(completeSample: MeasureValues[], validSample: MeasureValues[]):
     Promise<{[key: string]: any}> {
   return PromiseWrapper.resolve(
       {'id': this._id, 'completeSample': completeSample, 'validSample': validSample});
 }