error origins

jest.config.js

@@ -19,7 +19,7 @@ module.exports = {
   // A set of global variables that need to be available in all test environments
   globals: {
     "ts-jest": {
-      "tsConfig": "tsconfig.jest.json"
+      "tsConfig": "./test/tsconfig.json"
     }
   },
 
@@ -32,7 +32,8 @@ module.exports = {
 
   // The paths to modules that run some code to configure or set up the testing environment after each test
   setupFilesAfterEnv: [
-    '<rootDir>/test/_setupFiles/bootstrap.ts'
+    '<rootDir>/test/_setupFiles/bootstrap.ts',
+    '<rootDir>/test/_setupFiles/jest/bootstrap.ts'
   ],
 
   // The test environment that will be used for testing

src/BuildEngineFactory.ts

@@ -80,7 +80,7 @@ export class BuildEngineFactory {
     lazilyTransformingAstService.undoRedo = crudOperations.undoRedo
     lazilyTransformingAstService.parser = parser
 
-    const exporter = new Exporter(config, namedExpressions)
+    const exporter = new Exporter(config, namedExpressions, sheetMapping.fetchDisplayName)
     const serialization = new Serialization(dependencyGraph, unparser, config, exporter)
 
     const evaluator = new Evaluator(dependencyGraph, columnSearch, config, stats, dateHelper, numberLiteralHelper, functionRegistry, namedExpressions, serialization)

src/Cell.ts

@@ -112,6 +112,7 @@ export class CellError {
   constructor(
     public readonly type: ErrorType,
     public readonly message?: string,
+    public address?: SimpleCellAddress,
   ) {
   }
 

src/CellValue.ts

@@ -9,6 +9,7 @@ import {CellValueChange} from './ContentChanges'
 import {ErrorMessage} from './error-message'
 import {NamedExpressions} from './NamedExpressions'
 import {InterpreterValue, SimpleRangeValue} from './interpreter/InterpreterValue'
+import {SheetIndexMappingFn, simpleCellAddressToString} from './parser/addressRepresentationConverters'
 
 export type NoErrorCellValue = number | string | boolean | null
 export type CellValue = NoErrorCellValue | DetailedCellError
@@ -53,10 +54,10 @@ export class ExportedNamedExpressionChange {
 export class DetailedCellError {
   public readonly type: ErrorType
   public readonly message: string
-
   constructor(
     error: CellError,
     public readonly value: string,
+    public readonly address?: string,
   ) {
     this.type = error.type
     this.message = error.message || ''
@@ -67,6 +68,7 @@ export class Exporter {
   constructor(
     private readonly config: Config,
     private readonly namedExpressions: NamedExpressions,
+    private readonly sheetIndexMapping: SheetIndexMappingFn,
   ) {
   }
 
@@ -103,7 +105,15 @@ export class Exporter {
   }
 
   private detailedError(error: CellError): DetailedCellError {
-    return new DetailedCellError(error, this.config.translationPackage.getErrorTranslation(error.type))
+    let address = undefined
+    if(error.address !== undefined) {
+      if (error.address.sheet === NamedExpressions.SHEET_FOR_WORKBOOK_EXPRESSIONS) {
+        address = this.namedExpressions.namedExpressionInAddress(error.address.row)?.displayName
+      } else {
+        address = simpleCellAddressToString(this.sheetIndexMapping, error.address, -1)
+      }
+    }
+    return new DetailedCellError(error, this.config.translationPackage.getErrorTranslation(error.type), address)
   }
 
   private cellValueRounding(value: number): number {

src/interpreter/Interpreter.ts

@@ -54,24 +54,23 @@ export class Interpreter {
   }
 
   public evaluateAst(ast: Ast, formulaAddress: SimpleCellAddress): InterpreterValue {
-    const val = this.evaluateAstWithoutPostoprocessing(ast, formulaAddress)
+    let val = this.evaluateAstWithoutPostoprocessing(ast, formulaAddress)
     if (typeof val === 'number') {
       if (isNumberOverflow(val)) {
-        return new CellError(ErrorType.NUM, ErrorMessage.NaN)
+        val = new CellError(ErrorType.NUM, ErrorMessage.NaN)
       } else {
-        return fixNegativeZero(val)
+        val = fixNegativeZero(val)
       }
-    } else {
-      return val
     }
+    return wrapperForAddress(val, formulaAddress)
   }
   /**
    * Calculates cell value from formula abstract syntax tree
    *
    * @param formula - abstract syntax tree of formula
    * @param formulaAddress - address of the cell in which formula is located
    */
-  public evaluateAstWithoutPostoprocessing(ast: Ast, formulaAddress: SimpleCellAddress): InterpreterValue {
+  private evaluateAstWithoutPostoprocessing(ast: Ast, formulaAddress: SimpleCellAddress): InterpreterValue {
     switch (ast.type) {
       case AstNodeType.EMPTY: {
         return EmptyValue
@@ -322,3 +321,9 @@ function wrapperBinary<T extends InterpreterValue>(op: (a: T, b: T) => Interpret
   }
 }
 
+function wrapperForAddress(val: InterpreterValue, adr: SimpleCellAddress): InterpreterValue {
+  if(val instanceof CellError) {
+    val.address = val.address ?? adr
+  }
+  return val
+}

test/CellValueExporter.spec.ts

@@ -3,15 +3,17 @@ import {CellError, EmptyValue, ErrorType} from '../src/Cell'
 import {Exporter} from '../src/CellValue'
 import {Config} from '../src/Config'
 import {plPL} from '../src/i18n/languages'
+import {SheetIndexMappingFn} from '../src/parser/addressRepresentationConverters'
 import {detailedError} from './testUtils'
 import {NamedExpressions} from '../src/NamedExpressions'
 
 const namedExpressionsMock = {} as NamedExpressions
+const sheetIndexMock = {} as SheetIndexMappingFn
 
 describe( 'rounding', () => {
   it( 'no rounding', () =>{
     const config = new Config({ smartRounding : false })
-    const cellValueExporter = new Exporter(config, namedExpressionsMock)
+    const cellValueExporter = new Exporter(config, namedExpressionsMock, sheetIndexMock)
     expect(cellValueExporter.exportValue(1.000000000000001)).toBe(1.000000000000001)
     expect(cellValueExporter.exportValue(-1.000000000000001)).toBe(-1.000000000000001)
     expect(cellValueExporter.exportValue(0.000000000000001)).toBe(0.000000000000001)
@@ -25,7 +27,7 @@ describe( 'rounding', () => {
 
   it( 'with rounding', () =>{
     const config = new Config()
-    const cellValueExporter = new Exporter(config, namedExpressionsMock)
+    const cellValueExporter = new Exporter(config, namedExpressionsMock, sheetIndexMock)
     expect(cellValueExporter.exportValue(1.0000000000001)).toBe(1.0000000000001)
     expect(cellValueExporter.exportValue(-1.0000000000001)).toBe(-1.0000000000001)
     expect(cellValueExporter.exportValue(1.000000000000001)).toBe(1)
@@ -43,20 +45,20 @@ describe( 'rounding', () => {
 describe('detailed error', () => {
   it('should return detailed errors', () => {
     const config = new Config({ language: 'enGB' })
-    const cellValueExporter = new Exporter(config, namedExpressionsMock)
+    const cellValueExporter = new Exporter(config, namedExpressionsMock, sheetIndexMock)
 
     const error = cellValueExporter.exportValue(new CellError(ErrorType.VALUE)) as DetailedCellError
-    expect(error).toEqual(detailedError(ErrorType.VALUE))
+    expect(error).toEqualError(detailedError(ErrorType.VALUE))
     expect(error.value).toEqual('#VALUE!')
   })
 
   it('should return detailed errors with translation', () => {
     HyperFormula.registerLanguage('plPL', plPL)
     const config = new Config({ language: 'plPL' })
-    const cellValueExporter = new Exporter(config, namedExpressionsMock)
+    const cellValueExporter = new Exporter(config, namedExpressionsMock, sheetIndexMock)
 
     const error = cellValueExporter.exportValue(new CellError(ErrorType.VALUE)) as DetailedCellError
-    expect(error).toEqual(detailedError(ErrorType.VALUE, undefined, config))
+    expect(error).toEqualError(detailedError(ErrorType.VALUE, undefined, config))
     expect(error.value).toEqual('#ARG!')
   })
 })

test/_setupFiles/bootstrap.ts

@@ -7,7 +7,7 @@ import {Config} from '../../src/Config'
 import {AlwaysSparse} from '../../src/DependencyGraph/AddressMapping/ChooseAddressMappingPolicy'
 import {enGB} from '../../src/i18n/languages'
 import {unregisterAllLanguages} from './../testUtils'
-import {toContainEqualMatcher, toMatchObjectMatcher} from './matchers'
+import {toContainEqualMatcher, toEqualErrorMatcher, toMatchObjectMatcher} from './matchers'
 import * as plugins from '../../src/interpreter/plugin'
 
 Config.defaultConfig = Object.assign({}, Config.defaultConfig, {
@@ -53,14 +53,11 @@ beforeEach(() => {
 })
 
 beforeAll(() => {
-  if(jestPresent) {
-    // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
-    // @ts-ignore
-    spyOn = jest.spyOn
-  } else {
+  if(!jestPresent) {
     jasmine.addMatchers({
       ...toContainEqualMatcher,
       ...toMatchObjectMatcher,
+      ...toEqualErrorMatcher,
     })
   }
 })

test/_setupFiles/jest/bootstrap.ts

@@ -0,0 +1,8 @@
+import {toEqualError} from './toEqualError'
+
+beforeAll(() => {
+  // eslint-disable-next-line @typescript-eslint/ban-ts-ignore
+  // @ts-ignore
+  spyOn = jest.spyOn
+  expect.extend(toEqualError)
+})

test/_setupFiles/jest/toEqualError.ts

@@ -0,0 +1,27 @@
+type CustomMatcherResult = jest.CustomMatcherResult
+type ExpectExtendMap = jest.ExpectExtendMap
+
+declare global {
+  namespace jest {
+    interface Matchers<R, T> {
+      toEqualError(expected: any): CustomMatcherResult,
+    }
+  }
+}
+
+export const toEqualError: ExpectExtendMap = {toEqualError(received: any, expected: any): CustomMatcherResult {
+    let result = false
+    if (typeof received === 'object' && typeof expected === 'object') {
+      result = this.equals(
+        {...received, address: undefined},
+        {...expected, address: undefined}
+      )
+    } else {
+      result = this.equals(received, expected)
+    }
+    return {
+      pass: result,
+      message: () => (result ? '' : `Expected ${received} to be match ${expected}.`)
+    }
+  }
+}

test/_setupFiles/matchers/index.ts

@@ -1,2 +1,3 @@
 export { toContainEqualMatcher } from './toContainEqual'
 export { toMatchObjectMatcher } from './toMatchObject'
+export { toEqualErrorMatcher } from './toEqualError'

test/_setupFiles/matchers/toEqualError.ts

@@ -0,0 +1,34 @@
+type CustomMatcher = jasmine.CustomMatcher
+type CustomMatcherFactories = jasmine.CustomMatcherFactories
+type CustomMatcherResult = jasmine.CustomMatcherResult
+type MatchersUtil = jasmine.MatchersUtil
+
+declare global {
+  namespace jasmine {
+    interface Matchers<T> {
+      toEqualError(expected: any, expectationFailOutput?: string): boolean,
+    }
+  }
+}
+
+export const toEqualErrorMatcher: CustomMatcherFactories = {
+  toEqualError: function(util: MatchersUtil): CustomMatcher {
+    return {
+      compare: function(received: any, expected: any): CustomMatcherResult {
+        let result
+        if (typeof received === 'object' && typeof expected === 'object') {
+          result = util.equals(
+            {...received, address: undefined},
+            {...expected, address: undefined}
+          )
+        } else {
+          result = util.equals(received, expected)
+        }
+        return {
+          pass: result,
+          message: result ? '' : `Expected ${JSON.stringify(received, null, 2)} to match ${JSON.stringify(expected, null, 2)}.`
+        }
+      },
+    }
+  }
+}

test/criterion.spec.ts

@@ -1,4 +1,4 @@
-import {ErrorType} from '../src/Cell'
+import {CellError, ErrorType} from '../src/Cell'
 import {Config} from '../src/Config'
 import {DateTimeHelper} from '../src/DateTimeHelper'
 import {ArithmeticHelper} from '../src/interpreter/ArithmeticHelper'
@@ -70,7 +70,7 @@ describe('Criterion', () => {
   })
 
   it('null when criterion being error', () => {
-    expect(criterionBuilder.parseCriterion(detailedError(ErrorType.VALUE), arithmeticHelper)).toEqual(undefined)
+    expect(criterionBuilder.parseCriterion(new CellError(ErrorType.VALUE), arithmeticHelper)).toEqual(undefined)
   })
 
   it('works with criterion being just value', () => {

test/cruds/change-cell-content.spec.ts

@@ -209,7 +209,7 @@ describe('changing cell content', () => {
 
     engine.setCellContents(adr('A1'), '#DIV/0!')
 
-    expect(engine.getCellValue(adr('A1'))).toEqual(detailedError(ErrorType.DIV_BY_ZERO))
+    expect(engine.getCellValue(adr('A1'))).toEqualError(detailedError(ErrorType.DIV_BY_ZERO))
   })
 
   it('update value cell to error-like literal', () => {
@@ -227,7 +227,7 @@ describe('changing cell content', () => {
 
     engine.setCellContents(adr('A1'), '=SUM(')
 
-    expect(engine.getCellValue(adr('A1'))).toEqual(detailedError(ErrorType.ERROR, ErrorMessage.ParseError))
+    expect(engine.getCellValue(adr('A1'))).toEqualError(detailedError(ErrorType.ERROR, ErrorMessage.ParseError))
     expect(engine.getCellFormula(adr('A1'))).toEqual('=SUM(')
   })
 
@@ -526,7 +526,7 @@ describe('changing cell content', () => {
 
     engine.setCellContents(adr('A1'), '=SUM(')
 
-    expect(engine.getCellValue(adr('A1'))).toEqual(detailedError(ErrorType.ERROR, ErrorMessage.ParseError))
+    expect(engine.getCellValue(adr('A1'))).toEqualError(detailedError(ErrorType.ERROR, ErrorMessage.ParseError))
   })
 
   it('update dependecy value cell to parsing error ', () => {
@@ -540,8 +540,8 @@ describe('changing cell content', () => {
     const a1 = engine.addressMapping.fetchCell(adr('A1'))
     const b1 = engine.addressMapping.fetchCell(adr('B1'))
     expect(engine.graph.existsEdge(a1, b1)).toBe(true)
-    expect(engine.getCellValue(adr('A1'))).toEqual(detailedError(ErrorType.ERROR, ErrorMessage.ParseError))
-    expect(engine.getCellValue(adr('B1'))).toEqual(detailedError(ErrorType.ERROR, ErrorMessage.ParseError))
+    expect(engine.getCellValue(adr('A1'))).toEqualError(detailedError(ErrorType.ERROR, ErrorMessage.ParseError))
+    expect(engine.getCellValue(adr('B1'))).toEqualError(detailedError(ErrorType.ERROR, ErrorMessage.ParseError))
   })
 
   it('update formula cell to parsing error ', () => {
@@ -557,7 +557,7 @@ describe('changing cell content', () => {
     expect(engine.graph.existsEdge(a1, b1)).toBe(false)
 
     expect(engine.getCellValue(adr('A1'))).toEqual(1)
-    expect(engine.getCellValue(adr('B1'))).toEqual(detailedError(ErrorType.ERROR, ErrorMessage.ParseError))
+    expect(engine.getCellValue(adr('B1'))).toEqualError(detailedError(ErrorType.ERROR, ErrorMessage.ParseError))
   })
 
   it('update parsing error to formula', () => {
@@ -576,7 +576,7 @@ describe('changing cell content', () => {
 
     engine.setCellContents(adr('A1'), '{=TRANSPOSE(}')
 
-    expect(engine.getCellValue(adr('A1'))).toEqual(detailedError(ErrorType.ERROR, ErrorMessage.ParseError))
+    expect(engine.getCellValue(adr('A1'))).toEqualError(detailedError(ErrorType.ERROR, ErrorMessage.ParseError))
     expect(engine.getCellFormula(adr('A1'))).toEqual('{=TRANSPOSE(}')
   })
 

test/cruds/copy-paste.spec.ts

@@ -189,7 +189,7 @@ describe('Copy - paste integration', () => {
     engine.copy(adr('B2'), 1, 1)
     engine.paste(adr('A1'))
 
-    expect(engine.getCellValue(adr('A1'))).toEqual(detailedError(ErrorType.REF, ErrorMessage.BadRef))
+    expect(engine.getCellValue(adr('A1'))).toEqualError(detailedError(ErrorType.REF, ErrorMessage.BadRef))
   })
 
   it('should create new range vertex - cell range', () => {

test/cruds/cut-paste.spec.ts

@@ -44,10 +44,10 @@ describe('Address dependencies, moved formulas', () => {
     engine.cut(adr('A1'), 1, 4)
     engine.paste(adr('B1'))
 
-    expect(engine.getCellValue(adr('B1'))).toEqual(detailedError(ErrorType.CYCLE))
-    expect(engine.getCellValue(adr('B2'))).toEqual(detailedError(ErrorType.CYCLE))
-    expect(engine.getCellValue(adr('B3'))).toEqual(detailedError(ErrorType.CYCLE))
-    expect(engine.getCellValue(adr('B4'))).toEqual(detailedError(ErrorType.CYCLE))
+    expect(engine.getCellValue(adr('B1'))).toEqualError(detailedError(ErrorType.CYCLE))
+    expect(engine.getCellValue(adr('B2'))).toEqualError(detailedError(ErrorType.CYCLE))
+    expect(engine.getCellValue(adr('B3'))).toEqualError(detailedError(ErrorType.CYCLE))
+    expect(engine.getCellValue(adr('B4'))).toEqualError(detailedError(ErrorType.CYCLE))
     expect(engine.getCellFormula(adr('B1'))).toEqual('=B1')
     expect(engine.getCellFormula(adr('B2'))).toEqual('=$B2')
     expect(engine.getCellFormula(adr('B3'))).toEqual('=B$3')