TypeScript lang.isPresent函数代码示例

  sample({id, execute, prepare, microMetrics, providers, userMetrics}: {
    id: string,
    execute?: any,
    prepare?: any,
    microMetrics?: any,
    providers?: any,
    userMetrics?: any
  }): Promise<SampleState> {
    var sampleProviders = [
      _DEFAULT_PROVIDERS, this._defaultProviders, {provide: Options.SAMPLE_ID, useValue: id},
      {provide: Options.EXECUTE, useValue: execute}
    ];
    if (isPresent(prepare)) {
      sampleProviders.push({provide: Options.PREPARE, useValue: prepare});
    }
    if (isPresent(microMetrics)) {
      sampleProviders.push({provide: Options.MICRO_METRICS, useValue: microMetrics});
    }
    if (isPresent(userMetrics)) {
      sampleProviders.push({provide: Options.USER_METRICS, useValue: userMetrics});
    }
    if (isPresent(providers)) {
      sampleProviders.push(providers);
    }

    var inj = ReflectiveInjector.resolveAndCreate(sampleProviders);
    var adapter = inj.get(WebDriverAdapter);

    return Promise
        .all([adapter.capabilities(), adapter.executeScript('return window.navigator.userAgent;')])
        .then((args) => {
          var capabilities = args[0];
          var userAgent = args[1];

          // This might still create instances twice. We are creating a new injector with all the
          // providers.
          // Only WebDriverAdapter is reused.
          // TODO vsavkin consider changing it when toAsyncFactory is added back or when child
          // injectors are handled better.
          var injector = ReflectiveInjector.resolveAndCreate([
            sampleProviders, {provide: Options.CAPABILITIES, useValue: capabilities},
            {provide: Options.USER_AGENT, useValue: userAgent},
            {provide: WebDriverAdapter, useValue: adapter}
          ]);

          var sampler = injector.get(Sampler);
          return sampler.sample();
        });
  }

 it('should write all data into a file', inject([AsyncTestCompleter], (async) => {
      createReporter({
        sampleId: 'someId',
        descriptions: [{'a': 2}],
        path: 'somePath',
        metrics: {'script': 'script time'}
      })
          .reportSample(
              [mv(0, 0, {'a': 3, 'b': 6})],
              [mv(0, 0, {'a': 3, 'b': 6}), mv(1, 1, {'a': 5, 'b': 9})]);
      var regExp = /somePath\/someId_\d+\.json/g;
      expect(isPresent(RegExpWrapper.firstMatch(regExp, loggedFile['filename']))).toBe(true);
      var parsedContent = Json.parse(loggedFile['content']);
      expect(parsedContent).toEqual({
        'description':
            {'id': 'someId', 'description': {'a': 2}, 'metrics': {'script': 'script time'}},
        'completeSample': [
          {'timeStamp': '1970-01-01T00:00:00.000Z', 'runIndex': 0, 'values': {'a': 3, 'b': 6}}
        ],
        'validSample': [
          {'timeStamp': '1970-01-01T00:00:00.000Z', 'runIndex': 0, 'values': {'a': 3, 'b': 6}}, {
            'timeStamp': '1970-01-01T00:00:00.001Z',
            'runIndex': 1,
            'values': {'a': 5, 'b': 9}
          }
        ]
      });
      async.done();
    }));

 timeEnd(name: string, restartName: string = null): Promise<any> {
   var script = `console.timeEnd('${name}');`;
   if (isPresent(restartName)) {
     script += `console.time('${restartName}');`;
   }
   return this._driver.executeScript(script);
 }

 bindAction('#reset-btn', () => {
   this._getScrollDiv().scrollTop = 0;
   var existingMarker = this._locateFinishedMarker();
   if (isPresent(existingMarker)) {
     DOM.removeChild(document.body, existingMarker);
   }
 });

 return this._iterate(lastState).then((newState) => {
   if (isPresent(newState.validSample)) {
     return newState;
   } else {
     return loop(newState);
   }
 });

 timeEnd(name: string, restartName: string = null): Promise<any> {
   var script = 'window.markEnd("' + name + '");';
   if (isPresent(restartName)) {
     script += 'window.markStart("' + restartName + '");';
   }
   return this._driver.executeScript(script);
 }

