it('should parse the translations only once', () => {
      const transBundle = new TranslationBundle({}, null, () => 'id');
      spyOn(TranslationBundle, 'load').and.returnValue(transBundle);
      const htmlParser = new HtmlParser();
      const i18nHtmlParser = new I18NHtmlParser(htmlParser, 'translations');

      expect(TranslationBundle.load).toHaveBeenCalledTimes(1);

      i18nHtmlParser.parse('source', 'url');
      i18nHtmlParser.parse('source', 'url');
      expect(TranslationBundle.load).toHaveBeenCalledTimes(1);
    });

    it('should return the html nodes when no translations are given', () => {
      const htmlParser = new HtmlParser();
      const i18nHtmlParser = new I18NHtmlParser(htmlParser);
      const ptResult = new ParseTreeResult([], []);

      spyOn(htmlParser, 'parse').and.returnValue(ptResult);
      spyOn(i18nHtmlParser, 'parse').and.callThrough();

      expect(i18nHtmlParser.parse('source', 'url')).toBe(ptResult);

      expect(htmlParser.parse).toHaveBeenCalledTimes(1);
      expect(htmlParser.parse)
          .toHaveBeenCalledWith('source', 'url', jasmine.anything(), jasmine.anything());
    });

 getTemplateAst(template: TemplateSource, contextFile: string): AstResult {
   let result: AstResult;
   try {
     const resolvedMetadata =
         this.metadataResolver.getNonNormalizedDirectiveMetadata(template.type as any);
     const metadata = resolvedMetadata && resolvedMetadata.metadata;
     if (metadata) {
       const rawHtmlParser = new HtmlParser();
       const htmlParser = new I18NHtmlParser(rawHtmlParser);
       const expressionParser = new Parser(new Lexer());
       const config = new CompilerConfig();
       const parser = new TemplateParser(
           config, expressionParser, new DomElementSchemaRegistry(), htmlParser, null, []);
       const htmlResult = htmlParser.parse(template.source, '');
       const analyzedModules = this.host.getAnalyzedModules();
       let errors: Diagnostic[] = undefined;
       let ngModule = analyzedModules.ngModuleByPipeOrDirective.get(template.type);
       if (!ngModule) {
         // Reported by the the declaration diagnostics.
         ngModule = findSuitableDefaultModule(analyzedModules);
       }
       if (ngModule) {
         const resolvedDirectives = ngModule.transitiveModule.directives.map(
             d => this.host.resolver.getNonNormalizedDirectiveMetadata(d.reference));
         const directives =
             resolvedDirectives.filter(d => d !== null).map(d => d.metadata.toSummary());
         const pipes = ngModule.transitiveModule.pipes.map(
             p => this.host.resolver.getOrLoadPipeMetadata(p.reference).toSummary());
         const schemas = ngModule.schemas;
         const parseResult = parser.tryParseHtml(
             htmlResult, metadata, template.source, directives, pipes, schemas, '');
         result = {
           htmlAst: htmlResult.rootNodes,
           templateAst: parseResult.templateAst,
           directive: metadata, directives, pipes,
           parseErrors: parseResult.errors, expressionParser, errors
         };
       }
     }
   } catch (e) {
     let span = template.span;
     if (e.fileName == contextFile) {
       span = template.query.getSpanAt(e.line, e.column) || span;
     }
     result = {errors: [{kind: DiagnosticKind.Error, message: e.message, span}]};
   }
   return result;
 }