1import {
   2  ABS,
   3  ACOS,
   4  ACOSH,
   5  ACOTH,
   6  ASIN,
   7  ASINH,
   8  ATAN,
   9  ATAN2,
  10  ATANH,
  11  COT,
  12  COTH,
  13  COSH,
  14  COS,
  15  COUNTUNIQUE,
  16  EVEN,
  17  ERF,
  18  ERFC,
  19  INT,
  20  ISEVEN,
  21  ISODD,
  22  MULTIPLY,
  23  MOD,
  24  ODD,
  25  SIN,
  26  SINH,
  27  SUM,
  28  SQRT,
  29  SQRTPI,
  30  PI,
  31  POWER,
  32  LOG,
  33  LOG10,
  34  LN,
  35  TAN,
  36  TANH,
  37  ROUND,
  38  ROUNDDOWN,
  39  ROUNDUP,
  40  SUMPRODUCT,
  41  SUMIF,
  42  SUMSQ,
  43  SUMX2MY2,
  44  SUMX2PY2,
  45  FLOOR,
  46  IF,
  47  COUNTIF,
  48  COUNTIFS,
  49  CEILING,
  50  TRUNC,
  51  RADIANS,
  52  DEGREES,
  53  COMBIN,
  54  MINUS,
  55  RAND,
  56  RANDBETWEEN,
  57  SIGN,
  58  DIVIDE,
  59  EQ,
  60  GT,
  61  GTE,
  62  LT,
  63  LTE,
  64  NE,
  65  GCD,
  66  LCM,
  67  GAMMALN,
  68  PRODUCT,
  69  QUOTIENT,
  70  UPLUS,
  71  UMINUS,
  72  MROUND,
  73  FACTDOUBLE,
  74  UNARY_PERCENT,
  75  MULTINOMIAL,
  76  SERIESSUM,
  77  SUBTOTAL
  78} from "../../src/Formulas/Math";
  79import * as ERRORS from "../../src/Errors";
  80import {
  81  assertEquals,
  82  catchAndAssertEquals,
  83  test
  84} from "../Utils/Asserts";
  85
  86
  87test("MROUND", function(){
  88  assertEquals(MROUND(4.12121, 22), 0);
  89  assertEquals(MROUND(10, 0), 0);
  90  assertEquals(MROUND(10, 2), 10);
  91  assertEquals(MROUND(21, 14), 28);
  92  catchAndAssertEquals(function() {
  93    MROUND.apply(this, [10]);
  94  }, ERRORS.NA_ERROR);
  95  catchAndAssertEquals(function() {
  96    MROUND.apply(this, [10, 1, 1]);
  97  }, ERRORS.NA_ERROR);
  98});
  99
 100
 101test("FACTDOUBLE", function(){
 102  assertEquals(FACTDOUBLE(7), 105);
 103  assertEquals(FACTDOUBLE(6), 48);
 104  assertEquals(FACTDOUBLE(3), 3);
 105  catchAndAssertEquals(function() {
 106    FACTDOUBLE(-1);
 107  }, ERRORS.NUM_ERROR);
 108  catchAndAssertEquals(function() {
 109    FACTDOUBLE.apply(this, []);
 110  }, ERRORS.NA_ERROR);
 111  catchAndAssertEquals(function() {
 112    FACTDOUBLE.apply(this, [10, 10]);
 113  }, ERRORS.NA_ERROR);
 114});
 115
 116
 117test("GAMMALN", function(){
 118  assertEquals(GAMMALN(4.5), 2.453736570842444);
 119  assertEquals(GAMMALN(3), 0.6931471805599443);
 120  catchAndAssertEquals(function() {
 121    GAMMALN(0)
 122  }, ERRORS.NUM_ERROR);
 123  catchAndAssertEquals(function() {
 124    GAMMALN.apply(this, []);
 125  }, ERRORS.NA_ERROR);
 126  catchAndAssertEquals(function() {
 127    GAMMALN.apply(this, [10, 10]);
 128  }, ERRORS.NA_ERROR);
 129});
 130
 131
 132test("LCM", function(){
 133  assertEquals(LCM(2, 5), 10);
 134  assertEquals(LCM(10, 100), 100);
 135  assertEquals(LCM(12, 18), 36);
 136  assertEquals(LCM(12, 18, 24), 72);
 137  catchAndAssertEquals(function() {
 138    LCM.apply(this, []);
 139  }, ERRORS.NA_ERROR);
 140});
 141
 142
 143test("UPLUS", function(){
 144  assertEquals(UPLUS(2), 2);
 145  assertEquals(UPLUS(false), false);
 146  assertEquals(UPLUS([1, 2, 3]), 1);
 147  assertEquals(UPLUS("hello"), "hello");
 148  catchAndAssertEquals(function() {
 149    UPLUS.apply(this, []);
 150  }, ERRORS.NA_ERROR);
 151});
 152
 153
 154test("UMINUS", function(){
 155  assertEquals(UMINUS(2), -2);
 156  assertEquals(UMINUS(-1), 1);
 157  assertEquals(UMINUS(false), 0);
 158  assertEquals(UMINUS(0), 0);
 159  assertEquals(UMINUS([1, 2, 3]), -1);
 160  catchAndAssertEquals(function() {
 161    UMINUS.apply(this, []);
 162  }, ERRORS.NA_ERROR);
 163});
 164
 165
 166test("PRODUCT", function(){
 167  assertEquals(PRODUCT(2, 5), 10);
 168  assertEquals(PRODUCT(2, 5, 4, 2, 8, 1, 77, 2, 3, 1), 295680);
 169  assertEquals(PRODUCT(2, 5, 4, 2, 8, [1, 77, 2], 3, 1), 295680);
 170  assertEquals(PRODUCT(0, 1), 0);
 171  assertEquals(PRODUCT(8, "1992/2/2"), 269088);
 172  catchAndAssertEquals(function() {
 173    PRODUCT.apply(this, [1, [], 1]);
 174  }, ERRORS.REF_ERROR);
 175  catchAndAssertEquals(function() {
 176    PRODUCT.apply(this, [1]);
 177  }, ERRORS.NA_ERROR);
 178  catchAndAssertEquals(function() {
 179    PRODUCT.apply(this, []);
 180  }, ERRORS.NA_ERROR);
 181});
 182
 183
 184test("QUOTIENT", function(){
 185  assertEquals(QUOTIENT(2, 2), 1);
 186  assertEquals(QUOTIENT(4, 2), 2);
 187  catchAndAssertEquals(function() {
 188    QUOTIENT(1, 0);
 189  }, ERRORS.DIV_ZERO_ERROR);
 190  catchAndAssertEquals(function() {
 191    QUOTIENT.apply(this, [1]);
 192  }, ERRORS.NA_ERROR);
 193  catchAndAssertEquals(function() {
 194    QUOTIENT.apply(this, [1, 2, 3]);
 195  }, ERRORS.NA_ERROR);
 196});
 197
 198
 199test("GCD", function(){
 200  assertEquals(GCD(10, 100), 10);
 201  assertEquals(GCD(22, 44), 22);
 202  assertEquals(GCD(18, 24), 6);
 203  assertEquals(GCD(7, 9), 1);
 204  assertEquals(GCD(14, 21, 42), 7);
 205  catchAndAssertEquals(function() {
 206    GCD.apply(this, []);
 207  }, ERRORS.NA_ERROR);
 208});
 209
 210
 211test("ABS", function(){
 212  assertEquals(ABS(-10), 10);
 213  assertEquals(ABS(-10.111), 10.111);
 214  assertEquals(ABS(0), 0);
 215  assertEquals(ABS(false), 0);
 216  assertEquals(ABS("-44"), 44);
 217  catchAndAssertEquals(function() {
 218    ABS.apply(this, []);
 219  }, ERRORS.NA_ERROR);
 220  catchAndAssertEquals(function() {
 221    ABS.apply(this, ["str"]);
 222  }, ERRORS.VALUE_ERROR);
 223});
 224
 225
 226test("ACOS", function(){
 227  assertEquals(ACOS(0), 1.5707963267948966);
 228  assertEquals(ACOS(-1), 3.141592653589793);
 229  assertEquals(ACOS(1), 0);
 230  assertEquals(ACOS("-1"), 3.141592653589793);
 231  assertEquals(ACOS(false), 1.5707963267948966);
 232  catchAndAssertEquals(function() {
 233    ACOS("str");
 234  }, ERRORS.VALUE_ERROR);
 235  catchAndAssertEquals(function() {
 236    ACOS(2);
 237  }, ERRORS.NUM_ERROR);
 238  catchAndAssertEquals(function() {
 239    ACOS.apply(this, []);
 240  }, ERRORS.NA_ERROR);
 241});
 242
 243
 244test("ACOSH", function(){
 245  assertEquals(ACOSH(22), 3.783672704329451);
 246  assertEquals(ACOSH(1), 0);
 247  assertEquals(ACOSH("11"), 3.0889699048446033);
 248  catchAndAssertEquals(function() {
 249    ACOSH(-1);
 250  }, ERRORS.NUM_ERROR);
 251  catchAndAssertEquals(function() {
 252    ACOSH("str");
 253  }, ERRORS.VALUE_ERROR);
 254  catchAndAssertEquals(function() {
 255    ACOSH(false);
 256  }, ERRORS.NUM_ERROR);
 257  catchAndAssertEquals(function() {
 258    ACOSH.apply(this, []);
 259  }, ERRORS.NA_ERROR);
 260});
 261
 262
 263test("ACOTH", function(){
 264  assertEquals(ACOTH(22), 0.04548588910286339);
 265  assertEquals(ACOTH(-1.1), -1.522261218861711);
 266  assertEquals(ACOTH("-22"), -0.04548588910286338);
 267  catchAndAssertEquals(function() {
 268    ACOTH(-1);
 269  }, ERRORS.NUM_ERROR);
 270  catchAndAssertEquals(function() {
 271    ACOTH("str");
 272  }, ERRORS.VALUE_ERROR);
 273  catchAndAssertEquals(function() {
 274    ACOTH(false);
 275  }, ERRORS.NUM_ERROR);
 276  catchAndAssertEquals(function() {
 277    ACOTH.apply(this, []);
 278  }, ERRORS.NA_ERROR);
 279});
 280
 281
 282test("ASIN", function(){
 283  assertEquals(ASIN(0), 0);
 284  assertEquals(ASIN(1), 1.5707963267948966);
 285  assertEquals(ASIN("1"), 1.5707963267948966);
 286  assertEquals(ASIN(false), 0);
 287  catchAndAssertEquals(function() {
 288    ASIN(2);
 289  }, ERRORS.NUM_ERROR);
 290  catchAndAssertEquals(function() {
 291    ASIN("str");
 292  }, ERRORS.VALUE_ERROR);
 293  catchAndAssertEquals(function() {
 294    ASIN.apply(this, []);
 295  }, ERRORS.NA_ERROR);
 296});
 297
 298
 299test("ASINH", function(){
 300  assertEquals(ASINH(1), 0.8813735870195429);
 301  assertEquals(ASINH(0), 0);
 302  assertEquals(ASINH("1"), 0.8813735870195429);
 303  assertEquals(ASINH(false), 0);
 304  assertEquals(ASINH(true), 0.8813735870195429);
 305  catchAndAssertEquals(function() {
 306    ASINH("str");
 307  }, ERRORS.VALUE_ERROR);
 308  catchAndAssertEquals(function() {
 309    ASINH.apply(this, []);
 310  }, ERRORS.NA_ERROR);
 311});
 312
 313
 314test("ATAN", function(){
 315  assertEquals(ATAN(1), 0.7853981633974483);
 316  assertEquals(ATAN(0), 0);
 317  assertEquals(ATAN("1"), 0.7853981633974483);
 318  assertEquals(ATAN(false), 0);
 319  assertEquals(ATAN(true), 0.7853981633974483);
 320  catchAndAssertEquals(function() {
 321    ATAN("str");
 322  }, ERRORS.VALUE_ERROR);
 323  catchAndAssertEquals(function() {
 324    ATAN.apply(this, []);
 325  }, ERRORS.NA_ERROR);
 326});
 327
 328
 329test("ATAN2", function(){
 330  assertEquals(ATAN2(4, 3), 0.6435011087932844);
 331  assertEquals(ATAN2(-1, -1), -2.356194490192345);
 332  catchAndAssertEquals(function() {
 333    ATAN2(0, 0);
 334  }, ERRORS.DIV_ZERO_ERROR);
 335  assertEquals(ATAN2(1, 0), 0);
 336  assertEquals(ATAN2(0, 1), 1.5707963267948966);
 337  assertEquals(ATAN2(-1, "-1"), -2.356194490192345);
 338  assertEquals(ATAN2(true, false), 0);
 339  assertEquals(ATAN2(true, true), 0.7853981633974483);
 340  catchAndAssertEquals(function() {
 341    ATAN2("str", false);
 342  }, ERRORS.VALUE_ERROR);
 343  catchAndAssertEquals(function() {
 344    ATAN2.apply(this, []);
 345  }, ERRORS.NA_ERROR);
 346});
 347
 348
 349test("ATANH", function(){
 350  assertEquals(ATANH(0.51), 0.5627297693521489);
 351  assertEquals(ATANH(0.44), 0.4722308044204257);
 352  assertEquals(ATANH(0), 0);
 353  assertEquals(ATANH("0.1"), 0.10033534773107558);
 354  assertEquals(ATANH(false), 0);
 355  catchAndAssertEquals(function() {
 356    ATANH(true);
 357  }, ERRORS.NUM_ERROR);
 358  catchAndAssertEquals(function() {
 359    ATANH("str");
 360  }, ERRORS.VALUE_ERROR);
 361});
 362
 363
 364test("CEILING", function(){
 365  assertEquals(CEILING(10.1), 11);
 366  assertEquals(CEILING("10.1"), 11);
 367  assertEquals(CEILING(10.11111111, 0.1), 10.2);
 368  assertEquals(CEILING(10.22222222, 0.1), 10.3);
 369  assertEquals(CEILING(10.33333333, 0.2), 10.4);
 370  assertEquals(CEILING(10.33333333, 0.1), 10.4);
 371  assertEquals(CEILING([10.33333333], 0.1), 10.4);
 372  assertEquals(CEILING(10.22222222, 5), 15);
 373  assertEquals(CEILING(10.22222222, 8), 16);
 374  assertEquals(CEILING(10.22222222, true), 11);
 375  catchAndAssertEquals(function() {
 376    CEILING(10, 0);
 377  }, ERRORS.DIV_ZERO_ERROR);
 378  catchAndAssertEquals(function() {
 379    CEILING.apply(this, [10, 1, 2]);
 380  }, ERRORS.NA_ERROR);
 381  catchAndAssertEquals(function() {
 382    CEILING.apply(this, []);
 383  }, ERRORS.NA_ERROR);
 384});
 385
 386
 387test("COMBIN", function(){
 388  assertEquals(COMBIN(4, 2), 6);
 389  assertEquals(COMBIN(4.999, 2.888), 6);
 390  assertEquals(COMBIN([4, "str"], [2]), 6);
 391  assertEquals(COMBIN(0, 0), 1);
 392  catchAndAssertEquals(function() {
 393    COMBIN(2, "str");
 394  }, ERRORS.VALUE_ERROR);
 395  catchAndAssertEquals(function() {
 396    COMBIN(2, []);
 397  }, ERRORS.REF_ERROR);
 398  catchAndAssertEquals(function() {
 399    COMBIN(2, 4);
 400  }, ERRORS.NUM_ERROR);
 401  catchAndAssertEquals(function() {
 402    COMBIN(0, 1);
 403  }, ERRORS.NUM_ERROR);
 404  catchAndAssertEquals(function() {
 405    COMBIN.apply(this, []);
 406  }, ERRORS.NA_ERROR);
 407  catchAndAssertEquals(function() {
 408    COMBIN.apply(this, [4]);
 409  }, ERRORS.NA_ERROR);
 410  catchAndAssertEquals(function() {
 411    COMBIN.apply(this, [4, 2, 66]);
 412  }, ERRORS.NA_ERROR);
 413});
 414
 415
 416test("COS", function(){
 417  assertEquals(COS(PI()), -1);
 418  assertEquals(COS(1), 0.5403023058681398);
 419  assertEquals(COS(false), 1);
 420  assertEquals(COS(true), 0.5403023058681398);
 421  assertEquals(COS(""), 1);
 422  assertEquals(COS("0"), 1);
 423  catchAndAssertEquals(function() {
 424    COS("str");
 425  }, ERRORS.VALUE_ERROR);
 426  catchAndAssertEquals(function() {
 427    COS.apply(this, []);
 428  }, ERRORS.NA_ERROR);
 429  catchAndAssertEquals(function() {
 430    COS.apply(this, [1, 1]);
 431  }, ERRORS.NA_ERROR);
 432  assertEquals(COS([0, "str"]), 1);
 433});
 434
 435
 436test("COSH", function(){
 437  assertEquals(COSH(PI()), 11.591953275521519);
 438  assertEquals(COSH(1), 1.5430806348152437);
 439  assertEquals(COSH(false), 1);
 440  assertEquals(COSH(0), 1);
 441  assertEquals(COSH(true), 1.5430806348152437);
 442  assertEquals(COSH(""), 1);
 443  assertEquals(COSH([0, "str"]), 1);
 444  catchAndAssertEquals(function() {
 445    COSH("str");
 446  }, ERRORS.VALUE_ERROR);
 447  catchAndAssertEquals(function() {
 448    COSH.apply(this, []);
 449  }, ERRORS.NA_ERROR);
 450  catchAndAssertEquals(function() {
 451    COSH.apply(this, [1, 1]);
 452  }, ERRORS.NA_ERROR);
 453});
 454
 455
 456test("COT", function(){
 457  assertEquals(COT(30), -0.15611995216165922);
 458  assertEquals(COT(1), 0.6420926159343306);
 459  assertEquals(COT(true), 0.6420926159343306);
 460  assertEquals(COT([1, "str"]), 0.6420926159343306);
 461  catchAndAssertEquals(function() {
 462    COT(false);
 463  }, ERRORS.DIV_ZERO_ERROR);
 464  catchAndAssertEquals(function() {
 465    COT(0);
 466  }, ERRORS.DIV_ZERO_ERROR);
 467  catchAndAssertEquals(function() {
 468    COT("");
 469  }, ERRORS.DIV_ZERO_ERROR);
 470  catchAndAssertEquals(function() {
 471    COT("str");
 472  }, ERRORS.VALUE_ERROR);
 473  catchAndAssertEquals(function() {
 474    COT.apply(this, []);
 475  }, ERRORS.NA_ERROR);
 476  catchAndAssertEquals(function() {
 477    COT.apply(this, [1, 1]);
 478  }, ERRORS.NA_ERROR);
 479});
 480
 481
 482test("COTH", function(){
 483  assertEquals(COTH(30), 1);
 484  assertEquals(COTH(1), 1.3130352854993315);
 485  assertEquals(COTH(true), 1.3130352854993315);
 486  assertEquals(COTH([1, "str"]), 1.3130352854993315);
 487  assertEquals(COTH(-1), -1.3130352854993315);
 488  catchAndAssertEquals(function() {
 489    COTH(false);
 490  }, ERRORS.DIV_ZERO_ERROR);
 491  catchAndAssertEquals(function() {
 492    COTH(0);
 493  }, ERRORS.DIV_ZERO_ERROR);
 494  catchAndAssertEquals(function() {
 495    COTH("");
 496  }, ERRORS.DIV_ZERO_ERROR);
 497  catchAndAssertEquals(function() {
 498    COTH("str");
 499  }, ERRORS.VALUE_ERROR);
 500  catchAndAssertEquals(function() {
 501    COTH.apply(this, []);
 502  }, ERRORS.NA_ERROR);
 503  catchAndAssertEquals(function() {
 504    COTH.apply(this, [1, 1]);
 505  }, ERRORS.NA_ERROR);
 506});
 507
 508
 509test("COUNTIF", function(){
 510  assertEquals(COUNTIF(10, "= 10"), 1);
 511  assertEquals(COUNTIF([1, 5, 5, [5, 5, 5, 5], 10, 5], "= 5"), 7);
 512  assertEquals(COUNTIF([1, 5, 5, [5, 5, 5, 5], [], 10, 5], "= 5"), 7);
 513  assertEquals(COUNTIF([1, 5, 5, [5, 5, "5", "5.000"], [], 10, 5], "= 5"), 7);
 514  assertEquals(COUNTIF([1, 5, 10], ">4"), 2);
 515  assertEquals(COUNTIF([1, 2, 2, 2, 2, 2, 2, 2], ">1"), 7);
 516  assertEquals(COUNTIF([1, 5, 10], 5), 1);
 517  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], 5), 4);
 518  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], 10), 1);
 519  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], ">5"), 1);
 520  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], "=5"), 4);
 521  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], "=10"), 1);
 522  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], "=     10  "), 1);
 523  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], ">0"), 6);
 524  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], ">=5"), 5);
 525  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], "<10"), 5);
 526  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5, 44], "<=10"), 6);
 527  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], ">4.99"), 5);
 528  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], "<4.99"), 1);
 529  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], "=     1.0.0  "), 0);
 530  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], "=>5"), 0);
 531  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], "==5"), 0);
 532  assertEquals(COUNTIF(["mom", "pop", "dad", "etc", "boom"], "*o*"), 3);
 533  assertEquals(COUNTIF(["mom", "pop", "dad", "etc", "mom"], "mom"), 2);
 534  assertEquals(COUNTIF(["mom", "pop", "dad", "etc", "mom"], "?o?"), 3);
 535  assertEquals(COUNTIF(["mom", "pop", "dad", "etc", "mom"], "???"), 5);
 536  assertEquals(COUNTIF(["mom", "pop", "dad", "etc", "mom"], "????"), 0);
 537  assertEquals(COUNTIF(["mom", "pop", "dad", "etc", "mom"], "?"), 0);
 538  // dollar sign and negative values
 539  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], "=$5"), 4);
 540  assertEquals(COUNTIF([1, -5, -5, -5, 10, -5], "=-$5"), 4);
 541  assertEquals(COUNTIF([1, -5, -5, -5, 10, -5], "=-5"), 4);
 542  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], ">$5"), 1);
 543  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], "=$10"), 1);
 544  assertEquals(COUNTIF([1, 5, 5, 5, 10, 5], "=  $ 10"), 1);
 545  catchAndAssertEquals(function() {
 546    COUNTIF.apply(this, [[0, 1, 0, 1]]);
 547  }, ERRORS.NA_ERROR);
 548  catchAndAssertEquals(function() {
 549    COUNTIF.apply(this, []);
 550  }, ERRORS.NA_ERROR);
 551  catchAndAssertEquals(function() {
 552    COUNTIF.apply(this, [[], "=1", []]);
 553  }, ERRORS.NA_ERROR);
 554});
 555
 556
 557test("COUNTIFS", function(){
 558  // All COUNTIF tests should also work on COUNTIFS
 559  assertEquals(COUNTIFS([1, 5, 10], ">4"), 2);
 560  assertEquals(COUNTIFS([1, 2, 2, 2, 2, 2, 2, 2], ">1"), 7);
 561  assertEquals(COUNTIFS([1, 5, 10], 5), 1);
 562  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], 5), 4);
 563  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], 10), 1);
 564  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], ">5"), 1);
 565  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], "=5"), 4);
 566  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], "=10"), 1);
 567  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], "=     10  "), 1);
 568  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], ">0"), 6);
 569  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], ">=5"), 5);
 570  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], "<10"), 5);
 571  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5, 44], "<=10"), 6);
 572  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], ">4.99"), 5);
 573  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], "<4.99"), 1);
 574  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], "=     1.0.0  "), 0);
 575  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], "=>5"), 0);
 576  assertEquals(COUNTIFS([1, 5, 5, 5, 10, 5], "==5"), 0);
 577  assertEquals(COUNTIFS(["mom", "pop", "dad", "etc", "boom"], "*o*"), 3);
 578  assertEquals(COUNTIFS(["mom", "pop", "dad", "etc", "mom"], "mom"), 2);
 579  assertEquals(COUNTIFS(["mom", "pop", "dad", "etc", "mom"], "?o?"), 3);
 580  assertEquals(COUNTIFS(["mom", "pop", "dad", "etc", "mom"], "???"), 5);
 581  assertEquals(COUNTIFS(["mom", "pop", "dad", "etc", "mom"], "????"), 0);
 582  assertEquals(COUNTIFS(["mom", "pop", "dad", "etc", "mom"], "?"), 0);
 583  // Now actually test COUNTIFS
 584  assertEquals(COUNTIFS([1, 5, 5, [5, 5, 5, 5], 10, 5], "= 5"), 7);
 585  assertEquals(COUNTIFS([1, 5, 5, [5, 5, 5, 5], [], 10, 5], "= 5"), 7);
 586  assertEquals(COUNTIFS([1, 5, 5, [5, 5, 5, 5], [], 10, 8], "> 4", [false, false, false, [true, true, true, true], [], false, false], "= true"), 0);
 587  assertEquals(COUNTIFS([1, 5, 5, [5, 5, 5, 5], [], 10, 8], "> 4", [false, false, false, ["A", "A", "A", "A"], [], false, false], "= 'A'"), 0);
 588  assertEquals(COUNTIFS([1, 5, 5, [5, 5, 5, 5], [], 10, 8], "> 4", [1, 5, 5, [5, 5, 5, 5], [], 10, 8], "> 5"), 2);
 589  assertEquals(COUNTIFS([1, 5, 5, [5, 5, "5", "5.000"], [], 10, 5], "= 5"), 7);
 590  assertEquals(COUNTIFS([1, 5, 10, 20], ">4", [0, 0, 1, 1], "=1"), 2);
 591  assertEquals(COUNTIFS([1, 5, 10, 20], ">4", [0, 0, 1, 1], "=1"), 2);
 592  assertEquals(COUNTIFS([1, 5, 10, 20], ">4", [0, 0, 1, 1], "=1", [0, 0, 1, 1], "=1"), 2);
 593  assertEquals(COUNTIFS([1, 5, 10, 20, 40], ">4", [0, 0, 1, 1, 1], "=1", [0, 0, 0, 0, 0], "=1"), 0);
 594  assertEquals(COUNTIFS([1, 2, 3, 4], ">3", [true, true, false, true], true), 1);
 595  catchAndAssertEquals(function() {
 596    COUNTIFS([1, 5, 10, 20], ">4", [0, 0], "=1");
 597  }, ERRORS.VALUE_ERROR);
 598});
 599
 600
 601test("COUNTUNIQUE", function(){
 602  assertEquals(COUNTUNIQUE([1, 1, 10]), 2);
 603  assertEquals(COUNTUNIQUE(["1", 1, 10]), 3);
 604  assertEquals(COUNTUNIQUE(["1", 1, 10, ""]), 4);
 605  assertEquals(COUNTUNIQUE(["1", 1, 10, "", ""]), 4);
 606  assertEquals(COUNTUNIQUE(["1", 1, 10, "", " "]), 5);
 607  assertEquals(COUNTUNIQUE(["1", 1, 10, []]), 4);
 608  assertEquals(COUNTUNIQUE(["", " ", [""], []]), 2);
 609  assertEquals(COUNTUNIQUE([[""], []]), 1);
 610  catchAndAssertEquals(function() {
 611    COUNTUNIQUE.apply(this, []);
 612  }, ERRORS.NA_ERROR);
 613});
 614
 615
 616test("DEGREES", function(){
 617  assertEquals(DEGREES(PI()), 180);
 618  assertEquals(DEGREES([PI(), "str"]), 180);
 619  assertEquals(DEGREES(false), 0);
 620  assertEquals(DEGREES(true), 57.29577951308232);
 621  assertEquals(DEGREES(1), 57.29577951308232);
 622  assertEquals(DEGREES(12), 687.5493541569879);
 623  catchAndAssertEquals(function() {
 624    DEGREES("str");
 625  }, ERRORS.VALUE_ERROR);
 626  catchAndAssertEquals(function() {
 627    DEGREES.apply(this, []);
 628  }, ERRORS.NA_ERROR);
 629  catchAndAssertEquals(function() {
 630    DEGREES.apply(this, [10, 10]);
 631  }, ERRORS.NA_ERROR);
 632});
 633
 634
 635test("ERF", function(){
 636  assertEquals(ERF(2), 0.9953222650189527);
 637  assertEquals(ERF("2"), 0.9953222650189527);
 638  assertEquals(ERF(0), 1.1102230246251565e-16);
 639  assertEquals(ERF(1), 0.8427007929497149);
 640  assertEquals(ERF(true), 0.8427007929497149);
 641  assertEquals(ERF(false), 1.1102230246251565e-16);
 642  catchAndAssertEquals(function() {
 643    ERF.apply(this, []);
 644  }, ERRORS.NA_ERROR);
 645  catchAndAssertEquals(function() {
 646    ERF([]);
 647  }, ERRORS.REF_ERROR);
 648  assertEquals(ERF(1, 2), 0.15262147206923782);
 649  assertEquals(ERF(2, 1), -0.15262147206923782);
 650});
 651
 652
 653test("ERFC", function(){
 654  assertEquals(ERFC(2), 0.004677734981047288);
 655  assertEquals(ERFC("2"), 0.004677734981047288);
 656  assertEquals(ERFC(0), 1);
 657  assertEquals(ERFC(1), 0.1572992070502851);
 658  assertEquals(ERFC(-1), 1.842700792949715);
 659  assertEquals(ERFC(-10), 2);
 660  catchAndAssertEquals(function() {
 661    ERFC.apply(this, []);
 662  }, ERRORS.NA_ERROR);
 663  catchAndAssertEquals(function() {
 664    ERFC([]);
 665  }, ERRORS.REF_ERROR);
 666});
 667
 668
 669test("EVEN", function(){
 670  assertEquals(EVEN(3), 4);
 671  assertEquals(EVEN(4), 4);
 672  assertEquals(EVEN(5), 6);
 673  assertEquals(EVEN("4"), 4);
 674  assertEquals(EVEN(false), 0);
 675  assertEquals(EVEN(true), 2);
 676  assertEquals(EVEN([11, 22]), 12);
 677  assertEquals(EVEN([10, 22, "str"]), 10);
 678  catchAndAssertEquals(function() {
 679    EVEN.apply(this, []);
 680  }, ERRORS.NA_ERROR);
 681  catchAndAssertEquals(function() {
 682    EVEN.apply(this, [1, 2, 3]);
 683  }, ERRORS.NA_ERROR);
 684  catchAndAssertEquals(function() {
 685    EVEN("str");
 686  }, ERRORS.VALUE_ERROR);
 687});
 688
 689
 690test("FLOOR", function(){
 691  assertEquals(FLOOR(10.1), 10);
 692  assertEquals(FLOOR("10.1"), 10);
 693  assertEquals(FLOOR(10.11111111, 0.1), 10.1);
 694  assertEquals(FLOOR(10.22222222, 0.1), 10.2);
 695  assertEquals(FLOOR(10.33333333, 0.2), 10.2);
 696  assertEquals(FLOOR(10.33333333, 0.1), 10.3);
 697  assertEquals(FLOOR([10.33333333], 0.1), 10.3);
 698  assertEquals(FLOOR(10.22222222, 5), 10);
 699  assertEquals(FLOOR(10.22222222, 8), 8);
 700  assertEquals(FLOOR(10.22222222, true), 10);
 701  catchAndAssertEquals(function() {
 702    FLOOR(10, 0);
 703  }, ERRORS.DIV_ZERO_ERROR);
 704  catchAndAssertEquals(function() {
 705    FLOOR.apply(this, [10, 1, 2]);
 706  }, ERRORS.NA_ERROR);
 707  catchAndAssertEquals(function() {
 708    FLOOR.apply(this, []);
 709  }, ERRORS.NA_ERROR);
 710});
 711
 712
 713test("IF", function(){
 714  assertEquals(IF(true, "hit", "miss"), "hit");
 715  assertEquals(IF(false, "hit", "miss"), "miss");
 716  assertEquals(IF("", "hit", "miss"), "miss");
 717  assertEquals(IF("", "hit", "miss"), "miss");
 718  assertEquals(IF([true], "hit", "miss"), "hit");
 719  assertEquals(IF([false], "hit", "miss"), "miss");
 720  assertEquals(IF([""], "hit", "miss"), "miss");
 721  assertEquals(IF([""], "hit", "miss"), "miss");
 722  catchAndAssertEquals(function() {
 723    IF("str", 1, 2);
 724  }, ERRORS.VALUE_ERROR);
 725  catchAndAssertEquals(function() {
 726    IF([], 1, 2);
 727  }, ERRORS.REF_ERROR);
 728});
 729
 730
 731test("INT", function(){
 732  assertEquals(INT(99.33), 99);
 733  assertEquals(INT(99.99), 99);
 734  assertEquals(INT(true), 1);
 735  assertEquals(INT(false), 0);
 736  assertEquals(INT(""), 0);
 737  assertEquals(INT([1.1, "str"]), 1);
 738  catchAndAssertEquals(function() {
 739    INT.apply(this, [100, 10]);
 740  }, ERRORS.NA_ERROR);
 741  catchAndAssertEquals(function() {
 742    INT.apply(this, []);
 743  }, ERRORS.NA_ERROR);
 744  catchAndAssertEquals(function() {
 745    INT("str");
 746  }, ERRORS.VALUE_ERROR);
 747});
 748
 749
 750test("ISEVEN", function(){
 751  assertEquals(ISEVEN(4), true);
 752  assertEquals(ISEVEN(3), false);
 753  assertEquals(ISEVEN(4.1), true);
 754  assertEquals(ISEVEN(false), true);
 755  assertEquals(ISEVEN(true), false);
 756  assertEquals(ISEVEN([4]), true);
 757  catchAndAssertEquals(function() {
 758    ISEVEN.apply(this, [100, 10]);
 759  }, ERRORS.NA_ERROR);
 760  catchAndAssertEquals(function() {
 761    ISEVEN.apply(this, []);
 762  }, ERRORS.NA_ERROR);
 763  catchAndAssertEquals(function() {
 764    ISEVEN("");
 765  }, ERRORS.VALUE_ERROR);
 766});
 767
 768
 769test("ISODD", function(){
 770  assertEquals(ISODD(4), false);
 771  assertEquals(ISODD(3), true);
 772  assertEquals(ISODD(4.1), false);
 773  assertEquals(ISODD(false), false);
 774  assertEquals(ISODD(true), true);
 775  assertEquals(ISODD([4]), false);
 776  catchAndAssertEquals(function() {
 777    ISODD.apply(this, [100, 10]);
 778  }, ERRORS.NA_ERROR);
 779  catchAndAssertEquals(function() {
 780    ISODD.apply(this, []);
 781  }, ERRORS.NA_ERROR);
 782  catchAndAssertEquals(function() {
 783    ISODD("");
 784  }, ERRORS.VALUE_ERROR);
 785});
 786
 787
 788test("LN", function(){
 789  assertEquals(LN(100), 4.605170185988092);
 790  assertEquals(LN("100"), 4.605170185988092);
 791  assertEquals(LN(1), 0);
 792  assertEquals(LN(true), 0);
 793  catchAndAssertEquals(function() {
 794    LN(false);
 795  }, ERRORS.NUM_ERROR);
 796  catchAndAssertEquals(function() {
 797    LN("str");
 798  }, ERRORS.VALUE_ERROR);
 799  catchAndAssertEquals(function() {
 800    LN.apply(this, []);
 801  }, ERRORS.NA_ERROR);
 802  catchAndAssertEquals(function() {
 803    LN.apply(this, [10, 10]);
 804  }, ERRORS.NA_ERROR);
 805});
 806
 807
 808test("LOG", function(){
 809  assertEquals(LOG(256, 2), 8);
 810  assertEquals(LOG(100, 10), 2);
 811  assertEquals(LOG(256, 10), 2.408239965311849);
 812  assertEquals(LOG(1, 2), 0);
 813  catchAndAssertEquals(function() {
 814    LOG("str", 10);
 815  }, ERRORS.VALUE_ERROR);
 816  catchAndAssertEquals(function() {
 817    LOG(256, 0);
 818  }, ERRORS.NUM_ERROR);
 819  catchAndAssertEquals(function() {
 820    LOG(256, 1);
 821  }, ERRORS.DIV_ZERO_ERROR);
 822  catchAndAssertEquals(function() {
 823    LOG(256, false);
 824  }, ERRORS.NUM_ERROR);
 825  catchAndAssertEquals(function() {
 826    LOG(256, true);
 827  }, ERRORS.DIV_ZERO_ERROR);
 828  catchAndAssertEquals(function() {
 829    LOG.apply(this, [10]);
 830  }, ERRORS.NA_ERROR);
 831});
 832
 833
 834test("LOG10", function(){
 835  assertEquals(LOG10(100), 2);
 836  assertEquals(LOG10("100"), 2);
 837  assertEquals(LOG10(1), 0);
 838  assertEquals(LOG10(10.1), 1.0043213737826424);
 839  catchAndAssertEquals(function() {
 840    LOG10(false);
 841  }, ERRORS.NUM_ERROR);
 842  catchAndAssertEquals(function() {
 843    LOG10("");
 844  }, ERRORS.NUM_ERROR);
 845  catchAndAssertEquals(function() {
 846    LOG10("str");
 847  }, ERRORS.VALUE_ERROR);
 848  catchAndAssertEquals(function() {
 849    LOG10.apply(this, []);
 850  }, ERRORS.NA_ERROR);
 851  catchAndAssertEquals(function() {
 852    LOG10.apply(this, [10, 10]);
 853  }, ERRORS.NA_ERROR);
 854});
 855
 856
 857test("MOD", function(){
 858  assertEquals(MOD(10, 3), 1);
 859  assertEquals(MOD(10, "3"), 1);
 860  assertEquals(MOD(10.1, 3), 1.0999999999999996);
 861  assertEquals(MOD(10, 3.1), 0.6999999999999997);
 862  catchAndAssertEquals(function() {
 863    MOD.apply(this, [10, 3, 10]);
 864  }, ERRORS.NA_ERROR);
 865  catchAndAssertEquals(function() {
 866    MOD.apply(this, [[10, 3]]);
 867  }, ERRORS.NA_ERROR);
 868  catchAndAssertEquals(function() {
 869    MOD(0, 0);
 870  }, ERRORS.DIV_ZERO_ERROR);
 871  catchAndAssertEquals(function() {
 872    MOD.apply(this, [10]);
 873  }, ERRORS.NA_ERROR);
 874  catchAndAssertEquals(function() {
 875    MOD(10, false);
 876  }, ERRORS.DIV_ZERO_ERROR);
 877  catchAndAssertEquals(function() {
 878    MOD(10, 0);
 879  }, ERRORS.DIV_ZERO_ERROR);
 880  catchAndAssertEquals(function() {
 881    MOD(10, "str");
 882  }, ERRORS.VALUE_ERROR);
 883});
 884
 885
 886test("ODD", function(){
 887  assertEquals(ODD(2), 3);
 888  assertEquals(ODD(4), 5);
 889  assertEquals(ODD(5), 5);
 890  assertEquals(ODD("4"), 5);
 891  assertEquals(ODD(false), 1);
 892  assertEquals(ODD(true), 1);
 893  assertEquals(ODD([10, 22]), 11);
 894  assertEquals(ODD([10, 22, "str"]), 11);
 895  catchAndAssertEquals(function() {
 896    ODD.apply(this, []);
 897  }, ERRORS.NA_ERROR);
 898  catchAndAssertEquals(function() {
 899    ODD.apply(this, [1, 2, 3]);
 900  }, ERRORS.NA_ERROR);
 901  catchAndAssertEquals(function() {
 902    ODD("str");
 903  }, ERRORS.VALUE_ERROR);
 904});
 905
 906
 907test("PI", function(){
 908  assertEquals(PI(), 3.141592653589793);
 909  catchAndAssertEquals(function() {
 910    PI.apply(this, [1]);
 911  }, ERRORS.NA_ERROR);
 912});
 913
 914
 915test("POWER", function(){
 916  assertEquals(POWER(4, 10), 1048576);
 917  assertEquals(POWER(4, false), 1);
 918  assertEquals(POWER(4, true), 4);
 919  assertEquals(POWER([4], [10]), 1048576);
 920  assertEquals(POWER([4], [10, "str"]), 1048576);
 921  catchAndAssertEquals(function() {
 922    POWER(4, "str");
 923  }, ERRORS.VALUE_ERROR);
 924  catchAndAssertEquals(function() {
 925    POWER.apply(this, []);
 926  }, ERRORS.NA_ERROR);
 927  catchAndAssertEquals(function() {
 928    POWER.apply(this, [4]);
 929  }, ERRORS.NA_ERROR);
 930  catchAndAssertEquals(function() {
 931    POWER.apply(this, [4, 10, 22]);
 932  }, ERRORS.NA_ERROR);
 933});
 934
 935
 936test("RADIANS", function(){
 937  assertEquals(RADIANS(180), 3.141592653589793);
 938  assertEquals(RADIANS(false), 0);
 939  assertEquals(RADIANS(true), 0.017453292519943295);
 940  catchAndAssertEquals(function() {
 941    RADIANS("str");
 942  }, ERRORS.VALUE_ERROR);
 943  catchAndAssertEquals(function() {
 944    RADIANS.apply(this, []);
 945  }, ERRORS.NA_ERROR);
 946  catchAndAssertEquals(function() {
 947    RADIANS.apply(this, [4, 10]);
 948  }, ERRORS.NA_ERROR);
 949});
 950
 951
 952test("ROUND", function(){
 953  assertEquals(ROUND(99.44, 1), 99.4);
 954  assertEquals(ROUND(99.44, 0), 99);
 955  assertEquals(ROUND(99.4444444444444, 9), 99.444444444);
 956  assertEquals(ROUND("99.44", 0), 99);
 957  assertEquals(ROUND([99.44, 22.222], [1, 4]), 99.4);
 958  catchAndAssertEquals(function() {
 959    ROUND.apply(this, []);
 960  }, ERRORS.NA_ERROR);
 961  catchAndAssertEquals(function() {
 962    ROUND.apply(this, [99.44, 1, 44]);
 963  }, ERRORS.NA_ERROR);
 964  catchAndAssertEquals(function() {
 965    ROUND(99.999, "str");
 966  }, ERRORS.VALUE_ERROR);
 967});
 968
 969
 970test("ROUNDDOWN", function(){
 971  assertEquals(ROUNDDOWN(99.46, 1), 99.4);
 972  assertEquals(ROUNDDOWN(99.99, 1), 99.9);
 973  assertEquals(ROUNDDOWN(99.5555555555555, 9), 99.555555555);
 974  assertEquals(ROUNDDOWN(99.99), 99);
 975  assertEquals(ROUNDDOWN("99.99"), 99);
 976  assertEquals(ROUNDDOWN([99.46666, 22.222], [1, 4]), 99.4);
 977  catchAndAssertEquals(function() {
 978    ROUNDDOWN.apply(this, []);
 979  }, ERRORS.NA_ERROR);
 980  catchAndAssertEquals(function() {
 981    ROUNDDOWN.apply(this, [99.44, 1, 44]);
 982  }, ERRORS.NA_ERROR);
 983  catchAndAssertEquals(function() {
 984    ROUNDDOWN(99.999, "str");
 985  }, ERRORS.VALUE_ERROR);
 986});
 987
 988
 989test("ROUNDUP", function(){
 990  assertEquals(ROUNDUP(99.46, 1), 99.5);
 991  assertEquals(ROUNDUP(99.99, 1), 100);
 992  assertEquals(ROUNDUP(99.5555555555555, 9), 99.555555556);
 993  assertEquals(ROUNDUP(99.99), 100);
 994  assertEquals(ROUNDUP("99.99"), 100);
 995  assertEquals(ROUNDUP([99.46666, 22.222], [1, 4]), 99.5);
 996  catchAndAssertEquals(function() {
 997    ROUNDUP.apply(this, []);
 998  }, ERRORS.NA_ERROR);
 999  catchAndAssertEquals(function() {
1000    ROUNDUP.apply(this, [99.44, 1, 44]);
1001  }, ERRORS.NA_ERROR);
1002  catchAndAssertEquals(function() {
1003    ROUNDUP(99.999, "str");
1004  }, ERRORS.VALUE_ERROR);
1005});
1006
1007
1008test("SIN", function(){
1009  assertEquals(SIN(0), 0);
1010  assertEquals(SIN(1), 0.8414709848078965);
1011  assertEquals(SIN(PI() / 2), 1);
1012  assertEquals(SIN(PI()), 0);
1013  assertEquals(SIN(true), 0.8414709848078965);
1014  assertEquals(SIN(false), 0);
1015  assertEquals(SIN("0"), 0);
1016  assertEquals(SIN(""), 0);
1017  catchAndAssertEquals(function() {
1018    SIN("str");
1019  }, ERRORS.VALUE_ERROR);
1020  assertEquals(SIN([1]), 0.8414709848078965);
1021  assertEquals(SIN([[1]]), 0.8414709848078965);
1022  assertEquals(SIN([1, "str"]), 0.8414709848078965);
1023  catchAndAssertEquals(function() {
1024    SIN.apply(this, [1, 44]);
1025  }, ERRORS.NA_ERROR);
1026});
1027
1028
1029test("SINH", function(){
1030  assertEquals(SINH(PI()), 11.548739357257748);
1031  assertEquals(SINH(1), 1.1752011936438014);
1032  assertEquals(SINH(false), 0);
1033  assertEquals(SINH(true), 1.1752011936438014);
1034  assertEquals(SINH(""), 0);
1035  assertEquals(SINH("0"), 0);
1036  catchAndAssertEquals(function() {
1037    SINH("str");
1038  }, ERRORS.VALUE_ERROR);
1039  assertEquals(SINH([10]), 11013.232874703393);
1040  assertEquals(SINH([[10]]), 11013.232874703393);
1041  catchAndAssertEquals(function() {
1042    SIN([[]]);
1043  }, ERRORS.REF_ERROR);
1044  assertEquals(SINH([[10, "str"]]), 11013.232874703393);
1045});
1046
1047
1048test("SQRT", function(){
1049  assertEquals(SQRT(9), 3);
1050  assertEquals(SQRT("9"), 3);
1051  assertEquals(SQRT(4), 2);
1052  assertEquals(SQRT(false), 0);
1053  assertEquals(SQRT(true), 1);
1054  assertEquals(SQRT(""), 0);
1055  catchAndAssertEquals(function() {
1056    SQRT("str");
1057  }, ERRORS.VALUE_ERROR);
1058  catchAndAssertEquals(function() {
1059    SQRT(-9);
1060  }, ERRORS.VALUE_ERROR);
1061  catchAndAssertEquals(function() {
1062    SQRT.apply(this, []);
1063  }, ERRORS.NA_ERROR);
1064  catchAndAssertEquals(function() {
1065    SQRT.apply(this, [4, 4]);
1066  }, ERRORS.NA_ERROR);
1067});
1068
1069
1070test("SQRTPI", function(){
1071  assertEquals(SQRTPI(9), 5.317361552716548);
1072  assertEquals(SQRTPI("9"), 5.317361552716548);
1073  assertEquals(SQRTPI([9]), 5.317361552716548);
1074  assertEquals(SQRTPI(0), 0);
1075  assertEquals(SQRTPI(1), 1.7724538509055159);
1076  assertEquals(SQRTPI(""), 0);
1077  catchAndAssertEquals(function() {
1078    SQRTPI("str");
1079  }, ERRORS.VALUE_ERROR);
1080  catchAndAssertEquals(function() {
1081    SQRTPI(-1);
1082  }, ERRORS.NUM_ERROR);
1083  catchAndAssertEquals(function() {
1084    SQRTPI.apply(this, []);
1085  }, ERRORS.NA_ERROR);
1086  catchAndAssertEquals(function() {
1087    SQRTPI.apply(this, [4, 4]);
1088  }, ERRORS.NA_ERROR);
1089});
1090
1091
1092test("SUM", function(){
1093  assertEquals(SUM(10), 10);
1094  assertEquals(SUM(10, 10), 20);
1095  assertEquals(SUM(10, [5, 5]), 20);
1096  assertEquals(SUM("10", [5, 5]), 20);
1097  assertEquals(SUM(false, [10, 10]), 20);
1098  assertEquals(SUM(true, [10, 10]), 21);
1099  catchAndAssertEquals(function() {
1100    SUM([10, 10], "");
1101  }, ERRORS.VALUE_ERROR);
1102  catchAndAssertEquals(function() {
1103    SUM([10, 10], "str");
1104  }, ERRORS.VALUE_ERROR);
1105  catchAndAssertEquals(function() {
1106    SUM();
1107  }, ERRORS.NA_ERROR);
1108});
1109
1110
1111test("SUMIF", function(){
1112  assertEquals(SUMIF([1, 5, 10, [1, 1, 1, 1, 1], []], 1), 6);
1113  assertEquals(SUMIF([], 1), 0);
1114  assertEquals(SUMIF([1, 5, 10, [1, 1, "1.0", "1", 1]], 1), 4);
1115  assertEquals(SUMIF([1, 5, 10], 5), 5);
1116  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], 5), 20);
1117  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], 10), 10);
1118  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], ">5"), 10);
1119  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], "=5"), 20);
1120  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], "=1"), 1);
1121  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], "=     1  "), 1);
1122  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], ">0"), 31);
1123  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], ">=5"), 30);
1124  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], "<10"), 21);
1125  assertEquals(SUMIF([1, 5, 5, 5, 10, 5, 44], "<=10"), 31);
1126  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], ">4.99"), 30);
1127  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], "<4.99"), 1);
1128  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], "=     1.0.0  "), 0);
1129  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], "=>5"), 0);
1130  assertEquals(SUMIF([1, 5, 5, 5, 10, 5], "==5"), 0);
1131  assertEquals(SUMIF(["m", "m", 3, 11, true], "m"), 0);
1132  assertEquals(SUMIF(["m", "p", "m"], "m", [1, 1, 1]), 2);
1133  assertEquals(SUMIF(["p", "p", "p"], "m", [1, 1, 1]), 0);
1134  assertEquals(SUMIF(["p", "p", "p"], "", [1, 1, 1]), 0);
1135  assertEquals(SUMIF(["p", "p", "p"], "*", [1, 1, 1]), 3);
1136  assertEquals(SUMIF(["mom", "pop", "pap"], "*o*", [1, 1, 1]), 2);
1137  assertEquals(SUMIF(["mom", "pop", "pap"], "*a*", [1, 1, 1]), 1);
1138  assertEquals(SUMIF(["mom", "pop", "pap"], "p*p", [1, 1, 1]), 2);
1139  assertEquals(SUMIF(["mom", "pop", "pap"], "p*p", [1, 1, 1]), 2);
1140  assertEquals(SUMIF(["mom", "pop", "pap"], "p*p", [1, 1,]), 1);
1141  assertEquals(SUMIF(["pop", "pap"], "p*p", [1, 2, 4]), 3);
1142  assertEquals(SUMIF(["mom", "pop", "dad", "etc", "boom"], "*o*", [1, 1, 1, 1, 1]), 3);
1143  assertEquals(SUMIF(["mom", "pop", "dad", "etc", "mom"], "mom", [1, 1, 1, 1, 1]), 2);
1144  assertEquals(SUMIF(["mom", "pop", "dad", "etc", "mom"], "?o?", [1, 1, 1, 1, 1]), 3);
1145  assertEquals(SUMIF(["mom", "pop", "dad", "etc", "mom"], "???", [1, 1, 1, 1, 1]), 5);
1146  assertEquals(SUMIF(["mom", "pop", "dad", "etc", "mom"], "????", [1, 1, 1, 1, 1]), 0);
1147  assertEquals(SUMIF([0, 1, 0, 1], "=1", [1, 2, 4, 8]), 10);
1148  catchAndAssertEquals(function() {
1149    SUMIF.apply(this, [[0, 1, 0, 1]]);
1150  }, ERRORS.NA_ERROR);
1151  catchAndAssertEquals(function() {
1152    SUMIF.apply(this, []);
1153  }, ERRORS.NA_ERROR);
1154  catchAndAssertEquals(function() {
1155    SUMIF.apply(this, [[], "=1", [], true]);
1156  }, ERRORS.NA_ERROR);
1157});
1158
1159
1160test("SUMPRODUCT", function(){
1161  assertEquals(SUMPRODUCT([1, 5, 10], [2, 2, 2]), 32);
1162  assertEquals(SUMPRODUCT([1, 5, 10], [2, 2, 2], [2, 2, 2]), 64);
1163  assertEquals(SUMPRODUCT([1, 5, 10], [1, 2, 2], [1, 4, 4]), 121);
1164  assertEquals(SUMPRODUCT([1, 5, 10]), 16);
1165  assertEquals(SUMPRODUCT([1, 5, 10, ""]), 16);
1166  assertEquals(SUMPRODUCT([1, 5, 10, 200], [2, 2, 2, ""]), 32);
1167  assertEquals(SUMPRODUCT([1, 5, 10, "str"]), 16);
1168  assertEquals(SUMPRODUCT([10, 10, 22, "str"], [2, 2, [2, 2]]), 84);
1169  assertEquals(SUMPRODUCT(1, 5, 10), 50);
1170  assertEquals(SUMPRODUCT([1, 5, 10]), 16);
1171  catchAndAssertEquals(function() {
1172    SUMPRODUCT([1, 5, 10], [2, 2]);
1173  }, ERRORS.VALUE_ERROR);
1174  catchAndAssertEquals(function() {
1175    SUMPRODUCT([1, 5, 10], [2, 2, 2, []]);
1176  }, ERRORS.REF_ERROR);
1177  catchAndAssertEquals(function() {
1178    SUMPRODUCT();
1179  }, ERRORS.NA_ERROR);
1180});
1181
1182
1183test("SUMSQ", function(){
1184  assertEquals(SUMSQ([1, 5, 10], 10), 226);
1185  assertEquals(SUMSQ([10, 10, 22, ""]), 684);
1186  assertEquals(SUMSQ(10, 10, 22), 684);
1187  assertEquals(SUMSQ(10, 10, "22", true), 685);
1188  assertEquals(SUMSQ(10, 10, "22", false), 684);
1189  assertEquals(SUMSQ([10, 10, 22, true]), 684);
1190  catchAndAssertEquals(function() {
1191    SUMSQ([10, 10, 22, "", []]);
1192  }, ERRORS.REF_ERROR);
1193  catchAndAssertEquals(function() {
1194    SUMSQ([]);
1195  }, ERRORS.REF_ERROR);
1196  catchAndAssertEquals(function() {
1197    SUMSQ.apply(this, []);
1198  }, ERRORS.NA_ERROR);
1199});
1200
1201
1202test("SUMX2MY2", function(){
1203  assertEquals(SUMX2MY2([1,2,3],[4,5,6]), -63);
1204  assertEquals(SUMX2MY2([1, 2, 3], [[4, 5], [6]]), -63);
1205  assertEquals(SUMX2MY2(["1",2,3],[4,5,6]), -48);
1206  assertEquals(SUMX2MY2(["",2,3],[4,5,6]), -48);
1207  assertEquals(SUMX2MY2([false,2,3],[4,5,6]), -48);
1208  assertEquals(SUMX2MY2([true,2,3],[4,5,6]), -48);
1209  catchAndAssertEquals(function() {
1210    SUMX2MY2([1,2,3],[4,5, []]);
1211  }, ERRORS.REF_ERROR);
1212  catchAndAssertEquals(function() {
1213    SUMX2MY2.apply(this, [[1,2,3],[4,5]]);
1214  }, ERRORS.NA_ERROR);
1215  catchAndAssertEquals(function() {
1216    SUMX2MY2.apply(this, []);
1217  }, ERRORS.NA_ERROR);
1218});
1219
1220
1221test("SUMX2PY2", function(){
1222  assertEquals(SUMX2PY2([1, 2, 3], [4, 5, 6]), 91);
1223  assertEquals(SUMX2PY2([1, 2, 3], [[4, 5], [6]]), 91);
1224  assertEquals(SUMX2PY2(["1",2,3],[4,5,6]), 74);
1225  assertEquals(SUMX2PY2(["",2,3],[4,5,6]), 74);
1226  assertEquals(SUMX2PY2([false,2,3],[4,5,6]), 74);
1227  assertEquals(SUMX2PY2([true,2,3],[4,5,6]), 74);
1228  catchAndAssertEquals(function() {
1229    SUMX2PY2([1,2,3],[4,5, []]);
1230  }, ERRORS.REF_ERROR);
1231  catchAndAssertEquals(function() {
1232    SUMX2PY2.apply(this, [[1,2,3],[4,5]]);
1233  }, ERRORS.NA_ERROR);
1234  catchAndAssertEquals(function() {
1235    SUMX2PY2.apply(this, []);
1236  }, ERRORS.NA_ERROR);
1237});
1238
1239
1240test("TAN", function(){
1241  assertEquals(TAN(0), 0);
1242  assertEquals(TAN(1), 1.5574077246549023);
1243  assertEquals(TAN(PI() / 2), 16331239353195370);
1244  assertEquals(TAN(PI()), 0);
1245  assertEquals(TAN(false), 0);
1246  assertEquals(TAN(true), 1.5574077246549023);
1247  assertEquals(TAN(""), 0);
1248  assertEquals(TAN("0"), 0);
1249  catchAndAssertEquals(function() {
1250    TAN("str");
1251  }, ERRORS.VALUE_ERROR);
1252  catchAndAssertEquals(function() {
1253    TAN.apply(this, []);
1254  }, ERRORS.NA_ERROR);
1255  catchAndAssertEquals(function() {
1256    TAN.apply(this, [1, 1]);
1257  }, ERRORS.NA_ERROR);
1258  assertEquals(TAN([1, 44]), 1.5574077246549023);
1259  assertEquals(TAN([1, "str"]), 1.5574077246549023);
1260});
1261
1262
1263test("TANH", function(){
1264  assertEquals(TANH(0), 0);
1265  assertEquals(TANH(1), 0.7615941559557649);
1266  assertEquals(TANH(PI() / 2), 0.9171523356672744);
1267  assertEquals(TANH(PI()), 0.99627207622075);
1268  assertEquals(TANH(false), 0);
1269  assertEquals(TANH(true), 0.7615941559557649);
1270  assertEquals(TANH(""), 0);
1271  assertEquals(TANH("0"), 0);
1272  catchAndAssertEquals(function() {
1273    TANH("str");
1274  }, ERRORS.VALUE_ERROR);
1275  catchAndAssertEquals(function() {
1276    TANH.apply(this, []);
1277  }, ERRORS.NA_ERROR);
1278  catchAndAssertEquals(function() {
1279    TANH.apply(this, [1, 1]);
1280  }, ERRORS.NA_ERROR);
1281  assertEquals(TANH([1, 44]), 0.7615941559557649);
1282  assertEquals(TANH([1, "str"]), 0.7615941559557649);
1283});
1284
1285
1286test("TRUNC", function(){
1287  assertEquals(TRUNC(PI(), 2), 3.14);
1288  assertEquals(TRUNC("3.141592653589793", "2"), 3.14);
1289  assertEquals(TRUNC(PI(), 1), 3.1);
1290  assertEquals(TRUNC(PI(), 0), 3);
1291  assertEquals(TRUNC(PI(), false), 3);
1292  assertEquals(TRUNC(PI(), -1), 0);
1293  assertEquals(TRUNC(31.41592653589793, -1), 30);
1294  assertEquals(TRUNC([31.41592653589793], [-1]), 30);
1295  assertEquals(TRUNC(31111.41592653589793, -4), 30000);
1296  assertEquals(TRUNC(31111.41592653589793, -2), 31100);
1297  catchAndAssertEquals(function() {
1298    TRUNC.apply(this, []);
1299  }, ERRORS.NA_ERROR);
1300  catchAndAssertEquals(function() {
1301    TRUNC.apply(this, [3.1, 1, 1]);
1302  }, ERRORS.NA_ERROR);
1303});
1304
1305
1306test("MULTIPLY", function(){
1307  assertEquals(MULTIPLY(2, 2), 4);
1308  assertEquals(MULTIPLY(2, "2"), 4);
1309  assertEquals(MULTIPLY([2, []], ["2"]), 4);
1310  catchAndAssertEquals(function() {
1311    MULTIPLY.apply(this, [3.1, 1, 1]);
1312  }, ERRORS.NA_ERROR);
1313  catchAndAssertEquals(function() {
1314    MULTIPLY.apply(this, [1]);
1315  }, ERRORS.NA_ERROR);
1316});
1317
1318
1319test("Minus", function(){
1320  assertEquals(MINUS(2, 2), 0);
1321  assertEquals(MINUS(2, 10), -8);
1322  assertEquals(MINUS(2, "12"), -10);
1323  assertEquals(MINUS([4, []], ["2"]), 2);
1324  catchAndAssertEquals(function() {
1325    MINUS.apply(this, [3.1, 1, 1]);
1326  }, ERRORS.NA_ERROR);
1327  catchAndAssertEquals(function() {
1328    MINUS.apply(this, [1]);
1329  }, ERRORS.NA_ERROR);
1330});
1331
1332
1333test("DIVIDE", function(){
1334  assertEquals(DIVIDE(2, 2), 1);
1335  assertEquals(DIVIDE(10, 2), 5);
1336  assertEquals(DIVIDE(2, "12"), 0.16666666666666666);
1337  assertEquals(DIVIDE([4, []], ["2"]), 2);
1338  catchAndAssertEquals(function() {
1339    DIVIDE.apply(this, [3.1, 1, 1]);
1340  }, ERRORS.NA_ERROR);
1341  catchAndAssertEquals(function() {
1342    DIVIDE.apply(this, [1]);
1343  }, ERRORS.NA_ERROR);
1344  catchAndAssertEquals(function() {
1345    DIVIDE.apply(this, [1, 1, 1]);
1346  }, ERRORS.NA_ERROR);
1347});
1348
1349
1350test("EQ", function(){
1351  assertEquals(EQ(2, 2), true);
1352  assertEquals(EQ("2", 2), false);
1353  assertEquals(EQ("2", "2"), true);
1354  assertEquals(EQ("abc", "abc"), true);
1355  assertEquals(EQ(true, true), true);
1356  assertEquals(EQ(false, true), false);
1357  assertEquals(EQ(false, false), true);
1358  assertEquals(EQ(0, 0), true);
1359  catchAndAssertEquals(function() {
1360    EQ.apply(this, [3.1, 1, 1]);
1361  }, ERRORS.NA_ERROR);
1362  catchAndAssertEquals(function() {
1363    EQ.apply(this, [1]);
1364  }, ERRORS.NA_ERROR);
1365});
1366
1367
1368test("GT", function(){
1369  assertEquals(GT(2, 2), false);
1370  assertEquals(GT(2, 3), false);
1371  assertEquals(GT(2, 1), true);
1372  assertEquals(GT("abc", "a"), true);
1373  assertEquals(GT("abc", "abcd"), false);
1374  assertEquals(GT(false, false), false);
1375  assertEquals(GT(true, false), true);
1376  catchAndAssertEquals(function() {
1377    GT.apply(this, [3]);
1378  }, ERRORS.NA_ERROR);
1379  catchAndAssertEquals(function() {
1380    GT.apply(this, [3, 3, 3]);
1381  }, ERRORS.NA_ERROR);
1382});
1383
1384
1385test("GTE", function(){
1386  assertEquals(GTE(2, 2), true);
1387  assertEquals(GTE(2, 3), false);
1388  assertEquals(GTE(2, 1), true);
1389  assertEquals(GTE("abc", "a"), true);
1390  assertEquals(GTE("abc", "abc"), true);
1391  assertEquals(GTE("abc", "abcd"), false);
1392  assertEquals(GTE(false, false), true);
1393  assertEquals(GTE(true, false), true);
1394  catchAndAssertEquals(function() {
1395    GTE.apply(this, [3]);
1396  }, ERRORS.NA_ERROR);
1397  catchAndAssertEquals(function() {
1398    GTE.apply(this, [3, 3, 3]);
1399  }, ERRORS.NA_ERROR);
1400});
1401
1402
1403test("LT", function(){
1404  assertEquals(LT(2, 2), false);
1405  assertEquals(LT(2, 3), true);
1406  assertEquals(LT(2, 1), false);
1407  assertEquals(LT("abc", "a"), false);
1408  assertEquals(LT("abc", "abc"), false);
1409  assertEquals(LT("abc", "abcd"), true);
1410  assertEquals(LT(false, false), false);
1411  assertEquals(LT(true, false), false);
1412  assertEquals(LT(false, true), true);
1413  catchAndAssertEquals(function() {
1414    LT.apply(this, [3]);
1415  }, ERRORS.NA_ERROR);
1416  catchAndAssertEquals(function() {
1417    LT.apply(this, [3, 3, 3]);
1418  }, ERRORS.NA_ERROR);
1419});
1420
1421
1422test("NE", function(){
1423  assertEquals(NE(2, 2), false);
1424  assertEquals(NE(2, 3), true);
1425  assertEquals(NE(2, 1), true);
1426  assertEquals(NE("abc", "a"), true);
1427  assertEquals(NE("abc", "abc"), false);
1428  assertEquals(NE("abc", "abcd"), true);
1429  assertEquals(NE(false, false), false);
1430  assertEquals(NE(true, false), true);
1431  assertEquals(NE(false, true), true);
1432  catchAndAssertEquals(function() {
1433    NE.apply(this, [3]);
1434  }, ERRORS.NA_ERROR);
1435  catchAndAssertEquals(function() {
1436    NE.apply(this, [3, 3, 3]);
1437  }, ERRORS.NA_ERROR);
1438});
1439
1440
1441test("LTE", function(){
1442  assertEquals(LTE(2, 2), true);
1443  assertEquals(LTE(2, 3), true);
1444  assertEquals(LTE(2, 1), false);
1445  assertEquals(LTE("abc", "a"), false);
1446  assertEquals(LTE("abc", "abc"), true);
1447  assertEquals(LTE("abc", "abcd"), true);
1448  assertEquals(LTE(false, false), true);
1449  assertEquals(LTE(true, false), false);
1450  assertEquals(LTE(false, true), true);
1451  assertEquals(LTE(true, true), true);
1452  catchAndAssertEquals(function() {
1453    LTE.apply(this, [3]);
1454  }, ERRORS.NA_ERROR);
1455  catchAndAssertEquals(function() {
1456    LTE.apply(this, [3, 3, 3]);
1457  }, ERRORS.NA_ERROR);
1458});
1459
1460
1461test("RAND", function(){
1462  catchAndAssertEquals(function() {
1463    RAND.apply(this, [3]);
1464  }, ERRORS.NA_ERROR);
1465});
1466
1467
1468test("RANDBETWEEN", function(){
1469  for(var i = 0; i < 1000; i++) {
1470    var x = RANDBETWEEN(1, 4);
1471    assertEquals(x >= 1, true);
1472    assertEquals(x <= 4, true);
1473    x = RANDBETWEEN(-1, 1);
1474    assertEquals(x >= -1, true);
1475    assertEquals(x <= 1, true);
1476  }
1477  catchAndAssertEquals(function() {
1478    RANDBETWEEN.apply(this, [3]);
1479  }, ERRORS.NA_ERROR);
1480  catchAndAssertEquals(function() {
1481    RANDBETWEEN.apply(this, [3, 4, 5]);
1482  }, ERRORS.NA_ERROR);
1483});
1484
1485
1486test("SIGN", function(){
1487  assertEquals(SIGN(2), 1);
1488  assertEquals(SIGN(0), 0);
1489  assertEquals(SIGN(-100), -1);
1490  assertEquals(SIGN([0]), 0);
1491  assertEquals(SIGN("0"), 0);
1492  assertEquals(SIGN(false), 0);
1493  assertEquals(SIGN(true), 1);
1494  catchAndAssertEquals(function() {
1495    SIGN.apply(this, [3, 2]);
1496  }, ERRORS.NA_ERROR);
1497});
1498
1499
1500test("UNARY_PERCENT", function(){
1501  assertEquals(UNARY_PERCENT(100), 1);
1502  assertEquals(UNARY_PERCENT(2), 0.02);
1503  assertEquals(UNARY_PERCENT(0), 0);
1504  catchAndAssertEquals(function() {
1505    UNARY_PERCENT.apply(this, []);
1506  }, ERRORS.NA_ERROR);
1507});
1508
1509
1510test("MULTINOMIAL", function(){
1511  assertEquals(MULTINOMIAL(1, 2, 3), 60);
1512  assertEquals(MULTINOMIAL(1, 33, 100), 2.4592658588587683e+33);
1513  assertEquals(MULTINOMIAL(2, 22), 276);
1514  assertEquals(MULTINOMIAL(3), 1);
1515  catchAndAssertEquals(function() {
1516    MULTINOMIAL.apply(this, []);
1517  }, ERRORS.NA_ERROR);
1518});
1519
1520
1521test("SERIESSUM", function(){
1522  assertEquals(SERIESSUM(1, 0, 1, [4, 5, 6]), 15);
1523  assertEquals(SERIESSUM(1, 0, 1, [4, 5, 6, 10, 22]), 47);
1524  assertEquals(SERIESSUM(3, 0, 2, [4, 5, 6]), 535);
1525  assertEquals(SERIESSUM(3, 0, 2, [4, 5, 6, 10]), 7825);
1526  assertEquals(SERIESSUM(3, 2, 2, [4, 5, 6, 10]), 70425);
1527  catchAndAssertEquals(function() {
1528    SERIESSUM.apply(this, [1, 0, 1, [4, 5, 6], 10])
1529  }, ERRORS.NA_ERROR);
1530  catchAndAssertEquals(function() {
1531    SERIESSUM.apply(this, [1, 0, 1])
1532  }, ERRORS.NA_ERROR);
1533});
1534
1535
1536test("SUBTOTAL", function(){
1537  assertEquals(SUBTOTAL(1, [1, 2, 3, 4, 5, 6, 7]), 4);
1538  assertEquals(SUBTOTAL(1, [1, 2, 3, 4, 5, 6, 7], [4, 5, 6, 7, 8, 9, 10]), 5.5);
1539  assertEquals(SUBTOTAL(2, [1, 2, 3, 4, 5, 6, 7], [4, 5, 6, 7, 8, 9, 10]), 14);
1540  assertEquals(SUBTOTAL(3, [1, 2, 3, 4, 5, 6, 7], [4, 5, 6, 7, 8, 9, 10]), 14);
1541  assertEquals(SUBTOTAL(4, [1, 2, 3, 4, 5, 6, 7], [4, 5, 6, 7, 8, 9, 10]), 10);
1542  assertEquals(SUBTOTAL(5, [1, 2, 3, 4, 5, 6, 7], [4, 5, 6, 7, 8, 9, 10]), 1);
1543  assertEquals(SUBTOTAL(6, [1, 2, 3, 4, 5, 6, 7], [4, 5, 6, 7, 8, 9, 10]), 3048192000);
1544  assertEquals(SUBTOTAL(7, [1, 2, 3, 4, 5, 6, 7], [4, 5, 6, 7, 8, 9, 10]), 2.5943726083138543);
1545  assertEquals(SUBTOTAL(8, [1, 2, 3, 4, 5, 6, 7], [4, 5, 6, 7, 8, 9, 10]), 2.5);
1546  assertEquals(SUBTOTAL(9, [1, 2, 3, 4, 5, 6, 7], [4, 5, 6, 7, 8, 9, 10]), 77);
1547  assertEquals(SUBTOTAL(10, [1, 2, 3, 4, 5, 6, 7], [4, 5, 6, 7, 8, 9, 10]), 6.730769230769231);
1548  assertEquals(SUBTOTAL(11, [1, 2, 3, 4, 5, 6, 7], [4, 5, 6, 7, 8, 9, 10]), 6.25);
1549  catchAndAssertEquals(function() {
1550    SUBTOTAL(0, [1, 2, 3, 4, 5, 6, 7]);
1551  }, ERRORS.VALUE_ERROR);
1552  catchAndAssertEquals(function() {
1553    SUBTOTAL(12, [1, 2, 3, 4, 5, 6, 7]);
1554  }, ERRORS.VALUE_ERROR);
1555  catchAndAssertEquals(function() {
1556    SUBTOTAL.apply(this, [1])
1557  }, ERRORS.NA_ERROR);
1558});