function _findStartingNode(segment: UrlSegment, node: TreeNode<UrlSegment>): TreeNode<UrlSegment> {
  if (node.value === segment) return node;
  for (var c of node.children) {
    let r = _findStartingNode(segment, c);
    if (isPresent(r)) return r;
  }
  return null;
}

 function createMetric(
     perfLogs, perfLogFeatures,
     {microMetrics, forceGc, captureFrames, receivedData, requestCount}: {
       microMetrics?: {[key: string]: string},
       forceGc?: boolean,
       captureFrames?: boolean,
       receivedData?: boolean,
       requestCount?: boolean
     } = {}): Metric {
   commandLog = [];
   if (isBlank(perfLogFeatures)) {
     perfLogFeatures =
         new PerfLogFeatures({render: true, gc: true, frameCapture: true, userTiming: true});
   }
   if (isBlank(microMetrics)) {
     microMetrics = StringMapWrapper.create();
   }
   var providers: Provider[] = [
     Options.DEFAULT_PROVIDERS, PerflogMetric.PROVIDERS,
     {provide: Options.MICRO_METRICS, useValue: microMetrics}, {
       provide: PerflogMetric.SET_TIMEOUT,
       useValue: (fn, millis) => {
         commandLog.push(['setTimeout', millis]);
         fn();
       },
     },
     {
       provide: WebDriverExtension,
       useValue: new MockDriverExtension(perfLogs, commandLog, perfLogFeatures)
     }
   ];
   if (isPresent(forceGc)) {
     providers.push({provide: Options.FORCE_GC, useValue: forceGc});
   }
   if (isPresent(captureFrames)) {
     providers.push({provide: Options.CAPTURE_FRAMES, useValue: captureFrames});
   }
   if (isPresent(receivedData)) {
     providers.push({provide: Options.RECEIVED_DATA, useValue: receivedData});
   }
   if (isPresent(requestCount)) {
     providers.push({provide: Options.REQUEST_COUNT, useValue: requestCount});
   }
   return ReflectiveInjector.resolveAndCreate(providers).get(PerflogMetric);
 }

 private _processAsPostChrome44Event(event, categories) {
   var name = event['name'];
   var args = event['args'];
   if (this._isEvent(categories, name, ['devtools.timeline', 'v8'], 'MajorGC')) {
     var normArgs = {
       'majorGc': true,
       'usedHeapSize': isPresent(args['usedHeapSizeAfter']) ? args['usedHeapSizeAfter'] :
                                                              args['usedHeapSizeBefore']
     };
     return normalizeEvent(event, {'name': 'gc', 'args': normArgs});
   } else if (this._isEvent(categories, name, ['devtools.timeline', 'v8'], 'MinorGC')) {
     var normArgs = {
       'majorGc': false,
       'usedHeapSize': isPresent(args['usedHeapSizeAfter']) ? args['usedHeapSizeAfter'] :
                                                              args['usedHeapSizeBefore']
     };
     return normalizeEvent(event, {'name': 'gc', 'args': normArgs});
   } else if (
       this._isEvent(categories, name, ['devtools.timeline', 'v8'], 'FunctionCall') &&
       (isBlank(args) || isBlank(args['data']) ||
        (!StringWrapper.equals(args['data']['scriptName'], 'InjectedScript') &&
         !StringWrapper.equals(args['data']['scriptName'], '')))) {
     return normalizeEvent(event, {'name': 'script'});
   } else if (this._isEvent(
                  categories, name, ['devtools.timeline', 'blink'], 'UpdateLayoutTree')) {
     return normalizeEvent(event, {'name': 'render'});
   } else if (
       this._isEvent(categories, name, ['devtools.timeline'], 'UpdateLayerTree') ||
       this._isEvent(categories, name, ['devtools.timeline'], 'Layout') ||
       this._isEvent(categories, name, ['devtools.timeline'], 'Paint')) {
     return normalizeEvent(event, {'name': 'render'});
   } else if (this._isEvent(categories, name, ['devtools.timeline'], 'ResourceReceivedData')) {
     let normArgs = {'encodedDataLength': args['data']['encodedDataLength']};
     return normalizeEvent(event, {'name': 'receivedData', 'args': normArgs});
   } else if (this._isEvent(categories, name, ['devtools.timeline'], 'ResourceSendRequest')) {
     let data = args['data'];
     let normArgs = {'url': data['url'], 'method': data['requestMethod']};
     return normalizeEvent(event, {'name': 'sendRequest', 'args': normArgs});
   } else if (this._isEvent(categories, name, ['blink.user_timing'], 'navigationStart')) {
     return normalizeEvent(event, {'name': name});
   }
   return null;  // nothing useful in this event
 }

 /** @internal */
 private _report(state: SampleState, metricValues: {[key: string]: any}): Promise<SampleState> {
   var measureValues = new MeasureValues(state.completeSample.length, this._now(), metricValues);
   var completeSample = state.completeSample.concat([measureValues]);
   var validSample = this._validator.validate(completeSample);
   var resultPromise = this._reporter.reportMeasureValues(measureValues);
   if (isPresent(validSample)) {
     resultPromise =
         resultPromise.then((_) => this._reporter.reportSample(completeSample, validSample));
   }
   return resultPromise.then((_) => new SampleState(completeSample, validSample));
 }