it('should return the last sampleSize runs when it has at least the given size', () => {
   createValidator(2);
   var sample = [mv(0, 0, {'a': 1}), mv(1, 1, {'b': 2}), mv(2, 2, {'c': 3})];
   expect(validator.validate(ListWrapper.slice(sample, 0, 2)))
       .toEqual(ListWrapper.slice(sample, 0, 2));
   expect(validator.validate(sample)).toEqual(ListWrapper.slice(sample, 1, 3));
 });

 it('should return the last sampleSize runs when the regression slope is >0', () => {
   createValidator({size: 2, metric: 'script'});
   var sample = [mv(0, 0, {'script': 1}), mv(1, 1, {'script': 2}), mv(2, 2, {'script': 3})];
   expect(validator.validate(ListWrapper.slice(sample, 0, 2)))
       .toEqual(ListWrapper.slice(sample, 0, 2));
   expect(validator.validate(sample)).toEqual(ListWrapper.slice(sample, 1, 3));
 });

 /** @internal */
 private _addEvents(events: {[key: string]: string}[]) {
   var needSort = false;
   events.forEach(event => {
     if (StringWrapper.equals(event['ph'], 'X')) {
       needSort = true;
       var startEvent = {};
       var endEvent = {};
       StringMapWrapper.forEach(event, (value, prop) => {
         startEvent[prop] = value;
         endEvent[prop] = value;
       });
       startEvent['ph'] = 'B';
       endEvent['ph'] = 'E';
       endEvent['ts'] = startEvent['ts'] + startEvent['dur'];
       this._remainingEvents.push(startEvent);
       this._remainingEvents.push(endEvent);
     } else {
       this._remainingEvents.push(event);
     }
   });
   if (needSort) {
     // Need to sort because of the ph==='X' events
     ListWrapper.sort(this._remainingEvents, (a, b) => {
       var diff = a['ts'] - b['ts'];
       return diff > 0 ? 1 : diff < 0 ? -1 : 0;
     });
   }
 }

function _update(node: TreeNode<UrlSegment>, changes: any[]): TreeNode<UrlSegment> {
  let rest = changes.slice(1);
  let outlet = _outlet(changes);
  let segment = _segment(changes);
  if (isString(segment) && segment[0] == "/") segment = segment.substring(1);

  // reach the end of the tree => create new tree nodes.
  if (isBlank(node)) {
    let urlSegment = new UrlSegment(segment, null, outlet);
    let children = rest.length === 0 ? [] : [_update(null, rest)];
    return new TreeNode<UrlSegment>(urlSegment, children);

    // different outlet => preserve the subtree
  } else if (outlet != node.value.outlet) {
    return node;

    // same outlet => modify the subtree
  } else {
    let urlSegment = isStringMap(segment) ? new UrlSegment(null, segment, null) :
                                            new UrlSegment(segment, null, outlet);
    if (rest.length === 0) {
      return new TreeNode<UrlSegment>(urlSegment, []);
    }

    return new TreeNode<UrlSegment>(urlSegment,
                                    _updateMany(ListWrapper.clone(node.children), rest));
  }
}

 validate(completeSample: MeasureValues[]): MeasureValues[] {
   if (completeSample.length >= this._sampleSize) {
     return ListWrapper.slice(
         completeSample, completeSample.length - this._sampleSize, completeSample.length);
   } else {
     return null;
   }
 }

function _findUrlSegment(segment: RouteSegment, routeTree: RouteTree): UrlSegment {
  let s = segment;
  let res = null;
  while (isBlank(res)) {
    res = ListWrapper.last(s.urlSegments);
    s = routeTree.parent(s);
  }
  return res;
}

 remove(key: string) {
   if (!StringWrapper.contains(key, '.')) {
     return this._data.delete(key);
   }
   var pieces = key.split('.');
   var last = ListWrapper.last(pieces);
   pieces.length = pieces.length - 1;
   var target = this._resolve(pieces, this);
   return target.remove(last);
 }

 set(key: string, value) {
   if (key.indexOf('.') == -1) {
     this._data[key] = value;
     return;
   }
   var pieces = key.split('.');
   var last = ListWrapper.last(pieces);
   pieces.length = pieces.length - 1;
   var target = this._resolve(pieces, this);
   target[last] = value;
 }

 get(key: string) {
   if (key.indexOf('.') == -1) {
     return this._data[key];
   }
   var pieces = key.split('.');
   var last = ListWrapper.last(pieces);
   pieces.length = pieces.length - 1;
   var target = this._resolve(pieces, this);
   if (target == null) {
     return null;
   }
   return target[last];
 }

 _computeStageButtons() {
   var disabled = true;
   this.stages = ListWrapper.clone(STATUS_LIST.map((status) => {
     var isCurrent = this._offering.status == status;
     var stage = new Stage();
     stage.name = status;
     stage.isDisabled = disabled;
     stage.backgroundColor = disabled ? '#DDD' : isCurrent ? '#DDF' : '#FDD';
     if (isCurrent) {
       disabled = false;
     }
     return stage;
   }));
 }