it('should add a class name to the flex panel children', () => {
   let p = new FlexPanel();
   p.addWidget(new Widget());
   p.addWidget(new Widget());
   p.addWidget(new Widget());
   each(p.widgets, (child) => {
     expect(child.hasClass('p-FlexPanel-child')).to.be(true);
   });
 });

 function toggleLineNumbers(widget: Notebook): void {
   if (!widget.model || !widget.activeCell) {
     return;
   }
   let lineNumbers = widget.activeCell.editor.lineNumbers;
   each(widget.widgets, child => {
     if (widget.isSelected(child)) {
       child.editor.lineNumbers = !lineNumbers;
     }
   });
 }

 function clearAllOutputs(widget: Notebook): void {
   if (!widget.model || !widget.activeCell) {
     return;
   }
   each(widget.model.cells, (cell: ICodeCellModel) => {
     if (cell.type === 'code') {
       cell.outputs.clear();
       cell.executionCount = null;
     }
   });
 }

 it('should clear the existing selection', () => {
   each(widget.widgets, child => {
     widget.select(child);
   });
   NotebookActions.splitCell(widget);
   for (let i = 0; i < widget.widgets.length; i++) {
     if (i === widget.activeCellIndex) {
       continue;
     }
     expect(widget.isSelected(widget.widgets.at(i))).to.be(false);
   }
 });

  function deleteCells(widget: Notebook): void {
    if (!widget.model || !widget.activeCell) {
      return;
    }
    let model = widget.model;
    let cells = model.cells;
    let toDelete: number[] = [];
    widget.mode = 'command';

    // Find the cells to delete.
    each(enumerate(widget.widgets), ([i, child]) => {
      let deletable = child.model.getMetadata('deletable').getValue();
      if (widget.isSelected(child) && deletable !== false) {
        toDelete.push(i);
      }
    });

    // If cells are not deletable, we may not have anything to delete.
    if (toDelete.length > 0) {
      // Delete the cells as one undo event.
      cells.beginCompoundOperation();
      each(toDelete.reverse(), i => {
        cells.removeAt(i);
      });
      // The model will add a new code cell if there are no
      // remaining cells.
      model.cells.endCompoundOperation();

      // Select the *first* interior cell not deleted or the cell
      // *after* the last selected cell.
      // Note: The activeCellIndex is clamped to the available cells,
      // so if the last cell is deleted the previous cell will be activated.
      widget.activeCellIndex = toDelete[0];
    }

    // Deselect any remaining, undeletable cells. Do this even if we don't
    // delete anything so that users are aware *something* happened.
    widget.deselectAll();
  }

 execute: () => {
   if (options.background === 'black') {
     options.background = 'white';
     options.color = 'black';
   } else {
     options.background = 'black';
     options.color = 'white';
   }
   each(tracker.widgets, widget => {
     widget.background = options.background;
     widget.color = options.color;
   });
 }

  function paste(widget: Notebook, clipboard: IClipboard): void {
    if (!widget.model || !widget.activeCell) {
      return;
    }
    if (!clipboard.hasData(JUPYTER_CELL_MIME)) {
      return;
    }
    let values = clipboard.getData(JUPYTER_CELL_MIME) as nbformat.IBaseCell[];
    let model = widget.model;
    let newCells: ICellModel[] = [];
    widget.mode = 'command';

    each(values, cell => {
      switch (cell.cell_type) {
      case 'code':
        newCells.push(model.contentFactory.createCodeCell({ cell }));
        break;
      case 'markdown':
        newCells.push(model.contentFactory.createMarkdownCell({ cell }));
        break;
      default:
        newCells.push(model.contentFactory.createRawCell({ cell }));
        break;
      }
    });
    let index = widget.activeCellIndex;

    let cells = widget.model.cells;
    cells.beginCompoundOperation();
    each(newCells, cell => {
      cells.insert(++index, cell);
    });
    cells.endCompoundOperation();

    widget.activeCellIndex += newCells.length;
    widget.deselectAll();
  }

  function run(widget: Notebook, kernel?: Kernel.IKernel): Promise<boolean> {
    if (!widget.model || !widget.activeCell) {
      return Promise.resolve(false);
    }
    widget.mode = 'command';
    let selected: BaseCellWidget[] = [];
    let lastIndex = widget.activeCellIndex;
    let i = 0;
    each(widget.widgets, child => {
      if (widget.isSelected(child)) {
        selected.push(child);
        lastIndex = i;
      }
      i++;
    });
    widget.activeCellIndex = lastIndex;
    widget.deselectAll();

    let promises: Promise<boolean>[] = [];
    each(selected, child => {
      promises.push(Private.runCell(widget, child, kernel));
    });
    return Promise.all(promises).then(results => {
      if (widget.isDisposed) {
        return false;
      }
      // Post an update request.
      widget.update();
      for (let result of results) {
        if (!result) {
          return false;
        }
      }
      return true;
    });
  }

 function clearOutputs(widget: Notebook): void {
   if (!widget.model || !widget.activeCell) {
     return;
   }
   let cells = widget.model.cells;
   let i = 0;
   each(cells, (cell: ICodeCellModel) => {
     let child = widget.widgets.at(i);
     if (widget.isSelected(child) && cell.type === 'code') {
       cell.outputs.clear();
       cell.executionCount = null;
     }
     i++;
   });
 }

 function setMarkdownHeader(widget: Notebook, level: number) {
   if (!widget.model || !widget.activeCell) {
     return;
   }
   level = Math.min(Math.max(level, 1), 6);
   let cells = widget.model.cells;
   let i = 0;
   each(widget.widgets, (child: MarkdownCellWidget) => {
     if (widget.isSelected(child)) {
       Private.setMarkdownHeader(cells.at(i), level);
     }
     i++;
   });
   changeCellType(widget, 'markdown');
 }