From e394f01a975247b0ebe6f014ff81257f7628136e Mon Sep 17 00:00:00 2001 From: Rizki Putra Date: Wed, 15 Mar 2023 08:17:30 +0700 Subject: [PATCH] This update the return value for the `CalcCellValue` function (#1490) - Using formula error string in the result of the `CalcCellValue` function - Using the error message in the `CalcCellValue` function returns error - Update unit tests --- calc.go | 15 +- calc_test.go | 4245 +++++++++++++++++++++++++------------------------- 2 files changed, 2131 insertions(+), 2129 deletions(-) diff --git a/calc.go b/calc.go index 7b8dcf52..47705caa 100644 --- a/calc.go +++ b/calc.go @@ -782,6 +782,7 @@ func (f *File) CalcCellValue(sheet, cell string, opts ...Options) (result string iterations: make(map[string]uint), iterationsCache: make(map[string]formulaArg), }, sheet, cell); err != nil { + result = token.String return } if !rawCellValue { @@ -1002,8 +1003,8 @@ func (f *File) evalInfixExp(ctx *calcContext, sheet, cell string, tokens []efp.T inArray = false continue } - if err = f.evalInfixExpFunc(ctx, sheet, cell, token, nextToken, opfStack, opdStack, opftStack, opfdStack, argsStack); err != nil { - return newEmptyFormulaArg(), err + if errArg := f.evalInfixExpFunc(ctx, sheet, cell, token, nextToken, opfStack, opdStack, opftStack, opfdStack, argsStack); errArg.Type == ArgError { + return errArg, errors.New(errArg.Error) } } } @@ -1021,9 +1022,9 @@ func (f *File) evalInfixExp(ctx *calcContext, sheet, cell string, tokens []efp.T } // evalInfixExpFunc evaluate formula function in the infix expression. -func (f *File) evalInfixExpFunc(ctx *calcContext, sheet, cell string, token, nextToken efp.Token, opfStack, opdStack, opftStack, opfdStack, argsStack *Stack) error { +func (f *File) evalInfixExpFunc(ctx *calcContext, sheet, cell string, token, nextToken efp.Token, opfStack, opdStack, opftStack, opfdStack, argsStack *Stack) formulaArg { if !isFunctionStopToken(token) { - return nil + return newEmptyFormulaArg() } prepareEvalInfixExp(opfStack, opftStack, opfdStack, argsStack) // call formula function to evaluate @@ -1031,7 +1032,7 @@ func (f *File) evalInfixExpFunc(ctx *calcContext, sheet, cell string, token, nex "_xlfn.", "", ".", "dot").Replace(opfStack.Peek().(efp.Token).TValue), []reflect.Value{reflect.ValueOf(argsStack.Peek().(*list.List))}) if arg.Type == ArgError && opfStack.Len() == 1 { - return errors.New(arg.Value()) + return arg } argsStack.Pop() opftStack.Pop() // remove current function separator @@ -1050,7 +1051,7 @@ func (f *File) evalInfixExpFunc(ctx *calcContext, sheet, cell string, token, nex } opdStack.Push(newStringFormulaArg(val)) } - return nil + return newEmptyFormulaArg() } // prepareEvalInfixExp check the token and stack state for formula function @@ -11612,7 +11613,7 @@ func (fn *formulaFuncs) IFNA(argsList *list.List) formulaArg { return newErrorFormulaArg(formulaErrorVALUE, "IFNA requires 2 arguments") } arg := argsList.Front().Value.(formulaArg) - if arg.Type == ArgError && arg.Value() == formulaErrorNA { + if arg.Type == ArgError && arg.String == formulaErrorNA { return argsList.Back().Value.(formulaArg) } return arg diff --git a/calc_test.go b/calc_test.go index 8c0ac2e3..1cb1580d 100644 --- a/calc_test.go +++ b/calc_test.go @@ -64,8 +64,8 @@ func TestCalcCellValue(t *testing.T) { "={1}+2": "3", "=1+{2}": "3", "={1}+{2}": "3", - `="A"="A"`: "TRUE", - `="A"<>"A"`: "FALSE", + "=\"A\"=\"A\"": "TRUE", + "=\"A\"<>\"A\"": "FALSE", // Engineering Functions // BESSELI "=BESSELI(4.5,1)": "15.3892227537359", @@ -531,11 +531,11 @@ func TestCalcCellValue(t *testing.T) { "=_xlfn.CSCH(-3.14159265358979)": "-0.0865895375300472", "=_xlfn.CSCH(_xlfn.CSCH(1))": "1.04451010395518", // _xlfn.DECIMAL - `=_xlfn.DECIMAL("1100",2)`: "12", - `=_xlfn.DECIMAL("186A0",16)`: "100000", - `=_xlfn.DECIMAL("31L0",32)`: "100000", - `=_xlfn.DECIMAL("70122",8)`: "28754", - `=_xlfn.DECIMAL("0x70122",8)`: "28754", + "=_xlfn.DECIMAL(\"1100\",2)": "12", + "=_xlfn.DECIMAL(\"186A0\",16)": "100000", + "=_xlfn.DECIMAL(\"31L0\",32)": "100000", + "=_xlfn.DECIMAL(\"70122\",8)": "28754", + "=_xlfn.DECIMAL(\"0x70122\",8)": "28754", // DEGREES "=DEGREES(1)": "57.2957795130823", "=DEGREES(2.5)": "143.239448782706", @@ -628,9 +628,9 @@ func TestCalcCellValue(t *testing.T) { "=LCM(1,8,12)": "24", "=LCM(7,2)": "14", "=LCM(7)": "7", - `=LCM("",1)`: "1", - `=LCM(0,0)`: "0", - `=LCM(0,LCM(0,0))`: "0", + "=LCM(\"\",1)": "1", + "=LCM(0,0)": "0", + "=LCM(0,LCM(0,0))": "0", // LN "=LN(1)": "0", "=LN(100)": "4.60517018598809", @@ -661,7 +661,7 @@ func TestCalcCellValue(t *testing.T) { "=IMPOWER(\"2+4i\",-2)": "-0.03-0.04i", // IMPRODUCT "=IMPRODUCT(3,6)": "18", - `=IMPRODUCT("",3,SUM(6))`: "18", + "=IMPRODUCT(\"\",3,SUM(6))": "18", "=IMPRODUCT(\"1-i\",\"5+10i\",2)": "30+10i", "=IMPRODUCT(COMPLEX(5,2),COMPLEX(0,1))": "-2+5i", "=IMPRODUCT(A1:C1)": "4", @@ -688,7 +688,7 @@ func TestCalcCellValue(t *testing.T) { "=MROUND(MROUND(1,1),1)": "1", // MULTINOMIAL "=MULTINOMIAL(3,1,2,5)": "27720", - `=MULTINOMIAL("",3,1,2,5)`: "27720", + "=MULTINOMIAL(\"\",3,1,2,5)": "27720", "=MULTINOMIAL(MULTINOMIAL(1))": "1", // _xlfn.MUNIT "=_xlfn.MUNIT(4)": "1", @@ -751,7 +751,7 @@ func TestCalcCellValue(t *testing.T) { "=ROUNDDOWN(-99.999,2)": "-99.99", "=ROUNDDOWN(-99.999,-1)": "-90", "=ROUNDDOWN(ROUNDDOWN(100,1),-1)": "100", - // ROUNDUP` + // ROUNDUP "=ROUNDUP(11.111,1)": "11.2", "=ROUNDUP(11.111,2)": "11.12", "=ROUNDUP(11.111,0)": "12", @@ -856,20 +856,20 @@ func TestCalcCellValue(t *testing.T) { "=SUM((SUM(2))+1)": "3", "=SUM({1,2,3,4,\"\"})": "10", // SUMIF - `=SUMIF(F1:F5, "")`: "0", - `=SUMIF(A1:A5, "3")`: "3", - `=SUMIF(F1:F5, "=36693")`: "36693", - `=SUMIF(F1:F5, "<100")`: "0", - `=SUMIF(F1:F5, "<=36693")`: "93233", - `=SUMIF(F1:F5, ">100")`: "146554", - `=SUMIF(F1:F5, ">=100")`: "146554", - `=SUMIF(F1:F5, ">=text")`: "0", - `=SUMIF(F1:F5, "*Jan",F2:F5)`: "0", - `=SUMIF(D3:D7,"Jan",F2:F5)`: "112114", - `=SUMIF(D2:D9,"Feb",F2:F9)`: "157559", - `=SUMIF(E2:E9,"North 1",F2:F9)`: "66582", - `=SUMIF(E2:E9,"North*",F2:F9)`: "138772", - "=SUMIF(D1:D3,\"Month\",D1:D3)": "0", + "=SUMIF(F1:F5, \"\")": "0", + "=SUMIF(A1:A5, \"3\")": "3", + "=SUMIF(F1:F5, \"=36693\")": "36693", + "=SUMIF(F1:F5, \"<100\")": "0", + "=SUMIF(F1:F5, \"<=36693\")": "93233", + "=SUMIF(F1:F5, \">100\")": "146554", + "=SUMIF(F1:F5, \">=100\")": "146554", + "=SUMIF(F1:F5, \">=text\")": "0", + "=SUMIF(F1:F5, \"*Jan\",F2:F5)": "0", + "=SUMIF(D3:D7,\"Jan\",F2:F5)": "112114", + "=SUMIF(D2:D9,\"Feb\",F2:F9)": "157559", + "=SUMIF(E2:E9,\"North 1\",F2:F9)": "66582", + "=SUMIF(E2:E9,\"North*\",F2:F9)": "138772", + "=SUMIF(D1:D3,\"Month\",D1:D3)": "0", // SUMPRODUCT "=SUMPRODUCT(A1,B1)": "4", "=SUMPRODUCT(A1:A2,B1:B2)": "14", @@ -1396,10 +1396,10 @@ func TestCalcCellValue(t *testing.T) { "=ISNA(A1)": "FALSE", "=ISNA(NA())": "TRUE", // ISNONTEXT - "=ISNONTEXT(A1)": "TRUE", - "=ISNONTEXT(A5)": "TRUE", - `=ISNONTEXT("Excelize")`: "FALSE", - "=ISNONTEXT(NA())": "TRUE", + "=ISNONTEXT(A1)": "TRUE", + "=ISNONTEXT(A5)": "TRUE", + "=ISNONTEXT(\"Excelize\")": "FALSE", + "=ISNONTEXT(NA())": "TRUE", // ISNUMBER "=ISNUMBER(A1)": "TRUE", "=ISNUMBER(D1)": "FALSE", @@ -1457,8 +1457,9 @@ func TestCalcCellValue(t *testing.T) { "=IFERROR(G1,2)": "0", "=IFERROR(B2/MROUND(A2,1),0)": "2.5", // IFNA - "=IFNA(1,\"not found\")": "1", - "=IFNA(NA(),\"not found\")": "not found", + "=IFNA(1,\"not found\")": "1", + "=IFNA(NA(),\"not found\")": "not found", + "=IFNA(HLOOKUP(D2,D:D,1,2),\"not found\")": "not found", // IFS "=IFS(4>1,5/4,4<-1,-5/4,TRUE,0)": "1.25", "=IFS(-2>1,5/-2,-2<-1,-5/-2,TRUE,0)": "2.5", @@ -2122,2247 +2123,2247 @@ func TestCalcCellValue(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - mathCalcError := map[string]string{ - "=1/0": "#DIV/0!", - "1^\"text\"": "strconv.ParseFloat: parsing \"text\": invalid syntax", - "\"text\"^1": "strconv.ParseFloat: parsing \"text\": invalid syntax", - "1+\"text\"": "strconv.ParseFloat: parsing \"text\": invalid syntax", - "\"text\"+1": "strconv.ParseFloat: parsing \"text\": invalid syntax", - "1-\"text\"": "strconv.ParseFloat: parsing \"text\": invalid syntax", - "\"text\"-1": "strconv.ParseFloat: parsing \"text\": invalid syntax", - "1*\"text\"": "strconv.ParseFloat: parsing \"text\": invalid syntax", - "\"text\"*1": "strconv.ParseFloat: parsing \"text\": invalid syntax", - "1/\"text\"": "strconv.ParseFloat: parsing \"text\": invalid syntax", - "\"text\"/1": "strconv.ParseFloat: parsing \"text\": invalid syntax", + mathCalcError := map[string][]string{ + "=1/0": {"", "#DIV/0!"}, + "1^\"text\"": {"", "strconv.ParseFloat: parsing \"text\": invalid syntax"}, + "\"text\"^1": {"", "strconv.ParseFloat: parsing \"text\": invalid syntax"}, + "1+\"text\"": {"", "strconv.ParseFloat: parsing \"text\": invalid syntax"}, + "\"text\"+1": {"", "strconv.ParseFloat: parsing \"text\": invalid syntax"}, + "1-\"text\"": {"", "strconv.ParseFloat: parsing \"text\": invalid syntax"}, + "\"text\"-1": {"", "strconv.ParseFloat: parsing \"text\": invalid syntax"}, + "1*\"text\"": {"", "strconv.ParseFloat: parsing \"text\": invalid syntax"}, + "\"text\"*1": {"", "strconv.ParseFloat: parsing \"text\": invalid syntax"}, + "1/\"text\"": {"", "strconv.ParseFloat: parsing \"text\": invalid syntax"}, + "\"text\"/1": {"", "strconv.ParseFloat: parsing \"text\": invalid syntax"}, // Engineering Functions // BESSELI - "=BESSELI()": "BESSELI requires 2 numeric arguments", - "=BESSELI(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BESSELI(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=BESSELI()": {"#VALUE!", "BESSELI requires 2 numeric arguments"}, + "=BESSELI(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BESSELI(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // BESSELJ - "=BESSELJ()": "BESSELJ requires 2 numeric arguments", - "=BESSELJ(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BESSELJ(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=BESSELJ()": {"#VALUE!", "BESSELJ requires 2 numeric arguments"}, + "=BESSELJ(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BESSELJ(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // BESSELK - "=BESSELK()": "BESSELK requires 2 numeric arguments", - "=BESSELK(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BESSELK(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BESSELK(-1,0)": "#NUM!", - "=BESSELK(1,-1)": "#NUM!", + "=BESSELK()": {"#VALUE!", "BESSELK requires 2 numeric arguments"}, + "=BESSELK(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BESSELK(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BESSELK(-1,0)": {"#NUM!", "#NUM!"}, + "=BESSELK(1,-1)": {"#NUM!", "#NUM!"}, // BESSELY - "=BESSELY()": "BESSELY requires 2 numeric arguments", - "=BESSELY(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BESSELY(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BESSELY(-1,0)": "#NUM!", - "=BESSELY(1,-1)": "#NUM!", + "=BESSELY()": {"#VALUE!", "BESSELY requires 2 numeric arguments"}, + "=BESSELY(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BESSELY(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BESSELY(-1,0)": {"#NUM!", "#NUM!"}, + "=BESSELY(1,-1)": {"#NUM!", "#NUM!"}, // BIN2DEC - "=BIN2DEC()": "BIN2DEC requires 1 numeric argument", - "=BIN2DEC(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=BIN2DEC()": {"#VALUE!", "BIN2DEC requires 1 numeric argument"}, + "=BIN2DEC(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // BIN2HEX - "=BIN2HEX()": "BIN2HEX requires at least 1 argument", - "=BIN2HEX(1,1,1)": "BIN2HEX allows at most 2 arguments", - "=BIN2HEX(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BIN2HEX(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BIN2HEX(12345678901,10)": "#NUM!", - "=BIN2HEX(1,-1)": "#NUM!", - "=BIN2HEX(31,1)": "#NUM!", + "=BIN2HEX()": {"#VALUE!", "BIN2HEX requires at least 1 argument"}, + "=BIN2HEX(1,1,1)": {"#VALUE!", "BIN2HEX allows at most 2 arguments"}, + "=BIN2HEX(\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BIN2HEX(1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BIN2HEX(12345678901,10)": {"#NUM!", "#NUM!"}, + "=BIN2HEX(1,-1)": {"#NUM!", "#NUM!"}, + "=BIN2HEX(31,1)": {"#NUM!", "#NUM!"}, // BIN2OCT - "=BIN2OCT()": "BIN2OCT requires at least 1 argument", - "=BIN2OCT(1,1,1)": "BIN2OCT allows at most 2 arguments", - "=BIN2OCT(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BIN2OCT(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BIN2OCT(-12345678901 ,10)": "#NUM!", - "=BIN2OCT(1,-1)": "#NUM!", - "=BIN2OCT(8,1)": "#NUM!", + "=BIN2OCT()": {"#VALUE!", "BIN2OCT requires at least 1 argument"}, + "=BIN2OCT(1,1,1)": {"#VALUE!", "BIN2OCT allows at most 2 arguments"}, + "=BIN2OCT(\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BIN2OCT(1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BIN2OCT(-12345678901 ,10)": {"#NUM!", "#NUM!"}, + "=BIN2OCT(1,-1)": {"#NUM!", "#NUM!"}, + "=BIN2OCT(8,1)": {"#NUM!", "#NUM!"}, // BITAND - "=BITAND()": "BITAND requires 2 numeric arguments", - "=BITAND(-1,2)": "#NUM!", - "=BITAND(2^48,2)": "#NUM!", - "=BITAND(1,-1)": "#NUM!", - "=BITAND(\"\",-1)": "#NUM!", - "=BITAND(1,\"\")": "#NUM!", - "=BITAND(1,2^48)": "#NUM!", + "=BITAND()": {"#VALUE!", "BITAND requires 2 numeric arguments"}, + "=BITAND(-1,2)": {"#NUM!", "#NUM!"}, + "=BITAND(2^48,2)": {"#NUM!", "#NUM!"}, + "=BITAND(1,-1)": {"#NUM!", "#NUM!"}, + "=BITAND(\"\",-1)": {"#NUM!", "#NUM!"}, + "=BITAND(1,\"\")": {"#NUM!", "#NUM!"}, + "=BITAND(1,2^48)": {"#NUM!", "#NUM!"}, // BITLSHIFT - "=BITLSHIFT()": "BITLSHIFT requires 2 numeric arguments", - "=BITLSHIFT(-1,2)": "#NUM!", - "=BITLSHIFT(2^48,2)": "#NUM!", - "=BITLSHIFT(1,-1)": "#NUM!", - "=BITLSHIFT(\"\",-1)": "#NUM!", - "=BITLSHIFT(1,\"\")": "#NUM!", - "=BITLSHIFT(1,2^48)": "#NUM!", + "=BITLSHIFT()": {"#VALUE!", "BITLSHIFT requires 2 numeric arguments"}, + "=BITLSHIFT(-1,2)": {"#NUM!", "#NUM!"}, + "=BITLSHIFT(2^48,2)": {"#NUM!", "#NUM!"}, + "=BITLSHIFT(1,-1)": {"#NUM!", "#NUM!"}, + "=BITLSHIFT(\"\",-1)": {"#NUM!", "#NUM!"}, + "=BITLSHIFT(1,\"\")": {"#NUM!", "#NUM!"}, + "=BITLSHIFT(1,2^48)": {"#NUM!", "#NUM!"}, // BITOR - "=BITOR()": "BITOR requires 2 numeric arguments", - "=BITOR(-1,2)": "#NUM!", - "=BITOR(2^48,2)": "#NUM!", - "=BITOR(1,-1)": "#NUM!", - "=BITOR(\"\",-1)": "#NUM!", - "=BITOR(1,\"\")": "#NUM!", - "=BITOR(1,2^48)": "#NUM!", + "=BITOR()": {"#VALUE!", "BITOR requires 2 numeric arguments"}, + "=BITOR(-1,2)": {"#NUM!", "#NUM!"}, + "=BITOR(2^48,2)": {"#NUM!", "#NUM!"}, + "=BITOR(1,-1)": {"#NUM!", "#NUM!"}, + "=BITOR(\"\",-1)": {"#NUM!", "#NUM!"}, + "=BITOR(1,\"\")": {"#NUM!", "#NUM!"}, + "=BITOR(1,2^48)": {"#NUM!", "#NUM!"}, // BITRSHIFT - "=BITRSHIFT()": "BITRSHIFT requires 2 numeric arguments", - "=BITRSHIFT(-1,2)": "#NUM!", - "=BITRSHIFT(2^48,2)": "#NUM!", - "=BITRSHIFT(1,-1)": "#NUM!", - "=BITRSHIFT(\"\",-1)": "#NUM!", - "=BITRSHIFT(1,\"\")": "#NUM!", - "=BITRSHIFT(1,2^48)": "#NUM!", + "=BITRSHIFT()": {"#VALUE!", "BITRSHIFT requires 2 numeric arguments"}, + "=BITRSHIFT(-1,2)": {"#NUM!", "#NUM!"}, + "=BITRSHIFT(2^48,2)": {"#NUM!", "#NUM!"}, + "=BITRSHIFT(1,-1)": {"#NUM!", "#NUM!"}, + "=BITRSHIFT(\"\",-1)": {"#NUM!", "#NUM!"}, + "=BITRSHIFT(1,\"\")": {"#NUM!", "#NUM!"}, + "=BITRSHIFT(1,2^48)": {"#NUM!", "#NUM!"}, // BITXOR - "=BITXOR()": "BITXOR requires 2 numeric arguments", - "=BITXOR(-1,2)": "#NUM!", - "=BITXOR(2^48,2)": "#NUM!", - "=BITXOR(1,-1)": "#NUM!", - "=BITXOR(\"\",-1)": "#NUM!", - "=BITXOR(1,\"\")": "#NUM!", - "=BITXOR(1,2^48)": "#NUM!", + "=BITXOR()": {"#VALUE!", "BITXOR requires 2 numeric arguments"}, + "=BITXOR(-1,2)": {"#NUM!", "#NUM!"}, + "=BITXOR(2^48,2)": {"#NUM!", "#NUM!"}, + "=BITXOR(1,-1)": {"#NUM!", "#NUM!"}, + "=BITXOR(\"\",-1)": {"#NUM!", "#NUM!"}, + "=BITXOR(1,\"\")": {"#NUM!", "#NUM!"}, + "=BITXOR(1,2^48)": {"#NUM!", "#NUM!"}, // COMPLEX - "=COMPLEX()": "COMPLEX requires at least 2 arguments", - "=COMPLEX(10,-5,\"\")": "#VALUE!", - "=COMPLEX(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=COMPLEX(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=COMPLEX(10,-5,\"i\",0)": "COMPLEX allows at most 3 arguments", + "=COMPLEX()": {"#VALUE!", "COMPLEX requires at least 2 arguments"}, + "=COMPLEX(10,-5,\"\")": {"#VALUE!", "#VALUE!"}, + "=COMPLEX(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=COMPLEX(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=COMPLEX(10,-5,\"i\",0)": {"#VALUE!", "COMPLEX allows at most 3 arguments"}, // CONVERT - "=CONVERT()": "CONVERT requires 3 arguments", - "=CONVERT(\"\",\"m\",\"yd\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CONVERT(20.2,\"m\",\"C\")": "#N/A", - "=CONVERT(20.2,\"\",\"C\")": "#N/A", - "=CONVERT(100,\"dapt\",\"pt\")": "#N/A", - "=CONVERT(1,\"ft\",\"day\")": "#N/A", - "=CONVERT(234.56,\"kpt\",\"lt\")": "#N/A", - "=CONVERT(234.56,\"lt\",\"kpt\")": "#N/A", - "=CONVERT(234.56,\"kiqt\",\"pt\")": "#N/A", - "=CONVERT(234.56,\"pt\",\"kiqt\")": "#N/A", - "=CONVERT(12345.6,\"baton\",\"cwt\")": "#N/A", - "=CONVERT(12345.6,\"cwt\",\"baton\")": "#N/A", - "=CONVERT(234.56,\"xxxx\",\"m\")": "#N/A", - "=CONVERT(234.56,\"m\",\"xxxx\")": "#N/A", + "=CONVERT()": {"#VALUE!", "CONVERT requires 3 arguments"}, + "=CONVERT(\"\",\"m\",\"yd\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CONVERT(20.2,\"m\",\"C\")": {"#N/A", "#N/A"}, + "=CONVERT(20.2,\"\",\"C\")": {"#N/A", "#N/A"}, + "=CONVERT(100,\"dapt\",\"pt\")": {"#N/A", "#N/A"}, + "=CONVERT(1,\"ft\",\"day\")": {"#N/A", "#N/A"}, + "=CONVERT(234.56,\"kpt\",\"lt\")": {"#N/A", "#N/A"}, + "=CONVERT(234.56,\"lt\",\"kpt\")": {"#N/A", "#N/A"}, + "=CONVERT(234.56,\"kiqt\",\"pt\")": {"#N/A", "#N/A"}, + "=CONVERT(234.56,\"pt\",\"kiqt\")": {"#N/A", "#N/A"}, + "=CONVERT(12345.6,\"baton\",\"cwt\")": {"#N/A", "#N/A"}, + "=CONVERT(12345.6,\"cwt\",\"baton\")": {"#N/A", "#N/A"}, + "=CONVERT(234.56,\"xxxx\",\"m\")": {"#N/A", "#N/A"}, + "=CONVERT(234.56,\"m\",\"xxxx\")": {"#N/A", "#N/A"}, // DEC2BIN - "=DEC2BIN()": "DEC2BIN requires at least 1 argument", - "=DEC2BIN(1,1,1)": "DEC2BIN allows at most 2 arguments", - "=DEC2BIN(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DEC2BIN(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DEC2BIN(-513,10)": "#NUM!", - "=DEC2BIN(1,-1)": "#NUM!", - "=DEC2BIN(2,1)": "#NUM!", + "=DEC2BIN()": {"#VALUE!", "DEC2BIN requires at least 1 argument"}, + "=DEC2BIN(1,1,1)": {"#VALUE!", "DEC2BIN allows at most 2 arguments"}, + "=DEC2BIN(\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DEC2BIN(1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DEC2BIN(-513,10)": {"#NUM!", "#NUM!"}, + "=DEC2BIN(1,-1)": {"#NUM!", "#NUM!"}, + "=DEC2BIN(2,1)": {"#NUM!", "#NUM!"}, // DEC2HEX - "=DEC2HEX()": "DEC2HEX requires at least 1 argument", - "=DEC2HEX(1,1,1)": "DEC2HEX allows at most 2 arguments", - "=DEC2HEX(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DEC2HEX(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DEC2HEX(-549755813888,10)": "#NUM!", - "=DEC2HEX(1,-1)": "#NUM!", - "=DEC2HEX(31,1)": "#NUM!", + "=DEC2HEX()": {"#VALUE!", "DEC2HEX requires at least 1 argument"}, + "=DEC2HEX(1,1,1)": {"#VALUE!", "DEC2HEX allows at most 2 arguments"}, + "=DEC2HEX(\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DEC2HEX(1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DEC2HEX(-549755813888,10)": {"#NUM!", "#NUM!"}, + "=DEC2HEX(1,-1)": {"#NUM!", "#NUM!"}, + "=DEC2HEX(31,1)": {"#NUM!", "#NUM!"}, // DEC2OCT - "=DEC2OCT()": "DEC2OCT requires at least 1 argument", - "=DEC2OCT(1,1,1)": "DEC2OCT allows at most 2 arguments", - "=DEC2OCT(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DEC2OCT(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DEC2OCT(-536870912 ,10)": "#NUM!", - "=DEC2OCT(1,-1)": "#NUM!", - "=DEC2OCT(8,1)": "#NUM!", + "=DEC2OCT()": {"#VALUE!", "DEC2OCT requires at least 1 argument"}, + "=DEC2OCT(1,1,1)": {"#VALUE!", "DEC2OCT allows at most 2 arguments"}, + "=DEC2OCT(\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DEC2OCT(1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DEC2OCT(-536870912 ,10)": {"#NUM!", "#NUM!"}, + "=DEC2OCT(1,-1)": {"#NUM!", "#NUM!"}, + "=DEC2OCT(8,1)": {"#NUM!", "#NUM!"}, // DELTA - "=DELTA()": "DELTA requires at least 1 argument", - "=DELTA(0,0,0)": "DELTA allows at most 2 arguments", - "=DELTA(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DELTA(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=DELTA()": {"#VALUE!", "DELTA requires at least 1 argument"}, + "=DELTA(0,0,0)": {"#VALUE!", "DELTA allows at most 2 arguments"}, + "=DELTA(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DELTA(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // ERF - "=ERF()": "ERF requires at least 1 argument", - "=ERF(0,0,0)": "ERF allows at most 2 arguments", - "=ERF(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=ERF(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=ERF()": {"#VALUE!", "ERF requires at least 1 argument"}, + "=ERF(0,0,0)": {"#VALUE!", "ERF allows at most 2 arguments"}, + "=ERF(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=ERF(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // ERF.PRECISE - "=ERF.PRECISE()": "ERF.PRECISE requires 1 argument", - "=ERF.PRECISE(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=ERF.PRECISE()": {"#VALUE!", "ERF.PRECISE requires 1 argument"}, + "=ERF.PRECISE(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // ERFC - "=ERFC()": "ERFC requires 1 argument", - "=ERFC(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=ERFC()": {"#VALUE!", "ERFC requires 1 argument"}, + "=ERFC(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // ERFC.PRECISE - "=ERFC.PRECISE()": "ERFC.PRECISE requires 1 argument", - "=ERFC.PRECISE(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=ERFC.PRECISE()": {"#VALUE!", "ERFC.PRECISE requires 1 argument"}, + "=ERFC.PRECISE(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // GESTEP - "=GESTEP()": "GESTEP requires at least 1 argument", - "=GESTEP(0,0,0)": "GESTEP allows at most 2 arguments", - "=GESTEP(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GESTEP(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=GESTEP()": {"#VALUE!", "GESTEP requires at least 1 argument"}, + "=GESTEP(0,0,0)": {"#VALUE!", "GESTEP allows at most 2 arguments"}, + "=GESTEP(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GESTEP(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // HEX2BIN - "=HEX2BIN()": "HEX2BIN requires at least 1 argument", - "=HEX2BIN(1,1,1)": "HEX2BIN allows at most 2 arguments", - "=HEX2BIN(\"X\",1)": "strconv.ParseInt: parsing \"X\": invalid syntax", - "=HEX2BIN(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=HEX2BIN(-513,10)": "strconv.ParseInt: parsing \"-\": invalid syntax", - "=HEX2BIN(1,-1)": "#NUM!", - "=HEX2BIN(2,1)": "#NUM!", + "=HEX2BIN()": {"#VALUE!", "HEX2BIN requires at least 1 argument"}, + "=HEX2BIN(1,1,1)": {"#VALUE!", "HEX2BIN allows at most 2 arguments"}, + "=HEX2BIN(\"X\",1)": {"#NUM!", "strconv.ParseInt: parsing \"X\": invalid syntax"}, + "=HEX2BIN(1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=HEX2BIN(-513,10)": {"#NUM!", "strconv.ParseInt: parsing \"-\": invalid syntax"}, + "=HEX2BIN(1,-1)": {"#NUM!", "#NUM!"}, + "=HEX2BIN(2,1)": {"#NUM!", "#NUM!"}, // HEX2DEC - "=HEX2DEC()": "HEX2DEC requires 1 numeric argument", - "=HEX2DEC(\"X\")": "strconv.ParseInt: parsing \"X\": invalid syntax", + "=HEX2DEC()": {"#VALUE!", "HEX2DEC requires 1 numeric argument"}, + "=HEX2DEC(\"X\")": {"#NUM!", "strconv.ParseInt: parsing \"X\": invalid syntax"}, // HEX2OCT - "=HEX2OCT()": "HEX2OCT requires at least 1 argument", - "=HEX2OCT(1,1,1)": "HEX2OCT allows at most 2 arguments", - "=HEX2OCT(\"X\",1)": "strconv.ParseInt: parsing \"X\": invalid syntax", - "=HEX2OCT(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=HEX2OCT(-513,10)": "strconv.ParseInt: parsing \"-\": invalid syntax", - "=HEX2OCT(1,-1)": "#NUM!", + "=HEX2OCT()": {"#VALUE!", "HEX2OCT requires at least 1 argument"}, + "=HEX2OCT(1,1,1)": {"#VALUE!", "HEX2OCT allows at most 2 arguments"}, + "=HEX2OCT(\"X\",1)": {"#NUM!", "strconv.ParseInt: parsing \"X\": invalid syntax"}, + "=HEX2OCT(1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=HEX2OCT(-513,10)": {"#NUM!", "strconv.ParseInt: parsing \"-\": invalid syntax"}, + "=HEX2OCT(1,-1)": {"#NUM!", "#NUM!"}, // IMABS - "=IMABS()": "IMABS requires 1 argument", - "=IMABS(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMABS()": {"#VALUE!", "IMABS requires 1 argument"}, + "=IMABS(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMAGINARY - "=IMAGINARY()": "IMAGINARY requires 1 argument", - "=IMAGINARY(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMAGINARY()": {"#VALUE!", "IMAGINARY requires 1 argument"}, + "=IMAGINARY(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMARGUMENT - "=IMARGUMENT()": "IMARGUMENT requires 1 argument", - "=IMARGUMENT(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMARGUMENT()": {"#VALUE!", "IMARGUMENT requires 1 argument"}, + "=IMARGUMENT(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMCONJUGATE - "=IMCONJUGATE()": "IMCONJUGATE requires 1 argument", - "=IMCONJUGATE(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMCONJUGATE()": {"#VALUE!", "IMCONJUGATE requires 1 argument"}, + "=IMCONJUGATE(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMCOS - "=IMCOS()": "IMCOS requires 1 argument", - "=IMCOS(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMCOS()": {"#VALUE!", "IMCOS requires 1 argument"}, + "=IMCOS(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMCOSH - "=IMCOSH()": "IMCOSH requires 1 argument", - "=IMCOSH(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMCOSH()": {"#VALUE!", "IMCOSH requires 1 argument"}, + "=IMCOSH(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMCOT - "=IMCOT()": "IMCOT requires 1 argument", - "=IMCOT(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMCOT()": {"#VALUE!", "IMCOT requires 1 argument"}, + "=IMCOT(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMCSC - "=IMCSC()": "IMCSC requires 1 argument", - "=IMCSC(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", - "=IMCSC(0)": "#NUM!", + "=IMCSC()": {"#VALUE!", "IMCSC requires 1 argument"}, + "=IMCSC(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, + "=IMCSC(0)": {"#NUM!", "#NUM!"}, // IMCSCH - "=IMCSCH()": "IMCSCH requires 1 argument", - "=IMCSCH(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", - "=IMCSCH(0)": "#NUM!", + "=IMCSCH()": {"#VALUE!", "IMCSCH requires 1 argument"}, + "=IMCSCH(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, + "=IMCSCH(0)": {"#NUM!", "#NUM!"}, // IMDIV - "=IMDIV()": "IMDIV requires 2 arguments", - "=IMDIV(0,\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", - "=IMDIV(\"\",0)": "strconv.ParseComplex: parsing \"\": invalid syntax", - "=IMDIV(1,0)": "#NUM!", + "=IMDIV()": {"#VALUE!", "IMDIV requires 2 arguments"}, + "=IMDIV(0,\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, + "=IMDIV(\"\",0)": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, + "=IMDIV(1,0)": {"#NUM!", "#NUM!"}, // IMEXP - "=IMEXP()": "IMEXP requires 1 argument", - "=IMEXP(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMEXP()": {"#VALUE!", "IMEXP requires 1 argument"}, + "=IMEXP(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMLN - "=IMLN()": "IMLN requires 1 argument", - "=IMLN(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", - "=IMLN(0)": "#NUM!", + "=IMLN()": {"#VALUE!", "IMLN requires 1 argument"}, + "=IMLN(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, + "=IMLN(0)": {"#NUM!", "#NUM!"}, // IMLOG10 - "=IMLOG10()": "IMLOG10 requires 1 argument", - "=IMLOG10(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", - "=IMLOG10(0)": "#NUM!", + "=IMLOG10()": {"#VALUE!", "IMLOG10 requires 1 argument"}, + "=IMLOG10(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, + "=IMLOG10(0)": {"#NUM!", "#NUM!"}, // IMLOG2 - "=IMLOG2()": "IMLOG2 requires 1 argument", - "=IMLOG2(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", - "=IMLOG2(0)": "#NUM!", + "=IMLOG2()": {"#VALUE!", "IMLOG2 requires 1 argument"}, + "=IMLOG2(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, + "=IMLOG2(0)": {"#NUM!", "#NUM!"}, // IMPOWER - "=IMPOWER()": "IMPOWER requires 2 arguments", - "=IMPOWER(0,\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", - "=IMPOWER(\"\",0)": "strconv.ParseComplex: parsing \"\": invalid syntax", - "=IMPOWER(0,0)": "#NUM!", - "=IMPOWER(0,-1)": "#NUM!", + "=IMPOWER()": {"#VALUE!", "IMPOWER requires 2 arguments"}, + "=IMPOWER(0,\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, + "=IMPOWER(\"\",0)": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, + "=IMPOWER(0,0)": {"#NUM!", "#NUM!"}, + "=IMPOWER(0,-1)": {"#NUM!", "#NUM!"}, // IMPRODUCT - "=IMPRODUCT(\"x\")": "strconv.ParseComplex: parsing \"x\": invalid syntax", - "=IMPRODUCT(A1:D1)": "strconv.ParseComplex: parsing \"Month\": invalid syntax", + "=IMPRODUCT(\"x\")": {"#NUM!", "strconv.ParseComplex: parsing \"x\": invalid syntax"}, + "=IMPRODUCT(A1:D1)": {"#NUM!", "strconv.ParseComplex: parsing \"Month\": invalid syntax"}, // IMREAL - "=IMREAL()": "IMREAL requires 1 argument", - "=IMREAL(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMREAL()": {"#VALUE!", "IMREAL requires 1 argument"}, + "=IMREAL(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMSEC - "=IMSEC()": "IMSEC requires 1 argument", - "=IMSEC(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMSEC()": {"#VALUE!", "IMSEC requires 1 argument"}, + "=IMSEC(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMSECH - "=IMSECH()": "IMSECH requires 1 argument", - "=IMSECH(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMSECH()": {"#VALUE!", "IMSECH requires 1 argument"}, + "=IMSECH(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMSIN - "=IMSIN()": "IMSIN requires 1 argument", - "=IMSIN(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMSIN()": {"#VALUE!", "IMSIN requires 1 argument"}, + "=IMSIN(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMSINH - "=IMSINH()": "IMSINH requires 1 argument", - "=IMSINH(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMSINH()": {"#VALUE!", "IMSINH requires 1 argument"}, + "=IMSINH(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMSQRT - "=IMSQRT()": "IMSQRT requires 1 argument", - "=IMSQRT(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMSQRT()": {"#VALUE!", "IMSQRT requires 1 argument"}, + "=IMSQRT(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMSUB - "=IMSUB()": "IMSUB requires 2 arguments", - "=IMSUB(0,\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", - "=IMSUB(\"\",0)": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMSUB()": {"#VALUE!", "IMSUB requires 2 arguments"}, + "=IMSUB(0,\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, + "=IMSUB(\"\",0)": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMSUM - "=IMSUM()": "IMSUM requires at least 1 argument", - "=IMSUM(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMSUM()": {"#VALUE!", "IMSUM requires at least 1 argument"}, + "=IMSUM(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // IMTAN - "=IMTAN()": "IMTAN requires 1 argument", - "=IMTAN(\"\")": "strconv.ParseComplex: parsing \"\": invalid syntax", + "=IMTAN()": {"#VALUE!", "IMTAN requires 1 argument"}, + "=IMTAN(\"\")": {"#NUM!", "strconv.ParseComplex: parsing \"\": invalid syntax"}, // OCT2BIN - "=OCT2BIN()": "OCT2BIN requires at least 1 argument", - "=OCT2BIN(1,1,1)": "OCT2BIN allows at most 2 arguments", - "=OCT2BIN(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=OCT2BIN(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=OCT2BIN(-536870912 ,10)": "#NUM!", - "=OCT2BIN(1,-1)": "#NUM!", + "=OCT2BIN()": {"#VALUE!", "OCT2BIN requires at least 1 argument"}, + "=OCT2BIN(1,1,1)": {"#VALUE!", "OCT2BIN allows at most 2 arguments"}, + "=OCT2BIN(\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=OCT2BIN(1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=OCT2BIN(-536870912 ,10)": {"#NUM!", "#NUM!"}, + "=OCT2BIN(1,-1)": {"#NUM!", "#NUM!"}, // OCT2DEC - "=OCT2DEC()": "OCT2DEC requires 1 numeric argument", - "=OCT2DEC(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=OCT2DEC()": {"#VALUE!", "OCT2DEC requires 1 numeric argument"}, + "=OCT2DEC(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // OCT2HEX - "=OCT2HEX()": "OCT2HEX requires at least 1 argument", - "=OCT2HEX(1,1,1)": "OCT2HEX allows at most 2 arguments", - "=OCT2HEX(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=OCT2HEX(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=OCT2HEX(-536870912 ,10)": "#NUM!", - "=OCT2HEX(1,-1)": "#NUM!", + "=OCT2HEX()": {"#VALUE!", "OCT2HEX requires at least 1 argument"}, + "=OCT2HEX(1,1,1)": {"#VALUE!", "OCT2HEX allows at most 2 arguments"}, + "=OCT2HEX(\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=OCT2HEX(1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=OCT2HEX(-536870912 ,10)": {"#NUM!", "#NUM!"}, + "=OCT2HEX(1,-1)": {"#NUM!", "#NUM!"}, // Math and Trigonometric Functions // ABS - "=ABS()": "ABS requires 1 numeric argument", - `=ABS("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=ABS(~)": newInvalidColumnNameError("~").Error(), + "=ABS()": {"#VALUE!", "ABS requires 1 numeric argument"}, + "=ABS(\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=ABS(~)": {"", newInvalidColumnNameError("~").Error()}, // ACOS - "=ACOS()": "ACOS requires 1 numeric argument", - `=ACOS("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=ACOS(ACOS(0))": "#NUM!", + "=ACOS()": {"#VALUE!", "ACOS requires 1 numeric argument"}, + "=ACOS(\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=ACOS(ACOS(0))": {"#NUM!", "#NUM!"}, // ACOSH - "=ACOSH()": "ACOSH requires 1 numeric argument", - `=ACOSH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=ACOSH()": {"#VALUE!", "ACOSH requires 1 numeric argument"}, + "=ACOSH(\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // _xlfn.ACOT - "=_xlfn.ACOT()": "ACOT requires 1 numeric argument", - `=_xlfn.ACOT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=_xlfn.ACOT()": {"#VALUE!", "ACOT requires 1 numeric argument"}, + "=_xlfn.ACOT(\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // _xlfn.ACOTH - "=_xlfn.ACOTH()": "ACOTH requires 1 numeric argument", - `=_xlfn.ACOTH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=_xlfn.ACOTH(_xlfn.ACOTH(2))": "#NUM!", + "=_xlfn.ACOTH()": {"#VALUE!", "ACOTH requires 1 numeric argument"}, + "=_xlfn.ACOTH(\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=_xlfn.ACOTH(_xlfn.ACOTH(2))": {"#NUM!", "#NUM!"}, // _xlfn.AGGREGATE - "=_xlfn.AGGREGATE()": "AGGREGATE requires at least 3 arguments", - "=_xlfn.AGGREGATE(\"\",0,A4:A5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=_xlfn.AGGREGATE(1,\"\",A4:A5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=_xlfn.AGGREGATE(0,A4:A5)": "AGGREGATE has invalid function_num", - "=_xlfn.AGGREGATE(1,8,A4:A5)": "AGGREGATE has invalid options", - "=_xlfn.AGGREGATE(1,0,A5:A6)": "#DIV/0!", - "=_xlfn.AGGREGATE(13,0,A1:A6)": "#N/A", - "=_xlfn.AGGREGATE(18,0,A1:A6,1)": "#NUM!", + "=_xlfn.AGGREGATE()": {"#VALUE!", "AGGREGATE requires at least 3 arguments"}, + "=_xlfn.AGGREGATE(\"\",0,A4:A5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=_xlfn.AGGREGATE(1,\"\",A4:A5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=_xlfn.AGGREGATE(0,A4:A5)": {"#VALUE!", "AGGREGATE has invalid function_num"}, + "=_xlfn.AGGREGATE(1,8,A4:A5)": {"#VALUE!", "AGGREGATE has invalid options"}, + "=_xlfn.AGGREGATE(1,0,A5:A6)": {"#DIV/0!", "#DIV/0!"}, + "=_xlfn.AGGREGATE(13,0,A1:A6)": {"#N/A", "#N/A"}, + "=_xlfn.AGGREGATE(18,0,A1:A6,1)": {"#NUM!", "#NUM!"}, // _xlfn.ARABIC - "=_xlfn.ARABIC()": "ARABIC requires 1 numeric argument", - "=_xlfn.ARABIC(\"" + strings.Repeat("I", 256) + "\")": "#VALUE!", + "=_xlfn.ARABIC()": {"#VALUE!", "ARABIC requires 1 numeric argument"}, + "=_xlfn.ARABIC(\"" + strings.Repeat("I", 256) + "\")": {"#VALUE!", "#VALUE!"}, // ASIN - "=ASIN()": "ASIN requires 1 numeric argument", - `=ASIN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=ASIN()": {"#VALUE!", "ASIN requires 1 numeric argument"}, + `=ASIN("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // ASINH - "=ASINH()": "ASINH requires 1 numeric argument", - `=ASINH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=ASINH()": {"#VALUE!", "ASINH requires 1 numeric argument"}, + `=ASINH("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // ATAN - "=ATAN()": "ATAN requires 1 numeric argument", - `=ATAN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=ATAN()": {"#VALUE!", "ATAN requires 1 numeric argument"}, + `=ATAN("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // ATANH - "=ATANH()": "ATANH requires 1 numeric argument", - `=ATANH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=ATANH()": {"#VALUE!", "ATANH requires 1 numeric argument"}, + `=ATANH("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // ATAN2 - "=ATAN2()": "ATAN2 requires 2 numeric arguments", - `=ATAN2("X",0)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=ATAN2(0,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=ATAN2()": {"#VALUE!", "ATAN2 requires 2 numeric arguments"}, + `=ATAN2("X",0)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=ATAN2(0,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // BASE - "=BASE()": "BASE requires at least 2 arguments", - "=BASE(1,2,3,4)": "BASE allows at most 3 arguments", - "=BASE(1,1)": "radix must be an integer >= 2 and <= 36", - `=BASE("X",2)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=BASE(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=BASE(1,2,"X")`: "strconv.Atoi: parsing \"X\": invalid syntax", + "=BASE()": {"#VALUE!", "BASE requires at least 2 arguments"}, + "=BASE(1,2,3,4)": {"#VALUE!", "BASE allows at most 3 arguments"}, + "=BASE(1,1)": {"#VALUE!", "radix must be an integer >= 2 and <= 36"}, + `=BASE("X",2)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=BASE(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=BASE(1,2,"X")`: {"#VALUE!", "strconv.Atoi: parsing \"X\": invalid syntax"}, // CEILING - "=CEILING()": "CEILING requires at least 1 argument", - "=CEILING(1,2,3)": "CEILING allows at most 2 arguments", - "=CEILING(1,-1)": "negative sig to CEILING invalid", - `=CEILING("X",0)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=CEILING(0,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=CEILING()": {"#VALUE!", "CEILING requires at least 1 argument"}, + "=CEILING(1,2,3)": {"#VALUE!", "CEILING allows at most 2 arguments"}, + "=CEILING(1,-1)": {"#VALUE!", "negative sig to CEILING invalid"}, + `=CEILING("X",0)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=CEILING(0,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // _xlfn.CEILING.MATH - "=_xlfn.CEILING.MATH()": "CEILING.MATH requires at least 1 argument", - "=_xlfn.CEILING.MATH(1,2,3,4)": "CEILING.MATH allows at most 3 arguments", - `=_xlfn.CEILING.MATH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=_xlfn.CEILING.MATH(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=_xlfn.CEILING.MATH(1,2,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=_xlfn.CEILING.MATH()": {"#VALUE!", "CEILING.MATH requires at least 1 argument"}, + "=_xlfn.CEILING.MATH(1,2,3,4)": {"#VALUE!", "CEILING.MATH allows at most 3 arguments"}, + `=_xlfn.CEILING.MATH("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=_xlfn.CEILING.MATH(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=_xlfn.CEILING.MATH(1,2,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // _xlfn.CEILING.PRECISE - "=_xlfn.CEILING.PRECISE()": "CEILING.PRECISE requires at least 1 argument", - "=_xlfn.CEILING.PRECISE(1,2,3)": "CEILING.PRECISE allows at most 2 arguments", - `=_xlfn.CEILING.PRECISE("X",2)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=_xlfn.CEILING.PRECISE(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=_xlfn.CEILING.PRECISE()": {"#VALUE!", "CEILING.PRECISE requires at least 1 argument"}, + "=_xlfn.CEILING.PRECISE(1,2,3)": {"#VALUE!", "CEILING.PRECISE allows at most 2 arguments"}, + `=_xlfn.CEILING.PRECISE("X",2)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=_xlfn.CEILING.PRECISE(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // COMBIN - "=COMBIN()": "COMBIN requires 2 argument", - "=COMBIN(-1,1)": "COMBIN requires number >= number_chosen", - `=COMBIN("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=COMBIN(-1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=COMBIN()": {"#VALUE!", "COMBIN requires 2 argument"}, + "=COMBIN(-1,1)": {"#VALUE!", "COMBIN requires number >= number_chosen"}, + `=COMBIN("X",1)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=COMBIN(-1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // _xlfn.COMBINA - "=_xlfn.COMBINA()": "COMBINA requires 2 argument", - "=_xlfn.COMBINA(-1,1)": "COMBINA requires number > number_chosen", - "=_xlfn.COMBINA(-1,-1)": "COMBIN requires number >= number_chosen", - `=_xlfn.COMBINA("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=_xlfn.COMBINA(-1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=_xlfn.COMBINA()": {"#VALUE!", "COMBINA requires 2 argument"}, + "=_xlfn.COMBINA(-1,1)": {"#VALUE!", "COMBINA requires number > number_chosen"}, + "=_xlfn.COMBINA(-1,-1)": {"#VALUE!", "COMBIN requires number >= number_chosen"}, + `=_xlfn.COMBINA("X",1)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=_xlfn.COMBINA(-1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // COS - "=COS()": "COS requires 1 numeric argument", - `=COS("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=COS()": {"#VALUE!", "COS requires 1 numeric argument"}, + `=COS("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // COSH - "=COSH()": "COSH requires 1 numeric argument", - `=COSH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=COSH()": {"#VALUE!", "COSH requires 1 numeric argument"}, + `=COSH("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // _xlfn.COT - "=COT()": "COT requires 1 numeric argument", - `=COT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=COT(0)": "#DIV/0!", + "=COT()": {"#VALUE!", "COT requires 1 numeric argument"}, + `=COT("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=COT(0)": {"#DIV/0!", "#DIV/0!"}, // _xlfn.COTH - "=COTH()": "COTH requires 1 numeric argument", - `=COTH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=COTH(0)": "#DIV/0!", + "=COTH()": {"#VALUE!", "COTH requires 1 numeric argument"}, + `=COTH("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=COTH(0)": {"#DIV/0!", "#DIV/0!"}, // _xlfn.CSC - "=_xlfn.CSC()": "CSC requires 1 numeric argument", - `=_xlfn.CSC("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=_xlfn.CSC(0)": "#DIV/0!", + "=_xlfn.CSC()": {"#VALUE!", "CSC requires 1 numeric argument"}, + `=_xlfn.CSC("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=_xlfn.CSC(0)": {"#DIV/0!", "#DIV/0!"}, // _xlfn.CSCH - "=_xlfn.CSCH()": "CSCH requires 1 numeric argument", - `=_xlfn.CSCH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=_xlfn.CSCH(0)": "#DIV/0!", + "=_xlfn.CSCH()": {"#VALUE!", "CSCH requires 1 numeric argument"}, + `=_xlfn.CSCH("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=_xlfn.CSCH(0)": {"#DIV/0!", "#DIV/0!"}, // _xlfn.DECIMAL - "=_xlfn.DECIMAL()": "DECIMAL requires 2 numeric arguments", - `=_xlfn.DECIMAL("X", 2)`: "strconv.ParseInt: parsing \"X\": invalid syntax", - `=_xlfn.DECIMAL(2000, "X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=_xlfn.DECIMAL()": {"#VALUE!", "DECIMAL requires 2 numeric arguments"}, + `=_xlfn.DECIMAL("X",2)`: {"#VALUE!", "strconv.ParseInt: parsing \"X\": invalid syntax"}, + `=_xlfn.DECIMAL(2000,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // DEGREES - "=DEGREES()": "DEGREES requires 1 numeric argument", - `=DEGREES("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=DEGREES(0)": "#DIV/0!", + "=DEGREES()": {"#VALUE!", "DEGREES requires 1 numeric argument"}, + `=DEGREES("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=DEGREES(0)": {"#DIV/0!", "#DIV/0!"}, // EVEN - "=EVEN()": "EVEN requires 1 numeric argument", - `=EVEN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=EVEN()": {"#VALUE!", "EVEN requires 1 numeric argument"}, + `=EVEN("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // EXP - "=EXP()": "EXP requires 1 numeric argument", - `=EXP("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=EXP()": {"#VALUE!", "EXP requires 1 numeric argument"}, + `=EXP("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // FACT - "=FACT()": "FACT requires 1 numeric argument", - `=FACT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=FACT(-1)": "#NUM!", + "=FACT()": {"#VALUE!", "FACT requires 1 numeric argument"}, + `=FACT("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=FACT(-1)": {"#NUM!", "#NUM!"}, // FACTDOUBLE - "=FACTDOUBLE()": "FACTDOUBLE requires 1 numeric argument", - `=FACTDOUBLE("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=FACTDOUBLE(-1)": "#NUM!", + "=FACTDOUBLE()": {"#VALUE!", "FACTDOUBLE requires 1 numeric argument"}, + `=FACTDOUBLE("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=FACTDOUBLE(-1)": {"#NUM!", "#NUM!"}, // FLOOR - "=FLOOR()": "FLOOR requires 2 numeric arguments", - `=FLOOR("X",-1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=FLOOR(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=FLOOR(1,-1)": "invalid arguments to FLOOR", + "=FLOOR()": {"#VALUE!", "FLOOR requires 2 numeric arguments"}, + `=FLOOR("X",-1)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=FLOOR(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=FLOOR(1,-1)": {"#NUM!", "invalid arguments to FLOOR"}, // _xlfn.FLOOR.MATH - "=_xlfn.FLOOR.MATH()": "FLOOR.MATH requires at least 1 argument", - "=_xlfn.FLOOR.MATH(1,2,3,4)": "FLOOR.MATH allows at most 3 arguments", - `=_xlfn.FLOOR.MATH("X",2,3)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=_xlfn.FLOOR.MATH(1,"X",3)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=_xlfn.FLOOR.MATH(1,2,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=_xlfn.FLOOR.MATH()": {"#VALUE!", "FLOOR.MATH requires at least 1 argument"}, + "=_xlfn.FLOOR.MATH(1,2,3,4)": {"#VALUE!", "FLOOR.MATH allows at most 3 arguments"}, + `=_xlfn.FLOOR.MATH("X",2,3)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=_xlfn.FLOOR.MATH(1,"X",3)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=_xlfn.FLOOR.MATH(1,2,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // _xlfn.FLOOR.PRECISE - "=_xlfn.FLOOR.PRECISE()": "FLOOR.PRECISE requires at least 1 argument", - "=_xlfn.FLOOR.PRECISE(1,2,3)": "FLOOR.PRECISE allows at most 2 arguments", - `=_xlfn.FLOOR.PRECISE("X",2)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=_xlfn.FLOOR.PRECISE(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=_xlfn.FLOOR.PRECISE()": {"#VALUE!", "FLOOR.PRECISE requires at least 1 argument"}, + "=_xlfn.FLOOR.PRECISE(1,2,3)": {"#VALUE!", "FLOOR.PRECISE allows at most 2 arguments"}, + `=_xlfn.FLOOR.PRECISE("X",2)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=_xlfn.FLOOR.PRECISE(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // GCD - "=GCD()": "GCD requires at least 1 argument", - "=GCD(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GCD(-1)": "GCD only accepts positive arguments", - "=GCD(1,-1)": "GCD only accepts positive arguments", - `=GCD("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=GCD()": {"#VALUE!", "GCD requires at least 1 argument"}, + "=GCD(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GCD(-1)": {"#VALUE!", "GCD only accepts positive arguments"}, + "=GCD(1,-1)": {"#VALUE!", "GCD only accepts positive arguments"}, + `=GCD("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // INT - "=INT()": "INT requires 1 numeric argument", - `=INT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=INT()": {"#VALUE!", "INT requires 1 numeric argument"}, + `=INT("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // ISO.CEILING - "=ISO.CEILING()": "ISO.CEILING requires at least 1 argument", - "=ISO.CEILING(1,2,3)": "ISO.CEILING allows at most 2 arguments", - `=ISO.CEILING("X",2)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=ISO.CEILING(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=ISO.CEILING()": {"#VALUE!", "ISO.CEILING requires at least 1 argument"}, + "=ISO.CEILING(1,2,3)": {"#VALUE!", "ISO.CEILING allows at most 2 arguments"}, + `=ISO.CEILING("X",2)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=ISO.CEILING(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // LCM - "=LCM()": "LCM requires at least 1 argument", - "=LCM(-1)": "LCM only accepts positive arguments", - "=LCM(1,-1)": "LCM only accepts positive arguments", - `=LCM("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=LCM()": {"#VALUE!", "LCM requires at least 1 argument"}, + "=LCM(-1)": {"#VALUE!", "LCM only accepts positive arguments"}, + "=LCM(1,-1)": {"#VALUE!", "LCM only accepts positive arguments"}, + `=LCM("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // LN - "=LN()": "LN requires 1 numeric argument", - `=LN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=LN()": {"#VALUE!", "LN requires 1 numeric argument"}, + "=LN(\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // LOG - "=LOG()": "LOG requires at least 1 argument", - "=LOG(1,2,3)": "LOG allows at most 2 arguments", - `=LOG("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=LOG(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=LOG(0,0)": "#DIV/0!", - "=LOG(1,0)": "#DIV/0!", - "=LOG(1,1)": "#DIV/0!", + "=LOG()": {"#VALUE!", "LOG requires at least 1 argument"}, + "=LOG(1,2,3)": {"#VALUE!", "LOG allows at most 2 arguments"}, + `=LOG("X",1)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=LOG(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=LOG(0,0)": {"#NUM!", "#DIV/0!"}, + "=LOG(1,0)": {"#NUM!", "#DIV/0!"}, + "=LOG(1,1)": {"#DIV/0!", "#DIV/0!"}, // LOG10 - "=LOG10()": "LOG10 requires 1 numeric argument", - `=LOG10("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=LOG10()": {"#VALUE!", "LOG10 requires 1 numeric argument"}, + "=LOG10(\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // MDETERM - "=MDETERM()": "MDETERM requires 1 argument", + "=MDETERM()": {"#VALUE!", "MDETERM requires 1 argument"}, // MINVERSE - "=MINVERSE()": "MINVERSE requires 1 argument", - "=MINVERSE(B3:C4)": "#VALUE!", - "=MINVERSE(A1:C2)": "#VALUE!", - "=MINVERSE(A4:A4)": "#NUM!", + "=MINVERSE()": {"#VALUE!", "MINVERSE requires 1 argument"}, + "=MINVERSE(B3:C4)": {"#VALUE!", "#VALUE!"}, + "=MINVERSE(A1:C2)": {"#VALUE!", "#VALUE!"}, + "=MINVERSE(A4:A4)": {"#NUM!", "#NUM!"}, // MMULT - "=MMULT()": "MMULT requires 2 argument", - "=MMULT(A1:B2,B3:C4)": "#VALUE!", - "=MMULT(B3:C4,A1:B2)": "#VALUE!", - "=MMULT(A1:A2,B1:B2)": "#VALUE!", + "=MMULT()": {"#VALUE!", "MMULT requires 2 argument"}, + "=MMULT(A1:B2,B3:C4)": {"#VALUE!", "#VALUE!"}, + "=MMULT(B3:C4,A1:B2)": {"#VALUE!", "#VALUE!"}, + "=MMULT(A1:A2,B1:B2)": {"#VALUE!", "#VALUE!"}, // MOD - "=MOD()": "MOD requires 2 numeric arguments", - "=MOD(6,0)": "MOD divide by zero", - `=MOD("X",0)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=MOD(6,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=MOD()": {"#VALUE!", "MOD requires 2 numeric arguments"}, + "=MOD(6,0)": {"#DIV/0!", "MOD divide by zero"}, + `=MOD("X",0)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=MOD(6,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // MROUND - "=MROUND()": "MROUND requires 2 numeric arguments", - "=MROUND(1,0)": "#NUM!", - "=MROUND(1,-1)": "#NUM!", - `=MROUND("X",0)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=MROUND(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=MROUND()": {"#VALUE!", "MROUND requires 2 numeric arguments"}, + "=MROUND(1,0)": {"#NUM!", "#NUM!"}, + "=MROUND(1,-1)": {"#NUM!", "#NUM!"}, + `=MROUND("X",0)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=MROUND(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // MULTINOMIAL - `=MULTINOMIAL("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + `=MULTINOMIAL("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // _xlfn.MUNIT - "=_xlfn.MUNIT()": "MUNIT requires 1 numeric argument", - `=_xlfn.MUNIT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=_xlfn.MUNIT(-1)": "", + "=_xlfn.MUNIT()": {"#VALUE!", "MUNIT requires 1 numeric argument"}, + `=_xlfn.MUNIT("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=_xlfn.MUNIT(-1)": {"#VALUE!", ""}, // ODD - "=ODD()": "ODD requires 1 numeric argument", - `=ODD("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=ODD()": {"#VALUE!", "ODD requires 1 numeric argument"}, + `=ODD("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // PI - "=PI(1)": "PI accepts no arguments", + "=PI(1)": {"#VALUE!", "PI accepts no arguments"}, // POWER - `=POWER("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=POWER(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=POWER(0,0)": "#NUM!", - "=POWER(0,-1)": "#DIV/0!", - "=POWER(1)": "POWER requires 2 numeric arguments", + `=POWER("X",1)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=POWER(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=POWER(0,0)": {"#NUM!", "#NUM!"}, + "=POWER(0,-1)": {"#DIV/0!", "#DIV/0!"}, + "=POWER(1)": {"#VALUE!", "POWER requires 2 numeric arguments"}, // PRODUCT - "=PRODUCT(\"X\")": "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=PRODUCT(\"\",3,6)": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=PRODUCT(\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=PRODUCT(\"\",3,6)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // QUOTIENT - `=QUOTIENT("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=QUOTIENT(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=QUOTIENT(1,0)": "#DIV/0!", - "=QUOTIENT(1)": "QUOTIENT requires 2 numeric arguments", + `=QUOTIENT("X",1)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=QUOTIENT(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=QUOTIENT(1,0)": {"#DIV/0!", "#DIV/0!"}, + "=QUOTIENT(1)": {"#VALUE!", "QUOTIENT requires 2 numeric arguments"}, // RADIANS - `=RADIANS("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=RADIANS()": "RADIANS requires 1 numeric argument", + `=RADIANS("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=RADIANS()": {"#VALUE!", "RADIANS requires 1 numeric argument"}, // RAND - "=RAND(1)": "RAND accepts no arguments", + "=RAND(1)": {"#VALUE!", "RAND accepts no arguments"}, // RANDBETWEEN - `=RANDBETWEEN("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=RANDBETWEEN(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=RANDBETWEEN()": "RANDBETWEEN requires 2 numeric arguments", - "=RANDBETWEEN(2,1)": "#NUM!", + `=RANDBETWEEN("X",1)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=RANDBETWEEN(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=RANDBETWEEN()": {"#VALUE!", "RANDBETWEEN requires 2 numeric arguments"}, + "=RANDBETWEEN(2,1)": {"#NUM!", "#NUM!"}, // ROMAN - "=ROMAN()": "ROMAN requires at least 1 argument", - "=ROMAN(1,2,3)": "ROMAN allows at most 2 arguments", - "=ROMAN(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=ROMAN(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=ROMAN(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=ROMAN()": {"#VALUE!", "ROMAN requires at least 1 argument"}, + "=ROMAN(1,2,3)": {"#VALUE!", "ROMAN allows at most 2 arguments"}, + "=ROMAN(1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=ROMAN(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=ROMAN(\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // ROUND - "=ROUND()": "ROUND requires 2 numeric arguments", - `=ROUND("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=ROUND(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=ROUND()": {"#VALUE!", "ROUND requires 2 numeric arguments"}, + `=ROUND("X",1)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=ROUND(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // ROUNDDOWN - "=ROUNDDOWN()": "ROUNDDOWN requires 2 numeric arguments", - `=ROUNDDOWN("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=ROUNDDOWN(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=ROUNDDOWN()": {"#VALUE!", "ROUNDDOWN requires 2 numeric arguments"}, + `=ROUNDDOWN("X",1)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=ROUNDDOWN(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // ROUNDUP - "=ROUNDUP()": "ROUNDUP requires 2 numeric arguments", - `=ROUNDUP("X",1)`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=ROUNDUP(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=ROUNDUP()": {"#VALUE!", "ROUNDUP requires 2 numeric arguments"}, + `=ROUNDUP("X",1)`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + `=ROUNDUP(1,"X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // SEC - "=_xlfn.SEC()": "SEC requires 1 numeric argument", - `=_xlfn.SEC("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=_xlfn.SEC()": {"#VALUE!", "SEC requires 1 numeric argument"}, + `=_xlfn.SEC("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // _xlfn.SECH - "=_xlfn.SECH()": "SECH requires 1 numeric argument", - `=_xlfn.SECH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=_xlfn.SECH()": {"#VALUE!", "SECH requires 1 numeric argument"}, + `=_xlfn.SECH("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // SERIESSUM - "=SERIESSUM()": "SERIESSUM requires 4 arguments", - "=SERIESSUM(\"\",2,3,A1:A4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=SERIESSUM(1,\"\",3,A1:A4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=SERIESSUM(1,2,\"\",A1:A4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=SERIESSUM(1,2,3,A1:D1)": "strconv.ParseFloat: parsing \"Month\": invalid syntax", + "=SERIESSUM()": {"#VALUE!", "SERIESSUM requires 4 arguments"}, + "=SERIESSUM(\"\",2,3,A1:A4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=SERIESSUM(1,\"\",3,A1:A4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=SERIESSUM(1,2,\"\",A1:A4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=SERIESSUM(1,2,3,A1:D1)": {"#VALUE!", "strconv.ParseFloat: parsing \"Month\": invalid syntax"}, // SIGN - "=SIGN()": "SIGN requires 1 numeric argument", - `=SIGN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=SIGN()": {"#VALUE!", "SIGN requires 1 numeric argument"}, + `=SIGN("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // SIN - "=SIN()": "SIN requires 1 numeric argument", - `=SIN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=SIN()": {"#VALUE!", "SIN requires 1 numeric argument"}, + `=SIN("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // SINH - "=SINH()": "SINH requires 1 numeric argument", - `=SINH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=SINH()": {"#VALUE!", "SINH requires 1 numeric argument"}, + `=SINH("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // SQRT - "=SQRT()": "SQRT requires 1 numeric argument", - `=SQRT("")`: "strconv.ParseFloat: parsing \"\": invalid syntax", - `=SQRT("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=SQRT(-1)": "#NUM!", + "=SQRT()": {"#VALUE!", "SQRT requires 1 numeric argument"}, + `=SQRT("")`: {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + `=SQRT("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=SQRT(-1)": {"#NUM!", "#NUM!"}, // SQRTPI - "=SQRTPI()": "SQRTPI requires 1 numeric argument", - `=SQRTPI("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=SQRTPI()": {"#VALUE!", "SQRTPI requires 1 numeric argument"}, + `=SQRTPI("X")`: {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // STDEV - "=STDEV()": "STDEV requires at least 1 argument", - "=STDEV(E2:E9)": "#DIV/0!", + "=STDEV()": {"#VALUE!", "STDEV requires at least 1 argument"}, + "=STDEV(E2:E9)": {"#DIV/0!", "#DIV/0!"}, // STDEV.S - "=STDEV.S()": "STDEV.S requires at least 1 argument", + "=STDEV.S()": {"#VALUE!", "STDEV.S requires at least 1 argument"}, // STDEVA - "=STDEVA()": "STDEVA requires at least 1 argument", - "=STDEVA(E2:E9)": "#DIV/0!", + "=STDEVA()": {"#VALUE!", "STDEVA requires at least 1 argument"}, + "=STDEVA(E2:E9)": {"#DIV/0!", "#DIV/0!"}, // POISSON.DIST - "=POISSON.DIST()": "POISSON.DIST requires 3 arguments", + "=POISSON.DIST()": {"#VALUE!", "POISSON.DIST requires 3 arguments"}, // POISSON - "=POISSON()": "POISSON requires 3 arguments", - "=POISSON(\"\",0,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=POISSON(0,\"\",FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=POISSON(0,0,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=POISSON(0,-1,TRUE)": "#N/A", + "=POISSON()": {"#VALUE!", "POISSON requires 3 arguments"}, + "=POISSON(\"\",0,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=POISSON(0,\"\",FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=POISSON(0,0,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=POISSON(0,-1,TRUE)": {"#N/A", "#N/A"}, // SUBTOTAL - "=SUBTOTAL()": "SUBTOTAL requires at least 2 arguments", - "=SUBTOTAL(\"\",A4:A5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=SUBTOTAL(0,A4:A5)": "SUBTOTAL has invalid function_num", - "=SUBTOTAL(1,A5:A6)": "#DIV/0!", + "=SUBTOTAL()": {"#VALUE!", "SUBTOTAL requires at least 2 arguments"}, + "=SUBTOTAL(\"\",A4:A5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=SUBTOTAL(0,A4:A5)": {"#VALUE!", "SUBTOTAL has invalid function_num"}, + "=SUBTOTAL(1,A5:A6)": {"#DIV/0!", "#DIV/0!"}, // SUM - "=SUM((": ErrInvalidFormula.Error(), - "=SUM(-)": ErrInvalidFormula.Error(), - "=SUM(1+)": ErrInvalidFormula.Error(), - "=SUM(1-)": ErrInvalidFormula.Error(), - "=SUM(1*)": ErrInvalidFormula.Error(), - "=SUM(1/)": ErrInvalidFormula.Error(), - "=SUM(1*SUM(1/0))": "#DIV/0!", - "=SUM(1*SUM(1/0)*1)": "#DIV/0!", + "=SUM((": {"", ErrInvalidFormula.Error()}, + "=SUM(-)": {ErrInvalidFormula.Error(), ErrInvalidFormula.Error()}, + "=SUM(1+)": {ErrInvalidFormula.Error(), ErrInvalidFormula.Error()}, + "=SUM(1-)": {ErrInvalidFormula.Error(), ErrInvalidFormula.Error()}, + "=SUM(1*)": {ErrInvalidFormula.Error(), ErrInvalidFormula.Error()}, + "=SUM(1/)": {ErrInvalidFormula.Error(), ErrInvalidFormula.Error()}, + "=SUM(1*SUM(1/0))": {"#DIV/0!", "#DIV/0!"}, + "=SUM(1*SUM(1/0)*1)": {"", "#DIV/0!"}, // SUMIF - "=SUMIF()": "SUMIF requires at least 2 arguments", + "=SUMIF()": {"#VALUE!", "SUMIF requires at least 2 arguments"}, // SUMSQ - `=SUMSQ("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - "=SUMSQ(C1:D2)": "strconv.ParseFloat: parsing \"Month\": invalid syntax", + "=SUMSQ(\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=SUMSQ(C1:D2)": {"#VALUE!", "strconv.ParseFloat: parsing \"Month\": invalid syntax"}, // SUMPRODUCT - "=SUMPRODUCT()": "SUMPRODUCT requires at least 1 argument", - "=SUMPRODUCT(A1,B1:B2)": "#VALUE!", - "=SUMPRODUCT(A1,D1)": "#VALUE!", - "=SUMPRODUCT(A1:A3,D1:D3)": "#VALUE!", - "=SUMPRODUCT(A1:A2,B1:B3)": "#VALUE!", - "=SUMPRODUCT(\"\")": "#VALUE!", - "=SUMPRODUCT(A1,NA())": "#N/A", + "=SUMPRODUCT()": {"#VALUE!", "SUMPRODUCT requires at least 1 argument"}, + "=SUMPRODUCT(A1,B1:B2)": {"#VALUE!", "#VALUE!"}, + "=SUMPRODUCT(A1,D1)": {"#VALUE!", "#VALUE!"}, + "=SUMPRODUCT(A1:A3,D1:D3)": {"#VALUE!", "#VALUE!"}, + "=SUMPRODUCT(A1:A2,B1:B3)": {"#VALUE!", "#VALUE!"}, + "=SUMPRODUCT(\"\")": {"#VALUE!", "#VALUE!"}, + "=SUMPRODUCT(A1,NA())": {"#N/A", "#N/A"}, // SUMX2MY2 - "=SUMX2MY2()": "SUMX2MY2 requires 2 arguments", - "=SUMX2MY2(A1,B1:B2)": "#N/A", + "=SUMX2MY2()": {"#VALUE!", "SUMX2MY2 requires 2 arguments"}, + "=SUMX2MY2(A1,B1:B2)": {"#N/A", "#N/A"}, // SUMX2PY2 - "=SUMX2PY2()": "SUMX2PY2 requires 2 arguments", - "=SUMX2PY2(A1,B1:B2)": "#N/A", + "=SUMX2PY2()": {"#VALUE!", "SUMX2PY2 requires 2 arguments"}, + "=SUMX2PY2(A1,B1:B2)": {"#N/A", "#N/A"}, // SUMXMY2 - "=SUMXMY2()": "SUMXMY2 requires 2 arguments", - "=SUMXMY2(A1,B1:B2)": "#N/A", + "=SUMXMY2()": {"#VALUE!", "SUMXMY2 requires 2 arguments"}, + "=SUMXMY2(A1,B1:B2)": {"#N/A", "#N/A"}, // TAN - "=TAN()": "TAN requires 1 numeric argument", - `=TAN("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=TAN()": {"#VALUE!", "TAN requires 1 numeric argument"}, + "=TAN(\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // TANH - "=TANH()": "TANH requires 1 numeric argument", - `=TANH("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=TANH()": {"#VALUE!", "TANH requires 1 numeric argument"}, + "=TANH(\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // TRUNC - "=TRUNC()": "TRUNC requires at least 1 argument", - `=TRUNC("X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", - `=TRUNC(1,"X")`: "strconv.ParseFloat: parsing \"X\": invalid syntax", + "=TRUNC()": {"#VALUE!", "TRUNC requires at least 1 argument"}, + "=TRUNC(\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, + "=TRUNC(1,\"X\")": {"#VALUE!", "strconv.ParseFloat: parsing \"X\": invalid syntax"}, // Statistical Functions // AVEDEV - "=AVEDEV()": "AVEDEV requires at least 1 argument", - "=AVEDEV(\"\")": "#VALUE!", - "=AVEDEV(1,\"\")": "#VALUE!", + "=AVEDEV()": {"#VALUE!", "AVEDEV requires at least 1 argument"}, + "=AVEDEV(\"\")": {"#VALUE!", "#VALUE!"}, + "=AVEDEV(1,\"\")": {"#VALUE!", "#VALUE!"}, // AVERAGE - "=AVERAGE(H1)": "#DIV/0!", + "=AVERAGE(H1)": {"#DIV/0!", "#DIV/0!"}, // AVERAGEA - "=AVERAGEA(H1)": "#DIV/0!", + "=AVERAGEA(H1)": {"#DIV/0!", "#DIV/0!"}, // AVERAGEIF - "=AVERAGEIF()": "AVERAGEIF requires at least 2 arguments", - "=AVERAGEIF(H1,\"\")": "#DIV/0!", - "=AVERAGEIF(D1:D3,\"Month\",D1:D3)": "#DIV/0!", - "=AVERAGEIF(C1:C3,\"Month\",D1:D3)": "#DIV/0!", + "=AVERAGEIF()": {"#VALUE!", "AVERAGEIF requires at least 2 arguments"}, + "=AVERAGEIF(H1,\"\")": {"#DIV/0!", "#DIV/0!"}, + "=AVERAGEIF(D1:D3,\"Month\",D1:D3)": {"#DIV/0!", "#DIV/0!"}, + "=AVERAGEIF(C1:C3,\"Month\",D1:D3)": {"#DIV/0!", "#DIV/0!"}, // BETA.DIST - "=BETA.DIST()": "BETA.DIST requires at least 4 arguments", - "=BETA.DIST(0.4,4,5,TRUE,0,1,0)": "BETA.DIST requires at most 6 arguments", - "=BETA.DIST(\"\",4,5,TRUE,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETA.DIST(0.4,\"\",5,TRUE,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETA.DIST(0.4,4,\"\",TRUE,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETA.DIST(0.4,4,5,\"\",0,1)": "strconv.ParseBool: parsing \"\": invalid syntax", - "=BETA.DIST(0.4,4,5,TRUE,\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETA.DIST(0.4,4,5,TRUE,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETA.DIST(0.4,0,5,TRUE,0,1)": "#NUM!", - "=BETA.DIST(0.4,4,0,TRUE,0,0)": "#NUM!", - "=BETA.DIST(0.4,4,5,TRUE,0.5,1)": "#NUM!", - "=BETA.DIST(0.4,4,5,TRUE,0,0.3)": "#NUM!", - "=BETA.DIST(0.4,4,5,TRUE,0.4,0.4)": "#NUM!", + "=BETA.DIST()": {"#VALUE!", "BETA.DIST requires at least 4 arguments"}, + "=BETA.DIST(0.4,4,5,TRUE,0,1,0)": {"#VALUE!", "BETA.DIST requires at most 6 arguments"}, + "=BETA.DIST(\"\",4,5,TRUE,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETA.DIST(0.4,\"\",5,TRUE,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETA.DIST(0.4,4,\"\",TRUE,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETA.DIST(0.4,4,5,\"\",0,1)": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=BETA.DIST(0.4,4,5,TRUE,\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETA.DIST(0.4,4,5,TRUE,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETA.DIST(0.4,0,5,TRUE,0,1)": {"#NUM!", "#NUM!"}, + "=BETA.DIST(0.4,4,0,TRUE,0,0)": {"#NUM!", "#NUM!"}, + "=BETA.DIST(0.4,4,5,TRUE,0.5,1)": {"#NUM!", "#NUM!"}, + "=BETA.DIST(0.4,4,5,TRUE,0,0.3)": {"#NUM!", "#NUM!"}, + "=BETA.DIST(0.4,4,5,TRUE,0.4,0.4)": {"#NUM!", "#NUM!"}, // BETADIST - "=BETADIST()": "BETADIST requires at least 3 arguments", - "=BETADIST(0.4,4,5,0,1,0)": "BETADIST requires at most 5 arguments", - "=BETADIST(\"\",4,5,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETADIST(0.4,\"\",5,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETADIST(0.4,4,\"\",0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETADIST(0.4,4,5,\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETADIST(0.4,4,5,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETADIST(2,4,5,3,1)": "#NUM!", - "=BETADIST(2,4,5,0,1)": "#NUM!", - "=BETADIST(0.4,0,5,0,1)": "#NUM!", - "=BETADIST(0.4,4,0,0,1)": "#NUM!", - "=BETADIST(0.4,4,5,0.4,0.4)": "#NUM!", + "=BETADIST()": {"#VALUE!", "BETADIST requires at least 3 arguments"}, + "=BETADIST(0.4,4,5,0,1,0)": {"#VALUE!", "BETADIST requires at most 5 arguments"}, + "=BETADIST(\"\",4,5,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETADIST(0.4,\"\",5,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETADIST(0.4,4,\"\",0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETADIST(0.4,4,5,\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETADIST(0.4,4,5,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETADIST(2,4,5,3,1)": {"#NUM!", "#NUM!"}, + "=BETADIST(2,4,5,0,1)": {"#NUM!", "#NUM!"}, + "=BETADIST(0.4,0,5,0,1)": {"#NUM!", "#NUM!"}, + "=BETADIST(0.4,4,0,0,1)": {"#NUM!", "#NUM!"}, + "=BETADIST(0.4,4,5,0.4,0.4)": {"#NUM!", "#NUM!"}, // BETAINV - "=BETAINV()": "BETAINV requires at least 3 arguments", - "=BETAINV(0.2,4,5,0,1,0)": "BETAINV requires at most 5 arguments", - "=BETAINV(\"\",4,5,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETAINV(0.2,\"\",5,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETAINV(0.2,4,\"\",0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETAINV(0.2,4,5,\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETAINV(0.2,4,5,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETAINV(0,4,5,0,1)": "#NUM!", - "=BETAINV(1,4,5,0,1)": "#NUM!", - "=BETAINV(0.2,0,5,0,1)": "#NUM!", - "=BETAINV(0.2,4,0,0,1)": "#NUM!", - "=BETAINV(0.2,4,5,2,2)": "#NUM!", + "=BETAINV()": {"#VALUE!", "BETAINV requires at least 3 arguments"}, + "=BETAINV(0.2,4,5,0,1,0)": {"#VALUE!", "BETAINV requires at most 5 arguments"}, + "=BETAINV(\"\",4,5,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETAINV(0.2,\"\",5,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETAINV(0.2,4,\"\",0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETAINV(0.2,4,5,\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETAINV(0.2,4,5,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETAINV(0,4,5,0,1)": {"#NUM!", "#NUM!"}, + "=BETAINV(1,4,5,0,1)": {"#NUM!", "#NUM!"}, + "=BETAINV(0.2,0,5,0,1)": {"#NUM!", "#NUM!"}, + "=BETAINV(0.2,4,0,0,1)": {"#NUM!", "#NUM!"}, + "=BETAINV(0.2,4,5,2,2)": {"#NUM!", "#NUM!"}, // BETA.INV - "=BETA.INV()": "BETA.INV requires at least 3 arguments", - "=BETA.INV(0.2,4,5,0,1,0)": "BETA.INV requires at most 5 arguments", - "=BETA.INV(\"\",4,5,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETA.INV(0.2,\"\",5,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETA.INV(0.2,4,\"\",0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETA.INV(0.2,4,5,\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETA.INV(0.2,4,5,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BETA.INV(0,4,5,0,1)": "#NUM!", - "=BETA.INV(1,4,5,0,1)": "#NUM!", - "=BETA.INV(0.2,0,5,0,1)": "#NUM!", - "=BETA.INV(0.2,4,0,0,1)": "#NUM!", - "=BETA.INV(0.2,4,5,2,2)": "#NUM!", + "=BETA.INV()": {"#VALUE!", "BETA.INV requires at least 3 arguments"}, + "=BETA.INV(0.2,4,5,0,1,0)": {"#VALUE!", "BETA.INV requires at most 5 arguments"}, + "=BETA.INV(\"\",4,5,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETA.INV(0.2,\"\",5,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETA.INV(0.2,4,\"\",0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETA.INV(0.2,4,5,\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETA.INV(0.2,4,5,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BETA.INV(0,4,5,0,1)": {"#NUM!", "#NUM!"}, + "=BETA.INV(1,4,5,0,1)": {"#NUM!", "#NUM!"}, + "=BETA.INV(0.2,0,5,0,1)": {"#NUM!", "#NUM!"}, + "=BETA.INV(0.2,4,0,0,1)": {"#NUM!", "#NUM!"}, + "=BETA.INV(0.2,4,5,2,2)": {"#NUM!", "#NUM!"}, // BINOMDIST - "=BINOMDIST()": "BINOMDIST requires 4 arguments", - "=BINOMDIST(\"\",100,0.5,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOMDIST(10,\"\",0.5,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOMDIST(10,100,\"\",FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOMDIST(10,100,0.5,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=BINOMDIST(-1,100,0.5,FALSE)": "#NUM!", - "=BINOMDIST(110,100,0.5,FALSE)": "#NUM!", - "=BINOMDIST(10,100,-1,FALSE)": "#NUM!", - "=BINOMDIST(10,100,2,FALSE)": "#NUM!", + "=BINOMDIST()": {"#VALUE!", "BINOMDIST requires 4 arguments"}, + "=BINOMDIST(\"\",100,0.5,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOMDIST(10,\"\",0.5,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOMDIST(10,100,\"\",FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOMDIST(10,100,0.5,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=BINOMDIST(-1,100,0.5,FALSE)": {"#NUM!", "#NUM!"}, + "=BINOMDIST(110,100,0.5,FALSE)": {"#NUM!", "#NUM!"}, + "=BINOMDIST(10,100,-1,FALSE)": {"#NUM!", "#NUM!"}, + "=BINOMDIST(10,100,2,FALSE)": {"#NUM!", "#NUM!"}, // BINOM.DIST - "=BINOM.DIST()": "BINOM.DIST requires 4 arguments", - "=BINOM.DIST(\"\",100,0.5,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOM.DIST(10,\"\",0.5,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOM.DIST(10,100,\"\",FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOM.DIST(10,100,0.5,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=BINOM.DIST(-1,100,0.5,FALSE)": "#NUM!", - "=BINOM.DIST(110,100,0.5,FALSE)": "#NUM!", - "=BINOM.DIST(10,100,-1,FALSE)": "#NUM!", - "=BINOM.DIST(10,100,2,FALSE)": "#NUM!", + "=BINOM.DIST()": {"#VALUE!", "BINOM.DIST requires 4 arguments"}, + "=BINOM.DIST(\"\",100,0.5,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOM.DIST(10,\"\",0.5,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOM.DIST(10,100,\"\",FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOM.DIST(10,100,0.5,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=BINOM.DIST(-1,100,0.5,FALSE)": {"#NUM!", "#NUM!"}, + "=BINOM.DIST(110,100,0.5,FALSE)": {"#NUM!", "#NUM!"}, + "=BINOM.DIST(10,100,-1,FALSE)": {"#NUM!", "#NUM!"}, + "=BINOM.DIST(10,100,2,FALSE)": {"#NUM!", "#NUM!"}, // BINOM.DIST.RANGE - "=BINOM.DIST.RANGE()": "BINOM.DIST.RANGE requires at least 3 arguments", - "=BINOM.DIST.RANGE(100,0.5,0,40,0)": "BINOM.DIST.RANGE requires at most 4 arguments", - "=BINOM.DIST.RANGE(\"\",0.5,0,40)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOM.DIST.RANGE(100,\"\",0,40)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOM.DIST.RANGE(100,0.5,\"\",40)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOM.DIST.RANGE(100,0.5,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOM.DIST.RANGE(100,-1,0,40)": "#NUM!", - "=BINOM.DIST.RANGE(100,2,0,40)": "#NUM!", - "=BINOM.DIST.RANGE(100,0.5,-1,40)": "#NUM!", - "=BINOM.DIST.RANGE(100,0.5,110,40)": "#NUM!", - "=BINOM.DIST.RANGE(100,0.5,0,-1)": "#NUM!", - "=BINOM.DIST.RANGE(100,0.5,0,110)": "#NUM!", + "=BINOM.DIST.RANGE()": {"#VALUE!", "BINOM.DIST.RANGE requires at least 3 arguments"}, + "=BINOM.DIST.RANGE(100,0.5,0,40,0)": {"#VALUE!", "BINOM.DIST.RANGE requires at most 4 arguments"}, + "=BINOM.DIST.RANGE(\"\",0.5,0,40)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOM.DIST.RANGE(100,\"\",0,40)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOM.DIST.RANGE(100,0.5,\"\",40)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOM.DIST.RANGE(100,0.5,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOM.DIST.RANGE(100,-1,0,40)": {"#NUM!", "#NUM!"}, + "=BINOM.DIST.RANGE(100,2,0,40)": {"#NUM!", "#NUM!"}, + "=BINOM.DIST.RANGE(100,0.5,-1,40)": {"#NUM!", "#NUM!"}, + "=BINOM.DIST.RANGE(100,0.5,110,40)": {"#NUM!", "#NUM!"}, + "=BINOM.DIST.RANGE(100,0.5,0,-1)": {"#NUM!", "#NUM!"}, + "=BINOM.DIST.RANGE(100,0.5,0,110)": {"#NUM!", "#NUM!"}, // BINOM.INV - "=BINOM.INV()": "BINOM.INV requires 3 numeric arguments", - "=BINOM.INV(\"\",0.5,20%)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOM.INV(100,\"\",20%)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOM.INV(100,0.5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=BINOM.INV(-1,0.5,20%)": "#NUM!", - "=BINOM.INV(100,-1,20%)": "#NUM!", - "=BINOM.INV(100,2,20%)": "#NUM!", - "=BINOM.INV(100,0.5,-1)": "#NUM!", - "=BINOM.INV(100,0.5,2)": "#NUM!", - "=BINOM.INV(1,1,20%)": "#NUM!", + "=BINOM.INV()": {"#VALUE!", "BINOM.INV requires 3 numeric arguments"}, + "=BINOM.INV(\"\",0.5,20%)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOM.INV(100,\"\",20%)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOM.INV(100,0.5,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=BINOM.INV(-1,0.5,20%)": {"#NUM!", "#NUM!"}, + "=BINOM.INV(100,-1,20%)": {"#NUM!", "#NUM!"}, + "=BINOM.INV(100,2,20%)": {"#NUM!", "#NUM!"}, + "=BINOM.INV(100,0.5,-1)": {"#NUM!", "#NUM!"}, + "=BINOM.INV(100,0.5,2)": {"#NUM!", "#NUM!"}, + "=BINOM.INV(1,1,20%)": {"#NUM!", "#NUM!"}, // CHIDIST - "=CHIDIST()": "CHIDIST requires 2 numeric arguments", - "=CHIDIST(\"\",3)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CHIDIST(0.5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=CHIDIST()": {"#VALUE!", "CHIDIST requires 2 numeric arguments"}, + "=CHIDIST(\"\",3)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CHIDIST(0.5,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // CHIINV - "=CHIINV()": "CHIINV requires 2 numeric arguments", - "=CHIINV(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CHIINV(0.5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CHIINV(0,1)": "#NUM!", - "=CHIINV(2,1)": "#NUM!", - "=CHIINV(0.5,0.5)": "#NUM!", + "=CHIINV()": {"#VALUE!", "CHIINV requires 2 numeric arguments"}, + "=CHIINV(\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CHIINV(0.5,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CHIINV(0,1)": {"#NUM!", "#NUM!"}, + "=CHIINV(2,1)": {"#NUM!", "#NUM!"}, + "=CHIINV(0.5,0.5)": {"#NUM!", "#NUM!"}, // CHISQ.DIST - "=CHISQ.DIST()": "CHISQ.DIST requires 3 arguments", - "=CHISQ.DIST(\"\",2,TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CHISQ.DIST(3,\"\",TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CHISQ.DIST(3,2,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=CHISQ.DIST(-1,2,TRUE)": "#NUM!", - "=CHISQ.DIST(3,0,TRUE)": "#NUM!", + "=CHISQ.DIST()": {"#VALUE!", "CHISQ.DIST requires 3 arguments"}, + "=CHISQ.DIST(\"\",2,TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CHISQ.DIST(3,\"\",TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CHISQ.DIST(3,2,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=CHISQ.DIST(-1,2,TRUE)": {"#NUM!", "#NUM!"}, + "=CHISQ.DIST(3,0,TRUE)": {"#NUM!", "#NUM!"}, // CHISQ.DIST.RT - "=CHISQ.DIST.RT()": "CHISQ.DIST.RT requires 2 numeric arguments", - "=CHISQ.DIST.RT(\"\",3)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CHISQ.DIST.RT(0.5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=CHISQ.DIST.RT()": {"#VALUE!", "CHISQ.DIST.RT requires 2 numeric arguments"}, + "=CHISQ.DIST.RT(\"\",3)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CHISQ.DIST.RT(0.5,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // CHISQ.INV - "=CHISQ.INV()": "CHISQ.INV requires 2 numeric arguments", - "=CHISQ.INV(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CHISQ.INV(0.5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CHISQ.INV(-1,1)": "#NUM!", - "=CHISQ.INV(1,1)": "#NUM!", - "=CHISQ.INV(0.5,0.5)": "#NUM!", - "=CHISQ.INV(0.5,10000000001)": "#NUM!", + "=CHISQ.INV()": {"#VALUE!", "CHISQ.INV requires 2 numeric arguments"}, + "=CHISQ.INV(\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CHISQ.INV(0.5,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CHISQ.INV(-1,1)": {"#NUM!", "#NUM!"}, + "=CHISQ.INV(1,1)": {"#NUM!", "#NUM!"}, + "=CHISQ.INV(0.5,0.5)": {"#NUM!", "#NUM!"}, + "=CHISQ.INV(0.5,10000000001)": {"#NUM!", "#NUM!"}, // CHISQ.INV.RT - "=CHISQ.INV.RT()": "CHISQ.INV.RT requires 2 numeric arguments", - "=CHISQ.INV.RT(\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CHISQ.INV.RT(0.5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CHISQ.INV.RT(0,1)": "#NUM!", - "=CHISQ.INV.RT(2,1)": "#NUM!", - "=CHISQ.INV.RT(0.5,0.5)": "#NUM!", + "=CHISQ.INV.RT()": {"#VALUE!", "CHISQ.INV.RT requires 2 numeric arguments"}, + "=CHISQ.INV.RT(\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CHISQ.INV.RT(0.5,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CHISQ.INV.RT(0,1)": {"#NUM!", "#NUM!"}, + "=CHISQ.INV.RT(2,1)": {"#NUM!", "#NUM!"}, + "=CHISQ.INV.RT(0.5,0.5)": {"#NUM!", "#NUM!"}, // CONFIDENCE - "=CONFIDENCE()": "CONFIDENCE requires 3 numeric arguments", - "=CONFIDENCE(\"\",0.07,100)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CONFIDENCE(0.05,\"\",100)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CONFIDENCE(0.05,0.07,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CONFIDENCE(0,0.07,100)": "#NUM!", - "=CONFIDENCE(1,0.07,100)": "#NUM!", - "=CONFIDENCE(0.05,0,100)": "#NUM!", - "=CONFIDENCE(0.05,0.07,0.5)": "#NUM!", + "=CONFIDENCE()": {"#VALUE!", "CONFIDENCE requires 3 numeric arguments"}, + "=CONFIDENCE(\"\",0.07,100)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CONFIDENCE(0.05,\"\",100)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CONFIDENCE(0.05,0.07,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CONFIDENCE(0,0.07,100)": {"#NUM!", "#NUM!"}, + "=CONFIDENCE(1,0.07,100)": {"#NUM!", "#NUM!"}, + "=CONFIDENCE(0.05,0,100)": {"#NUM!", "#NUM!"}, + "=CONFIDENCE(0.05,0.07,0.5)": {"#NUM!", "#NUM!"}, // CONFIDENCE.NORM - "=CONFIDENCE.NORM()": "CONFIDENCE.NORM requires 3 numeric arguments", - "=CONFIDENCE.NORM(\"\",0.07,100)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CONFIDENCE.NORM(0.05,\"\",100)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CONFIDENCE.NORM(0.05,0.07,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CONFIDENCE.NORM(0,0.07,100)": "#NUM!", - "=CONFIDENCE.NORM(1,0.07,100)": "#NUM!", - "=CONFIDENCE.NORM(0.05,0,100)": "#NUM!", - "=CONFIDENCE.NORM(0.05,0.07,0.5)": "#NUM!", + "=CONFIDENCE.NORM()": {"#VALUE!", "CONFIDENCE.NORM requires 3 numeric arguments"}, + "=CONFIDENCE.NORM(\"\",0.07,100)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CONFIDENCE.NORM(0.05,\"\",100)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CONFIDENCE.NORM(0.05,0.07,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CONFIDENCE.NORM(0,0.07,100)": {"#NUM!", "#NUM!"}, + "=CONFIDENCE.NORM(1,0.07,100)": {"#NUM!", "#NUM!"}, + "=CONFIDENCE.NORM(0.05,0,100)": {"#NUM!", "#NUM!"}, + "=CONFIDENCE.NORM(0.05,0.07,0.5)": {"#NUM!", "#NUM!"}, // CORREL - "=CORREL()": "CORREL requires 2 arguments", - "=CORREL(A1:A3,B1:B5)": "#N/A", - "=CORREL(A1:A1,B1:B1)": "#DIV/0!", + "=CORREL()": {"#VALUE!", "CORREL requires 2 arguments"}, + "=CORREL(A1:A3,B1:B5)": {"#N/A", "#N/A"}, + "=CORREL(A1:A1,B1:B1)": {"#DIV/0!", "#DIV/0!"}, // CONFIDENCE.T - "=CONFIDENCE.T()": "CONFIDENCE.T requires 3 arguments", - "=CONFIDENCE.T(\"\",0.07,100)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CONFIDENCE.T(0.05,\"\",100)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CONFIDENCE.T(0.05,0.07,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CONFIDENCE.T(0,0.07,100)": "#NUM!", - "=CONFIDENCE.T(1,0.07,100)": "#NUM!", - "=CONFIDENCE.T(0.05,0,100)": "#NUM!", - "=CONFIDENCE.T(0.05,0.07,0)": "#NUM!", - "=CONFIDENCE.T(0.05,0.07,1)": "#DIV/0!", + "=CONFIDENCE.T()": {"#VALUE!", "CONFIDENCE.T requires 3 arguments"}, + "=CONFIDENCE.T(\"\",0.07,100)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CONFIDENCE.T(0.05,\"\",100)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CONFIDENCE.T(0.05,0.07,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CONFIDENCE.T(0,0.07,100)": {"#NUM!", "#NUM!"}, + "=CONFIDENCE.T(1,0.07,100)": {"#NUM!", "#NUM!"}, + "=CONFIDENCE.T(0.05,0,100)": {"#NUM!", "#NUM!"}, + "=CONFIDENCE.T(0.05,0.07,0)": {"#NUM!", "#NUM!"}, + "=CONFIDENCE.T(0.05,0.07,1)": {"#DIV/0!", "#DIV/0!"}, // COUNTBLANK - "=COUNTBLANK()": "COUNTBLANK requires 1 argument", - "=COUNTBLANK(1,2)": "COUNTBLANK requires 1 argument", + "=COUNTBLANK()": {"#VALUE!", "COUNTBLANK requires 1 argument"}, + "=COUNTBLANK(1,2)": {"#VALUE!", "COUNTBLANK requires 1 argument"}, // COUNTIF - "=COUNTIF()": "COUNTIF requires 2 arguments", + "=COUNTIF()": {"#VALUE!", "COUNTIF requires 2 arguments"}, // COUNTIFS - "=COUNTIFS()": "COUNTIFS requires at least 2 arguments", - "=COUNTIFS(A1:A9,2,D1:D9)": "#N/A", + "=COUNTIFS()": {"#VALUE!", "COUNTIFS requires at least 2 arguments"}, + "=COUNTIFS(A1:A9,2,D1:D9)": {"#N/A", "#N/A"}, // CRITBINOM - "=CRITBINOM()": "CRITBINOM requires 3 numeric arguments", - "=CRITBINOM(\"\",0.5,20%)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CRITBINOM(100,\"\",20%)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CRITBINOM(100,0.5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CRITBINOM(-1,0.5,20%)": "#NUM!", - "=CRITBINOM(100,-1,20%)": "#NUM!", - "=CRITBINOM(100,2,20%)": "#NUM!", - "=CRITBINOM(100,0.5,-1)": "#NUM!", - "=CRITBINOM(100,0.5,2)": "#NUM!", - "=CRITBINOM(1,1,20%)": "#NUM!", + "=CRITBINOM()": {"#VALUE!", "CRITBINOM requires 3 numeric arguments"}, + "=CRITBINOM(\"\",0.5,20%)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CRITBINOM(100,\"\",20%)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CRITBINOM(100,0.5,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CRITBINOM(-1,0.5,20%)": {"#NUM!", "#NUM!"}, + "=CRITBINOM(100,-1,20%)": {"#NUM!", "#NUM!"}, + "=CRITBINOM(100,2,20%)": {"#NUM!", "#NUM!"}, + "=CRITBINOM(100,0.5,-1)": {"#NUM!", "#NUM!"}, + "=CRITBINOM(100,0.5,2)": {"#NUM!", "#NUM!"}, + "=CRITBINOM(1,1,20%)": {"#NUM!", "#NUM!"}, // DEVSQ - "=DEVSQ()": "DEVSQ requires at least 1 numeric argument", - "=DEVSQ(D1:D2)": "#N/A", + "=DEVSQ()": {"#VALUE!", "DEVSQ requires at least 1 numeric argument"}, + "=DEVSQ(D1:D2)": {"#N/A", "#N/A"}, // FISHER - "=FISHER()": "FISHER requires 1 numeric argument", - "=FISHER(2)": "#N/A", - "=FISHER(\"2\")": "#N/A", - "=FISHER(INT(-2)))": "#N/A", - "=FISHER(F1)": "FISHER requires 1 numeric argument", + "=FISHER()": {"#VALUE!", "FISHER requires 1 numeric argument"}, + "=FISHER(2)": {"#N/A", "#N/A"}, + "=FISHER(\"2\")": {"#N/A", "#N/A"}, + "=FISHER(INT(-2)))": {"#N/A", "#N/A"}, + "=FISHER(F1)": {"#VALUE!", "FISHER requires 1 numeric argument"}, // FISHERINV - "=FISHERINV()": "FISHERINV requires 1 numeric argument", - "=FISHERINV(F1)": "FISHERINV requires 1 numeric argument", + "=FISHERINV()": {"#VALUE!", "FISHERINV requires 1 numeric argument"}, + "=FISHERINV(F1)": {"#VALUE!", "FISHERINV requires 1 numeric argument"}, // GAMMA - "=GAMMA()": "GAMMA requires 1 numeric argument", - "=GAMMA(F1)": "GAMMA requires 1 numeric argument", - "=GAMMA(0)": "#N/A", - "=GAMMA(\"0\")": "#N/A", - "=GAMMA(INT(0))": "#N/A", + "=GAMMA()": {"#VALUE!", "GAMMA requires 1 numeric argument"}, + "=GAMMA(F1)": {"#VALUE!", "GAMMA requires 1 numeric argument"}, + "=GAMMA(0)": {"#N/A", "#N/A"}, + "=GAMMA(\"0\")": {"#N/A", "#N/A"}, + "=GAMMA(INT(0))": {"#N/A", "#N/A"}, // GAMMA.DIST - "=GAMMA.DIST()": "GAMMA.DIST requires 4 arguments", - "=GAMMA.DIST(\"\",3,2,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMA.DIST(6,\"\",2,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMA.DIST(6,3,\"\",FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMA.DIST(6,3,2,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=GAMMA.DIST(-1,3,2,FALSE)": "#NUM!", - "=GAMMA.DIST(6,0,2,FALSE)": "#NUM!", - "=GAMMA.DIST(6,3,0,FALSE)": "#NUM!", + "=GAMMA.DIST()": {"#VALUE!", "GAMMA.DIST requires 4 arguments"}, + "=GAMMA.DIST(\"\",3,2,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMA.DIST(6,\"\",2,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMA.DIST(6,3,\"\",FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMA.DIST(6,3,2,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=GAMMA.DIST(-1,3,2,FALSE)": {"#NUM!", "#NUM!"}, + "=GAMMA.DIST(6,0,2,FALSE)": {"#NUM!", "#NUM!"}, + "=GAMMA.DIST(6,3,0,FALSE)": {"#NUM!", "#NUM!"}, // GAMMADIST - "=GAMMADIST()": "GAMMADIST requires 4 arguments", - "=GAMMADIST(\"\",3,2,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMADIST(6,\"\",2,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMADIST(6,3,\"\",FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMADIST(6,3,2,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=GAMMADIST(-1,3,2,FALSE)": "#NUM!", - "=GAMMADIST(6,0,2,FALSE)": "#NUM!", - "=GAMMADIST(6,3,0,FALSE)": "#NUM!", + "=GAMMADIST()": {"#VALUE!", "GAMMADIST requires 4 arguments"}, + "=GAMMADIST(\"\",3,2,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMADIST(6,\"\",2,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMADIST(6,3,\"\",FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMADIST(6,3,2,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=GAMMADIST(-1,3,2,FALSE)": {"#NUM!", "#NUM!"}, + "=GAMMADIST(6,0,2,FALSE)": {"#NUM!", "#NUM!"}, + "=GAMMADIST(6,3,0,FALSE)": {"#NUM!", "#NUM!"}, // GAMMA.INV - "=GAMMA.INV()": "GAMMA.INV requires 3 arguments", - "=GAMMA.INV(\"\",3,2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMA.INV(0.5,\"\",2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMA.INV(0.5,3,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMA.INV(-1,3,2)": "#NUM!", - "=GAMMA.INV(2,3,2)": "#NUM!", - "=GAMMA.INV(0.5,0,2)": "#NUM!", - "=GAMMA.INV(0.5,3,0)": "#NUM!", + "=GAMMA.INV()": {"#VALUE!", "GAMMA.INV requires 3 arguments"}, + "=GAMMA.INV(\"\",3,2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMA.INV(0.5,\"\",2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMA.INV(0.5,3,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMA.INV(-1,3,2)": {"#NUM!", "#NUM!"}, + "=GAMMA.INV(2,3,2)": {"#NUM!", "#NUM!"}, + "=GAMMA.INV(0.5,0,2)": {"#NUM!", "#NUM!"}, + "=GAMMA.INV(0.5,3,0)": {"#NUM!", "#NUM!"}, // GAMMAINV - "=GAMMAINV()": "GAMMAINV requires 3 arguments", - "=GAMMAINV(\"\",3,2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMAINV(0.5,\"\",2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMAINV(0.5,3,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMAINV(-1,3,2)": "#NUM!", - "=GAMMAINV(2,3,2)": "#NUM!", - "=GAMMAINV(0.5,0,2)": "#NUM!", - "=GAMMAINV(0.5,3,0)": "#NUM!", + "=GAMMAINV()": {"#VALUE!", "GAMMAINV requires 3 arguments"}, + "=GAMMAINV(\"\",3,2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMAINV(0.5,\"\",2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMAINV(0.5,3,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMAINV(-1,3,2)": {"#NUM!", "#NUM!"}, + "=GAMMAINV(2,3,2)": {"#NUM!", "#NUM!"}, + "=GAMMAINV(0.5,0,2)": {"#NUM!", "#NUM!"}, + "=GAMMAINV(0.5,3,0)": {"#NUM!", "#NUM!"}, // GAMMALN - "=GAMMALN()": "GAMMALN requires 1 numeric argument", - "=GAMMALN(F1)": "GAMMALN requires 1 numeric argument", - "=GAMMALN(0)": "#N/A", - "=GAMMALN(INT(0))": "#N/A", + "=GAMMALN()": {"#VALUE!", "GAMMALN requires 1 numeric argument"}, + "=GAMMALN(F1)": {"#VALUE!", "GAMMALN requires 1 numeric argument"}, + "=GAMMALN(0)": {"#N/A", "#N/A"}, + "=GAMMALN(INT(0))": {"#N/A", "#N/A"}, // GAMMALN.PRECISE - "=GAMMALN.PRECISE()": "GAMMALN.PRECISE requires 1 numeric argument", - "=GAMMALN.PRECISE(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=GAMMALN.PRECISE(0)": "#NUM!", + "=GAMMALN.PRECISE()": {"#VALUE!", "GAMMALN.PRECISE requires 1 numeric argument"}, + "=GAMMALN.PRECISE(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=GAMMALN.PRECISE(0)": {"#NUM!", "#NUM!"}, // GAUSS - "=GAUSS()": "GAUSS requires 1 numeric argument", - "=GAUSS(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=GAUSS()": {"#VALUE!", "GAUSS requires 1 numeric argument"}, + "=GAUSS(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // GEOMEAN - "=GEOMEAN()": "GEOMEAN requires at least 1 numeric argument", - "=GEOMEAN(0)": "#NUM!", - "=GEOMEAN(D1:D2)": "#NUM!", - "=GEOMEAN(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=GEOMEAN()": {"#VALUE!", "GEOMEAN requires at least 1 numeric argument"}, + "=GEOMEAN(0)": {"#NUM!", "#NUM!"}, + "=GEOMEAN(D1:D2)": {"#NUM!", "#NUM!"}, + "=GEOMEAN(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // HARMEAN - "=HARMEAN()": "HARMEAN requires at least 1 argument", - "=HARMEAN(-1)": "#N/A", - "=HARMEAN(0)": "#N/A", + "=HARMEAN()": {"#VALUE!", "HARMEAN requires at least 1 argument"}, + "=HARMEAN(-1)": {"#N/A", "#N/A"}, + "=HARMEAN(0)": {"#N/A", "#N/A"}, // HYPGEOM.DIST - "=HYPGEOM.DIST()": "HYPGEOM.DIST requires 5 arguments", - "=HYPGEOM.DIST(\"\",4,4,12,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=HYPGEOM.DIST(1,\"\",4,12,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=HYPGEOM.DIST(1,4,\"\",12,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=HYPGEOM.DIST(1,4,4,\"\",FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=HYPGEOM.DIST(1,4,4,12,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=HYPGEOM.DIST(-1,4,4,12,FALSE)": "#NUM!", - "=HYPGEOM.DIST(2,1,4,12,FALSE)": "#NUM!", - "=HYPGEOM.DIST(2,4,1,12,FALSE)": "#NUM!", - "=HYPGEOM.DIST(2,2,2,1,FALSE)": "#NUM!", - "=HYPGEOM.DIST(1,0,4,12,FALSE)": "#NUM!", - "=HYPGEOM.DIST(1,4,4,2,FALSE)": "#NUM!", - "=HYPGEOM.DIST(1,4,0,12,FALSE)": "#NUM!", - "=HYPGEOM.DIST(1,4,4,0,FALSE)": "#NUM!", + "=HYPGEOM.DIST()": {"#VALUE!", "HYPGEOM.DIST requires 5 arguments"}, + "=HYPGEOM.DIST(\"\",4,4,12,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=HYPGEOM.DIST(1,\"\",4,12,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=HYPGEOM.DIST(1,4,\"\",12,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=HYPGEOM.DIST(1,4,4,\"\",FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=HYPGEOM.DIST(1,4,4,12,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=HYPGEOM.DIST(-1,4,4,12,FALSE)": {"#NUM!", "#NUM!"}, + "=HYPGEOM.DIST(2,1,4,12,FALSE)": {"#NUM!", "#NUM!"}, + "=HYPGEOM.DIST(2,4,1,12,FALSE)": {"#NUM!", "#NUM!"}, + "=HYPGEOM.DIST(2,2,2,1,FALSE)": {"#NUM!", "#NUM!"}, + "=HYPGEOM.DIST(1,0,4,12,FALSE)": {"#NUM!", "#NUM!"}, + "=HYPGEOM.DIST(1,4,4,2,FALSE)": {"#NUM!", "#NUM!"}, + "=HYPGEOM.DIST(1,4,0,12,FALSE)": {"#NUM!", "#NUM!"}, + "=HYPGEOM.DIST(1,4,4,0,FALSE)": {"#NUM!", "#NUM!"}, // HYPGEOMDIST - "=HYPGEOMDIST()": "HYPGEOMDIST requires 4 numeric arguments", - "=HYPGEOMDIST(\"\",4,4,12)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=HYPGEOMDIST(1,\"\",4,12)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=HYPGEOMDIST(1,4,\"\",12)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=HYPGEOMDIST(1,4,4,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=HYPGEOMDIST(-1,4,4,12)": "#NUM!", - "=HYPGEOMDIST(2,1,4,12)": "#NUM!", - "=HYPGEOMDIST(2,4,1,12)": "#NUM!", - "=HYPGEOMDIST(2,2,2,1)": "#NUM!", - "=HYPGEOMDIST(1,0,4,12)": "#NUM!", - "=HYPGEOMDIST(1,4,4,2)": "#NUM!", - "=HYPGEOMDIST(1,4,0,12)": "#NUM!", - "=HYPGEOMDIST(1,4,4,0)": "#NUM!", + "=HYPGEOMDIST()": {"#VALUE!", "HYPGEOMDIST requires 4 numeric arguments"}, + "=HYPGEOMDIST(\"\",4,4,12)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=HYPGEOMDIST(1,\"\",4,12)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=HYPGEOMDIST(1,4,\"\",12)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=HYPGEOMDIST(1,4,4,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=HYPGEOMDIST(-1,4,4,12)": {"#NUM!", "#NUM!"}, + "=HYPGEOMDIST(2,1,4,12)": {"#NUM!", "#NUM!"}, + "=HYPGEOMDIST(2,4,1,12)": {"#NUM!", "#NUM!"}, + "=HYPGEOMDIST(2,2,2,1)": {"#NUM!", "#NUM!"}, + "=HYPGEOMDIST(1,0,4,12)": {"#NUM!", "#NUM!"}, + "=HYPGEOMDIST(1,4,4,2)": {"#NUM!", "#NUM!"}, + "=HYPGEOMDIST(1,4,0,12)": {"#NUM!", "#NUM!"}, + "=HYPGEOMDIST(1,4,4,0)": {"#NUM!", "#NUM!"}, // KURT - "=KURT()": "KURT requires at least 1 argument", - "=KURT(F1,INT(1))": "#DIV/0!", + "=KURT()": {"#VALUE!", "KURT requires at least 1 argument"}, + "=KURT(F1,INT(1))": {"#DIV/0!", "#DIV/0!"}, // EXPON.DIST - "=EXPON.DIST()": "EXPON.DIST requires 3 arguments", - "=EXPON.DIST(\"\",1,TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=EXPON.DIST(0,\"\",TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=EXPON.DIST(0,1,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=EXPON.DIST(-1,1,TRUE)": "#NUM!", - "=EXPON.DIST(1,0,TRUE)": "#NUM!", + "=EXPON.DIST()": {"#VALUE!", "EXPON.DIST requires 3 arguments"}, + "=EXPON.DIST(\"\",1,TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=EXPON.DIST(0,\"\",TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=EXPON.DIST(0,1,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=EXPON.DIST(-1,1,TRUE)": {"#NUM!", "#NUM!"}, + "=EXPON.DIST(1,0,TRUE)": {"#NUM!", "#NUM!"}, // EXPONDIST - "=EXPONDIST()": "EXPONDIST requires 3 arguments", - "=EXPONDIST(\"\",1,TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=EXPONDIST(0,\"\",TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=EXPONDIST(0,1,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=EXPONDIST(-1,1,TRUE)": "#NUM!", - "=EXPONDIST(1,0,TRUE)": "#NUM!", + "=EXPONDIST()": {"#VALUE!", "EXPONDIST requires 3 arguments"}, + "=EXPONDIST(\"\",1,TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=EXPONDIST(0,\"\",TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=EXPONDIST(0,1,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=EXPONDIST(-1,1,TRUE)": {"#NUM!", "#NUM!"}, + "=EXPONDIST(1,0,TRUE)": {"#NUM!", "#NUM!"}, // FDIST - "=FDIST()": "FDIST requires 3 arguments", - "=FDIST(\"\",1,2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FDIST(5,\"\",2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FDIST(5,1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FDIST(-1,1,2)": "#NUM!", - "=FDIST(5,0,2)": "#NUM!", - "=FDIST(5,10000000000,2)": "#NUM!", - "=FDIST(5,1,0)": "#NUM!", - "=FDIST(5,1,10000000000)": "#NUM!", + "=FDIST()": {"#VALUE!", "FDIST requires 3 arguments"}, + "=FDIST(\"\",1,2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FDIST(5,\"\",2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FDIST(5,1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FDIST(-1,1,2)": {"#NUM!", "#NUM!"}, + "=FDIST(5,0,2)": {"#NUM!", "#NUM!"}, + "=FDIST(5,10000000000,2)": {"#NUM!", "#NUM!"}, + "=FDIST(5,1,0)": {"#NUM!", "#NUM!"}, + "=FDIST(5,1,10000000000)": {"#NUM!", "#NUM!"}, // F.DIST - "=F.DIST()": "F.DIST requires 4 arguments", - "=F.DIST(\"\",2,5,TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=F.DIST(1,\"\",5,TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=F.DIST(1,2,\"\",TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=F.DIST(1,2,5,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=F.DIST(-1,1,2,TRUE)": "#NUM!", - "=F.DIST(5,0,2,TRUE)": "#NUM!", - "=F.DIST(5,10000000000,2,TRUE)": "#NUM!", - "=F.DIST(5,1,0,TRUE)": "#NUM!", - "=F.DIST(5,1,10000000000,TRUE)": "#NUM!", + "=F.DIST()": {"#VALUE!", "F.DIST requires 4 arguments"}, + "=F.DIST(\"\",2,5,TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=F.DIST(1,\"\",5,TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=F.DIST(1,2,\"\",TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=F.DIST(1,2,5,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=F.DIST(-1,1,2,TRUE)": {"#NUM!", "#NUM!"}, + "=F.DIST(5,0,2,TRUE)": {"#NUM!", "#NUM!"}, + "=F.DIST(5,10000000000,2,TRUE)": {"#NUM!", "#NUM!"}, + "=F.DIST(5,1,0,TRUE)": {"#NUM!", "#NUM!"}, + "=F.DIST(5,1,10000000000,TRUE)": {"#NUM!", "#NUM!"}, // F.DIST.RT - "=F.DIST.RT()": "F.DIST.RT requires 3 arguments", - "=F.DIST.RT(\"\",1,2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=F.DIST.RT(5,\"\",2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=F.DIST.RT(5,1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=F.DIST.RT(-1,1,2)": "#NUM!", - "=F.DIST.RT(5,0,2)": "#NUM!", - "=F.DIST.RT(5,10000000000,2)": "#NUM!", - "=F.DIST.RT(5,1,0)": "#NUM!", - "=F.DIST.RT(5,1,10000000000)": "#NUM!", + "=F.DIST.RT()": {"#VALUE!", "F.DIST.RT requires 3 arguments"}, + "=F.DIST.RT(\"\",1,2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=F.DIST.RT(5,\"\",2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=F.DIST.RT(5,1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=F.DIST.RT(-1,1,2)": {"#NUM!", "#NUM!"}, + "=F.DIST.RT(5,0,2)": {"#NUM!", "#NUM!"}, + "=F.DIST.RT(5,10000000000,2)": {"#NUM!", "#NUM!"}, + "=F.DIST.RT(5,1,0)": {"#NUM!", "#NUM!"}, + "=F.DIST.RT(5,1,10000000000)": {"#NUM!", "#NUM!"}, // F.INV - "=F.INV()": "F.INV requires 3 arguments", - "=F.INV(\"\",1,2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=F.INV(0.2,\"\",2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=F.INV(0.2,1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=F.INV(0,1,2)": "#NUM!", - "=F.INV(0.2,0.5,2)": "#NUM!", - "=F.INV(0.2,1,0.5)": "#NUM!", + "=F.INV()": {"#VALUE!", "F.INV requires 3 arguments"}, + "=F.INV(\"\",1,2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=F.INV(0.2,\"\",2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=F.INV(0.2,1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=F.INV(0,1,2)": {"#NUM!", "#NUM!"}, + "=F.INV(0.2,0.5,2)": {"#NUM!", "#NUM!"}, + "=F.INV(0.2,1,0.5)": {"#NUM!", "#NUM!"}, // FINV - "=FINV()": "FINV requires 3 arguments", - "=FINV(\"\",1,2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FINV(0.2,\"\",2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FINV(0.2,1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FINV(0,1,2)": "#NUM!", - "=FINV(0.2,0.5,2)": "#NUM!", - "=FINV(0.2,1,0.5)": "#NUM!", + "=FINV()": {"#VALUE!", "FINV requires 3 arguments"}, + "=FINV(\"\",1,2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FINV(0.2,\"\",2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FINV(0.2,1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FINV(0,1,2)": {"#NUM!", "#NUM!"}, + "=FINV(0.2,0.5,2)": {"#NUM!", "#NUM!"}, + "=FINV(0.2,1,0.5)": {"#NUM!", "#NUM!"}, // F.INV.RT - "=F.INV.RT()": "F.INV.RT requires 3 arguments", - "=F.INV.RT(\"\",1,2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=F.INV.RT(0.2,\"\",2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=F.INV.RT(0.2,1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=F.INV.RT(0,1,2)": "#NUM!", - "=F.INV.RT(0.2,0.5,2)": "#NUM!", - "=F.INV.RT(0.2,1,0.5)": "#NUM!", + "=F.INV.RT()": {"#VALUE!", "F.INV.RT requires 3 arguments"}, + "=F.INV.RT(\"\",1,2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=F.INV.RT(0.2,\"\",2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=F.INV.RT(0.2,1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=F.INV.RT(0,1,2)": {"#NUM!", "#NUM!"}, + "=F.INV.RT(0.2,0.5,2)": {"#NUM!", "#NUM!"}, + "=F.INV.RT(0.2,1,0.5)": {"#NUM!", "#NUM!"}, // LOGINV - "=LOGINV()": "LOGINV requires 3 arguments", - "=LOGINV(\"\",2,0.2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LOGINV(0.3,\"\",0.2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LOGINV(0.3,2,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LOGINV(0,2,0.2)": "#NUM!", - "=LOGINV(1,2,0.2)": "#NUM!", - "=LOGINV(0.3,2,0)": "#NUM!", + "=LOGINV()": {"#VALUE!", "LOGINV requires 3 arguments"}, + "=LOGINV(\"\",2,0.2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LOGINV(0.3,\"\",0.2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LOGINV(0.3,2,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LOGINV(0,2,0.2)": {"#NUM!", "#NUM!"}, + "=LOGINV(1,2,0.2)": {"#NUM!", "#NUM!"}, + "=LOGINV(0.3,2,0)": {"#NUM!", "#NUM!"}, // LOGNORM.INV - "=LOGNORM.INV()": "LOGNORM.INV requires 3 arguments", - "=LOGNORM.INV(\"\",2,0.2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LOGNORM.INV(0.3,\"\",0.2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LOGNORM.INV(0.3,2,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LOGNORM.INV(0,2,0.2)": "#NUM!", - "=LOGNORM.INV(1,2,0.2)": "#NUM!", - "=LOGNORM.INV(0.3,2,0)": "#NUM!", + "=LOGNORM.INV()": {"#VALUE!", "LOGNORM.INV requires 3 arguments"}, + "=LOGNORM.INV(\"\",2,0.2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LOGNORM.INV(0.3,\"\",0.2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LOGNORM.INV(0.3,2,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LOGNORM.INV(0,2,0.2)": {"#NUM!", "#NUM!"}, + "=LOGNORM.INV(1,2,0.2)": {"#NUM!", "#NUM!"}, + "=LOGNORM.INV(0.3,2,0)": {"#NUM!", "#NUM!"}, // LOGNORM.DIST - "=LOGNORM.DIST()": "LOGNORM.DIST requires 4 arguments", - "=LOGNORM.DIST(\"\",10,5,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LOGNORM.DIST(0.5,\"\",5,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LOGNORM.DIST(0.5,10,\"\",FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LOGNORM.DIST(0.5,10,5,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=LOGNORM.DIST(0,10,5,FALSE)": "#NUM!", - "=LOGNORM.DIST(0.5,10,0,FALSE)": "#NUM!", + "=LOGNORM.DIST()": {"#VALUE!", "LOGNORM.DIST requires 4 arguments"}, + "=LOGNORM.DIST(\"\",10,5,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LOGNORM.DIST(0.5,\"\",5,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LOGNORM.DIST(0.5,10,\"\",FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LOGNORM.DIST(0.5,10,5,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=LOGNORM.DIST(0,10,5,FALSE)": {"#NUM!", "#NUM!"}, + "=LOGNORM.DIST(0.5,10,0,FALSE)": {"#NUM!", "#NUM!"}, // LOGNORMDIST - "=LOGNORMDIST()": "LOGNORMDIST requires 3 arguments", - "=LOGNORMDIST(\"\",10,5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LOGNORMDIST(12,\"\",5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LOGNORMDIST(12,10,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LOGNORMDIST(0,2,5)": "#NUM!", - "=LOGNORMDIST(12,10,0)": "#NUM!", + "=LOGNORMDIST()": {"#VALUE!", "LOGNORMDIST requires 3 arguments"}, + "=LOGNORMDIST(\"\",10,5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LOGNORMDIST(12,\"\",5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LOGNORMDIST(12,10,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LOGNORMDIST(0,2,5)": {"#NUM!", "#NUM!"}, + "=LOGNORMDIST(12,10,0)": {"#NUM!", "#NUM!"}, // NEGBINOM.DIST - "=NEGBINOM.DIST()": "NEGBINOM.DIST requires 4 arguments", - "=NEGBINOM.DIST(\"\",12,0.5,TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NEGBINOM.DIST(6,\"\",0.5,TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NEGBINOM.DIST(6,12,\"\",TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NEGBINOM.DIST(6,12,0.5,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=NEGBINOM.DIST(-1,12,0.5,TRUE)": "#NUM!", - "=NEGBINOM.DIST(6,0,0.5,TRUE)": "#NUM!", - "=NEGBINOM.DIST(6,12,-1,TRUE)": "#NUM!", - "=NEGBINOM.DIST(6,12,2,TRUE)": "#NUM!", + "=NEGBINOM.DIST()": {"#VALUE!", "NEGBINOM.DIST requires 4 arguments"}, + "=NEGBINOM.DIST(\"\",12,0.5,TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NEGBINOM.DIST(6,\"\",0.5,TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NEGBINOM.DIST(6,12,\"\",TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NEGBINOM.DIST(6,12,0.5,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=NEGBINOM.DIST(-1,12,0.5,TRUE)": {"#NUM!", "#NUM!"}, + "=NEGBINOM.DIST(6,0,0.5,TRUE)": {"#NUM!", "#NUM!"}, + "=NEGBINOM.DIST(6,12,-1,TRUE)": {"#NUM!", "#NUM!"}, + "=NEGBINOM.DIST(6,12,2,TRUE)": {"#NUM!", "#NUM!"}, // NEGBINOMDIST - "=NEGBINOMDIST()": "NEGBINOMDIST requires 3 arguments", - "=NEGBINOMDIST(\"\",12,0.5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NEGBINOMDIST(6,\"\",0.5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NEGBINOMDIST(6,12,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NEGBINOMDIST(-1,12,0.5)": "#NUM!", - "=NEGBINOMDIST(6,0,0.5)": "#NUM!", - "=NEGBINOMDIST(6,12,-1)": "#NUM!", - "=NEGBINOMDIST(6,12,2)": "#NUM!", + "=NEGBINOMDIST()": {"#VALUE!", "NEGBINOMDIST requires 3 arguments"}, + "=NEGBINOMDIST(\"\",12,0.5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NEGBINOMDIST(6,\"\",0.5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NEGBINOMDIST(6,12,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NEGBINOMDIST(-1,12,0.5)": {"#NUM!", "#NUM!"}, + "=NEGBINOMDIST(6,0,0.5)": {"#NUM!", "#NUM!"}, + "=NEGBINOMDIST(6,12,-1)": {"#NUM!", "#NUM!"}, + "=NEGBINOMDIST(6,12,2)": {"#NUM!", "#NUM!"}, // NORM.DIST - "=NORM.DIST()": "NORM.DIST requires 4 arguments", + "=NORM.DIST()": {"#VALUE!", "NORM.DIST requires 4 arguments"}, // NORMDIST - "=NORMDIST()": "NORMDIST requires 4 arguments", - "=NORMDIST(\"\",0,0,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NORMDIST(0,\"\",0,FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NORMDIST(0,0,\"\",FALSE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NORMDIST(0,0,0,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=NORMDIST(0,0,-1,TRUE)": "#N/A", + "=NORMDIST()": {"#VALUE!", "NORMDIST requires 4 arguments"}, + "=NORMDIST(\"\",0,0,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NORMDIST(0,\"\",0,FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NORMDIST(0,0,\"\",FALSE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NORMDIST(0,0,0,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=NORMDIST(0,0,-1,TRUE)": {"#N/A", "#N/A"}, // NORM.INV - "=NORM.INV()": "NORM.INV requires 3 arguments", + "=NORM.INV()": {"#VALUE!", "NORM.INV requires 3 arguments"}, // NORMINV - "=NORMINV()": "NORMINV requires 3 arguments", - "=NORMINV(\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NORMINV(0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NORMINV(0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NORMINV(0,0,-1)": "#N/A", - "=NORMINV(-1,0,0)": "#N/A", - "=NORMINV(0,0,0)": "#NUM!", + "=NORMINV()": {"#VALUE!", "NORMINV requires 3 arguments"}, + "=NORMINV(\"\",0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NORMINV(0,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NORMINV(0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NORMINV(0,0,-1)": {"#N/A", "#N/A"}, + "=NORMINV(-1,0,0)": {"#N/A", "#N/A"}, + "=NORMINV(0,0,0)": {"#NUM!", "#NUM!"}, // NORM.S.DIST - "=NORM.S.DIST()": "NORM.S.DIST requires 2 numeric arguments", + "=NORM.S.DIST()": {"#VALUE!", "NORM.S.DIST requires 2 numeric arguments"}, // NORMSDIST - "=NORMSDIST()": "NORMSDIST requires 1 numeric argument", + "=NORMSDIST()": {"#VALUE!", "NORMSDIST requires 1 numeric argument"}, // NORM.S.INV - "=NORM.S.INV()": "NORM.S.INV requires 1 numeric argument", + "=NORM.S.INV()": {"#VALUE!", "NORM.S.INV requires 1 numeric argument"}, // NORMSINV - "=NORMSINV()": "NORMSINV requires 1 numeric argument", + "=NORMSINV()": {"#VALUE!", "NORMSINV requires 1 numeric argument"}, // LARGE - "=LARGE()": "LARGE requires 2 arguments", - "=LARGE(A1:A5,0)": "k should be > 0", - "=LARGE(A1:A5,6)": "k should be <= length of array", - "=LARGE(A1:A5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=LARGE()": {"#VALUE!", "LARGE requires 2 arguments"}, + "=LARGE(A1:A5,0)": {"#NUM!", "k should be > 0"}, + "=LARGE(A1:A5,6)": {"#NUM!", "k should be <= length of array"}, + "=LARGE(A1:A5,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // MAX - "=MAX()": "MAX requires at least 1 argument", - "=MAX(NA())": "#N/A", + "=MAX()": {"#VALUE!", "MAX requires at least 1 argument"}, + "=MAX(NA())": {"#N/A", "#N/A"}, // MAXA - "=MAXA()": "MAXA requires at least 1 argument", - "=MAXA(NA())": "#N/A", + "=MAXA()": {"#VALUE!", "MAXA requires at least 1 argument"}, + "=MAXA(NA())": {"#N/A", "#N/A"}, // MAXIFS - "=MAXIFS()": "MAXIFS requires at least 3 arguments", - "=MAXIFS(F2:F4,A2:A4,\">0\",D2:D9)": "#N/A", + "=MAXIFS()": {"#VALUE!", "MAXIFS requires at least 3 arguments"}, + "=MAXIFS(F2:F4,A2:A4,\">0\",D2:D9)": {"#N/A", "#N/A"}, // MEDIAN - "=MEDIAN()": "MEDIAN requires at least 1 argument", - "=MEDIAN(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=MEDIAN(D1:D2)": "#NUM!", + "=MEDIAN()": {"#VALUE!", "MEDIAN requires at least 1 argument"}, + "=MEDIAN(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=MEDIAN(D1:D2)": {"#NUM!", "#NUM!"}, // MIN - "=MIN()": "MIN requires at least 1 argument", - "=MIN(NA())": "#N/A", + "=MIN()": {"#VALUE!", "MIN requires at least 1 argument"}, + "=MIN(NA())": {"#N/A", "#N/A"}, // MINA - "=MINA()": "MINA requires at least 1 argument", - "=MINA(NA())": "#N/A", + "=MINA()": {"#VALUE!", "MINA requires at least 1 argument"}, + "=MINA(NA())": {"#N/A", "#N/A"}, // MINIFS - "=MINIFS()": "MINIFS requires at least 3 arguments", - "=MINIFS(F2:F4,A2:A4,\"<0\",D2:D9)": "#N/A", + "=MINIFS()": {"#VALUE!", "MINIFS requires at least 3 arguments"}, + "=MINIFS(F2:F4,A2:A4,\"<0\",D2:D9)": {"#N/A", "#N/A"}, // PEARSON - "=PEARSON()": "PEARSON requires 2 arguments", - "=PEARSON(A1:A2,B1:B1)": "#N/A", - "=PEARSON(A4,A4)": "#DIV/0!", + "=PEARSON()": {"#VALUE!", "PEARSON requires 2 arguments"}, + "=PEARSON(A1:A2,B1:B1)": {"#N/A", "#N/A"}, + "=PEARSON(A4,A4)": {"#DIV/0!", "#DIV/0!"}, // PERCENTILE.EXC - "=PERCENTILE.EXC()": "PERCENTILE.EXC requires 2 arguments", - "=PERCENTILE.EXC(A1:A4,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PERCENTILE.EXC(A1:A4,-1)": "#NUM!", - "=PERCENTILE.EXC(A1:A4,0)": "#NUM!", - "=PERCENTILE.EXC(A1:A4,1)": "#NUM!", - "=PERCENTILE.EXC(NA(),0.5)": "#NUM!", + "=PERCENTILE.EXC()": {"#VALUE!", "PERCENTILE.EXC requires 2 arguments"}, + "=PERCENTILE.EXC(A1:A4,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PERCENTILE.EXC(A1:A4,-1)": {"#NUM!", "#NUM!"}, + "=PERCENTILE.EXC(A1:A4,0)": {"#NUM!", "#NUM!"}, + "=PERCENTILE.EXC(A1:A4,1)": {"#NUM!", "#NUM!"}, + "=PERCENTILE.EXC(NA(),0.5)": {"#NUM!", "#NUM!"}, // PERCENTILE.INC - "=PERCENTILE.INC()": "PERCENTILE.INC requires 2 arguments", + "=PERCENTILE.INC()": {"#VALUE!", "PERCENTILE.INC requires 2 arguments"}, // PERCENTILE - "=PERCENTILE()": "PERCENTILE requires 2 arguments", - "=PERCENTILE(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PERCENTILE(0,-1)": "#N/A", - "=PERCENTILE(NA(),1)": "#N/A", + "=PERCENTILE()": {"#VALUE!", "PERCENTILE requires 2 arguments"}, + "=PERCENTILE(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PERCENTILE(0,-1)": {"#N/A", "#N/A"}, + "=PERCENTILE(NA(),1)": {"#N/A", "#N/A"}, // PERCENTRANK.EXC - "=PERCENTRANK.EXC()": "PERCENTRANK.EXC requires 2 or 3 arguments", - "=PERCENTRANK.EXC(A1:B4,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PERCENTRANK.EXC(A1:B4,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PERCENTRANK.EXC(A1:B4,0,0)": "PERCENTRANK.EXC arguments significance should be > 1", - "=PERCENTRANK.EXC(A1:B4,6)": "#N/A", - "=PERCENTRANK.EXC(NA(),1)": "#N/A", + "=PERCENTRANK.EXC()": {"#VALUE!", "PERCENTRANK.EXC requires 2 or 3 arguments"}, + "=PERCENTRANK.EXC(A1:B4,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PERCENTRANK.EXC(A1:B4,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PERCENTRANK.EXC(A1:B4,0,0)": {"#NUM!", "PERCENTRANK.EXC arguments significance should be > 1"}, + "=PERCENTRANK.EXC(A1:B4,6)": {"#N/A", "#N/A"}, + "=PERCENTRANK.EXC(NA(),1)": {"#N/A", "#N/A"}, // PERCENTRANK.INC - "=PERCENTRANK.INC()": "PERCENTRANK.INC requires 2 or 3 arguments", - "=PERCENTRANK.INC(A1:B4,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PERCENTRANK.INC(A1:B4,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PERCENTRANK.INC(A1:B4,0,0)": "PERCENTRANK.INC arguments significance should be > 1", - "=PERCENTRANK.INC(A1:B4,6)": "#N/A", - "=PERCENTRANK.INC(NA(),1)": "#N/A", + "=PERCENTRANK.INC()": {"#VALUE!", "PERCENTRANK.INC requires 2 or 3 arguments"}, + "=PERCENTRANK.INC(A1:B4,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PERCENTRANK.INC(A1:B4,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PERCENTRANK.INC(A1:B4,0,0)": {"#NUM!", "PERCENTRANK.INC arguments significance should be > 1"}, + "=PERCENTRANK.INC(A1:B4,6)": {"#N/A", "#N/A"}, + "=PERCENTRANK.INC(NA(),1)": {"#N/A", "#N/A"}, // PERCENTRANK - "=PERCENTRANK()": "PERCENTRANK requires 2 or 3 arguments", - "=PERCENTRANK(A1:B4,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PERCENTRANK(A1:B4,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PERCENTRANK(A1:B4,0,0)": "PERCENTRANK arguments significance should be > 1", - "=PERCENTRANK(A1:B4,6)": "#N/A", - "=PERCENTRANK(NA(),1)": "#N/A", + "=PERCENTRANK()": {"#VALUE!", "PERCENTRANK requires 2 or 3 arguments"}, + "=PERCENTRANK(A1:B4,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PERCENTRANK(A1:B4,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PERCENTRANK(A1:B4,0,0)": {"#NUM!", "PERCENTRANK arguments significance should be > 1"}, + "=PERCENTRANK(A1:B4,6)": {"#N/A", "#N/A"}, + "=PERCENTRANK(NA(),1)": {"#N/A", "#N/A"}, // PERMUT - "=PERMUT()": "PERMUT requires 2 numeric arguments", - "=PERMUT(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PERMUT(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PERMUT(6,8)": "#N/A", + "=PERMUT()": {"#VALUE!", "PERMUT requires 2 numeric arguments"}, + "=PERMUT(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PERMUT(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PERMUT(6,8)": {"#N/A", "#N/A"}, // PERMUTATIONA - "=PERMUTATIONA()": "PERMUTATIONA requires 2 numeric arguments", - "=PERMUTATIONA(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PERMUTATIONA(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PERMUTATIONA(-1,0)": "#N/A", - "=PERMUTATIONA(0,-1)": "#N/A", + "=PERMUTATIONA()": {"#VALUE!", "PERMUTATIONA requires 2 numeric arguments"}, + "=PERMUTATIONA(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PERMUTATIONA(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PERMUTATIONA(-1,0)": {"#N/A", "#N/A"}, + "=PERMUTATIONA(0,-1)": {"#N/A", "#N/A"}, // PHI - "=PHI()": "PHI requires 1 argument", - "=PHI(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=PHI()": {"#VALUE!", "PHI requires 1 argument"}, + "=PHI(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // QUARTILE - "=QUARTILE()": "QUARTILE requires 2 arguments", - "=QUARTILE(A1:A4,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=QUARTILE(A1:A4,-1)": "#NUM!", - "=QUARTILE(A1:A4,5)": "#NUM!", + "=QUARTILE()": {"#VALUE!", "QUARTILE requires 2 arguments"}, + "=QUARTILE(A1:A4,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=QUARTILE(A1:A4,-1)": {"#NUM!", "#NUM!"}, + "=QUARTILE(A1:A4,5)": {"#NUM!", "#NUM!"}, // QUARTILE.EXC - "=QUARTILE.EXC()": "QUARTILE.EXC requires 2 arguments", - "=QUARTILE.EXC(A1:A4,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=QUARTILE.EXC(A1:A4,0)": "#NUM!", - "=QUARTILE.EXC(A1:A4,4)": "#NUM!", + "=QUARTILE.EXC()": {"#VALUE!", "QUARTILE.EXC requires 2 arguments"}, + "=QUARTILE.EXC(A1:A4,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=QUARTILE.EXC(A1:A4,0)": {"#NUM!", "#NUM!"}, + "=QUARTILE.EXC(A1:A4,4)": {"#NUM!", "#NUM!"}, // QUARTILE.INC - "=QUARTILE.INC()": "QUARTILE.INC requires 2 arguments", + "=QUARTILE.INC()": {"#VALUE!", "QUARTILE.INC requires 2 arguments"}, // RANK - "=RANK()": "RANK requires at least 2 arguments", - "=RANK(1,A1:B5,0,0)": "RANK requires at most 3 arguments", - "=RANK(-1,A1:B5)": "#N/A", - "=RANK(\"\",A1:B5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=RANK(1,A1:B5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=RANK()": {"#VALUE!", "RANK requires at least 2 arguments"}, + "=RANK(1,A1:B5,0,0)": {"#VALUE!", "RANK requires at most 3 arguments"}, + "=RANK(-1,A1:B5)": {"#N/A", "#N/A"}, + "=RANK(\"\",A1:B5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=RANK(1,A1:B5,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // RANK.EQ - "=RANK.EQ()": "RANK.EQ requires at least 2 arguments", - "=RANK.EQ(1,A1:B5,0,0)": "RANK.EQ requires at most 3 arguments", - "=RANK.EQ(-1,A1:B5)": "#N/A", - "=RANK.EQ(\"\",A1:B5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=RANK.EQ(1,A1:B5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=RANK.EQ()": {"#VALUE!", "RANK.EQ requires at least 2 arguments"}, + "=RANK.EQ(1,A1:B5,0,0)": {"#VALUE!", "RANK.EQ requires at most 3 arguments"}, + "=RANK.EQ(-1,A1:B5)": {"#N/A", "#N/A"}, + "=RANK.EQ(\"\",A1:B5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=RANK.EQ(1,A1:B5,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // RSQ - "=RSQ()": "RSQ requires 2 arguments", - "=RSQ(A1:A2,B1:B1)": "#N/A", - "=RSQ(A4,A4)": "#DIV/0!", + "=RSQ()": {"#VALUE!", "RSQ requires 2 arguments"}, + "=RSQ(A1:A2,B1:B1)": {"#N/A", "#N/A"}, + "=RSQ(A4,A4)": {"#DIV/0!", "#DIV/0!"}, // SKEW - "=SKEW()": "SKEW requires at least 1 argument", - "=SKEW(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=SKEW(0)": "#DIV/0!", + "=SKEW()": {"#VALUE!", "SKEW requires at least 1 argument"}, + "=SKEW(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=SKEW(0)": {"#DIV/0!", "#DIV/0!"}, // SKEW.P - "=SKEW.P()": "SKEW.P requires at least 1 argument", - "=SKEW.P(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=SKEW.P(0)": "#DIV/0!", + "=SKEW.P()": {"#VALUE!", "SKEW.P requires at least 1 argument"}, + "=SKEW.P(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=SKEW.P(0)": {"#DIV/0!", "#DIV/0!"}, // SLOPE - "=SLOPE()": "SLOPE requires 2 arguments", - "=SLOPE(A1:A2,B1:B1)": "#N/A", - "=SLOPE(A4,A4)": "#DIV/0!", + "=SLOPE()": {"#VALUE!", "SLOPE requires 2 arguments"}, + "=SLOPE(A1:A2,B1:B1)": {"#N/A", "#N/A"}, + "=SLOPE(A4,A4)": {"#DIV/0!", "#DIV/0!"}, // SMALL - "=SMALL()": "SMALL requires 2 arguments", - "=SMALL(A1:A5,0)": "k should be > 0", - "=SMALL(A1:A5,6)": "k should be <= length of array", - "=SMALL(A1:A5,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=SMALL()": {"#VALUE!", "SMALL requires 2 arguments"}, + "=SMALL(A1:A5,0)": {"#NUM!", "k should be > 0"}, + "=SMALL(A1:A5,6)": {"#NUM!", "k should be <= length of array"}, + "=SMALL(A1:A5,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // STANDARDIZE - "=STANDARDIZE()": "STANDARDIZE requires 3 arguments", - "=STANDARDIZE(\"\",0,5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=STANDARDIZE(0,\"\",5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=STANDARDIZE(0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=STANDARDIZE(0,0,0)": "#N/A", + "=STANDARDIZE()": {"#VALUE!", "STANDARDIZE requires 3 arguments"}, + "=STANDARDIZE(\"\",0,5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=STANDARDIZE(0,\"\",5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=STANDARDIZE(0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=STANDARDIZE(0,0,0)": {"#N/A", "#N/A"}, // STDEVP - "=STDEVP()": "STDEVP requires at least 1 argument", - "=STDEVP(\"\")": "#DIV/0!", + "=STDEVP()": {"#VALUE!", "STDEVP requires at least 1 argument"}, + "=STDEVP(\"\")": {"#DIV/0!", "#DIV/0!"}, // STDEV.P - "=STDEV.P()": "STDEV.P requires at least 1 argument", - "=STDEV.P(\"\")": "#DIV/0!", + "=STDEV.P()": {"#VALUE!", "STDEV.P requires at least 1 argument"}, + "=STDEV.P(\"\")": {"#DIV/0!", "#DIV/0!"}, // STDEVPA - "=STDEVPA()": "STDEVPA requires at least 1 argument", - "=STDEVPA(\"\")": "#DIV/0!", + "=STDEVPA()": {"#VALUE!", "STDEVPA requires at least 1 argument"}, + "=STDEVPA(\"\")": {"#DIV/0!", "#DIV/0!"}, // T.DIST - "=T.DIST()": "T.DIST requires 3 arguments", - "=T.DIST(\"\",10,TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=T.DIST(1,\"\",TRUE)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=T.DIST(1,10,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=T.DIST(1,0,TRUE)": "#NUM!", - "=T.DIST(1,-1,FALSE)": "#NUM!", - "=T.DIST(1,0,FALSE)": "#DIV/0!", + "=T.DIST()": {"#VALUE!", "T.DIST requires 3 arguments"}, + "=T.DIST(\"\",10,TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=T.DIST(1,\"\",TRUE)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=T.DIST(1,10,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=T.DIST(1,0,TRUE)": {"#NUM!", "#NUM!"}, + "=T.DIST(1,-1,FALSE)": {"#NUM!", "#NUM!"}, + "=T.DIST(1,0,FALSE)": {"#DIV/0!", "#DIV/0!"}, // T.DIST.2T - "=T.DIST.2T()": "T.DIST.2T requires 2 arguments", - "=T.DIST.2T(\"\",10)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=T.DIST.2T(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=T.DIST.2T(-1,10)": "#NUM!", - "=T.DIST.2T(1,0)": "#NUM!", + "=T.DIST.2T()": {"#VALUE!", "T.DIST.2T requires 2 arguments"}, + "=T.DIST.2T(\"\",10)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=T.DIST.2T(1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=T.DIST.2T(-1,10)": {"#NUM!", "#NUM!"}, + "=T.DIST.2T(1,0)": {"#NUM!", "#NUM!"}, // T.DIST.RT - "=T.DIST.RT()": "T.DIST.RT requires 2 arguments", - "=T.DIST.RT(\"\",10)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=T.DIST.RT(1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=T.DIST.RT(1,0)": "#NUM!", + "=T.DIST.RT()": {"#VALUE!", "T.DIST.RT requires 2 arguments"}, + "=T.DIST.RT(\"\",10)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=T.DIST.RT(1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=T.DIST.RT(1,0)": {"#NUM!", "#NUM!"}, // TDIST - "=TDIST()": "TDIST requires 3 arguments", - "=TDIST(\"\",10,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=TDIST(1,\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=TDIST(1,10,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=TDIST(-1,10,1)": "#NUM!", - "=TDIST(1,0,1)": "#NUM!", - "=TDIST(1,10,0)": "#NUM!", + "=TDIST()": {"#VALUE!", "TDIST requires 3 arguments"}, + "=TDIST(\"\",10,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=TDIST(1,\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=TDIST(1,10,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=TDIST(-1,10,1)": {"#NUM!", "#NUM!"}, + "=TDIST(1,0,1)": {"#NUM!", "#NUM!"}, + "=TDIST(1,10,0)": {"#NUM!", "#NUM!"}, // T.INV - "=T.INV()": "T.INV requires 2 arguments", - "=T.INV(\"\",10)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=T.INV(0.25,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=T.INV(0,10)": "#NUM!", - "=T.INV(1,10)": "#NUM!", - "=T.INV(0.25,0.5)": "#NUM!", + "=T.INV()": {"#VALUE!", "T.INV requires 2 arguments"}, + "=T.INV(\"\",10)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=T.INV(0.25,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=T.INV(0,10)": {"#NUM!", "#NUM!"}, + "=T.INV(1,10)": {"#NUM!", "#NUM!"}, + "=T.INV(0.25,0.5)": {"#NUM!", "#NUM!"}, // T.INV.2T - "=T.INV.2T()": "T.INV.2T requires 2 arguments", - "=T.INV.2T(\"\",10)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=T.INV.2T(0.25,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=T.INV.2T(0,10)": "#NUM!", - "=T.INV.2T(0.25,0.5)": "#NUM!", + "=T.INV.2T()": {"#VALUE!", "T.INV.2T requires 2 arguments"}, + "=T.INV.2T(\"\",10)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=T.INV.2T(0.25,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=T.INV.2T(0,10)": {"#NUM!", "#NUM!"}, + "=T.INV.2T(0.25,0.5)": {"#NUM!", "#NUM!"}, // TINV - "=TINV()": "TINV requires 2 arguments", - "=TINV(\"\",10)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=TINV(0.25,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=TINV(0,10)": "#NUM!", - "=TINV(0.25,0.5)": "#NUM!", + "=TINV()": {"#VALUE!", "TINV requires 2 arguments"}, + "=TINV(\"\",10)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=TINV(0.25,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=TINV(0,10)": {"#NUM!", "#NUM!"}, + "=TINV(0.25,0.5)": {"#NUM!", "#NUM!"}, // TRIMMEAN - "=TRIMMEAN()": "TRIMMEAN requires 2 arguments", - "=TRIMMEAN(A1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=TRIMMEAN(A1,1)": "#NUM!", - "=TRIMMEAN(A1,-1)": "#NUM!", + "=TRIMMEAN()": {"#VALUE!", "TRIMMEAN requires 2 arguments"}, + "=TRIMMEAN(A1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=TRIMMEAN(A1,1)": {"#NUM!", "#NUM!"}, + "=TRIMMEAN(A1,-1)": {"#NUM!", "#NUM!"}, // VAR - "=VAR()": "VAR requires at least 1 argument", + "=VAR()": {"#VALUE!", "VAR requires at least 1 argument"}, // VARA - "=VARA()": "VARA requires at least 1 argument", + "=VARA()": {"#VALUE!", "VARA requires at least 1 argument"}, // VARP - "=VARP()": "VARP requires at least 1 argument", - "=VARP(\"\")": "#DIV/0!", + "=VARP()": {"#VALUE!", "VARP requires at least 1 argument"}, + "=VARP(\"\")": {"#DIV/0!", "#DIV/0!"}, // VAR.P - "=VAR.P()": "VAR.P requires at least 1 argument", - "=VAR.P(\"\")": "#DIV/0!", + "=VAR.P()": {"#VALUE!", "VAR.P requires at least 1 argument"}, + "=VAR.P(\"\")": {"#DIV/0!", "#DIV/0!"}, // VAR.S - "=VAR.S()": "VAR.S requires at least 1 argument", + "=VAR.S()": {"#VALUE!", "VAR.S requires at least 1 argument"}, // VARPA - "=VARPA()": "VARPA requires at least 1 argument", + "=VARPA()": {"#VALUE!", "VARPA requires at least 1 argument"}, // WEIBULL - "=WEIBULL()": "WEIBULL requires 4 arguments", - "=WEIBULL(\"\",1,1,FALSE)": "#VALUE!", - "=WEIBULL(1,0,1,FALSE)": "#N/A", - "=WEIBULL(1,1,-1,FALSE)": "#N/A", + "=WEIBULL()": {"#VALUE!", "WEIBULL requires 4 arguments"}, + "=WEIBULL(\"\",1,1,FALSE)": {"#VALUE!", "#VALUE!"}, + "=WEIBULL(1,0,1,FALSE)": {"#N/A", "#N/A"}, + "=WEIBULL(1,1,-1,FALSE)": {"#N/A", "#N/A"}, // WEIBULL.DIST - "=WEIBULL.DIST()": "WEIBULL.DIST requires 4 arguments", - "=WEIBULL.DIST(\"\",1,1,FALSE)": "#VALUE!", - "=WEIBULL.DIST(1,0,1,FALSE)": "#N/A", - "=WEIBULL.DIST(1,1,-1,FALSE)": "#N/A", + "=WEIBULL.DIST()": {"#VALUE!", "WEIBULL.DIST requires 4 arguments"}, + "=WEIBULL.DIST(\"\",1,1,FALSE)": {"#VALUE!", "#VALUE!"}, + "=WEIBULL.DIST(1,0,1,FALSE)": {"#N/A", "#N/A"}, + "=WEIBULL.DIST(1,1,-1,FALSE)": {"#N/A", "#N/A"}, // Z.TEST - "=Z.TEST(A1)": "Z.TEST requires at least 2 arguments", - "=Z.TEST(A1,0,0,0)": "Z.TEST accepts at most 3 arguments", - "=Z.TEST(H1,0)": "#N/A", - "=Z.TEST(A1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=Z.TEST(A1,1)": "#DIV/0!", - "=Z.TEST(A1,1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=Z.TEST(A1)": {"#VALUE!", "Z.TEST requires at least 2 arguments"}, + "=Z.TEST(A1,0,0,0)": {"#VALUE!", "Z.TEST accepts at most 3 arguments"}, + "=Z.TEST(H1,0)": {"#N/A", "#N/A"}, + "=Z.TEST(A1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=Z.TEST(A1,1)": {"#DIV/0!", "#DIV/0!"}, + "=Z.TEST(A1,1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // ZTEST - "=ZTEST(A1)": "ZTEST requires at least 2 arguments", - "=ZTEST(A1,0,0,0)": "ZTEST accepts at most 3 arguments", - "=ZTEST(H1,0)": "#N/A", - "=ZTEST(A1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=ZTEST(A1,1)": "#DIV/0!", - "=ZTEST(A1,1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=ZTEST(A1)": {"#VALUE!", "ZTEST requires at least 2 arguments"}, + "=ZTEST(A1,0,0,0)": {"#VALUE!", "ZTEST accepts at most 3 arguments"}, + "=ZTEST(H1,0)": {"#N/A", "#N/A"}, + "=ZTEST(A1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=ZTEST(A1,1)": {"#DIV/0!", "#DIV/0!"}, + "=ZTEST(A1,1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // Information Functions // ERROR.TYPE - "=ERROR.TYPE()": "ERROR.TYPE requires 1 argument", - "=ERROR.TYPE(1)": "#N/A", + "=ERROR.TYPE()": {"#VALUE!", "ERROR.TYPE requires 1 argument"}, + "=ERROR.TYPE(1)": {"#N/A", "#N/A"}, // ISBLANK - "=ISBLANK(A1,A2)": "ISBLANK requires 1 argument", + "=ISBLANK(A1,A2)": {"#VALUE!", "ISBLANK requires 1 argument"}, // ISERR - "=ISERR()": "ISERR requires 1 argument", + "=ISERR()": {"#VALUE!", "ISERR requires 1 argument"}, // ISERROR - "=ISERROR()": "ISERROR requires 1 argument", + "=ISERROR()": {"#VALUE!", "ISERROR requires 1 argument"}, // ISEVEN - "=ISEVEN()": "ISEVEN requires 1 argument", - "=ISEVEN(\"text\")": "#VALUE!", - "=ISEVEN(A1:A2)": "#VALUE!", + "=ISEVEN()": {"#VALUE!", "ISEVEN requires 1 argument"}, + "=ISEVEN(\"text\")": {"#VALUE!", "#VALUE!"}, + "=ISEVEN(A1:A2)": {"#VALUE!", "#VALUE!"}, // ISFORMULA - "=ISFORMULA()": "ISFORMULA requires 1 argument", + "=ISFORMULA()": {"#VALUE!", "ISFORMULA requires 1 argument"}, // ISLOGICAL - "=ISLOGICAL()": "ISLOGICAL requires 1 argument", + "=ISLOGICAL()": {"#VALUE!", "ISLOGICAL requires 1 argument"}, // ISNA - "=ISNA()": "ISNA requires 1 argument", + "=ISNA()": {"#VALUE!", "ISNA requires 1 argument"}, // ISNONTEXT - "=ISNONTEXT()": "ISNONTEXT requires 1 argument", + "=ISNONTEXT()": {"#VALUE!", "ISNONTEXT requires 1 argument"}, // ISNUMBER - "=ISNUMBER()": "ISNUMBER requires 1 argument", + "=ISNUMBER()": {"#VALUE!", "ISNUMBER requires 1 argument"}, // ISODD - "=ISODD()": "ISODD requires 1 argument", - "=ISODD(\"text\")": "#VALUE!", + "=ISODD()": {"#VALUE!", "ISODD requires 1 argument"}, + "=ISODD(\"text\")": {"#VALUE!", "#VALUE!"}, // ISREF - "=ISREF()": "ISREF requires 1 argument", + "=ISREF()": {"#VALUE!", "ISREF requires 1 argument"}, // ISTEXT - "=ISTEXT()": "ISTEXT requires 1 argument", + "=ISTEXT()": {"#VALUE!", "ISTEXT requires 1 argument"}, // N - "=N()": "N requires 1 argument", - "=N(NA())": "#N/A", + "=N()": {"#VALUE!", "N requires 1 argument"}, + "=N(NA())": {"#N/A", "#N/A"}, // NA - "=NA()": "#N/A", - "=NA(1)": "NA accepts no arguments", + "=NA()": {"#N/A", "#N/A"}, + "=NA(1)": {"#VALUE!", "NA accepts no arguments"}, // SHEET - "=SHEET(\"\",\"\")": "SHEET accepts at most 1 argument", - "=SHEET(\"Sheet2\")": "#N/A", + "=SHEET(\"\",\"\")": {"#VALUE!", "SHEET accepts at most 1 argument"}, + "=SHEET(\"Sheet2\")": {"#N/A", "#N/A"}, // SHEETS - "=SHEETS(\"\",\"\")": "SHEETS accepts at most 1 argument", - "=SHEETS(\"Sheet1\")": "#N/A", + "=SHEETS(\"\",\"\")": {"#VALUE!", "SHEETS accepts at most 1 argument"}, + "=SHEETS(\"Sheet1\")": {"#N/A", "#N/A"}, // TYPE - "=TYPE()": "TYPE requires 1 argument", + "=TYPE()": {"#VALUE!", "TYPE requires 1 argument"}, // T - "=T()": "T requires 1 argument", - "=T(NA())": "#N/A", + "=T()": {"#VALUE!", "T requires 1 argument"}, + "=T(NA())": {"#N/A", "#N/A"}, // Logical Functions // AND - "=AND(\"text\")": "#VALUE!", - "=AND(A1:B1)": "#VALUE!", - "=AND(\"1\",\"TRUE\",\"FALSE\")": "#VALUE!", - "=AND()": "AND requires at least 1 argument", - "=AND(1" + strings.Repeat(",1", 30) + ")": "AND accepts at most 30 arguments", + "=AND(\"text\")": {"#VALUE!", "#VALUE!"}, + "=AND(A1:B1)": {"#VALUE!", "#VALUE!"}, + "=AND(\"1\",\"TRUE\",\"FALSE\")": {"#VALUE!", "#VALUE!"}, + "=AND()": {"#VALUE!", "AND requires at least 1 argument"}, + "=AND(1" + strings.Repeat(",1", 30) + ")": {"#VALUE!", "AND accepts at most 30 arguments"}, // FALSE - "=FALSE(A1)": "FALSE takes no arguments", + "=FALSE(A1)": {"#VALUE!", "FALSE takes no arguments"}, // IFERROR - "=IFERROR()": "IFERROR requires 2 arguments", + "=IFERROR()": {"#VALUE!", "IFERROR requires 2 arguments"}, // IFNA - "=IFNA()": "IFNA requires 2 arguments", + "=IFNA()": {"#VALUE!", "IFNA requires 2 arguments"}, // IFS - "=IFS()": "IFS requires at least 2 arguments", - "=IFS(FALSE,FALSE)": "#N/A", + "=IFS()": {"#VALUE!", "IFS requires at least 2 arguments"}, + "=IFS(FALSE,FALSE)": {"#N/A", "#N/A"}, // NOT - "=NOT()": "NOT requires 1 argument", - "=NOT(NOT())": "NOT requires 1 argument", - "=NOT(\"\")": "NOT expects 1 boolean or numeric argument", + "=NOT()": {"#VALUE!", "NOT requires 1 argument"}, + "=NOT(NOT())": {"#VALUE!", "NOT requires 1 argument"}, + "=NOT(\"\")": {"#VALUE!", "NOT expects 1 boolean or numeric argument"}, // OR - "=OR(\"text\")": "#VALUE!", - "=OR(A1:B1)": "#VALUE!", - "=OR(\"1\",\"TRUE\",\"FALSE\")": "#VALUE!", - "=OR()": "OR requires at least 1 argument", - "=OR(1" + strings.Repeat(",1", 30) + ")": "OR accepts at most 30 arguments", + "=OR(\"text\")": {"#VALUE!", "#VALUE!"}, + "=OR(A1:B1)": {"#VALUE!", "#VALUE!"}, + "=OR(\"1\",\"TRUE\",\"FALSE\")": {"#VALUE!", "#VALUE!"}, + "=OR()": {"#VALUE!", "OR requires at least 1 argument"}, + "=OR(1" + strings.Repeat(",1", 30) + ")": {"#VALUE!", "OR accepts at most 30 arguments"}, // SWITCH - "=SWITCH()": "SWITCH requires at least 3 arguments", - "=SWITCH(0,1,2)": "#N/A", + "=SWITCH()": {"#VALUE!", "SWITCH requires at least 3 arguments"}, + "=SWITCH(0,1,2)": {"#N/A", "#N/A"}, // TRUE - "=TRUE(A1)": "TRUE takes no arguments", + "=TRUE(A1)": {"#VALUE!", "TRUE takes no arguments"}, // XOR - "=XOR()": "XOR requires at least 1 argument", - "=XOR(\"1\")": "#VALUE!", - "=XOR(\"text\")": "#VALUE!", - "=XOR(XOR(\"text\"))": "#VALUE!", + "=XOR()": {"#VALUE!", "XOR requires at least 1 argument"}, + "=XOR(\"1\")": {"#VALUE!", "#VALUE!"}, + "=XOR(\"text\")": {"#VALUE!", "#VALUE!"}, + "=XOR(XOR(\"text\"))": {"#VALUE!", "#VALUE!"}, // Date and Time Functions // DATE - "=DATE()": "DATE requires 3 number arguments", - `=DATE("text",10,21)`: "DATE requires 3 number arguments", - `=DATE(2020,"text",21)`: "DATE requires 3 number arguments", - `=DATE(2020,10,"text")`: "DATE requires 3 number arguments", + "=DATE()": {"#VALUE!", "DATE requires 3 number arguments"}, + "=DATE(\"text\",10,21)": {"#VALUE!", "DATE requires 3 number arguments"}, + "=DATE(2020,\"text\",21)": {"#VALUE!", "DATE requires 3 number arguments"}, + "=DATE(2020,10,\"text\")": {"#VALUE!", "DATE requires 3 number arguments"}, // DATEDIF - "=DATEDIF()": "DATEDIF requires 3 number arguments", - "=DATEDIF(\"\",\"\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DATEDIF(43891,43101,\"Y\")": "start_date > end_date", - "=DATEDIF(43101,43891,\"x\")": "DATEDIF has invalid unit", + "=DATEDIF()": {"#VALUE!", "DATEDIF requires 3 number arguments"}, + "=DATEDIF(\"\",\"\",\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DATEDIF(43891,43101,\"Y\")": {"#NUM!", "start_date > end_date"}, + "=DATEDIF(43101,43891,\"x\")": {"#VALUE!", "DATEDIF has invalid unit"}, // DATEVALUE - "=DATEVALUE()": "DATEVALUE requires 1 argument", - "=DATEVALUE(\"01/01\")": "#VALUE!", // valid in Excel, which uses years by the system date - "=DATEVALUE(\"1900-0-0\")": "#VALUE!", + "=DATEVALUE()": {"#VALUE!", "DATEVALUE requires 1 argument"}, + "=DATEVALUE(\"01/01\")": {"#VALUE!", "#VALUE!"}, // valid in Excel, which uses years by the system date + "=DATEVALUE(\"1900-0-0\")": {"#VALUE!", "#VALUE!"}, // DAY - "=DAY()": "DAY requires exactly 1 argument", - "=DAY(-1)": "DAY only accepts positive argument", - "=DAY(0,0)": "DAY requires exactly 1 argument", - "=DAY(\"text\")": "#VALUE!", - "=DAY(\"January 25, 2020 9223372036854775808 AM\")": "#VALUE!", - "=DAY(\"January 25, 2020 9223372036854775808:00 AM\")": "#VALUE!", - "=DAY(\"January 25, 2020 00:9223372036854775808 AM\")": "#VALUE!", - "=DAY(\"January 25, 2020 9223372036854775808:00.0 AM\")": "#VALUE!", - "=DAY(\"January 25, 2020 0:1" + strings.Repeat("0", 309) + ".0 AM\")": "#VALUE!", - "=DAY(\"January 25, 2020 9223372036854775808:00:00 AM\")": "#VALUE!", - "=DAY(\"January 25, 2020 0:9223372036854775808:0 AM\")": "#VALUE!", - "=DAY(\"January 25, 2020 0:0:1" + strings.Repeat("0", 309) + " AM\")": "#VALUE!", - "=DAY(\"January 25, 2020 0:61:0 AM\")": "#VALUE!", - "=DAY(\"January 25, 2020 0:00:60 AM\")": "#VALUE!", - "=DAY(\"January 25, 2020 24:00:00\")": "#VALUE!", - "=DAY(\"January 25, 2020 00:00:10001\")": "#VALUE!", - "=DAY(\"9223372036854775808/25/2020\")": "#VALUE!", - "=DAY(\"01/9223372036854775808/2020\")": "#VALUE!", - "=DAY(\"01/25/9223372036854775808\")": "#VALUE!", - "=DAY(\"01/25/10000\")": "#VALUE!", - "=DAY(\"01/25/100\")": "#VALUE!", - "=DAY(\"January 9223372036854775808, 2020\")": "#VALUE!", - "=DAY(\"January 25, 9223372036854775808\")": "#VALUE!", - "=DAY(\"January 25, 10000\")": "#VALUE!", - "=DAY(\"January 25, 100\")": "#VALUE!", - "=DAY(\"9223372036854775808-25-2020\")": "#VALUE!", - "=DAY(\"01-9223372036854775808-2020\")": "#VALUE!", - "=DAY(\"01-25-9223372036854775808\")": "#VALUE!", - "=DAY(\"1900-0-0\")": "#VALUE!", - "=DAY(\"14-25-1900\")": "#VALUE!", - "=DAY(\"3-January-9223372036854775808\")": "#VALUE!", - "=DAY(\"9223372036854775808-January-1900\")": "#VALUE!", - "=DAY(\"0-January-1900\")": "#VALUE!", + "=DAY()": {"#VALUE!", "DAY requires exactly 1 argument"}, + "=DAY(-1)": {"#NUM!", "DAY only accepts positive argument"}, + "=DAY(0,0)": {"#VALUE!", "DAY requires exactly 1 argument"}, + "=DAY(\"text\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 2020 9223372036854775808 AM\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 2020 9223372036854775808:00 AM\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 2020 00:9223372036854775808 AM\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 2020 9223372036854775808:00.0 AM\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 2020 0:1" + strings.Repeat("0", 309) + ".0 AM\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 2020 9223372036854775808:00:00 AM\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 2020 0:9223372036854775808:0 AM\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 2020 0:0:1" + strings.Repeat("0", 309) + " AM\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 2020 0:61:0 AM\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 2020 0:00:60 AM\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 2020 24:00:00\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 2020 00:00:10001\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"9223372036854775808/25/2020\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"01/9223372036854775808/2020\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"01/25/9223372036854775808\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"01/25/10000\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"01/25/100\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 9223372036854775808, 2020\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 9223372036854775808\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 10000\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"January 25, 100\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"9223372036854775808-25-2020\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"01-9223372036854775808-2020\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"01-25-9223372036854775808\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"1900-0-0\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"14-25-1900\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"3-January-9223372036854775808\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"9223372036854775808-January-1900\")": {"#VALUE!", "#VALUE!"}, + "=DAY(\"0-January-1900\")": {"#VALUE!", "#VALUE!"}, // DAYS - "=DAYS()": "DAYS requires 2 arguments", - "=DAYS(\"\",0)": "#VALUE!", - "=DAYS(0,\"\")": "#VALUE!", - "=DAYS(NA(),0)": "#VALUE!", - "=DAYS(0,NA())": "#VALUE!", + "=DAYS()": {"#VALUE!", "DAYS requires 2 arguments"}, + "=DAYS(\"\",0)": {"#VALUE!", "#VALUE!"}, + "=DAYS(0,\"\")": {"#VALUE!", "#VALUE!"}, + "=DAYS(NA(),0)": {"#VALUE!", "#VALUE!"}, + "=DAYS(0,NA())": {"#VALUE!", "#VALUE!"}, // DAYS360 - "=DAYS360(\"12/12/1999\")": "DAYS360 requires at least 2 arguments", - "=DAYS360(\"12/12/1999\", \"11/30/1999\",TRUE,\"\")": "DAYS360 requires at most 3 arguments", - "=DAYS360(\"12/12/1999\", \"11/30/1999\",\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=DAYS360(\"12/12/1999\", \"\")": "#VALUE!", - "=DAYS360(\"\", \"11/30/1999\")": "#VALUE!", + "=DAYS360(\"12/12/1999\")": {"#VALUE!", "DAYS360 requires at least 2 arguments"}, + "=DAYS360(\"12/12/1999\", \"11/30/1999\",TRUE,\"\")": {"#VALUE!", "DAYS360 requires at most 3 arguments"}, + "=DAYS360(\"12/12/1999\", \"11/30/1999\",\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=DAYS360(\"12/12/1999\", \"\")": {"#VALUE!", "#VALUE!"}, + "=DAYS360(\"\", \"11/30/1999\")": {"#VALUE!", "#VALUE!"}, // EDATE - "=EDATE()": "EDATE requires 2 arguments", - "=EDATE(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=EDATE(-1,0)": "#NUM!", - "=EDATE(\"\",0)": "#VALUE!", - "=EDATE(\"January 25, 100\",0)": "#VALUE!", + "=EDATE()": {"#VALUE!", "EDATE requires 2 arguments"}, + "=EDATE(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=EDATE(-1,0)": {"#NUM!", "#NUM!"}, + "=EDATE(\"\",0)": {"#VALUE!", "#VALUE!"}, + "=EDATE(\"January 25, 100\",0)": {"#VALUE!", "#VALUE!"}, // EOMONTH - "=EOMONTH()": "EOMONTH requires 2 arguments", - "=EOMONTH(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=EOMONTH(-1,0)": "#NUM!", - "=EOMONTH(\"\",0)": "#VALUE!", - "=EOMONTH(\"January 25, 100\",0)": "#VALUE!", + "=EOMONTH()": {"#VALUE!", "EOMONTH requires 2 arguments"}, + "=EOMONTH(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=EOMONTH(-1,0)": {"#NUM!", "#NUM!"}, + "=EOMONTH(\"\",0)": {"#VALUE!", "#VALUE!"}, + "=EOMONTH(\"January 25, 100\",0)": {"#VALUE!", "#VALUE!"}, // HOUR - "=HOUR()": "HOUR requires exactly 1 argument", - "=HOUR(-1)": "HOUR only accepts positive argument", - "=HOUR(\"\")": "#VALUE!", - "=HOUR(\"25:10:55\")": "#VALUE!", + "=HOUR()": {"#VALUE!", "HOUR requires exactly 1 argument"}, + "=HOUR(-1)": {"#NUM!", "HOUR only accepts positive argument"}, + "=HOUR(\"\")": {"#VALUE!", "#VALUE!"}, + "=HOUR(\"25:10:55\")": {"#VALUE!", "#VALUE!"}, // ISOWEEKNUM - "=ISOWEEKNUM()": "ISOWEEKNUM requires 1 argument", - "=ISOWEEKNUM(\"\")": "#VALUE!", - "=ISOWEEKNUM(\"January 25, 100\")": "#VALUE!", - "=ISOWEEKNUM(-1)": "#NUM!", + "=ISOWEEKNUM()": {"#VALUE!", "ISOWEEKNUM requires 1 argument"}, + "=ISOWEEKNUM(\"\")": {"#VALUE!", "#VALUE!"}, + "=ISOWEEKNUM(\"January 25, 100\")": {"#VALUE!", "#VALUE!"}, + "=ISOWEEKNUM(-1)": {"#NUM!", "#NUM!"}, // MINUTE - "=MINUTE()": "MINUTE requires exactly 1 argument", - "=MINUTE(-1)": "MINUTE only accepts positive argument", - "=MINUTE(\"\")": "#VALUE!", - "=MINUTE(\"13:60:55\")": "#VALUE!", + "=MINUTE()": {"#VALUE!", "MINUTE requires exactly 1 argument"}, + "=MINUTE(-1)": {"#NUM!", "MINUTE only accepts positive argument"}, + "=MINUTE(\"\")": {"#VALUE!", "#VALUE!"}, + "=MINUTE(\"13:60:55\")": {"#VALUE!", "#VALUE!"}, // MONTH - "=MONTH()": "MONTH requires exactly 1 argument", - "=MONTH(0,0)": "MONTH requires exactly 1 argument", - "=MONTH(-1)": "MONTH only accepts positive argument", - "=MONTH(\"text\")": "#VALUE!", - "=MONTH(\"January 25, 100\")": "#VALUE!", + "=MONTH()": {"#VALUE!", "MONTH requires exactly 1 argument"}, + "=MONTH(0,0)": {"#VALUE!", "MONTH requires exactly 1 argument"}, + "=MONTH(-1)": {"#NUM!", "MONTH only accepts positive argument"}, + "=MONTH(\"text\")": {"#VALUE!", "#VALUE!"}, + "=MONTH(\"January 25, 100\")": {"#VALUE!", "#VALUE!"}, // YEAR - "=YEAR()": "YEAR requires exactly 1 argument", - "=YEAR(0,0)": "YEAR requires exactly 1 argument", - "=YEAR(-1)": "YEAR only accepts positive argument", - "=YEAR(\"text\")": "#VALUE!", - "=YEAR(\"January 25, 100\")": "#VALUE!", + "=YEAR()": {"#VALUE!", "YEAR requires exactly 1 argument"}, + "=YEAR(0,0)": {"#VALUE!", "YEAR requires exactly 1 argument"}, + "=YEAR(-1)": {"#NUM!", "YEAR only accepts positive argument"}, + "=YEAR(\"text\")": {"#VALUE!", "#VALUE!"}, + "=YEAR(\"January 25, 100\")": {"#VALUE!", "#VALUE!"}, // YEARFRAC - "=YEARFRAC()": "YEARFRAC requires 3 or 4 arguments", - "=YEARFRAC(42005,42094,5)": "invalid basis", - "=YEARFRAC(\"\",42094,5)": "#VALUE!", - "=YEARFRAC(42005,\"\",5)": "#VALUE!", - "=YEARFRAC(42005,42094,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=YEARFRAC()": {"#VALUE!", "YEARFRAC requires 3 or 4 arguments"}, + "=YEARFRAC(42005,42094,5)": {"#NUM!", "invalid basis"}, + "=YEARFRAC(\"\",42094,5)": {"#VALUE!", "#VALUE!"}, + "=YEARFRAC(42005,\"\",5)": {"#VALUE!", "#VALUE!"}, + "=YEARFRAC(42005,42094,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // NOW - "=NOW(A1)": "NOW accepts no arguments", + "=NOW(A1)": {"#VALUE!", "NOW accepts no arguments"}, // SECOND - "=SECOND()": "SECOND requires exactly 1 argument", - "=SECOND(-1)": "SECOND only accepts positive argument", - "=SECOND(\"\")": "#VALUE!", - "=SECOND(\"25:55\")": "#VALUE!", + "=SECOND()": {"#VALUE!", "SECOND requires exactly 1 argument"}, + "=SECOND(-1)": {"#NUM!", "SECOND only accepts positive argument"}, + "=SECOND(\"\")": {"#VALUE!", "#VALUE!"}, + "=SECOND(\"25:55\")": {"#VALUE!", "#VALUE!"}, // TIME - "=TIME()": "TIME requires 3 number arguments", - "=TIME(\"\",0,0)": "TIME requires 3 number arguments", - "=TIME(0,0,-1)": "#NUM!", + "=TIME()": {"#VALUE!", "TIME requires 3 number arguments"}, + "=TIME(\"\",0,0)": {"#VALUE!", "TIME requires 3 number arguments"}, + "=TIME(0,0,-1)": {"#NUM!", "#NUM!"}, // TIMEVALUE - "=TIMEVALUE()": "TIMEVALUE requires exactly 1 argument", - "=TIMEVALUE(1)": "#VALUE!", - "=TIMEVALUE(-1)": "#VALUE!", - "=TIMEVALUE(\"25:55\")": "#VALUE!", + "=TIMEVALUE()": {"#VALUE!", "TIMEVALUE requires exactly 1 argument"}, + "=TIMEVALUE(1)": {"#VALUE!", "#VALUE!"}, + "=TIMEVALUE(-1)": {"#VALUE!", "#VALUE!"}, + "=TIMEVALUE(\"25:55\")": {"#VALUE!", "#VALUE!"}, // TODAY - "=TODAY(A1)": "TODAY accepts no arguments", + "=TODAY(A1)": {"#VALUE!", "TODAY accepts no arguments"}, // WEEKDAY - "=WEEKDAY()": "WEEKDAY requires at least 1 argument", - "=WEEKDAY(0,1,0)": "WEEKDAY allows at most 2 arguments", - "=WEEKDAY(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=WEEKDAY(\"\",1)": "#VALUE!", - "=WEEKDAY(0,0)": "#VALUE!", - "=WEEKDAY(\"January 25, 100\")": "#VALUE!", - "=WEEKDAY(-1,1)": "#NUM!", + "=WEEKDAY()": {"#VALUE!", "WEEKDAY requires at least 1 argument"}, + "=WEEKDAY(0,1,0)": {"#VALUE!", "WEEKDAY allows at most 2 arguments"}, + "=WEEKDAY(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=WEEKDAY(\"\",1)": {"#VALUE!", "#VALUE!"}, + "=WEEKDAY(0,0)": {"#VALUE!", "#VALUE!"}, + "=WEEKDAY(\"January 25, 100\")": {"#VALUE!", "#VALUE!"}, + "=WEEKDAY(-1,1)": {"#NUM!", "#NUM!"}, // WEEKNUM - "=WEEKNUM()": "WEEKNUM requires at least 1 argument", - "=WEEKNUM(0,1,0)": "WEEKNUM allows at most 2 arguments", - "=WEEKNUM(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=WEEKNUM(\"\",1)": "#VALUE!", - "=WEEKNUM(\"January 25, 100\")": "#VALUE!", - "=WEEKNUM(0,0)": "#NUM!", - "=WEEKNUM(-1,1)": "#NUM!", + "=WEEKNUM()": {"#VALUE!", "WEEKNUM requires at least 1 argument"}, + "=WEEKNUM(0,1,0)": {"#VALUE!", "WEEKNUM allows at most 2 arguments"}, + "=WEEKNUM(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=WEEKNUM(\"\",1)": {"#VALUE!", "#VALUE!"}, + "=WEEKNUM(\"January 25, 100\")": {"#VALUE!", "#VALUE!"}, + "=WEEKNUM(0,0)": {"#NUM!", "#NUM!"}, + "=WEEKNUM(-1,1)": {"#NUM!", "#NUM!"}, // Text Functions // CHAR - "=CHAR()": "CHAR requires 1 argument", - "=CHAR(-1)": "#VALUE!", - "=CHAR(256)": "#VALUE!", - "=CHAR(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=CHAR()": {"#VALUE!", "CHAR requires 1 argument"}, + "=CHAR(-1)": {"#VALUE!", "#VALUE!"}, + "=CHAR(256)": {"#VALUE!", "#VALUE!"}, + "=CHAR(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // CLEAN - "=CLEAN()": "CLEAN requires 1 argument", - "=CLEAN(1,2)": "CLEAN requires 1 argument", + "=CLEAN()": {"#VALUE!", "CLEAN requires 1 argument"}, + "=CLEAN(1,2)": {"#VALUE!", "CLEAN requires 1 argument"}, // CODE - "=CODE()": "CODE requires 1 argument", - "=CODE(1,2)": "CODE requires 1 argument", + "=CODE()": {"#VALUE!", "CODE requires 1 argument"}, + "=CODE(1,2)": {"#VALUE!", "CODE requires 1 argument"}, // CONCAT - "=CONCAT(MUNIT(2))": "CONCAT requires arguments to be strings", + "=CONCAT(MUNIT(2))": {"#VALUE!", "CONCAT requires arguments to be strings"}, // CONCATENATE - "=CONCATENATE(MUNIT(2))": "CONCATENATE requires arguments to be strings", + "=CONCATENATE(MUNIT(2))": {"#VALUE!", "CONCATENATE requires arguments to be strings"}, // EXACT - "=EXACT()": "EXACT requires 2 arguments", - "=EXACT(1,2,3)": "EXACT requires 2 arguments", + "=EXACT()": {"#VALUE!", "EXACT requires 2 arguments"}, + "=EXACT(1,2,3)": {"#VALUE!", "EXACT requires 2 arguments"}, // FIXED - "=FIXED()": "FIXED requires at least 1 argument", - "=FIXED(0,1,2,3)": "FIXED allows at most 3 arguments", - "=FIXED(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FIXED(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FIXED(0,0,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", + "=FIXED()": {"#VALUE!", "FIXED requires at least 1 argument"}, + "=FIXED(0,1,2,3)": {"#VALUE!", "FIXED allows at most 3 arguments"}, + "=FIXED(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FIXED(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FIXED(0,0,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, // FIND - "=FIND()": "FIND requires at least 2 arguments", - "=FIND(1,2,3,4)": "FIND allows at most 3 arguments", - "=FIND(\"x\",\"\")": "#VALUE!", - "=FIND(\"x\",\"x\",-1)": "#VALUE!", - "=FIND(\"x\",\"x\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=FIND()": {"#VALUE!", "FIND requires at least 2 arguments"}, + "=FIND(1,2,3,4)": {"#VALUE!", "FIND allows at most 3 arguments"}, + "=FIND(\"x\",\"\")": {"#VALUE!", "#VALUE!"}, + "=FIND(\"x\",\"x\",-1)": {"#VALUE!", "#VALUE!"}, + "=FIND(\"x\",\"x\",\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // FINDB - "=FINDB()": "FINDB requires at least 2 arguments", - "=FINDB(1,2,3,4)": "FINDB allows at most 3 arguments", - "=FINDB(\"x\",\"\")": "#VALUE!", - "=FINDB(\"x\",\"x\",-1)": "#VALUE!", - "=FINDB(\"x\",\"x\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=FINDB()": {"#VALUE!", "FINDB requires at least 2 arguments"}, + "=FINDB(1,2,3,4)": {"#VALUE!", "FINDB allows at most 3 arguments"}, + "=FINDB(\"x\",\"\")": {"#VALUE!", "#VALUE!"}, + "=FINDB(\"x\",\"x\",-1)": {"#VALUE!", "#VALUE!"}, + "=FINDB(\"x\",\"x\",\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // LEFT - "=LEFT()": "LEFT requires at least 1 argument", - "=LEFT(\"\",2,3)": "LEFT allows at most 2 arguments", - "=LEFT(\"\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LEFT(\"\",-1)": "#VALUE!", + "=LEFT()": {"#VALUE!", "LEFT requires at least 1 argument"}, + "=LEFT(\"\",2,3)": {"#VALUE!", "LEFT allows at most 2 arguments"}, + "=LEFT(\"\",\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LEFT(\"\",-1)": {"#VALUE!", "#VALUE!"}, // LEFTB - "=LEFTB()": "LEFTB requires at least 1 argument", - "=LEFTB(\"\",2,3)": "LEFTB allows at most 2 arguments", - "=LEFTB(\"\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=LEFTB(\"\",-1)": "#VALUE!", + "=LEFTB()": {"#VALUE!", "LEFTB requires at least 1 argument"}, + "=LEFTB(\"\",2,3)": {"#VALUE!", "LEFTB allows at most 2 arguments"}, + "=LEFTB(\"\",\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=LEFTB(\"\",-1)": {"#VALUE!", "#VALUE!"}, // LEN - "=LEN()": "LEN requires 1 string argument", + "=LEN()": {"#VALUE!", "LEN requires 1 string argument"}, // LENB - "=LENB()": "LENB requires 1 string argument", + "=LENB()": {"#VALUE!", "LENB requires 1 string argument"}, // LOWER - "=LOWER()": "LOWER requires 1 argument", - "=LOWER(1,2)": "LOWER requires 1 argument", + "=LOWER()": {"#VALUE!", "LOWER requires 1 argument"}, + "=LOWER(1,2)": {"#VALUE!", "LOWER requires 1 argument"}, // MID - "=MID()": "MID requires 3 arguments", - "=MID(\"\",-1,1)": "#VALUE!", - "=MID(\"\",\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=MID(\"\",1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=MID()": {"#VALUE!", "MID requires 3 arguments"}, + "=MID(\"\",-1,1)": {"#VALUE!", "#VALUE!"}, + "=MID(\"\",\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=MID(\"\",1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // MIDB - "=MIDB()": "MIDB requires 3 arguments", - "=MIDB(\"\",-1,1)": "#VALUE!", - "=MIDB(\"\",\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=MIDB(\"\",1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=MIDB()": {"#VALUE!", "MIDB requires 3 arguments"}, + "=MIDB(\"\",-1,1)": {"#VALUE!", "#VALUE!"}, + "=MIDB(\"\",\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=MIDB(\"\",1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // PROPER - "=PROPER()": "PROPER requires 1 argument", - "=PROPER(1,2)": "PROPER requires 1 argument", + "=PROPER()": {"#VALUE!", "PROPER requires 1 argument"}, + "=PROPER(1,2)": {"#VALUE!", "PROPER requires 1 argument"}, // REPLACE - "=REPLACE()": "REPLACE requires 4 arguments", - "=REPLACE(\"text\",0,4,\"string\")": "#VALUE!", - "=REPLACE(\"text\",\"\",0,\"string\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=REPLACE(\"text\",1,\"\",\"string\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=REPLACE()": {"#VALUE!", "REPLACE requires 4 arguments"}, + "=REPLACE(\"text\",0,4,\"string\")": {"#VALUE!", "#VALUE!"}, + "=REPLACE(\"text\",\"\",0,\"string\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=REPLACE(\"text\",1,\"\",\"string\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // REPLACEB - "=REPLACEB()": "REPLACEB requires 4 arguments", - "=REPLACEB(\"text\",0,4,\"string\")": "#VALUE!", - "=REPLACEB(\"text\",\"\",0,\"string\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=REPLACEB(\"text\",1,\"\",\"string\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=REPLACEB()": {"#VALUE!", "REPLACEB requires 4 arguments"}, + "=REPLACEB(\"text\",0,4,\"string\")": {"#VALUE!", "#VALUE!"}, + "=REPLACEB(\"text\",\"\",0,\"string\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=REPLACEB(\"text\",1,\"\",\"string\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // REPT - "=REPT()": "REPT requires 2 arguments", - "=REPT(INT(0),2)": "REPT requires first argument to be a string", - "=REPT(\"*\",\"*\")": "REPT requires second argument to be a number", - "=REPT(\"*\",-1)": "REPT requires second argument to be >= 0", + "=REPT()": {"#VALUE!", "REPT requires 2 arguments"}, + "=REPT(INT(0),2)": {"#VALUE!", "REPT requires first argument to be a string"}, + "=REPT(\"*\",\"*\")": {"#VALUE!", "REPT requires second argument to be a number"}, + "=REPT(\"*\",-1)": {"#VALUE!", "REPT requires second argument to be >= 0"}, // RIGHT - "=RIGHT()": "RIGHT requires at least 1 argument", - "=RIGHT(\"\",2,3)": "RIGHT allows at most 2 arguments", - "=RIGHT(\"\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=RIGHT(\"\",-1)": "#VALUE!", + "=RIGHT()": {"#VALUE!", "RIGHT requires at least 1 argument"}, + "=RIGHT(\"\",2,3)": {"#VALUE!", "RIGHT allows at most 2 arguments"}, + "=RIGHT(\"\",\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=RIGHT(\"\",-1)": {"#VALUE!", "#VALUE!"}, // RIGHTB - "=RIGHTB()": "RIGHTB requires at least 1 argument", - "=RIGHTB(\"\",2,3)": "RIGHTB allows at most 2 arguments", - "=RIGHTB(\"\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=RIGHTB(\"\",-1)": "#VALUE!", + "=RIGHTB()": {"#VALUE!", "RIGHTB requires at least 1 argument"}, + "=RIGHTB(\"\",2,3)": {"#VALUE!", "RIGHTB allows at most 2 arguments"}, + "=RIGHTB(\"\",\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=RIGHTB(\"\",-1)": {"#VALUE!", "#VALUE!"}, // SUBSTITUTE - "=SUBSTITUTE()": "SUBSTITUTE requires 3 or 4 arguments", - "=SUBSTITUTE(\"\",\"\",\"\",\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=SUBSTITUTE(\"\",\"\",\"\",0)": "instance_num should be > 0", + "=SUBSTITUTE()": {"#VALUE!", "SUBSTITUTE requires 3 or 4 arguments"}, + "=SUBSTITUTE(\"\",\"\",\"\",\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=SUBSTITUTE(\"\",\"\",\"\",0)": {"#VALUE!", "instance_num should be > 0"}, // TEXTJOIN - "=TEXTJOIN()": "TEXTJOIN requires at least 3 arguments", - "=TEXTJOIN(\"\",\"\",1)": "#VALUE!", - "=TEXTJOIN(\"\",TRUE,NA())": "#N/A", - "=TEXTJOIN(\"\",TRUE," + strings.Repeat("0,", 250) + ",0)": "TEXTJOIN accepts at most 252 arguments", - "=TEXTJOIN(\",\",FALSE,REPT(\"*\",32768))": "TEXTJOIN function exceeds 32767 characters", + "=TEXTJOIN()": {"#VALUE!", "TEXTJOIN requires at least 3 arguments"}, + "=TEXTJOIN(\"\",\"\",1)": {"#VALUE!", "#VALUE!"}, + "=TEXTJOIN(\"\",TRUE,NA())": {"#N/A", "#N/A"}, + "=TEXTJOIN(\"\",TRUE," + strings.Repeat("0,", 250) + ",0)": {"#VALUE!", "TEXTJOIN accepts at most 252 arguments"}, + "=TEXTJOIN(\",\",FALSE,REPT(\"*\",32768))": {"#VALUE!", "TEXTJOIN function exceeds 32767 characters"}, // TRIM - "=TRIM()": "TRIM requires 1 argument", - "=TRIM(1,2)": "TRIM requires 1 argument", + "=TRIM()": {"#VALUE!", "TRIM requires 1 argument"}, + "=TRIM(1,2)": {"#VALUE!", "TRIM requires 1 argument"}, // UNICHAR - "=UNICHAR()": "UNICHAR requires 1 argument", - "=UNICHAR(\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=UNICHAR(55296)": "#VALUE!", - "=UNICHAR(0)": "#VALUE!", + "=UNICHAR()": {"#VALUE!", "UNICHAR requires 1 argument"}, + "=UNICHAR(\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=UNICHAR(55296)": {"#VALUE!", "#VALUE!"}, + "=UNICHAR(0)": {"#VALUE!", "#VALUE!"}, // UNICODE - "=UNICODE()": "UNICODE requires 1 argument", - "=UNICODE(\"\")": "#VALUE!", + "=UNICODE()": {"#VALUE!", "UNICODE requires 1 argument"}, + "=UNICODE(\"\")": {"#VALUE!", "#VALUE!"}, // VALUE - "=VALUE()": "VALUE requires 1 argument", - "=VALUE(\"\")": "#VALUE!", + "=VALUE()": {"#VALUE!", "VALUE requires 1 argument"}, + "=VALUE(\"\")": {"#VALUE!", "#VALUE!"}, // UPPER - "=UPPER()": "UPPER requires 1 argument", - "=UPPER(1,2)": "UPPER requires 1 argument", + "=UPPER()": {"#VALUE!", "UPPER requires 1 argument"}, + "=UPPER(1,2)": {"#VALUE!", "UPPER requires 1 argument"}, // Conditional Functions // IF - "=IF()": "IF requires at least 1 argument", - "=IF(0,1,2,3)": "IF accepts at most 3 arguments", - "=IF(D1,1,2)": "strconv.ParseBool: parsing \"Month\": invalid syntax", + "=IF()": {"#VALUE!", "IF requires at least 1 argument"}, + "=IF(0,1,2,3)": {"#VALUE!", "IF accepts at most 3 arguments"}, + "=IF(D1,1,2)": {"#VALUE!", "strconv.ParseBool: parsing \"Month\": invalid syntax"}, // Excel Lookup and Reference Functions // ADDRESS - "=ADDRESS()": "ADDRESS requires at least 2 arguments", - "=ADDRESS(1,1,1,TRUE,\"Sheet1\",0)": "ADDRESS requires at most 5 arguments", - "=ADDRESS(\"\",1,1,TRUE)": "#VALUE!", - "=ADDRESS(1,\"\",1,TRUE)": "#VALUE!", - "=ADDRESS(1,1,\"\",TRUE)": "#VALUE!", - "=ADDRESS(1,1,1,\"\")": "#VALUE!", - "=ADDRESS(1,1,0,TRUE)": "#NUM!", - "=ADDRESS(1,16385,2,TRUE)": "#VALUE!", - "=ADDRESS(1,16385,3,TRUE)": "#VALUE!", - "=ADDRESS(1048576,1,1,TRUE)": "#VALUE!", + "=ADDRESS()": {"#VALUE!", "ADDRESS requires at least 2 arguments"}, + "=ADDRESS(1,1,1,TRUE,\"Sheet1\",0)": {"#VALUE!", "ADDRESS requires at most 5 arguments"}, + "=ADDRESS(\"\",1,1,TRUE)": {"#VALUE!", "#VALUE!"}, + "=ADDRESS(1,\"\",1,TRUE)": {"#VALUE!", "#VALUE!"}, + "=ADDRESS(1,1,\"\",TRUE)": {"#VALUE!", "#VALUE!"}, + "=ADDRESS(1,1,1,\"\")": {"#VALUE!", "#VALUE!"}, + "=ADDRESS(1,1,0,TRUE)": {"#NUM!", "#NUM!"}, + "=ADDRESS(1,16385,2,TRUE)": {"#VALUE!", "#VALUE!"}, + "=ADDRESS(1,16385,3,TRUE)": {"#VALUE!", "#VALUE!"}, + "=ADDRESS(1048576,1,1,TRUE)": {"#VALUE!", "#VALUE!"}, // CHOOSE - "=CHOOSE()": "CHOOSE requires 2 arguments", - "=CHOOSE(\"index_num\",0)": "CHOOSE requires first argument of type number", - "=CHOOSE(2,0)": "index_num should be <= to the number of values", - "=CHOOSE(1,NA())": "#N/A", + "=CHOOSE()": {"#VALUE!", "CHOOSE requires 2 arguments"}, + "=CHOOSE(\"index_num\",0)": {"#VALUE!", "CHOOSE requires first argument of type number"}, + "=CHOOSE(2,0)": {"#VALUE!", "index_num should be <= to the number of values"}, + "=CHOOSE(1,NA())": {"#N/A", "#N/A"}, // COLUMN - "=COLUMN(1,2)": "COLUMN requires at most 1 argument", - "=COLUMN(\"\")": "invalid reference", - "=COLUMN(Sheet1)": newInvalidColumnNameError("Sheet1").Error(), - "=COLUMN(Sheet1!A1!B1)": newInvalidColumnNameError("Sheet1").Error(), + "=COLUMN(1,2)": {"#VALUE!", "COLUMN requires at most 1 argument"}, + "=COLUMN(\"\")": {"#VALUE!", "invalid reference"}, + "=COLUMN(Sheet1)": {"", newInvalidColumnNameError("Sheet1").Error()}, + "=COLUMN(Sheet1!A1!B1)": {"", newInvalidColumnNameError("Sheet1").Error()}, // COLUMNS - "=COLUMNS()": "COLUMNS requires 1 argument", - "=COLUMNS(1)": "invalid reference", - "=COLUMNS(\"\")": "invalid reference", - "=COLUMNS(Sheet1)": newInvalidColumnNameError("Sheet1").Error(), - "=COLUMNS(Sheet1!A1!B1)": newInvalidColumnNameError("Sheet1").Error(), - "=COLUMNS(Sheet1!Sheet1)": newInvalidColumnNameError("Sheet1").Error(), + "=COLUMNS()": {"#VALUE!", "COLUMNS requires 1 argument"}, + "=COLUMNS(1)": {"#VALUE!", "invalid reference"}, + "=COLUMNS(\"\")": {"#VALUE!", "invalid reference"}, + "=COLUMNS(Sheet1)": {"", newInvalidColumnNameError("Sheet1").Error()}, + "=COLUMNS(Sheet1!A1!B1)": {"", newInvalidColumnNameError("Sheet1").Error()}, + "=COLUMNS(Sheet1!Sheet1)": {"", newInvalidColumnNameError("Sheet1").Error()}, // FORMULATEXT - "=FORMULATEXT()": "FORMULATEXT requires 1 argument", - "=FORMULATEXT(1)": "#VALUE!", + "=FORMULATEXT()": {"#VALUE!", "FORMULATEXT requires 1 argument"}, + "=FORMULATEXT(1)": {"#VALUE!", "#VALUE!"}, // HLOOKUP - "=HLOOKUP()": "HLOOKUP requires at least 3 arguments", - "=HLOOKUP(D2,D1,1,FALSE)": "HLOOKUP requires second argument of table array", - "=HLOOKUP(D2,D:D,FALSE,FALSE)": "HLOOKUP requires numeric row argument", - "=HLOOKUP(D2,D:D,1,FALSE,FALSE)": "HLOOKUP requires at most 4 arguments", - "=HLOOKUP(D2,D:D,1,2)": "HLOOKUP no result found", - "=HLOOKUP(D2,D10:D10,1,FALSE)": "HLOOKUP no result found", - "=HLOOKUP(D2,D2:D3,4,FALSE)": "HLOOKUP has invalid row index", - "=HLOOKUP(D2,C:C,1,FALSE)": "HLOOKUP no result found", - "=HLOOKUP(ISNUMBER(1),F3:F9,1)": "HLOOKUP no result found", - "=HLOOKUP(INT(1),E2:E9,1)": "HLOOKUP no result found", - "=HLOOKUP(MUNIT(2),MUNIT(3),1)": "HLOOKUP no result found", - "=HLOOKUP(A1:B2,B2:B3,1)": "HLOOKUP no result found", + "=HLOOKUP()": {"#VALUE!", "HLOOKUP requires at least 3 arguments"}, + "=HLOOKUP(D2,D1,1,FALSE)": {"#VALUE!", "HLOOKUP requires second argument of table array"}, + "=HLOOKUP(D2,D:D,FALSE,FALSE)": {"#VALUE!", "HLOOKUP requires numeric row argument"}, + "=HLOOKUP(D2,D:D,1,FALSE,FALSE)": {"#VALUE!", "HLOOKUP requires at most 4 arguments"}, + "=HLOOKUP(D2,D:D,1,2)": {"#N/A", "HLOOKUP no result found"}, + "=HLOOKUP(D2,D10:D10,1,FALSE)": {"#N/A", "HLOOKUP no result found"}, + "=HLOOKUP(D2,D2:D3,4,FALSE)": {"#N/A", "HLOOKUP has invalid row index"}, + "=HLOOKUP(D2,C:C,1,FALSE)": {"#N/A", "HLOOKUP no result found"}, + "=HLOOKUP(ISNUMBER(1),F3:F9,1)": {"#N/A", "HLOOKUP no result found"}, + "=HLOOKUP(INT(1),E2:E9,1)": {"#N/A", "HLOOKUP no result found"}, + "=HLOOKUP(MUNIT(2),MUNIT(3),1)": {"#N/A", "HLOOKUP no result found"}, + "=HLOOKUP(A1:B2,B2:B3,1)": {"#N/A", "HLOOKUP no result found"}, // MATCH - "=MATCH()": "MATCH requires 1 or 2 arguments", - "=MATCH(0,A1:A1,0,0)": "MATCH requires 1 or 2 arguments", - "=MATCH(0,A1:A1,\"x\")": "MATCH requires numeric match_type argument", - "=MATCH(0,A1)": "MATCH arguments lookup_array should be one-dimensional array", - "=MATCH(0,A1:B1)": "MATCH arguments lookup_array should be one-dimensional array", + "=MATCH()": {"#VALUE!", "MATCH requires 1 or 2 arguments"}, + "=MATCH(0,A1:A1,0,0)": {"#VALUE!", "MATCH requires 1 or 2 arguments"}, + "=MATCH(0,A1:A1,\"x\")": {"#VALUE!", "MATCH requires numeric match_type argument"}, + "=MATCH(0,A1)": {"#N/A", "MATCH arguments lookup_array should be one-dimensional array"}, + "=MATCH(0,A1:B1)": {"#N/A", "MATCH arguments lookup_array should be one-dimensional array"}, // TRANSPOSE - "=TRANSPOSE()": "TRANSPOSE requires 1 argument", + "=TRANSPOSE()": {"#VALUE!", "TRANSPOSE requires 1 argument"}, // HYPERLINK - "=HYPERLINK()": "HYPERLINK requires at least 1 argument", - "=HYPERLINK(\"https://github.com/xuri/excelize\",\"Excelize\",\"\")": "HYPERLINK allows at most 2 arguments", + "=HYPERLINK()": {"#VALUE!", "HYPERLINK requires at least 1 argument"}, + "=HYPERLINK(\"https://github.com/xuri/excelize\",\"Excelize\",\"\")": {"#VALUE!", "HYPERLINK allows at most 2 arguments"}, // VLOOKUP - "=VLOOKUP()": "VLOOKUP requires at least 3 arguments", - "=VLOOKUP(D2,D1,1,FALSE)": "VLOOKUP requires second argument of table array", - "=VLOOKUP(D2,D:D,FALSE,FALSE)": "VLOOKUP requires numeric col argument", - "=VLOOKUP(D2,D:D,1,FALSE,FALSE)": "VLOOKUP requires at most 4 arguments", - "=VLOOKUP(D2,D10:D10,1,FALSE)": "VLOOKUP no result found", - "=VLOOKUP(D2,D:D,2,FALSE)": "VLOOKUP has invalid column index", - "=VLOOKUP(D2,C:C,1,FALSE)": "VLOOKUP no result found", - "=VLOOKUP(ISNUMBER(1),F3:F9,1)": "VLOOKUP no result found", - "=VLOOKUP(INT(1),E2:E9,1)": "VLOOKUP no result found", - "=VLOOKUP(MUNIT(2),MUNIT(3),1)": "VLOOKUP no result found", - "=VLOOKUP(1,G1:H2,1,FALSE)": "VLOOKUP no result found", + "=VLOOKUP()": {"#VALUE!", "VLOOKUP requires at least 3 arguments"}, + "=VLOOKUP(D2,D1,1,FALSE)": {"#VALUE!", "VLOOKUP requires second argument of table array"}, + "=VLOOKUP(D2,D:D,FALSE,FALSE)": {"#VALUE!", "VLOOKUP requires numeric col argument"}, + "=VLOOKUP(D2,D:D,1,FALSE,FALSE)": {"#VALUE!", "VLOOKUP requires at most 4 arguments"}, + "=VLOOKUP(D2,D10:D10,1,FALSE)": {"#N/A", "VLOOKUP no result found"}, + "=VLOOKUP(D2,D:D,2,FALSE)": {"#N/A", "VLOOKUP has invalid column index"}, + "=VLOOKUP(D2,C:C,1,FALSE)": {"#N/A", "VLOOKUP no result found"}, + "=VLOOKUP(ISNUMBER(1),F3:F9,1)": {"#N/A", "VLOOKUP no result found"}, + "=VLOOKUP(INT(1),E2:E9,1)": {"#N/A", "VLOOKUP no result found"}, + "=VLOOKUP(MUNIT(2),MUNIT(3),1)": {"#N/A", "VLOOKUP no result found"}, + "=VLOOKUP(1,G1:H2,1,FALSE)": {"#N/A", "VLOOKUP no result found"}, // INDEX - "=INDEX()": "INDEX requires 2 or 3 arguments", - "=INDEX(A1,2)": "INDEX row_num out of range", - "=INDEX(A1,0,2)": "INDEX col_num out of range", - "=INDEX(A1:A1,2)": "INDEX row_num out of range", - "=INDEX(A1:A1,0,2)": "INDEX col_num out of range", - "=INDEX(A1:B2,2,3)": "INDEX col_num out of range", - "=INDEX(A1:A2,0,0)": "#VALUE!", - "=INDEX(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=INDEX(0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=INDEX()": {"#VALUE!", "INDEX requires 2 or 3 arguments"}, + "=INDEX(A1,2)": {"#REF!", "INDEX row_num out of range"}, + "=INDEX(A1,0,2)": {"#REF!", "INDEX col_num out of range"}, + "=INDEX(A1:A1,2)": {"#REF!", "INDEX row_num out of range"}, + "=INDEX(A1:A1,0,2)": {"#REF!", "INDEX col_num out of range"}, + "=INDEX(A1:B2,2,3)": {"#REF!", "INDEX col_num out of range"}, + "=INDEX(A1:A2,0,0)": {"#VALUE!", "#VALUE!"}, + "=INDEX(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=INDEX(0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // INDIRECT - "=INDIRECT()": "INDIRECT requires 1 or 2 arguments", - "=INDIRECT(\"E\"&1,TRUE,1)": "INDIRECT requires 1 or 2 arguments", - "=INDIRECT(\"R1048577C1\",\"\")": "#VALUE!", - "=INDIRECT(\"E1048577\")": "#REF!", - "=INDIRECT(\"R1048577C1\",FALSE)": "#REF!", - "=INDIRECT(\"R1C16385\",FALSE)": "#REF!", - "=INDIRECT(\"\",FALSE)": "#REF!", - "=INDIRECT(\"R C1\",FALSE)": "#REF!", - "=INDIRECT(\"R1C \",FALSE)": "#REF!", - "=INDIRECT(\"R1C1:R2C \",FALSE)": "#REF!", + "=INDIRECT()": {"#VALUE!", "INDIRECT requires 1 or 2 arguments"}, + "=INDIRECT(\"E\"&1,TRUE,1)": {"#VALUE!", "INDIRECT requires 1 or 2 arguments"}, + "=INDIRECT(\"R1048577C1\",\"\")": {"#VALUE!", "#VALUE!"}, + "=INDIRECT(\"E1048577\")": {"#REF!", "#REF!"}, + "=INDIRECT(\"R1048577C1\",FALSE)": {"#REF!", "#REF!"}, + "=INDIRECT(\"R1C16385\",FALSE)": {"#REF!", "#REF!"}, + "=INDIRECT(\"\",FALSE)": {"#REF!", "#REF!"}, + "=INDIRECT(\"R C1\",FALSE)": {"#REF!", "#REF!"}, + "=INDIRECT(\"R1C \",FALSE)": {"#REF!", "#REF!"}, + "=INDIRECT(\"R1C1:R2C \",FALSE)": {"#REF!", "#REF!"}, // LOOKUP - "=LOOKUP()": "LOOKUP requires at least 2 arguments", - "=LOOKUP(D2,D1,D2)": "LOOKUP requires second argument of table array", - "=LOOKUP(D2,D1,D2,FALSE)": "LOOKUP requires at most 3 arguments", - "=LOOKUP(1,MUNIT(0))": "LOOKUP requires not empty range as second argument", - "=LOOKUP(D1,MUNIT(1),MUNIT(1))": "LOOKUP no result found", + "=LOOKUP()": {"#VALUE!", "LOOKUP requires at least 2 arguments"}, + "=LOOKUP(D2,D1,D2)": {"#VALUE!", "LOOKUP requires second argument of table array"}, + "=LOOKUP(D2,D1,D2,FALSE)": {"#VALUE!", "LOOKUP requires at most 3 arguments"}, + "=LOOKUP(1,MUNIT(0))": {"#VALUE!", "LOOKUP requires not empty range as second argument"}, + "=LOOKUP(D1,MUNIT(1),MUNIT(1))": {"#N/A", "LOOKUP no result found"}, // ROW - "=ROW(1,2)": "ROW requires at most 1 argument", - "=ROW(\"\")": "invalid reference", - "=ROW(Sheet1)": newInvalidColumnNameError("Sheet1").Error(), - "=ROW(Sheet1!A1!B1)": newInvalidColumnNameError("Sheet1").Error(), + "=ROW(1,2)": {"#VALUE!", "ROW requires at most 1 argument"}, + "=ROW(\"\")": {"#VALUE!", "invalid reference"}, + "=ROW(Sheet1)": {"", newInvalidColumnNameError("Sheet1").Error()}, + "=ROW(Sheet1!A1!B1)": {"", newInvalidColumnNameError("Sheet1").Error()}, // ROWS - "=ROWS()": "ROWS requires 1 argument", - "=ROWS(1)": "invalid reference", - "=ROWS(\"\")": "invalid reference", - "=ROWS(Sheet1)": newInvalidColumnNameError("Sheet1").Error(), - "=ROWS(Sheet1!A1!B1)": newInvalidColumnNameError("Sheet1").Error(), - "=ROWS(Sheet1!Sheet1)": newInvalidColumnNameError("Sheet1").Error(), + "=ROWS()": {"#VALUE!", "ROWS requires 1 argument"}, + "=ROWS(1)": {"#VALUE!", "invalid reference"}, + "=ROWS(\"\")": {"#VALUE!", "invalid reference"}, + "=ROWS(Sheet1)": {"", newInvalidColumnNameError("Sheet1").Error()}, + "=ROWS(Sheet1!A1!B1)": {"", newInvalidColumnNameError("Sheet1").Error()}, + "=ROWS(Sheet1!Sheet1)": {"", newInvalidColumnNameError("Sheet1").Error()}, // Web Functions // ENCODEURL - "=ENCODEURL()": "ENCODEURL requires 1 argument", + "=ENCODEURL()": {"#VALUE!", "ENCODEURL requires 1 argument"}, // Financial Functions // ACCRINT - "=ACCRINT()": "ACCRINT requires at least 6 arguments", - "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,10000,4,1,FALSE,0)": "ACCRINT allows at most 8 arguments", - "=ACCRINT(\"\",\"04/01/2012\",\"12/31/2013\",8%,10000,4,1,FALSE)": "#VALUE!", - "=ACCRINT(\"01/01/2012\",\"\",\"12/31/2013\",8%,10000,4,1,FALSE)": "#VALUE!", - "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"\",8%,10000,4,1,FALSE)": "#VALUE!", - "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",\"\",10000,4,1,FALSE)": "#NUM!", - "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,\"\",4,1,FALSE)": "#NUM!", - "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,10000,3)": "#NUM!", - "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,10000,\"\",1,FALSE)": "#NUM!", - "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,10000,4,\"\",FALSE)": "#NUM!", - "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,10000,4,1,\"\")": "#VALUE!", - "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,10000,4,5,FALSE)": "invalid basis", + "=ACCRINT()": {"#VALUE!", "ACCRINT requires at least 6 arguments"}, + "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,10000,4,1,FALSE,0)": {"#VALUE!", "ACCRINT allows at most 8 arguments"}, + "=ACCRINT(\"\",\"04/01/2012\",\"12/31/2013\",8%,10000,4,1,FALSE)": {"#VALUE!", "#VALUE!"}, + "=ACCRINT(\"01/01/2012\",\"\",\"12/31/2013\",8%,10000,4,1,FALSE)": {"#VALUE!", "#VALUE!"}, + "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"\",8%,10000,4,1,FALSE)": {"#VALUE!", "#VALUE!"}, + "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",\"\",10000,4,1,FALSE)": {"#NUM!", "#NUM!"}, + "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,\"\",4,1,FALSE)": {"#NUM!", "#NUM!"}, + "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,10000,3)": {"#NUM!", "#NUM!"}, + "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,10000,\"\",1,FALSE)": {"#NUM!", "#NUM!"}, + "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,10000,4,\"\",FALSE)": {"#NUM!", "#NUM!"}, + "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,10000,4,1,\"\")": {"#VALUE!", "#VALUE!"}, + "=ACCRINT(\"01/01/2012\",\"04/01/2012\",\"12/31/2013\",8%,10000,4,5,FALSE)": {"#NUM!", "invalid basis"}, // ACCRINTM - "=ACCRINTM()": "ACCRINTM requires 4 or 5 arguments", - "=ACCRINTM(\"\",\"01/01/2012\",8%,10000)": "#VALUE!", - "=ACCRINTM(\"01/01/2012\",\"\",8%,10000)": "#VALUE!", - "=ACCRINTM(\"12/31/2012\",\"01/01/2012\",8%,10000)": "#NUM!", - "=ACCRINTM(\"01/01/2012\",\"12/31/2012\",\"\",10000)": "#NUM!", - "=ACCRINTM(\"01/01/2012\",\"12/31/2012\",8%,\"\",10000)": "#NUM!", - "=ACCRINTM(\"01/01/2012\",\"12/31/2012\",8%,-1,10000)": "#NUM!", - "=ACCRINTM(\"01/01/2012\",\"12/31/2012\",8%,10000,\"\")": "#NUM!", - "=ACCRINTM(\"01/01/2012\",\"12/31/2012\",8%,10000,5)": "invalid basis", + "=ACCRINTM()": {"#VALUE!", "ACCRINTM requires 4 or 5 arguments"}, + "=ACCRINTM(\"\",\"01/01/2012\",8%,10000)": {"#VALUE!", "#VALUE!"}, + "=ACCRINTM(\"01/01/2012\",\"\",8%,10000)": {"#VALUE!", "#VALUE!"}, + "=ACCRINTM(\"12/31/2012\",\"01/01/2012\",8%,10000)": {"#NUM!", "#NUM!"}, + "=ACCRINTM(\"01/01/2012\",\"12/31/2012\",\"\",10000)": {"#NUM!", "#NUM!"}, + "=ACCRINTM(\"01/01/2012\",\"12/31/2012\",8%,\"\",10000)": {"#NUM!", "#NUM!"}, + "=ACCRINTM(\"01/01/2012\",\"12/31/2012\",8%,-1,10000)": {"#NUM!", "#NUM!"}, + "=ACCRINTM(\"01/01/2012\",\"12/31/2012\",8%,10000,\"\")": {"#NUM!", "#NUM!"}, + "=ACCRINTM(\"01/01/2012\",\"12/31/2012\",8%,10000,5)": {"#NUM!", "invalid basis"}, // AMORDEGRC - "=AMORDEGRC()": "AMORDEGRC requires 6 or 7 arguments", - "=AMORDEGRC(\"\",\"01/01/2015\",\"09/30/2015\",20,1,20%)": "AMORDEGRC requires cost to be number argument", - "=AMORDEGRC(-1,\"01/01/2015\",\"09/30/2015\",20,1,20%)": "AMORDEGRC requires cost >= 0", - "=AMORDEGRC(150,\"\",\"09/30/2015\",20,1,20%)": "#VALUE!", - "=AMORDEGRC(150,\"01/01/2015\",\"\",20,1,20%)": "#VALUE!", - "=AMORDEGRC(150,\"09/30/2015\",\"01/01/2015\",20,1,20%)": "#NUM!", - "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",\"\",1,20%)": "#NUM!", - "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",-1,1,20%)": "#NUM!", - "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,\"\",20%)": "#NUM!", - "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,-1,20%)": "#NUM!", - "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,1,\"\")": "#NUM!", - "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,1,-1)": "#NUM!", - "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,1,20%,\"\")": "#NUM!", - "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,1,50%)": "AMORDEGRC requires rate to be < 0.5", - "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,1,20%,5)": "invalid basis", + "=AMORDEGRC()": {"#VALUE!", "AMORDEGRC requires 6 or 7 arguments"}, + "=AMORDEGRC(\"\",\"01/01/2015\",\"09/30/2015\",20,1,20%)": {"#VALUE!", "AMORDEGRC requires cost to be number argument"}, + "=AMORDEGRC(-1,\"01/01/2015\",\"09/30/2015\",20,1,20%)": {"#VALUE!", "AMORDEGRC requires cost >= 0"}, + "=AMORDEGRC(150,\"\",\"09/30/2015\",20,1,20%)": {"#VALUE!", "#VALUE!"}, + "=AMORDEGRC(150,\"01/01/2015\",\"\",20,1,20%)": {"#VALUE!", "#VALUE!"}, + "=AMORDEGRC(150,\"09/30/2015\",\"01/01/2015\",20,1,20%)": {"#NUM!", "#NUM!"}, + "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",\"\",1,20%)": {"#NUM!", "#NUM!"}, + "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",-1,1,20%)": {"#NUM!", "#NUM!"}, + "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,\"\",20%)": {"#NUM!", "#NUM!"}, + "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,-1,20%)": {"#NUM!", "#NUM!"}, + "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,1,\"\")": {"#NUM!", "#NUM!"}, + "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,1,-1)": {"#NUM!", "#NUM!"}, + "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,1,20%,\"\")": {"#NUM!", "#NUM!"}, + "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,1,50%)": {"#NUM!", "AMORDEGRC requires rate to be < 0.5"}, + "=AMORDEGRC(150,\"01/01/2015\",\"09/30/2015\",20,1,20%,5)": {"#NUM!", "invalid basis"}, // AMORLINC - "=AMORLINC()": "AMORLINC requires 6 or 7 arguments", - "=AMORLINC(\"\",\"01/01/2015\",\"09/30/2015\",20,1,20%)": "AMORLINC requires cost to be number argument", - "=AMORLINC(-1,\"01/01/2015\",\"09/30/2015\",20,1,20%)": "AMORLINC requires cost >= 0", - "=AMORLINC(150,\"\",\"09/30/2015\",20,1,20%)": "#VALUE!", - "=AMORLINC(150,\"01/01/2015\",\"\",20,1,20%)": "#VALUE!", - "=AMORLINC(150,\"09/30/2015\",\"01/01/2015\",20,1,20%)": "#NUM!", - "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",\"\",1,20%)": "#NUM!", - "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",-1,1,20%)": "#NUM!", - "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",20,\"\",20%)": "#NUM!", - "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",20,-1,20%)": "#NUM!", - "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",20,1,\"\")": "#NUM!", - "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",20,1,-1)": "#NUM!", - "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",20,1,20%,\"\")": "#NUM!", - "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",20,1,20%,5)": "invalid basis", + "=AMORLINC()": {"#VALUE!", "AMORLINC requires 6 or 7 arguments"}, + "=AMORLINC(\"\",\"01/01/2015\",\"09/30/2015\",20,1,20%)": {"#VALUE!", "AMORLINC requires cost to be number argument"}, + "=AMORLINC(-1,\"01/01/2015\",\"09/30/2015\",20,1,20%)": {"#VALUE!", "AMORLINC requires cost >= 0"}, + "=AMORLINC(150,\"\",\"09/30/2015\",20,1,20%)": {"#VALUE!", "#VALUE!"}, + "=AMORLINC(150,\"01/01/2015\",\"\",20,1,20%)": {"#VALUE!", "#VALUE!"}, + "=AMORLINC(150,\"09/30/2015\",\"01/01/2015\",20,1,20%)": {"#NUM!", "#NUM!"}, + "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",\"\",1,20%)": {"#NUM!", "#NUM!"}, + "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",-1,1,20%)": {"#NUM!", "#NUM!"}, + "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",20,\"\",20%)": {"#NUM!", "#NUM!"}, + "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",20,-1,20%)": {"#NUM!", "#NUM!"}, + "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",20,1,\"\")": {"#NUM!", "#NUM!"}, + "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",20,1,-1)": {"#NUM!", "#NUM!"}, + "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",20,1,20%,\"\")": {"#NUM!", "#NUM!"}, + "=AMORLINC(150,\"01/01/2015\",\"09/30/2015\",20,1,20%,5)": {"#NUM!", "invalid basis"}, // COUPDAYBS - "=COUPDAYBS()": "COUPDAYBS requires 3 or 4 arguments", - "=COUPDAYBS(\"\",\"10/25/2012\",4)": "#VALUE!", - "=COUPDAYBS(\"01/01/2011\",\"\",4)": "#VALUE!", - "=COUPDAYBS(\"01/01/2011\",\"10/25/2012\",\"\")": "#VALUE!", - "=COUPDAYBS(\"01/01/2011\",\"10/25/2012\",4,\"\")": "#NUM!", - "=COUPDAYBS(\"10/25/2012\",\"01/01/2011\",4)": "COUPDAYBS requires maturity > settlement", + "=COUPDAYBS()": {"#VALUE!", "COUPDAYBS requires 3 or 4 arguments"}, + "=COUPDAYBS(\"\",\"10/25/2012\",4)": {"#VALUE!", "#VALUE!"}, + "=COUPDAYBS(\"01/01/2011\",\"\",4)": {"#VALUE!", "#VALUE!"}, + "=COUPDAYBS(\"01/01/2011\",\"10/25/2012\",\"\")": {"#VALUE!", "#VALUE!"}, + "=COUPDAYBS(\"01/01/2011\",\"10/25/2012\",4,\"\")": {"#NUM!", "#NUM!"}, + "=COUPDAYBS(\"10/25/2012\",\"01/01/2011\",4)": {"#NUM!", "COUPDAYBS requires maturity > settlement"}, // COUPDAYS - "=COUPDAYS()": "COUPDAYS requires 3 or 4 arguments", - "=COUPDAYS(\"\",\"10/25/2012\",4)": "#VALUE!", - "=COUPDAYS(\"01/01/2011\",\"\",4)": "#VALUE!", - "=COUPDAYS(\"01/01/2011\",\"10/25/2012\",\"\")": "#VALUE!", - "=COUPDAYS(\"01/01/2011\",\"10/25/2012\",4,\"\")": "#NUM!", - "=COUPDAYS(\"10/25/2012\",\"01/01/2011\",4)": "COUPDAYS requires maturity > settlement", + "=COUPDAYS()": {"#VALUE!", "COUPDAYS requires 3 or 4 arguments"}, + "=COUPDAYS(\"\",\"10/25/2012\",4)": {"#VALUE!", "#VALUE!"}, + "=COUPDAYS(\"01/01/2011\",\"\",4)": {"#VALUE!", "#VALUE!"}, + "=COUPDAYS(\"01/01/2011\",\"10/25/2012\",\"\")": {"#VALUE!", "#VALUE!"}, + "=COUPDAYS(\"01/01/2011\",\"10/25/2012\",4,\"\")": {"#NUM!", "#NUM!"}, + "=COUPDAYS(\"10/25/2012\",\"01/01/2011\",4)": {"#NUM!", "COUPDAYS requires maturity > settlement"}, // COUPDAYSNC - "=COUPDAYSNC()": "COUPDAYSNC requires 3 or 4 arguments", - "=COUPDAYSNC(\"\",\"10/25/2012\",4)": "#VALUE!", - "=COUPDAYSNC(\"01/01/2011\",\"\",4)": "#VALUE!", - "=COUPDAYSNC(\"01/01/2011\",\"10/25/2012\",\"\")": "#VALUE!", - "=COUPDAYSNC(\"01/01/2011\",\"10/25/2012\",4,\"\")": "#NUM!", - "=COUPDAYSNC(\"10/25/2012\",\"01/01/2011\",4)": "COUPDAYSNC requires maturity > settlement", + "=COUPDAYSNC()": {"#VALUE!", "COUPDAYSNC requires 3 or 4 arguments"}, + "=COUPDAYSNC(\"\",\"10/25/2012\",4)": {"#VALUE!", "#VALUE!"}, + "=COUPDAYSNC(\"01/01/2011\",\"\",4)": {"#VALUE!", "#VALUE!"}, + "=COUPDAYSNC(\"01/01/2011\",\"10/25/2012\",\"\")": {"#VALUE!", "#VALUE!"}, + "=COUPDAYSNC(\"01/01/2011\",\"10/25/2012\",4,\"\")": {"#NUM!", "#NUM!"}, + "=COUPDAYSNC(\"10/25/2012\",\"01/01/2011\",4)": {"#NUM!", "COUPDAYSNC requires maturity > settlement"}, // COUPNCD - "=COUPNCD()": "COUPNCD requires 3 or 4 arguments", - "=COUPNCD(\"01/01/2011\",\"10/25/2012\",4,0,0)": "COUPNCD requires 3 or 4 arguments", - "=COUPNCD(\"\",\"10/25/2012\",4)": "#VALUE!", - "=COUPNCD(\"01/01/2011\",\"\",4)": "#VALUE!", - "=COUPNCD(\"01/01/2011\",\"10/25/2012\",\"\")": "#VALUE!", - "=COUPNCD(\"01/01/2011\",\"10/25/2012\",4,\"\")": "#NUM!", - "=COUPNCD(\"01/01/2011\",\"10/25/2012\",3)": "#NUM!", - "=COUPNCD(\"10/25/2012\",\"01/01/2011\",4)": "COUPNCD requires maturity > settlement", + "=COUPNCD()": {"#VALUE!", "COUPNCD requires 3 or 4 arguments"}, + "=COUPNCD(\"01/01/2011\",\"10/25/2012\",4,0,0)": {"#VALUE!", "COUPNCD requires 3 or 4 arguments"}, + "=COUPNCD(\"\",\"10/25/2012\",4)": {"#VALUE!", "#VALUE!"}, + "=COUPNCD(\"01/01/2011\",\"\",4)": {"#VALUE!", "#VALUE!"}, + "=COUPNCD(\"01/01/2011\",\"10/25/2012\",\"\")": {"#VALUE!", "#VALUE!"}, + "=COUPNCD(\"01/01/2011\",\"10/25/2012\",4,\"\")": {"#NUM!", "#NUM!"}, + "=COUPNCD(\"01/01/2011\",\"10/25/2012\",3)": {"#NUM!", "#NUM!"}, + "=COUPNCD(\"10/25/2012\",\"01/01/2011\",4)": {"#NUM!", "COUPNCD requires maturity > settlement"}, // COUPNUM - "=COUPNUM()": "COUPNUM requires 3 or 4 arguments", - "=COUPNUM(\"01/01/2011\",\"10/25/2012\",4,0,0)": "COUPNUM requires 3 or 4 arguments", - "=COUPNUM(\"\",\"10/25/2012\",4)": "#VALUE!", - "=COUPNUM(\"01/01/2011\",\"\",4)": "#VALUE!", - "=COUPNUM(\"01/01/2011\",\"10/25/2012\",\"\")": "#VALUE!", - "=COUPNUM(\"01/01/2011\",\"10/25/2012\",4,\"\")": "#NUM!", - "=COUPNUM(\"01/01/2011\",\"10/25/2012\",3)": "#NUM!", - "=COUPNUM(\"10/25/2012\",\"01/01/2011\",4)": "COUPNUM requires maturity > settlement", + "=COUPNUM()": {"#VALUE!", "COUPNUM requires 3 or 4 arguments"}, + "=COUPNUM(\"01/01/2011\",\"10/25/2012\",4,0,0)": {"#VALUE!", "COUPNUM requires 3 or 4 arguments"}, + "=COUPNUM(\"\",\"10/25/2012\",4)": {"#VALUE!", "#VALUE!"}, + "=COUPNUM(\"01/01/2011\",\"\",4)": {"#VALUE!", "#VALUE!"}, + "=COUPNUM(\"01/01/2011\",\"10/25/2012\",\"\")": {"#VALUE!", "#VALUE!"}, + "=COUPNUM(\"01/01/2011\",\"10/25/2012\",4,\"\")": {"#NUM!", "#NUM!"}, + "=COUPNUM(\"01/01/2011\",\"10/25/2012\",3)": {"#NUM!", "#NUM!"}, + "=COUPNUM(\"10/25/2012\",\"01/01/2011\",4)": {"#NUM!", "COUPNUM requires maturity > settlement"}, // COUPPCD - "=COUPPCD()": "COUPPCD requires 3 or 4 arguments", - "=COUPPCD(\"01/01/2011\",\"10/25/2012\",4,0,0)": "COUPPCD requires 3 or 4 arguments", - "=COUPPCD(\"\",\"10/25/2012\",4)": "#VALUE!", - "=COUPPCD(\"01/01/2011\",\"\",4)": "#VALUE!", - "=COUPPCD(\"01/01/2011\",\"10/25/2012\",\"\")": "#VALUE!", - "=COUPPCD(\"01/01/2011\",\"10/25/2012\",4,\"\")": "#NUM!", - "=COUPPCD(\"01/01/2011\",\"10/25/2012\",3)": "#NUM!", - "=COUPPCD(\"10/25/2012\",\"01/01/2011\",4)": "COUPPCD requires maturity > settlement", + "=COUPPCD()": {"#VALUE!", "COUPPCD requires 3 or 4 arguments"}, + "=COUPPCD(\"01/01/2011\",\"10/25/2012\",4,0,0)": {"#VALUE!", "COUPPCD requires 3 or 4 arguments"}, + "=COUPPCD(\"\",\"10/25/2012\",4)": {"#VALUE!", "#VALUE!"}, + "=COUPPCD(\"01/01/2011\",\"\",4)": {"#VALUE!", "#VALUE!"}, + "=COUPPCD(\"01/01/2011\",\"10/25/2012\",\"\")": {"#VALUE!", "#VALUE!"}, + "=COUPPCD(\"01/01/2011\",\"10/25/2012\",4,\"\")": {"#NUM!", "#NUM!"}, + "=COUPPCD(\"01/01/2011\",\"10/25/2012\",3)": {"#NUM!", "#NUM!"}, + "=COUPPCD(\"10/25/2012\",\"01/01/2011\",4)": {"#NUM!", "COUPPCD requires maturity > settlement"}, // CUMIPMT - "=CUMIPMT()": "CUMIPMT requires 6 arguments", - "=CUMIPMT(0,0,0,0,0,2)": "#N/A", - "=CUMIPMT(0,0,0,-1,0,0)": "#N/A", - "=CUMIPMT(0,0,0,1,0,0)": "#N/A", - "=CUMIPMT(\"\",0,0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CUMIPMT(0,\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CUMIPMT(0,0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CUMIPMT(0,0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CUMIPMT(0,0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CUMIPMT(0,0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=CUMIPMT()": {"#VALUE!", "CUMIPMT requires 6 arguments"}, + "=CUMIPMT(0,0,0,0,0,2)": {"#N/A", "#N/A"}, + "=CUMIPMT(0,0,0,-1,0,0)": {"#N/A", "#N/A"}, + "=CUMIPMT(0,0,0,1,0,0)": {"#N/A", "#N/A"}, + "=CUMIPMT(\"\",0,0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CUMIPMT(0,\"\",0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CUMIPMT(0,0,\"\",0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CUMIPMT(0,0,0,\"\",0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CUMIPMT(0,0,0,0,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CUMIPMT(0,0,0,0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // CUMPRINC - "=CUMPRINC()": "CUMPRINC requires 6 arguments", - "=CUMPRINC(0,0,0,0,0,2)": "#N/A", - "=CUMPRINC(0,0,0,-1,0,0)": "#N/A", - "=CUMPRINC(0,0,0,1,0,0)": "#N/A", - "=CUMPRINC(\"\",0,0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CUMPRINC(0,\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CUMPRINC(0,0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CUMPRINC(0,0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CUMPRINC(0,0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=CUMPRINC(0,0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=CUMPRINC()": {"#VALUE!", "CUMPRINC requires 6 arguments"}, + "=CUMPRINC(0,0,0,0,0,2)": {"#N/A", "#N/A"}, + "=CUMPRINC(0,0,0,-1,0,0)": {"#N/A", "#N/A"}, + "=CUMPRINC(0,0,0,1,0,0)": {"#N/A", "#N/A"}, + "=CUMPRINC(\"\",0,0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CUMPRINC(0,\"\",0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CUMPRINC(0,0,\"\",0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CUMPRINC(0,0,0,\"\",0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CUMPRINC(0,0,0,0,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=CUMPRINC(0,0,0,0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // DB - "=DB()": "DB requires at least 4 arguments", - "=DB(0,0,0,0,0,0)": "DB allows at most 5 arguments", - "=DB(-1,0,0,0)": "#N/A", - "=DB(\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DB(0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DB(0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DB(0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DB(0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=DB()": {"#VALUE!", "DB requires at least 4 arguments"}, + "=DB(0,0,0,0,0,0)": {"#VALUE!", "DB allows at most 5 arguments"}, + "=DB(-1,0,0,0)": {"#N/A", "#N/A"}, + "=DB(\"\",0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DB(0,\"\",0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DB(0,0,\"\",0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DB(0,0,0,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DB(0,0,0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // DDB - "=DDB()": "DDB requires at least 4 arguments", - "=DDB(0,0,0,0,0,0)": "DDB allows at most 5 arguments", - "=DDB(-1,0,0,0)": "#N/A", - "=DDB(\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DDB(0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DDB(0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DDB(0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DDB(0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=DDB()": {"#VALUE!", "DDB requires at least 4 arguments"}, + "=DDB(0,0,0,0,0,0)": {"#VALUE!", "DDB allows at most 5 arguments"}, + "=DDB(-1,0,0,0)": {"#N/A", "#N/A"}, + "=DDB(\"\",0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DDB(0,\"\",0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DDB(0,0,\"\",0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DDB(0,0,0,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DDB(0,0,0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // DISC - "=DISC()": "DISC requires 4 or 5 arguments", - "=DISC(\"\",\"03/31/2021\",95,100)": "#VALUE!", - "=DISC(\"04/01/2016\",\"\",95,100)": "#VALUE!", - "=DISC(\"04/01/2016\",\"03/31/2021\",\"\",100)": "#VALUE!", - "=DISC(\"04/01/2016\",\"03/31/2021\",95,\"\")": "#VALUE!", - "=DISC(\"04/01/2016\",\"03/31/2021\",95,100,\"\")": "#NUM!", - "=DISC(\"03/31/2021\",\"04/01/2016\",95,100)": "DISC requires maturity > settlement", - "=DISC(\"04/01/2016\",\"03/31/2021\",0,100)": "DISC requires pr > 0", - "=DISC(\"04/01/2016\",\"03/31/2021\",95,0)": "DISC requires redemption > 0", - "=DISC(\"04/01/2016\",\"03/31/2021\",95,100,5)": "invalid basis", + "=DISC()": {"#VALUE!", "DISC requires 4 or 5 arguments"}, + "=DISC(\"\",\"03/31/2021\",95,100)": {"#VALUE!", "#VALUE!"}, + "=DISC(\"04/01/2016\",\"\",95,100)": {"#VALUE!", "#VALUE!"}, + "=DISC(\"04/01/2016\",\"03/31/2021\",\"\",100)": {"#VALUE!", "#VALUE!"}, + "=DISC(\"04/01/2016\",\"03/31/2021\",95,\"\")": {"#VALUE!", "#VALUE!"}, + "=DISC(\"04/01/2016\",\"03/31/2021\",95,100,\"\")": {"#NUM!", "#NUM!"}, + "=DISC(\"03/31/2021\",\"04/01/2016\",95,100)": {"#NUM!", "DISC requires maturity > settlement"}, + "=DISC(\"04/01/2016\",\"03/31/2021\",0,100)": {"#NUM!", "DISC requires pr > 0"}, + "=DISC(\"04/01/2016\",\"03/31/2021\",95,0)": {"#NUM!", "DISC requires redemption > 0"}, + "=DISC(\"04/01/2016\",\"03/31/2021\",95,100,5)": {"#NUM!", "invalid basis"}, // DOLLARDE - "=DOLLARDE()": "DOLLARDE requires 2 arguments", - "=DOLLARDE(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DOLLARDE(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DOLLARDE(0,-1)": "#NUM!", - "=DOLLARDE(0,0)": "#DIV/0!", + "=DOLLARDE()": {"#VALUE!", "DOLLARDE requires 2 arguments"}, + "=DOLLARDE(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DOLLARDE(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DOLLARDE(0,-1)": {"#NUM!", "#NUM!"}, + "=DOLLARDE(0,0)": {"#DIV/0!", "#DIV/0!"}, // DOLLARFR - "=DOLLARFR()": "DOLLARFR requires 2 arguments", - "=DOLLARFR(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DOLLARFR(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DOLLARFR(0,-1)": "#NUM!", - "=DOLLARFR(0,0)": "#DIV/0!", + "=DOLLARFR()": {"#VALUE!", "DOLLARFR requires 2 arguments"}, + "=DOLLARFR(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DOLLARFR(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DOLLARFR(0,-1)": {"#NUM!", "#NUM!"}, + "=DOLLARFR(0,0)": {"#DIV/0!", "#DIV/0!"}, // DURATION - "=DURATION()": "DURATION requires 5 or 6 arguments", - "=DURATION(\"\",\"03/31/2025\",10%,8%,4)": "#VALUE!", - "=DURATION(\"04/01/2015\",\"\",10%,8%,4)": "#VALUE!", - "=DURATION(\"03/31/2025\",\"04/01/2015\",10%,8%,4)": "DURATION requires maturity > settlement", - "=DURATION(\"04/01/2015\",\"03/31/2025\",-1,8%,4)": "DURATION requires coupon >= 0", - "=DURATION(\"04/01/2015\",\"03/31/2025\",10%,-1,4)": "DURATION requires yld >= 0", - "=DURATION(\"04/01/2015\",\"03/31/2025\",\"\",8%,4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DURATION(\"04/01/2015\",\"03/31/2025\",10%,\"\",4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=DURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,3)": "#NUM!", - "=DURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,4,\"\")": "#NUM!", - "=DURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,4,5)": "invalid basis", + "=DURATION()": {"#VALUE!", "DURATION requires 5 or 6 arguments"}, + "=DURATION(\"\",\"03/31/2025\",10%,8%,4)": {"#VALUE!", "#VALUE!"}, + "=DURATION(\"04/01/2015\",\"\",10%,8%,4)": {"#VALUE!", "#VALUE!"}, + "=DURATION(\"03/31/2025\",\"04/01/2015\",10%,8%,4)": {"#NUM!", "DURATION requires maturity > settlement"}, + "=DURATION(\"04/01/2015\",\"03/31/2025\",-1,8%,4)": {"#NUM!", "DURATION requires coupon >= 0"}, + "=DURATION(\"04/01/2015\",\"03/31/2025\",10%,-1,4)": {"#NUM!", "DURATION requires yld >= 0"}, + "=DURATION(\"04/01/2015\",\"03/31/2025\",\"\",8%,4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DURATION(\"04/01/2015\",\"03/31/2025\",10%,\"\",4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=DURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,3)": {"#NUM!", "#NUM!"}, + "=DURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,4,\"\")": {"#NUM!", "#NUM!"}, + "=DURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,4,5)": {"#NUM!", "invalid basis"}, // EFFECT - "=EFFECT()": "EFFECT requires 2 arguments", - "=EFFECT(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=EFFECT(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=EFFECT(0,0)": "#NUM!", - "=EFFECT(1,0)": "#NUM!", + "=EFFECT()": {"#VALUE!", "EFFECT requires 2 arguments"}, + "=EFFECT(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=EFFECT(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=EFFECT(0,0)": {"#NUM!", "#NUM!"}, + "=EFFECT(1,0)": {"#NUM!", "#NUM!"}, // EUROCONVERT - "=EUROCONVERT()": "EUROCONVERT requires at least 3 arguments", - "=EUROCONVERT(1.47,\"FRF\",\"DEM\",TRUE,3,1)": "EUROCONVERT allows at most 5 arguments", - "=EUROCONVERT(\"\",\"FRF\",\"DEM\",TRUE,3)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=EUROCONVERT(1.47,\"FRF\",\"DEM\",\"\",3)": "strconv.ParseBool: parsing \"\": invalid syntax", - "=EUROCONVERT(1.47,\"FRF\",\"DEM\",TRUE,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=EUROCONVERT(1.47,\"\",\"DEM\")": "#VALUE!", - "=EUROCONVERT(1.47,\"FRF\",\"\",TRUE,3)": "#VALUE!", + "=EUROCONVERT()": {"#VALUE!", "EUROCONVERT requires at least 3 arguments"}, + "=EUROCONVERT(1.47,\"FRF\",\"DEM\",TRUE,3,1)": {"#VALUE!", "EUROCONVERT allows at most 5 arguments"}, + "=EUROCONVERT(\"\",\"FRF\",\"DEM\",TRUE,3)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=EUROCONVERT(1.47,\"FRF\",\"DEM\",\"\",3)": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=EUROCONVERT(1.47,\"FRF\",\"DEM\",TRUE,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=EUROCONVERT(1.47,\"\",\"DEM\")": {"#VALUE!", "#VALUE!"}, + "=EUROCONVERT(1.47,\"FRF\",\"\",TRUE,3)": {"#VALUE!", "#VALUE!"}, // FV - "=FV()": "FV requires at least 3 arguments", - "=FV(0,0,0,0,0,0,0)": "FV allows at most 5 arguments", - "=FV(0,0,0,0,2)": "#N/A", - "=FV(\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FV(0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FV(0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FV(0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FV(0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=FV()": {"#VALUE!", "FV requires at least 3 arguments"}, + "=FV(0,0,0,0,0,0,0)": {"#VALUE!", "FV allows at most 5 arguments"}, + "=FV(0,0,0,0,2)": {"#N/A", "#N/A"}, + "=FV(\"\",0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FV(0,\"\",0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FV(0,0,\"\",0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FV(0,0,0,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FV(0,0,0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // FVSCHEDULE - "=FVSCHEDULE()": "FVSCHEDULE requires 2 arguments", - "=FVSCHEDULE(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=FVSCHEDULE(0,\"x\")": "strconv.ParseFloat: parsing \"x\": invalid syntax", + "=FVSCHEDULE()": {"#VALUE!", "FVSCHEDULE requires 2 arguments"}, + "=FVSCHEDULE(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=FVSCHEDULE(0,\"x\")": {"#VALUE!", "strconv.ParseFloat: parsing \"x\": invalid syntax"}, // INTRATE - "=INTRATE()": "INTRATE requires 4 or 5 arguments", - "=INTRATE(\"\",\"03/31/2021\",95,100)": "#VALUE!", - "=INTRATE(\"04/01/2016\",\"\",95,100)": "#VALUE!", - "=INTRATE(\"04/01/2016\",\"03/31/2021\",\"\",100)": "#VALUE!", - "=INTRATE(\"04/01/2016\",\"03/31/2021\",95,\"\")": "#VALUE!", - "=INTRATE(\"04/01/2016\",\"03/31/2021\",95,100,\"\")": "#NUM!", - "=INTRATE(\"03/31/2021\",\"04/01/2016\",95,100)": "INTRATE requires maturity > settlement", - "=INTRATE(\"04/01/2016\",\"03/31/2021\",0,100)": "INTRATE requires investment > 0", - "=INTRATE(\"04/01/2016\",\"03/31/2021\",95,0)": "INTRATE requires redemption > 0", - "=INTRATE(\"04/01/2016\",\"03/31/2021\",95,100,5)": "invalid basis", + "=INTRATE()": {"#VALUE!", "INTRATE requires 4 or 5 arguments"}, + "=INTRATE(\"\",\"03/31/2021\",95,100)": {"#VALUE!", "#VALUE!"}, + "=INTRATE(\"04/01/2016\",\"\",95,100)": {"#VALUE!", "#VALUE!"}, + "=INTRATE(\"04/01/2016\",\"03/31/2021\",\"\",100)": {"#VALUE!", "#VALUE!"}, + "=INTRATE(\"04/01/2016\",\"03/31/2021\",95,\"\")": {"#VALUE!", "#VALUE!"}, + "=INTRATE(\"04/01/2016\",\"03/31/2021\",95,100,\"\")": {"#NUM!", "#NUM!"}, + "=INTRATE(\"03/31/2021\",\"04/01/2016\",95,100)": {"#NUM!", "INTRATE requires maturity > settlement"}, + "=INTRATE(\"04/01/2016\",\"03/31/2021\",0,100)": {"#NUM!", "INTRATE requires investment > 0"}, + "=INTRATE(\"04/01/2016\",\"03/31/2021\",95,0)": {"#NUM!", "INTRATE requires redemption > 0"}, + "=INTRATE(\"04/01/2016\",\"03/31/2021\",95,100,5)": {"#NUM!", "invalid basis"}, // IPMT - "=IPMT()": "IPMT requires at least 4 arguments", - "=IPMT(0,0,0,0,0,0,0)": "IPMT allows at most 6 arguments", - "=IPMT(0,0,0,0,0,2)": "#N/A", - "=IPMT(0,-1,0,0,0,0)": "#N/A", - "=IPMT(0,1,0,0,0,0)": "#N/A", - "=IPMT(\"\",0,0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=IPMT(0,\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=IPMT(0,0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=IPMT(0,0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=IPMT(0,0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=IPMT(0,0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=IPMT()": {"#VALUE!", "IPMT requires at least 4 arguments"}, + "=IPMT(0,0,0,0,0,0,0)": {"#VALUE!", "IPMT allows at most 6 arguments"}, + "=IPMT(0,0,0,0,0,2)": {"#N/A", "#N/A"}, + "=IPMT(0,-1,0,0,0,0)": {"#N/A", "#N/A"}, + "=IPMT(0,1,0,0,0,0)": {"#N/A", "#N/A"}, + "=IPMT(\"\",0,0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=IPMT(0,\"\",0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=IPMT(0,0,\"\",0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=IPMT(0,0,0,\"\",0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=IPMT(0,0,0,0,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=IPMT(0,0,0,0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // ISPMT - "=ISPMT()": "ISPMT requires 4 arguments", - "=ISPMT(\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=ISPMT(0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=ISPMT(0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=ISPMT(0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=ISPMT()": {"#VALUE!", "ISPMT requires 4 arguments"}, + "=ISPMT(\"\",0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=ISPMT(0,\"\",0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=ISPMT(0,0,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=ISPMT(0,0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // MDURATION - "=MDURATION()": "MDURATION requires 5 or 6 arguments", - "=MDURATION(\"\",\"03/31/2025\",10%,8%,4)": "#VALUE!", - "=MDURATION(\"04/01/2015\",\"\",10%,8%,4)": "#VALUE!", - "=MDURATION(\"03/31/2025\",\"04/01/2015\",10%,8%,4)": "MDURATION requires maturity > settlement", - "=MDURATION(\"04/01/2015\",\"03/31/2025\",-1,8%,4)": "MDURATION requires coupon >= 0", - "=MDURATION(\"04/01/2015\",\"03/31/2025\",10%,-1,4)": "MDURATION requires yld >= 0", - "=MDURATION(\"04/01/2015\",\"03/31/2025\",\"\",8%,4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=MDURATION(\"04/01/2015\",\"03/31/2025\",10%,\"\",4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=MDURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=MDURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,3)": "#NUM!", - "=MDURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,4,\"\")": "#NUM!", - "=MDURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,4,5)": "invalid basis", + "=MDURATION()": {"#VALUE!", "MDURATION requires 5 or 6 arguments"}, + "=MDURATION(\"\",\"03/31/2025\",10%,8%,4)": {"#VALUE!", "#VALUE!"}, + "=MDURATION(\"04/01/2015\",\"\",10%,8%,4)": {"#VALUE!", "#VALUE!"}, + "=MDURATION(\"03/31/2025\",\"04/01/2015\",10%,8%,4)": {"#NUM!", "MDURATION requires maturity > settlement"}, + "=MDURATION(\"04/01/2015\",\"03/31/2025\",-1,8%,4)": {"#NUM!", "MDURATION requires coupon >= 0"}, + "=MDURATION(\"04/01/2015\",\"03/31/2025\",10%,-1,4)": {"#NUM!", "MDURATION requires yld >= 0"}, + "=MDURATION(\"04/01/2015\",\"03/31/2025\",\"\",8%,4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=MDURATION(\"04/01/2015\",\"03/31/2025\",10%,\"\",4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=MDURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=MDURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,3)": {"#NUM!", "#NUM!"}, + "=MDURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,4,\"\")": {"#NUM!", "#NUM!"}, + "=MDURATION(\"04/01/2015\",\"03/31/2025\",10%,8%,4,5)": {"#NUM!", "invalid basis"}, // NOMINAL - "=NOMINAL()": "NOMINAL requires 2 arguments", - "=NOMINAL(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NOMINAL(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NOMINAL(0,0)": "#NUM!", - "=NOMINAL(1,0)": "#NUM!", + "=NOMINAL()": {"#VALUE!", "NOMINAL requires 2 arguments"}, + "=NOMINAL(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NOMINAL(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NOMINAL(0,0)": {"#NUM!", "#NUM!"}, + "=NOMINAL(1,0)": {"#NUM!", "#NUM!"}, // NPER - "=NPER()": "NPER requires at least 3 arguments", - "=NPER(0,0,0,0,0,0)": "NPER allows at most 5 arguments", - "=NPER(0,0,0)": "#NUM!", - "=NPER(0,0,0,0,2)": "#N/A", - "=NPER(\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NPER(0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NPER(0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NPER(0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=NPER(0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=NPER()": {"#VALUE!", "NPER requires at least 3 arguments"}, + "=NPER(0,0,0,0,0,0)": {"#VALUE!", "NPER allows at most 5 arguments"}, + "=NPER(0,0,0)": {"#NUM!", "#NUM!"}, + "=NPER(0,0,0,0,2)": {"#N/A", "#N/A"}, + "=NPER(\"\",0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NPER(0,\"\",0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NPER(0,0,\"\",0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NPER(0,0,0,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=NPER(0,0,0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // NPV - "=NPV()": "NPV requires at least 2 arguments", - "=NPV(\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=NPV()": {"#VALUE!", "NPV requires at least 2 arguments"}, + "=NPV(\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // ODDFPRICE - "=ODDFPRICE()": "ODDFPRICE requires 8 or 9 arguments", - "=ODDFPRICE(\"\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,2)": "#VALUE!", - "=ODDFPRICE(\"02/01/2017\",\"\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,2)": "#VALUE!", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"\",\"03/31/2017\",5.5%,3.5%,100,2)": "#VALUE!", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"\",5.5%,3.5%,100,2)": "#VALUE!", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",\"\",3.5%,100,2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,\"\",100,2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,\"\",2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"02/01/2017\",\"03/31/2017\",5.5%,3.5%,100,2)": "ODDFPRICE requires settlement > issue", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"02/01/2017\",5.5%,3.5%,100,2)": "ODDFPRICE requires first_coupon > settlement", - "=ODDFPRICE(\"02/01/2017\",\"02/01/2017\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,2)": "ODDFPRICE requires maturity > first_coupon", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",-1,3.5%,100,2)": "ODDFPRICE requires rate >= 0", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,-1,100,2)": "ODDFPRICE requires yld >= 0", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,0,2)": "ODDFPRICE requires redemption > 0", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,2,\"\")": "#NUM!", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,3)": "#NUM!", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/30/2017\",5.5%,3.5%,100,4)": "#NUM!", - "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,2,5)": "invalid basis", + "=ODDFPRICE()": {"#VALUE!", "ODDFPRICE requires 8 or 9 arguments"}, + "=ODDFPRICE(\"\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,2)": {"#VALUE!", "#VALUE!"}, + "=ODDFPRICE(\"02/01/2017\",\"\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,2)": {"#VALUE!", "#VALUE!"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"\",\"03/31/2017\",5.5%,3.5%,100,2)": {"#VALUE!", "#VALUE!"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"\",5.5%,3.5%,100,2)": {"#VALUE!", "#VALUE!"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",\"\",3.5%,100,2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,\"\",100,2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,\"\",2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"02/01/2017\",\"03/31/2017\",5.5%,3.5%,100,2)": {"#NUM!", "ODDFPRICE requires settlement > issue"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"02/01/2017\",5.5%,3.5%,100,2)": {"#NUM!", "ODDFPRICE requires first_coupon > settlement"}, + "=ODDFPRICE(\"02/01/2017\",\"02/01/2017\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,2)": {"#NUM!", "ODDFPRICE requires maturity > first_coupon"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",-1,3.5%,100,2)": {"#NUM!", "ODDFPRICE requires rate >= 0"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,-1,100,2)": {"#NUM!", "ODDFPRICE requires yld >= 0"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,0,2)": {"#NUM!", "ODDFPRICE requires redemption > 0"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,2,\"\")": {"#NUM!", "#NUM!"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,3)": {"#NUM!", "#NUM!"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/30/2017\",5.5%,3.5%,100,4)": {"#NUM!", "#NUM!"}, + "=ODDFPRICE(\"02/01/2017\",\"03/31/2021\",\"12/01/2016\",\"03/31/2017\",5.5%,3.5%,100,2,5)": {"#NUM!", "invalid basis"}, // PDURATION - "=PDURATION()": "PDURATION requires 3 arguments", - "=PDURATION(\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PDURATION(0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PDURATION(0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PDURATION(0,0,0)": "#NUM!", + "=PDURATION()": {"#VALUE!", "PDURATION requires 3 arguments"}, + "=PDURATION(\"\",0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PDURATION(0,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PDURATION(0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PDURATION(0,0,0)": {"#NUM!", "#NUM!"}, // PMT - "=PMT()": "PMT requires at least 3 arguments", - "=PMT(0,0,0,0,0,0)": "PMT allows at most 5 arguments", - "=PMT(0,0,0,0,2)": "#N/A", - "=PMT(\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PMT(0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PMT(0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PMT(0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PMT(0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=PMT()": {"#VALUE!", "PMT requires at least 3 arguments"}, + "=PMT(0,0,0,0,0,0)": {"#VALUE!", "PMT allows at most 5 arguments"}, + "=PMT(0,0,0,0,2)": {"#N/A", "#N/A"}, + "=PMT(\"\",0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PMT(0,\"\",0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PMT(0,0,\"\",0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PMT(0,0,0,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PMT(0,0,0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // PRICE - "=PRICE()": "PRICE requires 6 or 7 arguments", - "=PRICE(\"\",\"02/01/2020\",12%,10%,100,2,4)": "#VALUE!", - "=PRICE(\"04/01/2012\",\"\",12%,10%,100,2,4)": "#VALUE!", - "=PRICE(\"04/01/2012\",\"02/01/2020\",\"\",10%,100,2,4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,\"\",100,2,4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,10%,\"\",2,4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,10%,100,\"\",4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PRICE(\"04/01/2012\",\"02/01/2020\",-1,10%,100,2,4)": "PRICE requires rate >= 0", - "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,-1,100,2,4)": "PRICE requires yld >= 0", - "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,10%,0,2,4)": "PRICE requires redemption > 0", - "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,10%,100,2,\"\")": "#NUM!", - "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,10%,100,3,4)": "#NUM!", - "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,10%,100,2,5)": "invalid basis", + "=PRICE()": {"#VALUE!", "PRICE requires 6 or 7 arguments"}, + "=PRICE(\"\",\"02/01/2020\",12%,10%,100,2,4)": {"#VALUE!", "#VALUE!"}, + "=PRICE(\"04/01/2012\",\"\",12%,10%,100,2,4)": {"#VALUE!", "#VALUE!"}, + "=PRICE(\"04/01/2012\",\"02/01/2020\",\"\",10%,100,2,4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,\"\",100,2,4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,10%,\"\",2,4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,10%,100,\"\",4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PRICE(\"04/01/2012\",\"02/01/2020\",-1,10%,100,2,4)": {"#NUM!", "PRICE requires rate >= 0"}, + "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,-1,100,2,4)": {"#NUM!", "PRICE requires yld >= 0"}, + "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,10%,0,2,4)": {"#NUM!", "PRICE requires redemption > 0"}, + "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,10%,100,2,\"\")": {"#NUM!", "#NUM!"}, + "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,10%,100,3,4)": {"#NUM!", "#NUM!"}, + "=PRICE(\"04/01/2012\",\"02/01/2020\",12%,10%,100,2,5)": {"#NUM!", "invalid basis"}, // PPMT - "=PPMT()": "PPMT requires at least 4 arguments", - "=PPMT(0,0,0,0,0,0,0)": "PPMT allows at most 6 arguments", - "=PPMT(0,0,0,0,0,2)": "#N/A", - "=PPMT(0,-1,0,0,0,0)": "#N/A", - "=PPMT(0,1,0,0,0,0)": "#N/A", - "=PPMT(\"\",0,0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PPMT(0,\"\",0,0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PPMT(0,0,\"\",0,0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PPMT(0,0,0,\"\",0,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PPMT(0,0,0,0,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PPMT(0,0,0,0,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=PPMT()": {"#VALUE!", "PPMT requires at least 4 arguments"}, + "=PPMT(0,0,0,0,0,0,0)": {"#VALUE!", "PPMT allows at most 6 arguments"}, + "=PPMT(0,0,0,0,0,2)": {"#N/A", "#N/A"}, + "=PPMT(0,-1,0,0,0,0)": {"#N/A", "#N/A"}, + "=PPMT(0,1,0,0,0,0)": {"#N/A", "#N/A"}, + "=PPMT(\"\",0,0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PPMT(0,\"\",0,0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PPMT(0,0,\"\",0,0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PPMT(0,0,0,\"\",0,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PPMT(0,0,0,0,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PPMT(0,0,0,0,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // PRICEDISC - "=PRICEDISC()": "PRICEDISC requires 4 or 5 arguments", - "=PRICEDISC(\"\",\"03/31/2021\",95,100)": "#VALUE!", - "=PRICEDISC(\"04/01/2016\",\"\",95,100)": "#VALUE!", - "=PRICEDISC(\"04/01/2016\",\"03/31/2021\",\"\",100)": "#VALUE!", - "=PRICEDISC(\"04/01/2016\",\"03/31/2021\",95,\"\")": "#VALUE!", - "=PRICEDISC(\"04/01/2016\",\"03/31/2021\",95,100,\"\")": "#NUM!", - "=PRICEDISC(\"03/31/2021\",\"04/01/2016\",95,100)": "PRICEDISC requires maturity > settlement", - "=PRICEDISC(\"04/01/2016\",\"03/31/2021\",0,100)": "PRICEDISC requires discount > 0", - "=PRICEDISC(\"04/01/2016\",\"03/31/2021\",95,0)": "PRICEDISC requires redemption > 0", - "=PRICEDISC(\"04/01/2016\",\"03/31/2021\",95,100,5)": "invalid basis", + "=PRICEDISC()": {"#VALUE!", "PRICEDISC requires 4 or 5 arguments"}, + "=PRICEDISC(\"\",\"03/31/2021\",95,100)": {"#VALUE!", "#VALUE!"}, + "=PRICEDISC(\"04/01/2016\",\"\",95,100)": {"#VALUE!", "#VALUE!"}, + "=PRICEDISC(\"04/01/2016\",\"03/31/2021\",\"\",100)": {"#VALUE!", "#VALUE!"}, + "=PRICEDISC(\"04/01/2016\",\"03/31/2021\",95,\"\")": {"#VALUE!", "#VALUE!"}, + "=PRICEDISC(\"04/01/2016\",\"03/31/2021\",95,100,\"\")": {"#NUM!", "#NUM!"}, + "=PRICEDISC(\"03/31/2021\",\"04/01/2016\",95,100)": {"#NUM!", "PRICEDISC requires maturity > settlement"}, + "=PRICEDISC(\"04/01/2016\",\"03/31/2021\",0,100)": {"#NUM!", "PRICEDISC requires discount > 0"}, + "=PRICEDISC(\"04/01/2016\",\"03/31/2021\",95,0)": {"#NUM!", "PRICEDISC requires redemption > 0"}, + "=PRICEDISC(\"04/01/2016\",\"03/31/2021\",95,100,5)": {"#NUM!", "invalid basis"}, // PRICEMAT - "=PRICEMAT()": "PRICEMAT requires 5 or 6 arguments", - "=PRICEMAT(\"\",\"03/31/2021\",\"01/01/2017\",4.5%,2.5%)": "#VALUE!", - "=PRICEMAT(\"04/01/2017\",\"\",\"01/01/2017\",4.5%,2.5%)": "#VALUE!", - "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"\",4.5%,2.5%)": "#VALUE!", - "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"01/01/2017\",\"\",2.5%)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"01/01/2017\",4.5%,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"01/01/2017\",4.5%,2.5%,\"\")": "#NUM!", - "=PRICEMAT(\"03/31/2021\",\"04/01/2017\",\"01/01/2017\",4.5%,2.5%)": "PRICEMAT requires maturity > settlement", - "=PRICEMAT(\"01/01/2017\",\"03/31/2021\",\"04/01/2017\",4.5%,2.5%)": "PRICEMAT requires settlement > issue", - "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"01/01/2017\",-1,2.5%)": "PRICEMAT requires rate >= 0", - "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"01/01/2017\",4.5%,-1)": "PRICEMAT requires yld >= 0", - "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"01/01/2017\",4.5%,2.5%,5)": "invalid basis", + "=PRICEMAT()": {"#VALUE!", "PRICEMAT requires 5 or 6 arguments"}, + "=PRICEMAT(\"\",\"03/31/2021\",\"01/01/2017\",4.5%,2.5%)": {"#VALUE!", "#VALUE!"}, + "=PRICEMAT(\"04/01/2017\",\"\",\"01/01/2017\",4.5%,2.5%)": {"#VALUE!", "#VALUE!"}, + "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"\",4.5%,2.5%)": {"#VALUE!", "#VALUE!"}, + "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"01/01/2017\",\"\",2.5%)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"01/01/2017\",4.5%,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"01/01/2017\",4.5%,2.5%,\"\")": {"#NUM!", "#NUM!"}, + "=PRICEMAT(\"03/31/2021\",\"04/01/2017\",\"01/01/2017\",4.5%,2.5%)": {"#NUM!", "PRICEMAT requires maturity > settlement"}, + "=PRICEMAT(\"01/01/2017\",\"03/31/2021\",\"04/01/2017\",4.5%,2.5%)": {"#NUM!", "PRICEMAT requires settlement > issue"}, + "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"01/01/2017\",-1,2.5%)": {"#NUM!", "PRICEMAT requires rate >= 0"}, + "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"01/01/2017\",4.5%,-1)": {"#NUM!", "PRICEMAT requires yld >= 0"}, + "=PRICEMAT(\"04/01/2017\",\"03/31/2021\",\"01/01/2017\",4.5%,2.5%,5)": {"#NUM!", "invalid basis"}, // PV - "=PV()": "PV requires at least 3 arguments", - "=PV(10%/4,16,2000,0,1,0)": "PV allows at most 5 arguments", - "=PV(\"\",16,2000,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PV(10%/4,\"\",2000,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PV(10%/4,16,\"\",0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PV(10%/4,16,2000,\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=PV(10%/4,16,2000,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=PV()": {"#VALUE!", "PV requires at least 3 arguments"}, + "=PV(10%/4,16,2000,0,1,0)": {"#VALUE!", "PV allows at most 5 arguments"}, + "=PV(\"\",16,2000,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PV(10%/4,\"\",2000,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PV(10%/4,16,\"\",0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PV(10%/4,16,2000,\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=PV(10%/4,16,2000,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // RATE - "=RATE()": "RATE requires at least 3 arguments", - "=RATE(48,-200,8000,3,1,0.5,0)": "RATE allows at most 6 arguments", - "=RATE(\"\",-200,8000,3,1,0.5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=RATE(48,\"\",8000,3,1,0.5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=RATE(48,-200,\"\",3,1,0.5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=RATE(48,-200,8000,\"\",1,0.5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=RATE(48,-200,8000,3,\"\",0.5)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=RATE(48,-200,8000,3,1,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + "=RATE()": {"#VALUE!", "RATE requires at least 3 arguments"}, + "=RATE(48,-200,8000,3,1,0.5,0)": {"#VALUE!", "RATE allows at most 6 arguments"}, + "=RATE(\"\",-200,8000,3,1,0.5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=RATE(48,\"\",8000,3,1,0.5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=RATE(48,-200,\"\",3,1,0.5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=RATE(48,-200,8000,\"\",1,0.5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=RATE(48,-200,8000,3,\"\",0.5)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=RATE(48,-200,8000,3,1,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, // RECEIVED - "=RECEIVED()": "RECEIVED requires at least 4 arguments", - "=RECEIVED(\"04/01/2011\",\"03/31/2016\",1000,4.5%,1,0)": "RECEIVED allows at most 5 arguments", - "=RECEIVED(\"\",\"03/31/2016\",1000,4.5%,1)": "#VALUE!", - "=RECEIVED(\"04/01/2011\",\"\",1000,4.5%,1)": "#VALUE!", - "=RECEIVED(\"04/01/2011\",\"03/31/2016\",\"\",4.5%,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=RECEIVED(\"04/01/2011\",\"03/31/2016\",1000,\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=RECEIVED(\"04/01/2011\",\"03/31/2016\",1000,4.5%,\"\")": "#NUM!", - "=RECEIVED(\"04/01/2011\",\"03/31/2016\",1000,0)": "RECEIVED requires discount > 0", - "=RECEIVED(\"04/01/2011\",\"03/31/2016\",1000,4.5%,5)": "invalid basis", + "=RECEIVED()": {"#VALUE!", "RECEIVED requires at least 4 arguments"}, + "=RECEIVED(\"04/01/2011\",\"03/31/2016\",1000,4.5%,1,0)": {"#VALUE!", "RECEIVED allows at most 5 arguments"}, + "=RECEIVED(\"\",\"03/31/2016\",1000,4.5%,1)": {"#VALUE!", "#VALUE!"}, + "=RECEIVED(\"04/01/2011\",\"\",1000,4.5%,1)": {"#VALUE!", "#VALUE!"}, + "=RECEIVED(\"04/01/2011\",\"03/31/2016\",\"\",4.5%,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=RECEIVED(\"04/01/2011\",\"03/31/2016\",1000,\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=RECEIVED(\"04/01/2011\",\"03/31/2016\",1000,4.5%,\"\")": {"#NUM!", "#NUM!"}, + "=RECEIVED(\"04/01/2011\",\"03/31/2016\",1000,0)": {"#NUM!", "RECEIVED requires discount > 0"}, + "=RECEIVED(\"04/01/2011\",\"03/31/2016\",1000,4.5%,5)": {"#NUM!", "invalid basis"}, // RRI - "=RRI()": "RRI requires 3 arguments", - "=RRI(\"\",\"\",\"\")": "#NUM!", - "=RRI(0,10000,15000)": "RRI requires nper argument to be > 0", - "=RRI(10,0,15000)": "RRI requires pv argument to be > 0", - "=RRI(10,10000,-1)": "RRI requires fv argument to be >= 0", + "=RRI()": {"#VALUE!", "RRI requires 3 arguments"}, + "=RRI(\"\",\"\",\"\")": {"#NUM!", "#NUM!"}, + "=RRI(0,10000,15000)": {"#NUM!", "RRI requires nper argument to be > 0"}, + "=RRI(10,0,15000)": {"#NUM!", "RRI requires pv argument to be > 0"}, + "=RRI(10,10000,-1)": {"#NUM!", "RRI requires fv argument to be >= 0"}, // SLN - "=SLN()": "SLN requires 3 arguments", - "=SLN(\"\",\"\",\"\")": "#NUM!", - "=SLN(10000,1000,0)": "SLN requires life argument to be > 0", + "=SLN()": {"#VALUE!", "SLN requires 3 arguments"}, + "=SLN(\"\",\"\",\"\")": {"#NUM!", "#NUM!"}, + "=SLN(10000,1000,0)": {"#NUM!", "SLN requires life argument to be > 0"}, // SYD - "=SYD()": "SYD requires 4 arguments", - "=SYD(\"\",\"\",\"\",\"\")": "#NUM!", - "=SYD(10000,1000,0,1)": "SYD requires life argument to be > 0", - "=SYD(10000,1000,5,0)": "SYD requires per argument to be > 0", - "=SYD(10000,1000,1,5)": "#NUM!", + "=SYD()": {"#VALUE!", "SYD requires 4 arguments"}, + "=SYD(\"\",\"\",\"\",\"\")": {"#NUM!", "#NUM!"}, + "=SYD(10000,1000,0,1)": {"#NUM!", "SYD requires life argument to be > 0"}, + "=SYD(10000,1000,5,0)": {"#NUM!", "SYD requires per argument to be > 0"}, + "=SYD(10000,1000,1,5)": {"#NUM!", "#NUM!"}, // TBILLEQ - "=TBILLEQ()": "TBILLEQ requires 3 arguments", - "=TBILLEQ(\"\",\"06/30/2017\",2.5%)": "#VALUE!", - "=TBILLEQ(\"01/01/2017\",\"\",2.5%)": "#VALUE!", - "=TBILLEQ(\"01/01/2017\",\"06/30/2017\",\"\")": "#VALUE!", - "=TBILLEQ(\"01/01/2017\",\"06/30/2017\",0)": "#NUM!", - "=TBILLEQ(\"01/01/2017\",\"06/30/2018\",2.5%)": "#NUM!", - "=TBILLEQ(\"06/30/2017\",\"01/01/2017\",2.5%)": "#NUM!", + "=TBILLEQ()": {"#VALUE!", "TBILLEQ requires 3 arguments"}, + "=TBILLEQ(\"\",\"06/30/2017\",2.5%)": {"#VALUE!", "#VALUE!"}, + "=TBILLEQ(\"01/01/2017\",\"\",2.5%)": {"#VALUE!", "#VALUE!"}, + "=TBILLEQ(\"01/01/2017\",\"06/30/2017\",\"\")": {"#VALUE!", "#VALUE!"}, + "=TBILLEQ(\"01/01/2017\",\"06/30/2017\",0)": {"#NUM!", "#NUM!"}, + "=TBILLEQ(\"01/01/2017\",\"06/30/2018\",2.5%)": {"#NUM!", "#NUM!"}, + "=TBILLEQ(\"06/30/2017\",\"01/01/2017\",2.5%)": {"#NUM!", "#NUM!"}, // TBILLPRICE - "=TBILLPRICE()": "TBILLPRICE requires 3 arguments", - "=TBILLPRICE(\"\",\"06/30/2017\",2.5%)": "#VALUE!", - "=TBILLPRICE(\"01/01/2017\",\"\",2.5%)": "#VALUE!", - "=TBILLPRICE(\"01/01/2017\",\"06/30/2017\",\"\")": "#VALUE!", - "=TBILLPRICE(\"01/01/2017\",\"06/30/2017\",0)": "#NUM!", - "=TBILLPRICE(\"01/01/2017\",\"06/30/2018\",2.5%)": "#NUM!", - "=TBILLPRICE(\"06/30/2017\",\"01/01/2017\",2.5%)": "#NUM!", + "=TBILLPRICE()": {"#VALUE!", "TBILLPRICE requires 3 arguments"}, + "=TBILLPRICE(\"\",\"06/30/2017\",2.5%)": {"#VALUE!", "#VALUE!"}, + "=TBILLPRICE(\"01/01/2017\",\"\",2.5%)": {"#VALUE!", "#VALUE!"}, + "=TBILLPRICE(\"01/01/2017\",\"06/30/2017\",\"\")": {"#VALUE!", "#VALUE!"}, + "=TBILLPRICE(\"01/01/2017\",\"06/30/2017\",0)": {"#NUM!", "#NUM!"}, + "=TBILLPRICE(\"01/01/2017\",\"06/30/2018\",2.5%)": {"#NUM!", "#NUM!"}, + "=TBILLPRICE(\"06/30/2017\",\"01/01/2017\",2.5%)": {"#NUM!", "#NUM!"}, // TBILLYIELD - "=TBILLYIELD()": "TBILLYIELD requires 3 arguments", - "=TBILLYIELD(\"\",\"06/30/2017\",2.5%)": "#VALUE!", - "=TBILLYIELD(\"01/01/2017\",\"\",2.5%)": "#VALUE!", - "=TBILLYIELD(\"01/01/2017\",\"06/30/2017\",\"\")": "#VALUE!", - "=TBILLYIELD(\"01/01/2017\",\"06/30/2017\",0)": "#NUM!", - "=TBILLYIELD(\"01/01/2017\",\"06/30/2018\",2.5%)": "#NUM!", - "=TBILLYIELD(\"06/30/2017\",\"01/01/2017\",2.5%)": "#NUM!", + "=TBILLYIELD()": {"#VALUE!", "TBILLYIELD requires 3 arguments"}, + "=TBILLYIELD(\"\",\"06/30/2017\",2.5%)": {"#VALUE!", "#VALUE!"}, + "=TBILLYIELD(\"01/01/2017\",\"\",2.5%)": {"#VALUE!", "#VALUE!"}, + "=TBILLYIELD(\"01/01/2017\",\"06/30/2017\",\"\")": {"#VALUE!", "#VALUE!"}, + "=TBILLYIELD(\"01/01/2017\",\"06/30/2017\",0)": {"#NUM!", "#NUM!"}, + "=TBILLYIELD(\"01/01/2017\",\"06/30/2018\",2.5%)": {"#NUM!", "#NUM!"}, + "=TBILLYIELD(\"06/30/2017\",\"01/01/2017\",2.5%)": {"#NUM!", "#NUM!"}, // VDB - "=VDB()": "VDB requires 5 or 7 arguments", - "=VDB(-1,1000,5,0,1)": "VDB requires cost >= 0", - "=VDB(10000,-1,5,0,1)": "VDB requires salvage >= 0", - "=VDB(10000,1000,0,0,1)": "VDB requires life > 0", - "=VDB(10000,1000,5,-1,1)": "VDB requires start_period > 0", - "=VDB(10000,1000,5,2,1)": "VDB requires start_period <= end_period", - "=VDB(10000,1000,5,0,6)": "VDB requires end_period <= life", - "=VDB(10000,1000,5,0,1,-0.2)": "VDB requires factor >= 0", - "=VDB(\"\",1000,5,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=VDB(10000,\"\",5,0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=VDB(10000,1000,\"\",0,1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=VDB(10000,1000,5,\"\",1)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=VDB(10000,1000,5,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=VDB(10000,1000,5,0,1,\"\")": "#NUM!", - "=VDB(10000,1000,5,0,1,0.2,\"\")": "#NUM!", + "=VDB()": {"#VALUE!", "VDB requires 5 or 7 arguments"}, + "=VDB(-1,1000,5,0,1)": {"#NUM!", "VDB requires cost >= 0"}, + "=VDB(10000,-1,5,0,1)": {"#NUM!", "VDB requires salvage >= 0"}, + "=VDB(10000,1000,0,0,1)": {"#NUM!", "VDB requires life > 0"}, + "=VDB(10000,1000,5,-1,1)": {"#NUM!", "VDB requires start_period > 0"}, + "=VDB(10000,1000,5,2,1)": {"#NUM!", "VDB requires start_period <= end_period"}, + "=VDB(10000,1000,5,0,6)": {"#NUM!", "VDB requires end_period <= life"}, + "=VDB(10000,1000,5,0,1,-0.2)": {"#VALUE!", "VDB requires factor >= 0"}, + "=VDB(\"\",1000,5,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=VDB(10000,\"\",5,0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=VDB(10000,1000,\"\",0,1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=VDB(10000,1000,5,\"\",1)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=VDB(10000,1000,5,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=VDB(10000,1000,5,0,1,\"\")": {"#NUM!", "#NUM!"}, + "=VDB(10000,1000,5,0,1,0.2,\"\")": {"#NUM!", "#NUM!"}, // YIELD - "=YIELD()": "YIELD requires 6 or 7 arguments", - "=YIELD(\"\",\"06/30/2015\",10%,101,100,4)": "#VALUE!", - "=YIELD(\"01/01/2010\",\"\",10%,101,100,4)": "#VALUE!", - "=YIELD(\"01/01/2010\",\"06/30/2015\",\"\",101,100,4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,\"\",100,4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,101,\"\",4)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,101,100,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,101,100,4,\"\")": "#NUM!", - "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,101,100,3)": "#NUM!", - "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,101,100,4,5)": "invalid basis", - "=YIELD(\"01/01/2010\",\"06/30/2015\",-1,101,100,4)": "PRICE requires rate >= 0", - "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,0,100,4)": "PRICE requires pr > 0", - "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,101,-1,4)": "PRICE requires redemption >= 0", + "=YIELD()": {"#VALUE!", "YIELD requires 6 or 7 arguments"}, + "=YIELD(\"\",\"06/30/2015\",10%,101,100,4)": {"#VALUE!", "#VALUE!"}, + "=YIELD(\"01/01/2010\",\"\",10%,101,100,4)": {"#VALUE!", "#VALUE!"}, + "=YIELD(\"01/01/2010\",\"06/30/2015\",\"\",101,100,4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,\"\",100,4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,101,\"\",4)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,101,100,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,101,100,4,\"\")": {"#NUM!", "#NUM!"}, + "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,101,100,3)": {"#NUM!", "#NUM!"}, + "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,101,100,4,5)": {"#NUM!", "invalid basis"}, + "=YIELD(\"01/01/2010\",\"06/30/2015\",-1,101,100,4)": {"#NUM!", "PRICE requires rate >= 0"}, + "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,0,100,4)": {"#NUM!", "PRICE requires pr > 0"}, + "=YIELD(\"01/01/2010\",\"06/30/2015\",10%,101,-1,4)": {"#NUM!", "PRICE requires redemption >= 0"}, // YIELDDISC - "=YIELDDISC()": "YIELDDISC requires 4 or 5 arguments", - "=YIELDDISC(\"\",\"06/30/2017\",97,100,0)": "#VALUE!", - "=YIELDDISC(\"01/01/2017\",\"\",97,100,0)": "#VALUE!", - "=YIELDDISC(\"01/01/2017\",\"06/30/2017\",\"\",100,0)": "#VALUE!", - "=YIELDDISC(\"01/01/2017\",\"06/30/2017\",97,\"\",0)": "#VALUE!", - "=YIELDDISC(\"01/01/2017\",\"06/30/2017\",97,100,\"\")": "#NUM!", - "=YIELDDISC(\"01/01/2017\",\"06/30/2017\",0,100)": "YIELDDISC requires pr > 0", - "=YIELDDISC(\"01/01/2017\",\"06/30/2017\",97,0)": "YIELDDISC requires redemption > 0", - "=YIELDDISC(\"01/01/2017\",\"06/30/2017\",97,100,5)": "invalid basis", + "=YIELDDISC()": {"#VALUE!", "YIELDDISC requires 4 or 5 arguments"}, + "=YIELDDISC(\"\",\"06/30/2017\",97,100,0)": {"#VALUE!", "#VALUE!"}, + "=YIELDDISC(\"01/01/2017\",\"\",97,100,0)": {"#VALUE!", "#VALUE!"}, + "=YIELDDISC(\"01/01/2017\",\"06/30/2017\",\"\",100,0)": {"#VALUE!", "#VALUE!"}, + "=YIELDDISC(\"01/01/2017\",\"06/30/2017\",97,\"\",0)": {"#VALUE!", "#VALUE!"}, + "=YIELDDISC(\"01/01/2017\",\"06/30/2017\",97,100,\"\")": {"#NUM!", "#NUM!"}, + "=YIELDDISC(\"01/01/2017\",\"06/30/2017\",0,100)": {"#NUM!", "YIELDDISC requires pr > 0"}, + "=YIELDDISC(\"01/01/2017\",\"06/30/2017\",97,0)": {"#NUM!", "YIELDDISC requires redemption > 0"}, + "=YIELDDISC(\"01/01/2017\",\"06/30/2017\",97,100,5)": {"#NUM!", "invalid basis"}, // YIELDMAT - "=YIELDMAT()": "YIELDMAT requires 5 or 6 arguments", - "=YIELDMAT(\"\",\"06/30/2018\",\"06/01/2014\",5.5%,101,0)": "#VALUE!", - "=YIELDMAT(\"01/01/2017\",\"\",\"06/01/2014\",5.5%,101,0)": "#VALUE!", - "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"\",5.5%,101,0)": "#VALUE!", - "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"06/01/2014\",\"\",101,0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"06/01/2014\",5,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"06/01/2014\",5,5.5%,\"\")": "#NUM!", - "=YIELDMAT(\"06/01/2014\",\"06/30/2018\",\"01/01/2017\",5.5%,101,0)": "YIELDMAT requires settlement > issue", - "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"06/01/2014\",-1,101,0)": "YIELDMAT requires rate >= 0", - "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"06/01/2014\",1,0,0)": "YIELDMAT requires pr > 0", - "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"06/01/2014\",5.5%,101,5)": "invalid basis", + "=YIELDMAT()": {"#VALUE!", "YIELDMAT requires 5 or 6 arguments"}, + "=YIELDMAT(\"\",\"06/30/2018\",\"06/01/2014\",5.5%,101,0)": {"#VALUE!", "#VALUE!"}, + "=YIELDMAT(\"01/01/2017\",\"\",\"06/01/2014\",5.5%,101,0)": {"#VALUE!", "#VALUE!"}, + "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"\",5.5%,101,0)": {"#VALUE!", "#VALUE!"}, + "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"06/01/2014\",\"\",101,0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"06/01/2014\",5,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"06/01/2014\",5,5.5%,\"\")": {"#NUM!", "#NUM!"}, + "=YIELDMAT(\"06/01/2014\",\"06/30/2018\",\"01/01/2017\",5.5%,101,0)": {"#NUM!", "YIELDMAT requires settlement > issue"}, + "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"06/01/2014\",-1,101,0)": {"#NUM!", "YIELDMAT requires rate >= 0"}, + "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"06/01/2014\",1,0,0)": {"#NUM!", "YIELDMAT requires pr > 0"}, + "=YIELDMAT(\"01/01/2017\",\"06/30/2018\",\"06/01/2014\",5.5%,101,5)": {"#NUM!", "invalid basis"}, } for formula, expected := range mathCalcError { f := prepareCalcData(cellData) assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula)) result, err := f.CalcCellValue("Sheet1", "C1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } referenceCalc := map[string]string{ @@ -4393,18 +4394,18 @@ func TestCalcCellValue(t *testing.T) { assert.Equal(t, expected, result, formula) } - referenceCalcError := map[string]string{ + referenceCalcError := map[string][]string{ // MDETERM - "=MDETERM(A1:B3)": "#VALUE!", + "=MDETERM(A1:B3)": {"#VALUE!", "#VALUE!"}, // SUM - "=1+SUM(SUM(A1+A2/A4)*(2-3),2)": "#DIV/0!", + "=1+SUM(SUM(A1+A2/A4)*(2-3),2)": {"#VALUE!", "#DIV/0!"}, } for formula, expected := range referenceCalcError { f := prepareCalcData(cellData) assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula)) result, err := f.CalcCellValue("Sheet1", "C1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } volatileFuncs := []string{ @@ -4455,25 +4456,25 @@ func TestCalcWithDefinedName(t *testing.T) { // DefinedName with scope WorkSheet takes precedence over DefinedName with scope Workbook, so we should get B1 value assert.Equal(t, "B1_as_string", result, "=defined_name1") - assert.NoError(t, f.SetCellFormula("Sheet1", "D1", `=CONCATENATE("<",defined_name1,">")`)) + assert.NoError(t, f.SetCellFormula("Sheet1", "D1", "=CONCATENATE(\"<\",defined_name1,\">\")")) result, err = f.CalcCellValue("Sheet1", "D1") assert.NoError(t, err) assert.Equal(t, "", result, "=defined_name1") // comparing numeric values - assert.NoError(t, f.SetCellFormula("Sheet1", "D1", `=123=defined_name2`)) + assert.NoError(t, f.SetCellFormula("Sheet1", "D1", "=123=defined_name2")) result, err = f.CalcCellValue("Sheet1", "D1") assert.NoError(t, err) assert.Equal(t, "TRUE", result, "=123=defined_name2") // comparing text values - assert.NoError(t, f.SetCellFormula("Sheet1", "D1", `="B1_as_string"=defined_name1`)) + assert.NoError(t, f.SetCellFormula("Sheet1", "D1", "=\"B1_as_string\"=defined_name1")) result, err = f.CalcCellValue("Sheet1", "D1") assert.NoError(t, err) - assert.Equal(t, "TRUE", result, `="B1_as_string"=defined_name1`) + assert.Equal(t, "TRUE", result, "=\"B1_as_string\"=defined_name1") // comparing text values - assert.NoError(t, f.SetCellFormula("Sheet1", "D1", `=IF("B1_as_string"=defined_name1,"YES","NO")`)) + assert.NoError(t, f.SetCellFormula("Sheet1", "D1", "=IF(\"B1_as_string\"=defined_name1,\"YES\",\"NO\")")) result, err = f.CalcCellValue("Sheet1", "D1") assert.NoError(t, err) assert.Equal(t, "YES", result, `=IF("B1_as_string"=defined_name1,"YES","NO")`) @@ -4594,14 +4595,14 @@ func TestCalcVLOOKUP(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=VLOOKUP(INT(1),C3:C3,1,FALSE)": "VLOOKUP no result found", + calcError := map[string][]string{ + "=VLOOKUP(INT(1),C3:C3,1,FALSE)": {"#N/A", "VLOOKUP no result found"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "F4", formula)) result, err := f.CalcCellValue("Sheet1", "F4") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -4706,19 +4707,19 @@ func TestCalcCOVAR(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=COVAR()": "COVAR requires 2 arguments", - "=COVAR(A2:A9,B3:B3)": "#N/A", - "=COVARIANCE.P()": "COVARIANCE.P requires 2 arguments", - "=COVARIANCE.P(A2:A9,B3:B3)": "#N/A", - "=COVARIANCE.S()": "COVARIANCE.S requires 2 arguments", - "=COVARIANCE.S(A2:A9,B3:B3)": "#N/A", + calcError := map[string][]string{ + "=COVAR()": {"#VALUE!", "COVAR requires 2 arguments"}, + "=COVAR(A2:A9,B3:B3)": {"#N/A", "#N/A"}, + "=COVARIANCE.P()": {"#VALUE!", "COVARIANCE.P requires 2 arguments"}, + "=COVARIANCE.P(A2:A9,B3:B3)": {"#N/A", "#N/A"}, + "=COVARIANCE.S()": {"#VALUE!", "COVARIANCE.S requires 2 arguments"}, + "=COVARIANCE.S(A2:A9,B3:B3)": {"#N/A", "#N/A"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula)) result, err := f.CalcCellValue("Sheet1", "C1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -4769,47 +4770,47 @@ func TestCalcDatabase(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=DAVERAGE()": "DAVERAGE requires 3 arguments", - "=DAVERAGE(A4:E10,\"x\",A1:F3)": "#VALUE!", - "=DAVERAGE(A4:E10,\"Tree\",A1:F3)": "#DIV/0!", - "=DCOUNT()": "DCOUNT requires at least 2 arguments", - "=DCOUNT(A4:E10,\"Age\",A1:F2,\"\")": "DCOUNT allows at most 3 arguments", - "=DCOUNT(A4,\"Age\",A1:F2)": "#VALUE!", - "=DCOUNT(A4:E10,NA(),A1:F2)": "#VALUE!", - "=DCOUNT(A4:E4,,A1:F2)": "#VALUE!", - "=DCOUNT(A4:E10,\"x\",A2:F3)": "#VALUE!", - "=DCOUNTA()": "DCOUNTA requires at least 2 arguments", - "=DCOUNTA(A4:E10,\"Age\",A1:F2,\"\")": "DCOUNTA allows at most 3 arguments", - "=DCOUNTA(A4,\"Age\",A1:F2)": "#VALUE!", - "=DCOUNTA(A4:E10,NA(),A1:F2)": "#VALUE!", - "=DCOUNTA(A4:E4,,A1:F2)": "#VALUE!", - "=DCOUNTA(A4:E10,\"x\",A2:F3)": "#VALUE!", - "=DGET()": "DGET requires 3 arguments", - "=DGET(A4:E5,\"Profit\",A1:F3)": "#VALUE!", - "=DGET(A4:E10,\"Profit\",A1:F3)": "#NUM!", - "=DMAX()": "DMAX requires 3 arguments", - "=DMAX(A4:E10,\"x\",A1:F3)": "#VALUE!", - "=DMIN()": "DMIN requires 3 arguments", - "=DMIN(A4:E10,\"x\",A1:F3)": "#VALUE!", - "=DPRODUCT()": "DPRODUCT requires 3 arguments", - "=DPRODUCT(A4:E10,\"x\",A1:F3)": "#VALUE!", - "=DSTDEV()": "DSTDEV requires 3 arguments", - "=DSTDEV(A4:E10,\"x\",A1:F3)": "#VALUE!", - "=DSTDEVP()": "DSTDEVP requires 3 arguments", - "=DSTDEVP(A4:E10,\"x\",A1:F3)": "#VALUE!", - "=DSUM()": "DSUM requires 3 arguments", - "=DSUM(A4:E10,\"x\",A1:F3)": "#VALUE!", - "=DVAR()": "DVAR requires 3 arguments", - "=DVAR(A4:E10,\"x\",A1:F3)": "#VALUE!", - "=DVARP()": "DVARP requires 3 arguments", - "=DVARP(A4:E10,\"x\",A1:F3)": "#VALUE!", + calcError := map[string][]string{ + "=DAVERAGE()": {"#VALUE!", "DAVERAGE requires 3 arguments"}, + "=DAVERAGE(A4:E10,\"x\",A1:F3)": {"#VALUE!", "#VALUE!"}, + "=DAVERAGE(A4:E10,\"Tree\",A1:F3)": {"#DIV/0!", "#DIV/0!"}, + "=DCOUNT()": {"#VALUE!", "DCOUNT requires at least 2 arguments"}, + "=DCOUNT(A4:E10,\"Age\",A1:F2,\"\")": {"#VALUE!", "DCOUNT allows at most 3 arguments"}, + "=DCOUNT(A4,\"Age\",A1:F2)": {"#VALUE!", "#VALUE!"}, + "=DCOUNT(A4:E10,NA(),A1:F2)": {"#VALUE!", "#VALUE!"}, + "=DCOUNT(A4:E4,,A1:F2)": {"#VALUE!", "#VALUE!"}, + "=DCOUNT(A4:E10,\"x\",A2:F3)": {"#VALUE!", "#VALUE!"}, + "=DCOUNTA()": {"#VALUE!", "DCOUNTA requires at least 2 arguments"}, + "=DCOUNTA(A4:E10,\"Age\",A1:F2,\"\")": {"#VALUE!", "DCOUNTA allows at most 3 arguments"}, + "=DCOUNTA(A4,\"Age\",A1:F2)": {"#VALUE!", "#VALUE!"}, + "=DCOUNTA(A4:E10,NA(),A1:F2)": {"#VALUE!", "#VALUE!"}, + "=DCOUNTA(A4:E4,,A1:F2)": {"#VALUE!", "#VALUE!"}, + "=DCOUNTA(A4:E10,\"x\",A2:F3)": {"#VALUE!", "#VALUE!"}, + "=DGET()": {"#VALUE!", "DGET requires 3 arguments"}, + "=DGET(A4:E5,\"Profit\",A1:F3)": {"#VALUE!", "#VALUE!"}, + "=DGET(A4:E10,\"Profit\",A1:F3)": {"#NUM!", "#NUM!"}, + "=DMAX()": {"#VALUE!", "DMAX requires 3 arguments"}, + "=DMAX(A4:E10,\"x\",A1:F3)": {"#VALUE!", "#VALUE!"}, + "=DMIN()": {"#VALUE!", "DMIN requires 3 arguments"}, + "=DMIN(A4:E10,\"x\",A1:F3)": {"#VALUE!", "#VALUE!"}, + "=DPRODUCT()": {"#VALUE!", "DPRODUCT requires 3 arguments"}, + "=DPRODUCT(A4:E10,\"x\",A1:F3)": {"#VALUE!", "#VALUE!"}, + "=DSTDEV()": {"#VALUE!", "DSTDEV requires 3 arguments"}, + "=DSTDEV(A4:E10,\"x\",A1:F3)": {"#VALUE!", "#VALUE!"}, + "=DSTDEVP()": {"#VALUE!", "DSTDEVP requires 3 arguments"}, + "=DSTDEVP(A4:E10,\"x\",A1:F3)": {"#VALUE!", "#VALUE!"}, + "=DSUM()": {"#VALUE!", "DSUM requires 3 arguments"}, + "=DSUM(A4:E10,\"x\",A1:F3)": {"#VALUE!", "#VALUE!"}, + "=DVAR()": {"#VALUE!", "DVAR requires 3 arguments"}, + "=DVAR(A4:E10,\"x\",A1:F3)": {"#VALUE!", "#VALUE!"}, + "=DVARP()": {"#VALUE!", "DVARP requires 3 arguments"}, + "=DVARP(A4:E10,\"x\",A1:F3)": {"#VALUE!", "#VALUE!"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "A11", formula)) result, err := f.CalcCellValue("Sheet1", "A11") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -4867,38 +4868,38 @@ func TestCalcGROWTHandTREND(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=GROWTH()": "GROWTH requires at least 1 argument", - "=GROWTH(B2:B5,A2:A5,A8:A10,TRUE,0)": "GROWTH allows at most 4 arguments", - "=GROWTH(A1:B1,A2:A5,A8:A10,TRUE)": "#VALUE!", - "=GROWTH(B2:B5,A1:B1,A8:A10,TRUE)": "#VALUE!", - "=GROWTH(B2:B5,A2:A5,A1:B1,TRUE)": "#VALUE!", - "=GROWTH(B2:B5,A2:A5,A8:A10,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=GROWTH(A2:B3,A4:B4)": "#REF!", - "=GROWTH(A4:B4,A2:A2)": "#REF!", - "=GROWTH(A2:A2,A4:A5)": "#REF!", - "=GROWTH(C1:C1,A2:A3)": "#VALUE!", - "=GROWTH(D1:D1,A2:A3)": "#NUM!", - "=GROWTH(A2:A3,C1:C1)": "#VALUE!", - "=TREND()": "TREND requires at least 1 argument", - "=TREND(B2:B5,A2:A5,A8:A10,TRUE,0)": "TREND allows at most 4 arguments", - "=TREND(A1:B1,A2:A5,A8:A10,TRUE)": "#VALUE!", - "=TREND(B2:B5,A1:B1,A8:A10,TRUE)": "#VALUE!", - "=TREND(B2:B5,A2:A5,A1:B1,TRUE)": "#VALUE!", - "=TREND(B2:B5,A2:A5,A8:A10,\"\")": "strconv.ParseBool: parsing \"\": invalid syntax", - "=TREND(A2:B3,A4:B4)": "#REF!", - "=TREND(A4:B4,A2:A2)": "#REF!", - "=TREND(A2:A2,A4:A5)": "#REF!", - "=TREND(C1:C1,A2:A3)": "#VALUE!", - "=TREND(D1:D1,A2:A3)": "#REF!", - "=TREND(A2:A3,C1:C1)": "#VALUE!", - "=TREND(C1:C1,C1:C1)": "#VALUE!", + calcError := map[string][]string{ + "=GROWTH()": {"#VALUE!", "GROWTH requires at least 1 argument"}, + "=GROWTH(B2:B5,A2:A5,A8:A10,TRUE,0)": {"#VALUE!", "GROWTH allows at most 4 arguments"}, + "=GROWTH(A1:B1,A2:A5,A8:A10,TRUE)": {"#VALUE!", "#VALUE!"}, + "=GROWTH(B2:B5,A1:B1,A8:A10,TRUE)": {"#VALUE!", "#VALUE!"}, + "=GROWTH(B2:B5,A2:A5,A1:B1,TRUE)": {"#VALUE!", "#VALUE!"}, + "=GROWTH(B2:B5,A2:A5,A8:A10,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=GROWTH(A2:B3,A4:B4)": {"#REF!", "#REF!"}, + "=GROWTH(A4:B4,A2:A2)": {"#REF!", "#REF!"}, + "=GROWTH(A2:A2,A4:A5)": {"#REF!", "#REF!"}, + "=GROWTH(C1:C1,A2:A3)": {"#VALUE!", "#VALUE!"}, + "=GROWTH(D1:D1,A2:A3)": {"#NUM!", "#NUM!"}, + "=GROWTH(A2:A3,C1:C1)": {"#VALUE!", "#VALUE!"}, + "=TREND()": {"#VALUE!", "TREND requires at least 1 argument"}, + "=TREND(B2:B5,A2:A5,A8:A10,TRUE,0)": {"#VALUE!", "TREND allows at most 4 arguments"}, + "=TREND(A1:B1,A2:A5,A8:A10,TRUE)": {"#VALUE!", "#VALUE!"}, + "=TREND(B2:B5,A1:B1,A8:A10,TRUE)": {"#VALUE!", "#VALUE!"}, + "=TREND(B2:B5,A2:A5,A1:B1,TRUE)": {"#VALUE!", "#VALUE!"}, + "=TREND(B2:B5,A2:A5,A8:A10,\"\")": {"#VALUE!", "strconv.ParseBool: parsing \"\": invalid syntax"}, + "=TREND(A2:B3,A4:B4)": {"#REF!", "#REF!"}, + "=TREND(A4:B4,A2:A2)": {"#REF!", "#REF!"}, + "=TREND(A2:A2,A4:A5)": {"#REF!", "#REF!"}, + "=TREND(C1:C1,A2:A3)": {"#VALUE!", "#VALUE!"}, + "=TREND(D1:D1,A2:A3)": {"#REF!", "#REF!"}, + "=TREND(A2:A3,C1:C1)": {"#VALUE!", "#VALUE!"}, + "=TREND(C1:C1,C1:C1)": {"#VALUE!", "#VALUE!"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula)) result, err := f.CalcCellValue("Sheet1", "C1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -4929,14 +4930,14 @@ func TestCalcHLOOKUP(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=HLOOKUP(INT(1),A3:A3,1,FALSE)": "HLOOKUP no result found", + calcError := map[string][]string{ + "=HLOOKUP(INT(1),A3:A3,1,FALSE)": {"#N/A", "HLOOKUP no result found"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "B10", formula)) result, err := f.CalcCellValue("Sheet1", "B10") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -4966,23 +4967,23 @@ func TestCalcCHITESTandCHISQdotTEST(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=CHITEST()": "CHITEST requires 2 arguments", - "=CHITEST(B3:C5,F3:F4)": "#N/A", - "=CHITEST(B3:B3,F3:F3)": "#N/A", - "=CHITEST(F3:F5,B4:B6)": "#NUM!", - "=CHITEST(F3:F5,C4:C6)": "#DIV/0!", - "=CHISQ.TEST()": "CHISQ.TEST requires 2 arguments", - "=CHISQ.TEST(B3:C5,F3:F4)": "#N/A", - "=CHISQ.TEST(B3:B3,F3:F3)": "#N/A", - "=CHISQ.TEST(F3:F5,B4:B6)": "#NUM!", - "=CHISQ.TEST(F3:F5,C4:C6)": "#DIV/0!", + calcError := map[string][]string{ + "=CHITEST()": {"#VALUE!", "CHITEST requires 2 arguments"}, + "=CHITEST(B3:C5,F3:F4)": {"#N/A", "#N/A"}, + "=CHITEST(B3:B3,F3:F3)": {"#N/A", "#N/A"}, + "=CHITEST(F3:F5,B4:B6)": {"#NUM!", "#NUM!"}, + "=CHITEST(F3:F5,C4:C6)": {"#DIV/0!", "#DIV/0!"}, + "=CHISQ.TEST()": {"#VALUE!", "CHISQ.TEST requires 2 arguments"}, + "=CHISQ.TEST(B3:C5,F3:F4)": {"#N/A", "#N/A"}, + "=CHISQ.TEST(B3:B3,F3:F3)": {"#N/A", "#N/A"}, + "=CHISQ.TEST(F3:F5,B4:B6)": {"#NUM!", "#NUM!"}, + "=CHISQ.TEST(F3:F5,C4:C6)": {"#DIV/0!", "#DIV/0!"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "I1", formula)) result, err := f.CalcCellValue("Sheet1", "I1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -5011,23 +5012,23 @@ func TestCalcFTEST(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=FTEST()": "FTEST requires 2 arguments", - "=FTEST(A2:A2,B2:B2)": "#DIV/0!", - "=FTEST(A12:A14,B2:B4)": "#DIV/0!", - "=FTEST(A2:A4,B2:B2)": "#DIV/0!", - "=FTEST(A2:A4,B12:B14)": "#DIV/0!", - "=F.TEST()": "F.TEST requires 2 arguments", - "=F.TEST(A2:A2,B2:B2)": "#DIV/0!", - "=F.TEST(A12:A14,B2:B4)": "#DIV/0!", - "=F.TEST(A2:A4,B2:B2)": "#DIV/0!", - "=F.TEST(A2:A4,B12:B14)": "#DIV/0!", + calcError := map[string][]string{ + "=FTEST()": {"#VALUE!", "FTEST requires 2 arguments"}, + "=FTEST(A2:A2,B2:B2)": {"#DIV/0!", "#DIV/0!"}, + "=FTEST(A12:A14,B2:B4)": {"#DIV/0!", "#DIV/0!"}, + "=FTEST(A2:A4,B2:B2)": {"#DIV/0!", "#DIV/0!"}, + "=FTEST(A2:A4,B12:B14)": {"#DIV/0!", "#DIV/0!"}, + "=F.TEST()": {"#VALUE!", "F.TEST requires 2 arguments"}, + "=F.TEST(A2:A2,B2:B2)": {"#DIV/0!", "#DIV/0!"}, + "=F.TEST(A12:A14,B2:B4)": {"#DIV/0!", "#DIV/0!"}, + "=F.TEST(A2:A4,B2:B2)": {"#DIV/0!", "#DIV/0!"}, + "=F.TEST(A2:A4,B12:B14)": {"#DIV/0!", "#DIV/0!"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula)) result, err := f.CalcCellValue("Sheet1", "C1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -5045,17 +5046,17 @@ func TestCalcIRR(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=IRR()": "IRR requires at least 1 argument", - "=IRR(0,0,0)": "IRR allows at most 2 arguments", - "=IRR(0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=IRR(A2:A3)": "#NUM!", + calcError := map[string][]string{ + "=IRR()": {"#VALUE!", "IRR requires at least 1 argument"}, + "=IRR(0,0,0)": {"#VALUE!", "IRR allows at most 2 arguments"}, + "=IRR(0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=IRR(A2:A3)": {"#NUM!", "#NUM!"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "B1", formula)) result, err := f.CalcCellValue("Sheet1", "B1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -5095,17 +5096,17 @@ func TestCalcMIRR(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=MIRR()": "MIRR requires 3 arguments", - "=MIRR(A1:A5,\"\",0)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=MIRR(A1:A5,0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=MIRR(B1:B5,0,0)": "#DIV/0!", + calcError := map[string][]string{ + "=MIRR()": {"#VALUE!", "MIRR requires 3 arguments"}, + "=MIRR(A1:A5,\"\",0)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=MIRR(A1:A5,0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=MIRR(B1:B5,0,0)": {"#DIV/0!", "#DIV/0!"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "B1", formula)) result, err := f.CalcCellValue("Sheet1", "B1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -5138,20 +5139,20 @@ func TestCalcSUMIFSAndAVERAGEIFS(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=AVERAGEIFS()": "AVERAGEIFS requires at least 3 arguments", - "=AVERAGEIFS(H1,\"\")": "AVERAGEIFS requires at least 3 arguments", - "=AVERAGEIFS(H1,\"\",TRUE,1)": "#N/A", - "=AVERAGEIFS(H1,\"\",TRUE)": "AVERAGEIF divide by zero", - "=SUMIFS()": "SUMIFS requires at least 3 arguments", - "=SUMIFS(D2:D13,A2:A13,1,B2:B13)": "#N/A", - "=SUMIFS(D20:D23,A2:A13,\">2\",C2:C13,\"Jeff\")": "#VALUE!", + calcError := map[string][]string{ + "=AVERAGEIFS()": {"#VALUE!", "AVERAGEIFS requires at least 3 arguments"}, + "=AVERAGEIFS(H1,\"\")": {"#VALUE!", "AVERAGEIFS requires at least 3 arguments"}, + "=AVERAGEIFS(H1,\"\",TRUE,1)": {"#N/A", "#N/A"}, + "=AVERAGEIFS(H1,\"\",TRUE)": {"#DIV/0!", "AVERAGEIF divide by zero"}, + "=SUMIFS()": {"#VALUE!", "SUMIFS requires at least 3 arguments"}, + "=SUMIFS(D2:D13,A2:A13,1,B2:B13)": {"#N/A", "#N/A"}, + "=SUMIFS(D20:D23,A2:A13,\">2\",C2:C13,\"Jeff\")": {"#VALUE!", "#VALUE!"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "E1", formula)) result, err := f.CalcCellValue("Sheet1", "E1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -5176,20 +5177,20 @@ func TestCalcXIRR(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=XIRR()": "XIRR requires 2 or 3 arguments", - "=XIRR(A1:A4,B1:B4,-1)": "XIRR requires guess > -1", - "=XIRR(\"\",B1:B4)": "#NUM!", - "=XIRR(A1:A4,\"\")": "#NUM!", - "=XIRR(A1:A4,B1:B4,\"\")": "#NUM!", - "=XIRR(A2:A6,B2:B6)": "#NUM!", - "=XIRR(A2:A7,B2:B7)": "#NUM!", + calcError := map[string][]string{ + "=XIRR()": {"#VALUE!", "XIRR requires 2 or 3 arguments"}, + "=XIRR(A1:A4,B1:B4,-1)": {"#VALUE!", "XIRR requires guess > -1"}, + "=XIRR(\"\",B1:B4)": {"#NUM!", "#NUM!"}, + "=XIRR(A1:A4,\"\")": {"#NUM!", "#NUM!"}, + "=XIRR(A1:A4,B1:B4,\"\")": {"#NUM!", "#NUM!"}, + "=XIRR(A2:A6,B2:B6)": {"#NUM!", "#NUM!"}, + "=XIRR(A2:A7,B2:B7)": {"#NUM!", "#NUM!"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula)) result, err := f.CalcCellValue("Sheet1", "C1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -5230,25 +5231,25 @@ func TestCalcXLOOKUP(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=XLOOKUP()": "XLOOKUP requires at least 3 arguments", - "=XLOOKUP($C3,$C5:$C5,$C6:$C17,NA(),0,2,1)": "XLOOKUP allows at most 6 arguments", - "=XLOOKUP($C3,$C5,$C6,NA(),0,2)": "#N/A", - "=XLOOKUP(\"?\",B2:B9,C2:C9,NA(),2)": "#N/A", - "=XLOOKUP($C3,$C4:$D5,$C6:$C17,NA(),0,2)": "#VALUE!", - "=XLOOKUP($C3,$C5:$C5,$C6:$G17,NA(),0,-2)": "#VALUE!", - "=XLOOKUP($C3,$C5:$G5,$C6:$F7,NA(),0,2)": "#VALUE!", - "=XLOOKUP(D2,$B6:$B17,$C6:$G16,NA(),0,2)": "#VALUE!", - "=XLOOKUP(D2,$B6:$B17,$C6:$G17,NA(),3,2)": "#VALUE!", - "=XLOOKUP(D2,$B6:$B17,$C6:$G17,NA(),0,0)": "#VALUE!", - "=XLOOKUP(D2,$B6:$B17,$C6:$G17,NA(),\"\",2)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=XLOOKUP(D2,$B6:$B17,$C6:$G17,NA(),0,\"\")": "strconv.ParseFloat: parsing \"\": invalid syntax", + calcError := map[string][]string{ + "=XLOOKUP()": {"#VALUE!", "XLOOKUP requires at least 3 arguments"}, + "=XLOOKUP($C3,$C5:$C5,$C6:$C17,NA(),0,2,1)": {"#VALUE!", "XLOOKUP allows at most 6 arguments"}, + "=XLOOKUP($C3,$C5,$C6,NA(),0,2)": {"#N/A", "#N/A"}, + "=XLOOKUP(\"?\",B2:B9,C2:C9,NA(),2)": {"#N/A", "#N/A"}, + "=XLOOKUP($C3,$C4:$D5,$C6:$C17,NA(),0,2)": {"#VALUE!", "#VALUE!"}, + "=XLOOKUP($C3,$C5:$C5,$C6:$G17,NA(),0,-2)": {"#VALUE!", "#VALUE!"}, + "=XLOOKUP($C3,$C5:$G5,$C6:$F7,NA(),0,2)": {"#VALUE!", "#VALUE!"}, + "=XLOOKUP(D2,$B6:$B17,$C6:$G16,NA(),0,2)": {"#VALUE!", "#VALUE!"}, + "=XLOOKUP(D2,$B6:$B17,$C6:$G17,NA(),3,2)": {"#VALUE!", "#VALUE!"}, + "=XLOOKUP(D2,$B6:$B17,$C6:$G17,NA(),0,0)": {"#VALUE!", "#VALUE!"}, + "=XLOOKUP(D2,$B6:$B17,$C6:$G17,NA(),\"\",2)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=XLOOKUP(D2,$B6:$B17,$C6:$G17,NA(),0,\"\")": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "D3", formula)) result, err := f.CalcCellValue("Sheet1", "D3") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } cellData = [][]interface{}{ @@ -5289,15 +5290,15 @@ func TestCalcXLOOKUP(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError = map[string]string{ + calcError = map[string][]string{ // Test match mode with exact match - "=XLOOKUP(\"*p*\",B2:B9,C2:C9,NA(),0)": "#N/A", + "=XLOOKUP(\"*p*\",B2:B9,C2:C9,NA(),0)": {"#N/A", "#N/A"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "D3", formula)) result, err := f.CalcCellValue("Sheet1", "D3") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -5324,22 +5325,22 @@ func TestCalcXNPV(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=XNPV()": "XNPV requires 3 arguments", - "=XNPV(\"\",B2:B7,A2:A7)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=XNPV(0,B2:B7,A2:A7)": "XNPV requires rate > 0", - "=XNPV(B1,\"\",A2:A7)": "#NUM!", - "=XNPV(B1,B2:B7,\"\")": "#NUM!", - "=XNPV(B1,B2:B7,C2:C7)": "#NUM!", - "=XNPV(B1,B2,A2)": "#NUM!", - "=XNPV(B1,B2:B3,A2:A5)": "#NUM!", - "=XNPV(B1,B2:B3,A9:A10)": "#VALUE!", + calcError := map[string][]string{ + "=XNPV()": {"#VALUE!", "XNPV requires 3 arguments"}, + "=XNPV(\"\",B2:B7,A2:A7)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=XNPV(0,B2:B7,A2:A7)": {"#VALUE!", "XNPV requires rate > 0"}, + "=XNPV(B1,\"\",A2:A7)": {"#NUM!", "#NUM!"}, + "=XNPV(B1,B2:B7,\"\")": {"#NUM!", "#NUM!"}, + "=XNPV(B1,B2:B7,C2:C7)": {"#NUM!", "#NUM!"}, + "=XNPV(B1,B2,A2)": {"#NUM!", "#NUM!"}, + "=XNPV(B1,B2:B3,A2:A5)": {"#NUM!", "#NUM!"}, + "=XNPV(B1,B2:B3,A9:A10)": {"#VALUE!", "#VALUE!"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula)) result, err := f.CalcCellValue("Sheet1", "C1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -5380,7 +5381,7 @@ func TestCalcMATCH(t *testing.T) { assert.NoError(t, f.SetCellFormula("Sheet1", "E1", formula)) result, err := f.CalcCellValue("Sheet1", "E1") assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected, result, formula) } assert.Equal(t, newErrorFormulaArg(formulaErrorNA, formulaErrorNA), calcMatch(2, nil, []formulaArg{})) } @@ -5423,22 +5424,22 @@ func TestCalcMODE(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=MODE()": "MODE requires at least 1 argument", - "=MODE(0,\"\")": "#VALUE!", - "=MODE(D1:D3)": "#N/A", - "=MODE.MULT()": "MODE.MULT requires at least 1 argument", - "=MODE.MULT(0,\"\")": "#VALUE!", - "=MODE.MULT(D1:D3)": "#N/A", - "=MODE.SNGL()": "MODE.SNGL requires at least 1 argument", - "=MODE.SNGL(0,\"\")": "#VALUE!", - "=MODE.SNGL(D1:D3)": "#N/A", + calcError := map[string][]string{ + "=MODE()": {"#VALUE!", "MODE requires at least 1 argument"}, + "=MODE(0,\"\")": {"#VALUE!", "#VALUE!"}, + "=MODE(D1:D3)": {"#N/A", "#N/A"}, + "=MODE.MULT()": {"#VALUE!", "MODE.MULT requires at least 1 argument"}, + "=MODE.MULT(0,\"\")": {"#VALUE!", "#VALUE!"}, + "=MODE.MULT(D1:D3)": {"#N/A", "#N/A"}, + "=MODE.SNGL()": {"#VALUE!", "MODE.SNGL requires at least 1 argument"}, + "=MODE.SNGL(0,\"\")": {"#VALUE!", "#VALUE!"}, + "=MODE.SNGL(D1:D3)": {"#N/A", "#N/A"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula)) result, err := f.CalcCellValue("Sheet1", "C1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -5582,16 +5583,16 @@ func TestCalcSTEY(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=STEYX()": "STEYX requires 2 arguments", - "=STEYX(B2:B11,A1:A9)": "#N/A", - "=STEYX(B2,A2)": "#DIV/0!", + calcError := map[string][]string{ + "=STEYX()": {"#VALUE!", "STEYX requires 2 arguments"}, + "=STEYX(B2:B11,A1:A9)": {"#N/A", "#N/A"}, + "=STEYX(B2,A2)": {"#DIV/0!", "#DIV/0!"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula)) result, err := f.CalcCellValue("Sheet1", "C1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -5631,37 +5632,37 @@ func TestCalcTTEST(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=TTEST()": "TTEST requires 4 arguments", - "=TTEST(\"\",B1:B12,1,1)": "#NUM!", - "=TTEST(A1:A12,\"\",1,1)": "#NUM!", - "=TTEST(A1:A12,B1:B12,\"\",1)": "#VALUE!", - "=TTEST(A1:A12,B1:B12,1,\"\")": "#VALUE!", - "=TTEST(A1:A12,B1:B12,0,1)": "#NUM!", - "=TTEST(A1:A12,B1:B12,1,0)": "#NUM!", - "=TTEST(A1:A2,B1:B1,1,1)": "#N/A", - "=TTEST(A13:A14,B13:B14,1,1)": "#NUM!", - "=TTEST(A12:A13,B12:B13,1,1)": "#DIV/0!", - "=TTEST(A13:A14,B13:B14,1,2)": "#NUM!", - "=TTEST(D1:D4,E1:E4,1,3)": "#NUM!", - "=T.TEST()": "T.TEST requires 4 arguments", - "=T.TEST(\"\",B1:B12,1,1)": "#NUM!", - "=T.TEST(A1:A12,\"\",1,1)": "#NUM!", - "=T.TEST(A1:A12,B1:B12,\"\",1)": "#VALUE!", - "=T.TEST(A1:A12,B1:B12,1,\"\")": "#VALUE!", - "=T.TEST(A1:A12,B1:B12,0,1)": "#NUM!", - "=T.TEST(A1:A12,B1:B12,1,0)": "#NUM!", - "=T.TEST(A1:A2,B1:B1,1,1)": "#N/A", - "=T.TEST(A13:A14,B13:B14,1,1)": "#NUM!", - "=T.TEST(A12:A13,B12:B13,1,1)": "#DIV/0!", - "=T.TEST(A13:A14,B13:B14,1,2)": "#NUM!", - "=T.TEST(D1:D4,E1:E4,1,3)": "#NUM!", + calcError := map[string][]string{ + "=TTEST()": {"#VALUE!", "TTEST requires 4 arguments"}, + "=TTEST(\"\",B1:B12,1,1)": {"#NUM!", "#NUM!"}, + "=TTEST(A1:A12,\"\",1,1)": {"#NUM!", "#NUM!"}, + "=TTEST(A1:A12,B1:B12,\"\",1)": {"#VALUE!", "#VALUE!"}, + "=TTEST(A1:A12,B1:B12,1,\"\")": {"#VALUE!", "#VALUE!"}, + "=TTEST(A1:A12,B1:B12,0,1)": {"#NUM!", "#NUM!"}, + "=TTEST(A1:A12,B1:B12,1,0)": {"#NUM!", "#NUM!"}, + "=TTEST(A1:A2,B1:B1,1,1)": {"#N/A", "#N/A"}, + "=TTEST(A13:A14,B13:B14,1,1)": {"#NUM!", "#NUM!"}, + "=TTEST(A12:A13,B12:B13,1,1)": {"#DIV/0!", "#DIV/0!"}, + "=TTEST(A13:A14,B13:B14,1,2)": {"#NUM!", "#NUM!"}, + "=TTEST(D1:D4,E1:E4,1,3)": {"#NUM!", "#NUM!"}, + "=T.TEST()": {"#VALUE!", "T.TEST requires 4 arguments"}, + "=T.TEST(\"\",B1:B12,1,1)": {"#NUM!", "#NUM!"}, + "=T.TEST(A1:A12,\"\",1,1)": {"#NUM!", "#NUM!"}, + "=T.TEST(A1:A12,B1:B12,\"\",1)": {"#VALUE!", "#VALUE!"}, + "=T.TEST(A1:A12,B1:B12,1,\"\")": {"#VALUE!", "#VALUE!"}, + "=T.TEST(A1:A12,B1:B12,0,1)": {"#NUM!", "#NUM!"}, + "=T.TEST(A1:A12,B1:B12,1,0)": {"#NUM!", "#NUM!"}, + "=T.TEST(A1:A2,B1:B1,1,1)": {"#N/A", "#N/A"}, + "=T.TEST(A13:A14,B13:B14,1,1)": {"#NUM!", "#NUM!"}, + "=T.TEST(A12:A13,B12:B13,1,1)": {"#DIV/0!", "#DIV/0!"}, + "=T.TEST(A13:A14,B13:B14,1,2)": {"#NUM!", "#NUM!"}, + "=T.TEST(D1:D4,E1:E4,1,3)": {"#NUM!", "#NUM!"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula)) result, err := f.CalcCellValue("Sheet1", "C1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } } @@ -5735,41 +5736,41 @@ func TestCalcNETWORKDAYSandWORKDAY(t *testing.T) { assert.NoError(t, err, formula) assert.Equal(t, expected, result, formula) } - calcError := map[string]string{ - "=NETWORKDAYS()": "NETWORKDAYS requires at least 2 arguments", - "=NETWORKDAYS(\"01/01/2020\",\"09/12/2020\",2,\"\")": "NETWORKDAYS requires at most 3 arguments", - "=NETWORKDAYS(\"\",\"09/12/2020\",2)": "#VALUE!", - "=NETWORKDAYS(\"01/01/2020\",\"\",2)": "#VALUE!", - "=NETWORKDAYS.INTL()": "NETWORKDAYS.INTL requires at least 2 arguments", - "=NETWORKDAYS.INTL(\"01/01/2020\",\"09/12/2020\",4,A1:A12,\"\")": "NETWORKDAYS.INTL requires at most 4 arguments", - "=NETWORKDAYS.INTL(\"01/01/2020\",\"January 25, 100\",4)": "#VALUE!", - "=NETWORKDAYS.INTL(\"\",123,4,B1:B12)": "#VALUE!", - "=NETWORKDAYS.INTL(\"01/01/2020\",123,\"000000x\")": "#VALUE!", - "=NETWORKDAYS.INTL(\"01/01/2020\",123,\"0000002\")": "#VALUE!", - "=NETWORKDAYS.INTL(\"January 25, 100\",123)": "#VALUE!", - "=NETWORKDAYS.INTL(\"01/01/2020\",\"09/12/2020\",8)": "#VALUE!", - "=NETWORKDAYS.INTL(-1,123)": "#NUM!", - "=WORKDAY()": "WORKDAY requires at least 2 arguments", - "=WORKDAY(\"01/01/2020\",123,A1:A12,\"\")": "WORKDAY requires at most 3 arguments", - "=WORKDAY(\"01/01/2020\",\"\",B1:B12)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=WORKDAY(\"\",123,B1:B12)": "#VALUE!", - "=WORKDAY(\"January 25, 100\",123)": "#VALUE!", - "=WORKDAY(-1,123)": "#NUM!", - "=WORKDAY.INTL()": "WORKDAY.INTL requires at least 2 arguments", - "=WORKDAY.INTL(\"01/01/2020\",123,4,A1:A12,\"\")": "WORKDAY.INTL requires at most 4 arguments", - "=WORKDAY.INTL(\"01/01/2020\",\"\",4,B1:B12)": "strconv.ParseFloat: parsing \"\": invalid syntax", - "=WORKDAY.INTL(\"\",123,4,B1:B12)": "#VALUE!", - "=WORKDAY.INTL(\"01/01/2020\",123,\"\",B1:B12)": "#VALUE!", - "=WORKDAY.INTL(\"01/01/2020\",123,\"000000x\")": "#VALUE!", - "=WORKDAY.INTL(\"01/01/2020\",123,\"0000002\")": "#VALUE!", - "=WORKDAY.INTL(\"January 25, 100\",123)": "#VALUE!", - "=WORKDAY.INTL(-1,123)": "#NUM!", + calcError := map[string][]string{ + "=NETWORKDAYS()": {"#VALUE!", "NETWORKDAYS requires at least 2 arguments"}, + "=NETWORKDAYS(\"01/01/2020\",\"09/12/2020\",2,\"\")": {"#VALUE!", "NETWORKDAYS requires at most 3 arguments"}, + "=NETWORKDAYS(\"\",\"09/12/2020\",2)": {"#VALUE!", "#VALUE!"}, + "=NETWORKDAYS(\"01/01/2020\",\"\",2)": {"#VALUE!", "#VALUE!"}, + "=NETWORKDAYS.INTL()": {"#VALUE!", "NETWORKDAYS.INTL requires at least 2 arguments"}, + "=NETWORKDAYS.INTL(\"01/01/2020\",\"09/12/2020\",4,A1:A12,\"\")": {"#VALUE!", "NETWORKDAYS.INTL requires at most 4 arguments"}, + "=NETWORKDAYS.INTL(\"01/01/2020\",\"January 25, 100\",4)": {"#VALUE!", "#VALUE!"}, + "=NETWORKDAYS.INTL(\"\",123,4,B1:B12)": {"#VALUE!", "#VALUE!"}, + "=NETWORKDAYS.INTL(\"01/01/2020\",123,\"000000x\")": {"#VALUE!", "#VALUE!"}, + "=NETWORKDAYS.INTL(\"01/01/2020\",123,\"0000002\")": {"#VALUE!", "#VALUE!"}, + "=NETWORKDAYS.INTL(\"January 25, 100\",123)": {"#VALUE!", "#VALUE!"}, + "=NETWORKDAYS.INTL(\"01/01/2020\",\"09/12/2020\",8)": {"#VALUE!", "#VALUE!"}, + "=NETWORKDAYS.INTL(-1,123)": {"#NUM!", "#NUM!"}, + "=WORKDAY()": {"#VALUE!", "WORKDAY requires at least 2 arguments"}, + "=WORKDAY(\"01/01/2020\",123,A1:A12,\"\")": {"#VALUE!", "WORKDAY requires at most 3 arguments"}, + "=WORKDAY(\"01/01/2020\",\"\",B1:B12)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=WORKDAY(\"\",123,B1:B12)": {"#VALUE!", "#VALUE!"}, + "=WORKDAY(\"January 25, 100\",123)": {"#VALUE!", "#VALUE!"}, + "=WORKDAY(-1,123)": {"#NUM!", "#NUM!"}, + "=WORKDAY.INTL()": {"#VALUE!", "WORKDAY.INTL requires at least 2 arguments"}, + "=WORKDAY.INTL(\"01/01/2020\",123,4,A1:A12,\"\")": {"#VALUE!", "WORKDAY.INTL requires at most 4 arguments"}, + "=WORKDAY.INTL(\"01/01/2020\",\"\",4,B1:B12)": {"#VALUE!", "strconv.ParseFloat: parsing \"\": invalid syntax"}, + "=WORKDAY.INTL(\"\",123,4,B1:B12)": {"#VALUE!", "#VALUE!"}, + "=WORKDAY.INTL(\"01/01/2020\",123,\"\",B1:B12)": {"#VALUE!", "#VALUE!"}, + "=WORKDAY.INTL(\"01/01/2020\",123,\"000000x\")": {"#VALUE!", "#VALUE!"}, + "=WORKDAY.INTL(\"01/01/2020\",123,\"0000002\")": {"#VALUE!", "#VALUE!"}, + "=WORKDAY.INTL(\"January 25, 100\",123)": {"#VALUE!", "#VALUE!"}, + "=WORKDAY.INTL(-1,123)": {"#NUM!", "#NUM!"}, } for formula, expected := range calcError { assert.NoError(t, f.SetCellFormula("Sheet1", "C1", formula)) result, err := f.CalcCellValue("Sheet1", "C1") - assert.EqualError(t, err, expected, formula) - assert.Equal(t, "", result, formula) + assert.Equal(t, expected[0], result, formula) + assert.EqualError(t, err, expected[1], formula) } }