TypeScript DOM.getUserAgent方法代码示例

  inject,
  it,
  xdescribe,
  xit,
  Log,
  isInInnerZone
} from 'angular2/test_lib';

import {PromiseWrapper, TimerWrapper} from 'angular2/src/facade/async';
import {ListWrapper} from 'angular2/src/facade/collection';
import {BaseException} from 'angular2/src/facade/lang';
import {DOM} from 'angular2/src/dom/dom_adapter';

import {NgZone} from 'angular2/src/core/zone/ng_zone';

var isIE = DOM.getUserAgent().indexOf("Trident") > -1;
// Schedules a macrotask (using a timer)
function macroTask(fn: Function, timer = 1): void {
  // adds longer timers for passing tests in IE
  _zone.runOutsideAngular(() => TimerWrapper.setTimeout(fn, isIE ? timer : 1));
}

// Schedules a microtasks (using a resolved promise .then())
function microTask(fn: Function): void {
  PromiseWrapper.resolve(null).then((_) => { fn(); });
}

var _log;
var _errors;
var _traces;
var _zone;

  inject,
  it,
  xdescribe,
  xit,
  Log,
  isInInnerZone
} from 'angular2/test_lib';

import {PromiseCompleter, PromiseWrapper, TimerWrapper} from 'angular2/src/facade/async';
import {BaseException} from 'angular2/src/facade/lang';
import {DOM} from 'angular2/src/dom/dom_adapter';

import {NgZone} from 'angular2/src/core/zone/ng_zone';

var isIEorEdge =
    DOM.getUserAgent().indexOf("Trident") > -1 || DOM.getUserAgent().indexOf("Edge") > -1;
// Schedules a macrotask (using a timer)
function macroTask(fn: Function, timer = 1): void {
  // adds longer timers for passing tests in IE and Edge
  _zone.runOutsideAngular(() => TimerWrapper.setTimeout(fn, isIEorEdge ? timer : 1));
}

// Schedules a microtasks (using a resolved promise .then())
function microTask(fn: Function): void {
  PromiseWrapper.resolve(null).then((_) => { fn(); });
}

