it('Adding variable whose formula references a non-existent symbol', () => {
        const remath = new Remath();
        let view: ObservableMap<string> = observable.map<string>();
        const render = sinon.spy(() => {
            renderCells(remath, view);
        });
        autorun(render);

        // add a
        const a = remath.addCell({
            symbol: 'a',
            formula: '= b + 10'
        });
        expect(render.callCount).to.equal(2);
        expect(view.get('a')).to.equal('sym:a,formula:b + 10,val:NaN,disp:#REF?');

        // add b = 30
        runInAction(() => {
            const b = remath.addCell({
                symbol: 'b',
                formula: '=30'
            });
        });
        expect(view.get('b')).to.equal('sym:b,formula:30,val:30,disp:30');
        expect(view.get('a')).to.equal('sym:a,formula:b + 10,val:40,disp:40');
    });

 it("builds the data for the volcano plot graph with the correct values", ()=>{
     const map_genesets_selected_volcano = new ObservableMap<boolean>();
     map_genesets_selected_volcano.set("AKT_UP.V1_DN", true);
     const graphData = getVolcanoPlotData(genesets, map_genesets_selected_volcano);
     assert.deepEqual(
         graphData, 
         [{
             x: 0.1986,
             y: -(Math.log(genesets[0].representativePvalue)/Math.log(10)),
             fill: "tomato"
         },
         {
             x: 0.3945,
             y: -(Math.log(genesets[1].representativePvalue)/Math.log(10)),
             fill: "3786C2"
         }]
     );
 });

 find(symbolOrId: string): Cell {
    let cell: Cell;
    const probablyAnId = matchesIdFormat(symbolOrId);
    if (probablyAnId) {
       cell = this._cells.get(symbolOrId);
    }
    if (cell === undefined) { // maybe it is a symbol
       const hash = hasher.getHash(symbolOrId);
       cell = this._cells.get(hash) || null;
    }
    return cell;
 }

 @action
 addDependent(dependent: INode): void {
    if (this.dependsOn(dependent)) {
       this.throwCircRefError(`${dependent.id}'s formula references ${this.id}, but ${this.id} depends on ${dependent.id}`);
    }
    this._dependents.set(dependent.id, dependent);
 }

 @action
 addProvider(provider: INode): void {
    if (this.providesFor(provider)) {
       this.throwCircRefError(`${this.id}'s formula references ${provider.id}, but ${provider.id} depends on ${this.id}`);
    }
    this._providers.set(provider.id, provider);
 }

   @action
   removeCell(symbolOrId: string): Cell {
      const cell = this.find(symbolOrId);
      if (!cell) return;

      // remove reference to this node in all dependent nodes
      cell.dependents.forEach(node => {
         node.removeProvider(cell);
      });

      // delete node from graph
      this._cells.delete(cell.id);
      return cell;
   }

 @computed
 get errors(): IError[] {
     return this._errors.values();
 }

 @action
 __addError(error: IError): void {
     this._errors.set(ErrorType[error.type], error);
 }