it('should be reset when loading from disk', () => {
   let model = new NotebookModel();
   let cell = model.contentFactory.createCodeCell({});
   model.cells.pushBack(cell);
   model.fromJSON(DEFAULT_CONTENT);
   expect(ArrayExt.firstIndexOf(toArray(model.cells), cell)).to.be(-1);
   expect(model.cells.length).to.be(6);
 });

 it('adjust after inserting an item', function() {
     const insertedValue = 'value-before-1';
     ArrayExt.insert(sequence, 1, insertedValue);
     // sequence is now [value-0, value-before-1, value-1]
     selection.adjustSelectionForInsert(1, insertedValue);
     expect(selection.index).to.equal(1);
     expect(selection.value).to.equal(insertedValue);
 });

 /**
  * Resolve a button item.
  */
 private _resolve(item: Dialog.IButton): void {
   // Prevent loopback.
   let promise = this._promise;
   this._promise = null;
   this.close();
   ArrayExt.removeFirstOf(Private.launchQueue, promise.promise);
   promise.resolve(item);
 }

 it('should be reset when loading from disk', () => {
   const model = new NotebookModel();
   const cell = model.contentFactory.createCodeCell({});
   model.cells.push(cell);
   model.fromJSON(NBTestUtils.DEFAULT_CONTENT);
   expect(ArrayExt.firstIndexOf(toArray(model.cells), cell)).to.equal(-1);
   expect(model.cells.length).to.equal(6);
 });

 /**
  * Dispose of the resources used by the dialog.
  */
 dispose(): void {
   const promise = this._promise;
   if (promise) {
     this._promise = null;
     promise.reject(void 0);
     ArrayExt.removeFirstOf(Private.launchQueue, promise.promise);
   }
   super.dispose();
 }

 export function hitTestNodes(
   nodes: HTMLElement[] | HTMLCollection,
   x: number,
   y: number
 ): number {
   return ArrayExt.findFirstIndex(nodes, node => {
     return ElementExt.hitTest(node, x, y);
   });
 }

 /**
  * Dispose of the resources used by the dialog.
  */
 dispose(): void {
   if (this._promise) {
     let promise = this._promise;
     this._promise = null;
     promise.resolve(void 0);
     ArrayExt.removeFirstOf(Private.launchQueue, promise.promise);
   }
   super.dispose();
 }

 /**
  * Handle the `'p-dragenter'` event for the widget.
  */
 private _evtDragEnter(event: IDragEvent): void {
   if (event.mimeData.hasData(CONTENTS_MIME)) {
     let index = ArrayExt.findFirstIndex(this._crumbs, node => ElementExt.hitTest(node, event.clientX, event.clientY));
     if (index !== -1) {
       if (index !== Private.Crumb.Current) {
         this._crumbs[index].classList.add(DROP_TARGET_CLASS);
         event.preventDefault();
         event.stopPropagation();
       }
     }
   }
 }

      it('should remove a group from the menu', () => {
        const group1 = [ { command: 'run1'}, { command: 'run2' }];
        const group2 = [ { command: 'run3'}, { command: 'run4' }];
        menu.addGroup(group1);
        menu.addGroup(group2);
        menu.removeGroup(group1);

        let idx1 = ArrayExt.findFirstIndex(menu.menu.items,
                                           m => m.command === 'run1');
        let idx2 = ArrayExt.findFirstIndex(menu.menu.items,
                                           m => m.command === 'run2');
        let idx3 = ArrayExt.findFirstIndex(menu.menu.items,
                                           m => m.command === 'run3');
        let idx4 = ArrayExt.findFirstIndex(menu.menu.items,
                                           m => m.command === 'run4');

        expect(idx1).to.be(-1);
        expect(idx2).to.be(-1);
        expect(idx3 === -1).to.be(false);
        expect(idx4 === -1).to.be(false);
      });

 it('adjust after removing the selected item', function() {
     ArrayExt.removeAt(sequence, 1);
     selection.adjustSelectionForRemove(1, 'value-1');
     expect(selection.index).to.equal(0);
     expect(selection.value).to.equal('value-0');
     const message = getLastMessage(subscriber);
     expect(message).to.deep.equal({
         previousIndex: 1,
         previousValue: 'value-1',
         currentIndex: 0,
         currentValue: 'value-0'
     });
 });