var _log;
var _errors: any[];
var _traces: any[];
var _zone;

  describe('ShadowCss', function() {

    function s(css: string, contentAttr: string, hostAttr: string = '') {
      var shadowCss = new ShadowCss();
      var shim = shadowCss.shimCssText(css, contentAttr, hostAttr);
      var nlRegexp = RegExpWrapper.create('\\n');
      return normalizeCSS(StringWrapper.replaceAll(shim, nlRegexp, ''));
    }

    it('should handle empty string', () => { expect(s('', 'a')).toEqual(''); });

    it('should add an attribute to every rule', () => {
      var css = 'one {color: red;}two {color: red;}';
      var expected = 'one[a] {color:red;}two[a] {color:red;}';
      expect(s(css, 'a')).toEqual(expected);
    });

    it('should hanlde invalid css', () => {
      var css = 'one {color: red;}garbage';
      var expected = 'one[a] {color:red;}';
      expect(s(css, 'a')).toEqual(expected);
    });

    it('should add an attribute to every selector', () => {
      var css = 'one, two {color: red;}';
      var expected = 'one[a], two[a] {color:red;}';
      expect(s(css, 'a')).toEqual(expected);
    });

    it('should handle media rules', () => {
      var css = '@media screen and (max-width:800px) {div {font-size:50px;}}';
      var expected = '@media screen and (max-width:800px) {div[a] {font-size:50px;}}';
      expect(s(css, 'a')).toEqual(expected);
    });

    it('should handle media rules with simple rules', () => {
      var css = '@media screen and (max-width: 800px) {div {font-size: 50px;}} div {}';
      var expected = '@media screen and (max-width:800px) {div[a] {font-size:50px;}}div[a] {}';
      expect(s(css, 'a')).toEqual(expected);
    });

    it('should handle keyframes rules', () => {
      var css = '@keyframes foo {0% {transform: translate(-50%) scaleX(0);}}';
      var passRe = RegExpWrapper.create(
          '@keyframes foo {\\s*0% {\\s*transform:translate\\(-50%\\) scaleX\\(0\\);\\s*}\\s*}');
      expect(RegExpWrapper.test(passRe, s(css, 'a'))).toEqual(true);
    });

    if (DOM.getUserAgent().indexOf('AppleWebKit') > -1) {
      it('should handle -webkit-keyframes rules', () => {
        var css = '@-webkit-keyframes foo {0% {transform: translate(-50%) scaleX(0);}}';
        var passRe = RegExpWrapper.create(
            '@-webkit-keyframes foo {\\s*0% {\\s*transform:translate\\(-50%\\) scaleX\\(0\\);\\s*}}');
        expect(RegExpWrapper.test(passRe, s(css, 'a'))).toEqual(true);
      });
    }

    it('should handle complicated selectors', () => {
      expect(s('one::before {}', 'a')).toEqual('one[a]::before {}');
      expect(s('one two {}', 'a')).toEqual('one[a] two[a] {}');
      expect(s('one>two {}', 'a')).toEqual('one[a] > two[a] {}');
      expect(s('one+two {}', 'a')).toEqual('one[a] + two[a] {}');
      expect(s('one~two {}', 'a')).toEqual('one[a] ~ two[a] {}');
      var res = s('.one.two > three {}', 'a');  // IE swap classes
      expect(res == '.one.two[a] > three[a] {}' || res == '.two.one[a] > three[a] {}')
          .toEqual(true);
      expect(s('one[attr="value"] {}', 'a')).toEqual('one[attr="value"][a] {}');
      expect(s('one[attr=value] {}', 'a')).toEqual('one[attr="value"][a] {}');
      expect(s('one[attr^="value"] {}', 'a')).toEqual('one[attr^="value"][a] {}');
      expect(s('one[attr$="value"] {}', 'a')).toEqual('one[attr$="value"][a] {}');
      expect(s('one[attr*="value"] {}', 'a')).toEqual('one[attr*="value"][a] {}');
      expect(s('one[attr|="value"] {}', 'a')).toEqual('one[attr|="value"][a] {}');
      expect(s('one[attr] {}', 'a')).toEqual('one[attr][a] {}');
      expect(s('[is="one"] {}', 'a')).toEqual('[is="one"][a] {}');
    });

    it('should handle :host', () => {
      expect(s(':host {}', 'a', 'a-host')).toEqual('[a-host] {}');
      expect(s(':host(.x,.y) {}', 'a', 'a-host')).toEqual('[a-host].x, [a-host].y {}');
      expect(s(':host(.x,.y) > .z {}', 'a', 'a-host'))
          .toEqual('[a-host].x > .z, [a-host].y > .z {}');
    });

    it('should handle :host-context', () => {
      expect(s(':host-context(.x) {}', 'a', 'a-host')).toEqual('[a-host].x, .x [a-host] {}');
      expect(s(':host-context(.x) > .y {}', 'a', 'a-host'))
          .toEqual('[a-host].x > .y, .x [a-host] > .y {}');
    });

    it('should support polyfill-next-selector', () => {
      var css = s("polyfill-next-selector {content: 'x > y'} z {}", 'a');
      expect(css).toEqual('x[a] > y[a] {}');

      css = s('polyfill-next-selector {content: "x > y"} z {}', 'a');
      expect(css).toEqual('x[a] > y[a] {}');
    });

    it('should support polyfill-unscoped-rule', () => {
      var css = s("polyfill-unscoped-rule {content: '#menu > .bar';color: blue;}", 'a');
      expect(StringWrapper.contains(css, '#menu > .bar {;color:blue;}')).toBeTruthy();
//.........这里部分代码省略.........

  describe("PromisePipe", () => {
    var message = new Object();
    var pipe;
    var completer;
    var ref;
    // adds longer timers for passing tests in IE
    var timer = (!isBlank(DOM) && DOM.getUserAgent().indexOf("Trident") > -1) ? 50 : 0;

    beforeEach(() => {
      completer = PromiseWrapper.completer();
      ref = new SpyChangeDetectorRef();
      pipe = new PromisePipe(ref);
    });

    describe("supports", () => {
      it("should support promises", () => { expect(pipe.supports(completer.promise)).toBe(true); });

      it("should not support other objects", () => {
        expect(pipe.supports("string")).toBe(false);
        expect(pipe.supports(null)).toBe(false);
      });
    });

    describe("transform", () => {
      it("should return null when subscribing to a promise",
         () => { expect(pipe.transform(completer.promise)).toBe(null); });

      it("should return the latest available value", inject([AsyncTestCompleter], (async) => {
           pipe.transform(completer.promise);

           completer.resolve(message);

           TimerWrapper.setTimeout(() => {
             expect(pipe.transform(completer.promise)).toEqual(new WrappedValue(message));
             async.done();
           }, timer)
         }));

      it("should return unwrapped value when nothing has changed since the last call",
         inject([AsyncTestCompleter], (async) => {
           pipe.transform(completer.promise);
           completer.resolve(message);

           TimerWrapper.setTimeout(() => {
             pipe.transform(completer.promise);
             expect(pipe.transform(completer.promise)).toBe(message);
             async.done();
           }, timer)
         }));

      it("should dispose of the existing subscription when subscribing to a new promise",
         inject([AsyncTestCompleter], (async) => {
           pipe.transform(completer.promise);

           var newCompleter = PromiseWrapper.completer();
           expect(pipe.transform(newCompleter.promise)).toBe(null);

           // this should not affect the pipe, so it should return WrappedValue
           completer.resolve(message);

           TimerWrapper.setTimeout(() => {
             expect(pipe.transform(newCompleter.promise)).toBe(null);
             async.done();
           }, timer)
         }));

      it("should request a change detection check upon receiving a new value",
         inject([AsyncTestCompleter], (async) => {
           pipe.transform(completer.promise);
           completer.resolve(message);

           TimerWrapper.setTimeout(() => {
             expect(ref.spy('requestCheck')).toHaveBeenCalled();
             async.done();
           }, timer)
         }));

      describe("onDestroy", () => {
        it("should do nothing when no source",
           () => { expect(() => pipe.onDestroy()).not.toThrow(); });

        it("should dispose of the existing source", inject([AsyncTestCompleter], (async) => {
             pipe.transform(completer.promise);
             expect(pipe.transform(completer.promise)).toBe(null);
             completer.resolve(message)


                 TimerWrapper.setTimeout(() => {
                   expect(pipe.transform(completer.promise)).toEqual(new WrappedValue(message));
                   pipe.onDestroy();
                   expect(pipe.transform(completer.promise)).toBe(null);
                   async.done();
                 }, timer);
           }));
      });
    });
  });