1import {
   2  DATE,
   3  DATEVALUE,
   4  DATEDIF,
   5  EDATE,
   6  EOMONTH,
   7  DAY,
   8  DAYS,
   9  DAYS360,
  10  MONTH,
  11  YEAR,
  12  WEEKDAY,
  13  WEEKNUM,
  14  YEARFRAC,
  15  TIMEVALUE,
  16  HOUR,
  17  MINUTE,
  18  SECOND,
  19  NETWORKDAYS,
  20  NETWORKDAYS$INTL,
  21  TIME,
  22  WORKDAY,
  23  WORKDAY$INTL
  24} from "../../src/Formulas/Date"
  25import * as ERRORS from "../../src/Errors";
  26import {
  27  assertEquals,
  28  catchAndAssertEquals,
  29  test
  30} from "../Utils/Asserts"
  31
  32
  33test("WORKDAY.INTL", function () {
  34  assertEquals(WORKDAY$INTL(DATE(1999, 2, 2), 10), DATE(1999, 2, 16));
  35  assertEquals(WORKDAY$INTL(DATE(1999, 10, 10), 100), DATE(2000, 2, 25));
  36  assertEquals(WORKDAY$INTL(DATE(1909, 12, 11), 222), DATE(1910, 10, 18));
  37  assertEquals(WORKDAY$INTL(DATE(1922, 4, 1), 1234), DATE(1926, 12, 23));
  38  assertEquals(WORKDAY$INTL(DATE(1945, 1, 14), 6000), DATE(1968, 1, 12));
  39  assertEquals(WORKDAY$INTL(DATE(1945, 1, 14), 6000, "0000011"), DATE(1968, 1, 12));
  40  assertEquals(WORKDAY$INTL(DATE(1945, 1, 14), 6000, "1000001"), DATE(1968, 1, 13));
  41  assertEquals(WORKDAY$INTL(DATE(1945, 1, 14), 6000, "1100001"), DATE(1973, 10, 13));
  42  assertEquals(WORKDAY$INTL(DATE(1945, 1, 14), 6000, "1110000"), DATE(1973, 10, 14));
  43  assertEquals(WORKDAY$INTL(DATE(1945, 1, 14), 6000, "1110001"), DATE(1983, 5, 14));
  44  assertEquals(WORKDAY$INTL(DATE(1945, 1, 14), 6000, 6), DATE(1968, 1, 14));
  45  catchAndAssertEquals(function() {
  46    WORKDAY$INTL.apply(this, [12, 12, [12], false, 1]);
  47  }, ERRORS.NA_ERROR);
  48  catchAndAssertEquals(function() {
  49    WORKDAY$INTL.apply(this, [12]);
  50  }, ERRORS.NA_ERROR);
  51  catchAndAssertEquals(function() {
  52    WORKDAY$INTL("1992-1-1", "str");
  53  }, ERRORS.VALUE_ERROR);
  54  catchAndAssertEquals(function() {
  55    WORKDAY$INTL("1992-1-1", 12, []);
  56  }, ERRORS.REF_ERROR);
  57  catchAndAssertEquals(function() {
  58    WORKDAY$INTL("1992-1-1", 16, "000");
  59  }, ERRORS.NUM_ERROR);
  60  catchAndAssertEquals(function() {
  61    WORKDAY$INTL("1992-1-1", 12, 9);
  62  }, ERRORS.NUM_ERROR);
  63  catchAndAssertEquals(function() {
  64    WORKDAY$INTL("1992-1-1", 66, false);
  65  }, ERRORS.VALUE_ERROR);
  66});
  67
  68
  69test("WORKDAY", function () {
  70  assertEquals(WORKDAY(DATE(1999, 2, 2), 10), DATE(1999, 2, 16));
  71  assertEquals(WORKDAY(DATE(1999, 10, 10), 100), DATE(2000, 2, 25));
  72  assertEquals(WORKDAY(DATE(1909, 12, 11), 222), DATE(1910, 10, 18));
  73  assertEquals(WORKDAY(DATE(1922, 4, 1), 1234), DATE(1926, 12, 23));
  74  assertEquals(WORKDAY(DATE(1945, 1, 14), 6000), DATE(1968, 1, 12));
  75  assertEquals(WORKDAY(DATE(1945, 1, 14), 6000, [23855, 23856, 23857, 23858, 23859]), DATE(1968, 1, 17));
  76  assertEquals(WORKDAY(DATE(1945, 1, 14), 6000, 23859), DATE(1968, 1, 15));
  77  assertEquals(WORKDAY(DATE(2012, 5, 29), 1000, [41058, 41059, 41060, 41061, 41062]), DATE(2016, 4, 1));
  78  assertEquals(WORKDAY([DATE(1999, 2, 2)], [10]), DATE(1999, 2, 16));
  79  catchAndAssertEquals(function() {
  80    WORKDAY.apply(this, []);
  81  }, ERRORS.NA_ERROR);
  82  catchAndAssertEquals(function() {
  83    WORKDAY.apply(this, [DATE(2012, 5, 29), 1000, [10], 11]);
  84  }, ERRORS.NA_ERROR);
  85});
  86
  87
  88test("TIME", function () {
  89  assertEquals(TIME(10, 10, 10), 0.4237268518518518);
  90  assertEquals(TIME(34, 10, 10), 0.4237268518518518);
  91  assertEquals(TIME(29, 10, 10), 0.2153935185185185);
  92  assertEquals(TIME(13, 9, 6), 0.5479861111111111);
  93  assertEquals(TIME(3, 1, 14), 0.12585648148148149);
  94  assertEquals(TIME(0, 0, 0), 0);
  95  assertEquals(TIME(24, 0, 0), 0);
  96  assertEquals(TIME(23, 60, 0), 0);
  97  assertEquals(TIME(23, 59, 60), 0);
  98  assertEquals(TIME(18, 0, 0), 0.75);
  99  assertEquals(TIME(12, 0, 0), 0.5);
 100  assertEquals(TIME(6, 0, 0), 0.25);
 101  assertEquals(TIME(3, 0, 0), 0.125);
 102  assertEquals(TIME("3", ["0"], false), 0.125);
 103  catchAndAssertEquals(function() {
 104    TIME.apply(this, []);
 105  }, ERRORS.NA_ERROR);
 106  catchAndAssertEquals(function() {
 107    TIME.apply(this, [1, 1]);
 108  }, ERRORS.NA_ERROR);
 109  catchAndAssertEquals(function() {
 110    TIME.apply(this, [1, 1, 1, 1]);
 111  }, ERRORS.NA_ERROR);
 112  catchAndAssertEquals(function() {
 113    TIME(-29, 10, 10);
 114  }, ERRORS.NUM_ERROR);
 115  catchAndAssertEquals(function() {
 116    TIME(1, 1, []);
 117  }, ERRORS.REF_ERROR);
 118});
 119
 120
 121test("NETWORKDAYS$INTL", function () {
 122  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1992-1-30"), 22);
 123  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-1"), 263);
 124  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-4"), 264);
 125  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-5"), 265);
 126  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-6"), 266);
 127  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-7"), 267);
 128  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-8"), 268);
 129  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-9"), 268);
 130  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1992-1-30", "0000011"), 22);
 131  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-1", "0000011"), 263);
 132  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-4", "0000011"), 264);
 133  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-5", "0000011"), 265);
 134  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-6", "0000011"), 266);
 135  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-7", "0000011"), 267);
 136  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-8", "0000011"), 268);
 137  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-9", "0000011"), 268);
 138  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1992-1-30", 1), 22);
 139  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-1", 1), 263);
 140  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-4", 1), 264);
 141  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-5", 1), 265);
 142  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-6", 1), 266);
 143  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-7", 1), 267);
 144  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-8", 1), 268);
 145  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-1-9", 1), 268);
 146  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1992-1-6", "1110011"), 2);
 147  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1992-1-14", "1110011"), 4);
 148  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1992-1-30", "1110011"), 9);
 149  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1992-1-30", "0001110"), 17);
 150  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1992-2-22", "0001110"), 29);
 151  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1993-2-22", "0001110"), 239);
 152  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1992-2-22", "0000110"), 37);
 153  assertEquals(NETWORKDAYS$INTL("1992-1-1", "1992-2-22", 1, [DATE(1992, 1, 10), DATE(1992, 1, 11), DATE(1992, 1, 12), DATE(1992, 1, 13), DATE(1992, 1, 14)]), 35);
 154  assertEquals(NETWORKDAYS$INTL(["1992-1-1"], ["1992-1-30"], ["0000011"]), 22);
 155  assertEquals(NETWORKDAYS$INTL(900, 11999), 7928);
 156  assertEquals(NETWORKDAYS$INTL(900, 12000), 7929);
 157  assertEquals(NETWORKDAYS$INTL(900, 12001), 7930);
 158  assertEquals(NETWORKDAYS$INTL(900, 12002), 7931);
 159  assertEquals(NETWORKDAYS$INTL(900, 12003), 7932);
 160  assertEquals(NETWORKDAYS$INTL(900, 12004), 7933);
 161  assertEquals(NETWORKDAYS$INTL(900, 12005), 7933);
 162  catchAndAssertEquals(function() {
 163    NETWORKDAYS$INTL.apply(this, [12, 12, [12], false, 1]);
 164  }, ERRORS.NA_ERROR);
 165  catchAndAssertEquals(function() {
 166    NETWORKDAYS$INTL.apply(this, [12]);
 167  }, ERRORS.NA_ERROR);
 168  catchAndAssertEquals(function() {
 169    NETWORKDAYS$INTL("1992-1-1", "str");
 170  }, ERRORS.VALUE_ERROR);
 171  catchAndAssertEquals(function() {
 172    NETWORKDAYS$INTL(12, 12, 1, ["1992-11-1"]);
 173  }, ERRORS.VALUE_ERROR);
 174  catchAndAssertEquals(function() {
 175    NETWORKDAYS$INTL("1992-1-1", "1992-1-1", []);
 176  }, ERRORS.REF_ERROR);
 177  catchAndAssertEquals(function() {
 178    NETWORKDAYS$INTL("1992-1-1", "1994-1-1", "000");
 179  }, ERRORS.NUM_ERROR);
 180  catchAndAssertEquals(function() {
 181    NETWORKDAYS$INTL("1992-1-1", "1994-1-1", 9);
 182  }, ERRORS.NUM_ERROR);
 183  catchAndAssertEquals(function() {
 184    NETWORKDAYS$INTL("1992-1-1", "1994-1-1", false);
 185  }, ERRORS.VALUE_ERROR);
 186});
 187
 188
 189test("NETWORKDAYS", function(){
 190  assertEquals(NETWORKDAYS("1992-1-1", "1992-1-30"), 22);
 191  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-1"), 263);
 192  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-4"), 264);
 193  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-5"), 265);
 194  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-6"), 266);
 195  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-7"), 267);
 196  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-8"), 268);
 197  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-9"), 268);
 198  assertEquals(NETWORKDAYS("1992-1-1", "2000-4-24"), 2169);
 199  assertEquals(NETWORKDAYS("1992-1-1", false), -24003);
 200  assertEquals(NETWORKDAYS("2020-12-12", 0), -31555);
 201  assertEquals(NETWORKDAYS(12, 1423), 1008);
 202  assertEquals(NETWORKDAYS(12, 12), 1);
 203  assertEquals(NETWORKDAYS(DATE(1900, 1, 11), 12), 1);
 204  assertEquals(NETWORKDAYS(DATE(1998, 1, 1), DATE(1999, 1, 22)), 277);
 205  // Single holiday test
 206  assertEquals(NETWORKDAYS("1992-1-1", "1992-1-30", [DATEVALUE("1992-1-22")]), 21);
 207  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-1", [DATEVALUE("1992-6-19")]), 262);
 208  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-4", [DATEVALUE("1992-6-19")]), 263);
 209  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-5", [DATEVALUE("1992-6-19")]), 264);
 210  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-6", [DATEVALUE("1992-6-19")]), 265);
 211  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-7", [DATEVALUE("1992-6-19"), DATEVALUE("1992-6-18")]), 265);
 212  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-8", [DATEVALUE("1992-6-19")]), 267);
 213  assertEquals(NETWORKDAYS("1992-1-1", "1993-1-9", [DATEVALUE("1992-6-19")]), 267);
 214  assertEquals(NETWORKDAYS("1992-1-1", "2000-4-24", [DATEVALUE("1992-6-19")]), 2168);
 215  assertEquals(NETWORKDAYS("1992-1-1", false, [DATEVALUE("1991-6-19")]), -24002);
 216  assertEquals(NETWORKDAYS("2020-12-12", 0, [DATEVALUE("1992-6-19")]), -31554);
 217  assertEquals(NETWORKDAYS(12, 1423, [22]), 1008);// weekend and holdiay overlapping
 218  assertEquals(NETWORKDAYS(12, 1423, [20]), 1007);
 219  assertEquals(NETWORKDAYS(12, 12, [12]), 0);
 220  assertEquals(NETWORKDAYS(DATE(1998, 1, 1), DATE(1999, 1, 22), [DATE(1999, 1, 20)]), 276);
 221  catchAndAssertEquals(function() {
 222    NETWORKDAYS.apply(this, [12, 12, [12], false]);
 223  }, ERRORS.NA_ERROR);
 224  catchAndAssertEquals(function() {
 225    NETWORKDAYS.apply(this, [12]);
 226  }, ERRORS.NA_ERROR);
 227  catchAndAssertEquals(function() {
 228    NETWORKDAYS("1992-1-1", "str");
 229  }, ERRORS.VALUE_ERROR);
 230  catchAndAssertEquals(function() {
 231    NETWORKDAYS(12, 12, ["1992-11-1"]);
 232  }, ERRORS.VALUE_ERROR);
 233  catchAndAssertEquals(function() {
 234    NETWORKDAYS("1992-1-1", "1992-1-1", []);
 235  }, ERRORS.REF_ERROR);
 236});
 237
 238
 239test("SECOND", function() {
 240  assertEquals(SECOND("8:10"), 0);
 241  assertEquals(SECOND("8:11"), 0);
 242  assertEquals(SECOND("8:44"), 0);
 243  assertEquals(SECOND("8:70"), 0);
 244  assertEquals(SECOND("8:120"), 0);
 245  assertEquals(SECOND("8:10:22"), 22);
 246  assertEquals(SECOND("8:11:12"), 12);
 247  assertEquals(SECOND("8:44:09"), 9);
 248  assertEquals(SECOND("8:70:02"), 2);
 249  assertEquals(SECOND("8:120:44"), 44);
 250  assertEquals(SECOND("8:120:104"), 44);
 251  assertEquals(SECOND("1992-1-1 8:120:104"), 44);
 252  assertEquals(SECOND(0.511111111111), 0);
 253  catchAndAssertEquals(function() {
 254    SECOND.apply(this, ["8:10", 5]);
 255  }, ERRORS.NA_ERROR);
 256  catchAndAssertEquals(function() {
 257    SECOND.apply(this, []);
 258  }, ERRORS.NA_ERROR);
 259  catchAndAssertEquals(function() {
 260    SECOND("str");
 261  }, ERRORS.VALUE_ERROR);
 262  catchAndAssertEquals(function() {
 263    SECOND(" ");
 264  }, ERRORS.VALUE_ERROR);
 265  catchAndAssertEquals(function() {
 266    SECOND([]);
 267  }, ERRORS.REF_ERROR);
 268});
 269
 270
 271test("MINUTE", function() {
 272  assertEquals(MINUTE("8:10"), 10);
 273  assertEquals(MINUTE("8:11"), 11);
 274  assertEquals(MINUTE("8:44"), 44);
 275  assertEquals(MINUTE("8:70"), 10);
 276  assertEquals(MINUTE("8:120"), 0);
 277  assertEquals(MINUTE("8:10000pm"), 40);
 278  assertEquals(MINUTE("28:10000"), 40);
 279  assertEquals(MINUTE("14:23232:9999991"), 58);
 280  assertEquals(MINUTE(["8:10"]), 10);
 281  assertEquals(MINUTE("11:21222:2111pm"), 17);
 282  assertEquals(MINUTE("11:21222:2111am"), 17);
 283  assertEquals(MINUTE(""), 0);
 284  assertEquals(MINUTE(0), 0);
 285  assertEquals(MINUTE(1), 0);
 286  assertEquals(MINUTE(false), 0);
 287  assertEquals(MINUTE(true), 0);
 288  assertEquals(MINUTE(0.8), 12);
 289  assertEquals(MINUTE(0.5), 0);
 290  assertEquals(MINUTE(0.25), 0);
 291  assertEquals(MINUTE(0.125), 0);
 292  assertEquals(MINUTE(0.0625), 30);
 293  assertEquals(MINUTE(1.5), 0);
 294  assertEquals(MINUTE(99.5), 0);
 295  assertEquals(MINUTE("1969-7-6 5:05am"), 5);
 296  catchAndAssertEquals(function() {
 297    MINUTE.apply(this, ["8:10", 5]);
 298  }, ERRORS.NA_ERROR);
 299  catchAndAssertEquals(function() {
 300    MINUTE.apply(this, []);
 301  }, ERRORS.NA_ERROR);
 302  catchAndAssertEquals(function() {
 303    MINUTE("str");
 304  }, ERRORS.VALUE_ERROR);
 305  catchAndAssertEquals(function() {
 306    MINUTE(" ");
 307  }, ERRORS.VALUE_ERROR);
 308  catchAndAssertEquals(function() {
 309    MINUTE([]);
 310  }, ERRORS.REF_ERROR);
 311});
 312
 313
 314test("HOUR", function() {
 315  assertEquals(HOUR("8:10"), 8);
 316  assertEquals(HOUR("8am"), 8);
 317  assertEquals(HOUR("8:10pm"), 20);
 318  assertEquals(HOUR("8:10000pm"), 18);
 319  assertEquals(HOUR("28:10000"), 2);
 320  assertEquals(HOUR("14:23232:9999991"), 10);
 321  assertEquals(HOUR(["8:10"]), 8);
 322  assertEquals(HOUR("11:21222:2111pm"), 17);
 323  assertEquals(HOUR("11:21222:2111am"), 5);
 324  assertEquals(HOUR(""), 0);
 325  assertEquals(HOUR(0), 0);
 326  assertEquals(HOUR(1), 0);
 327  assertEquals(HOUR(false), 0);
 328  assertEquals(HOUR(true), 0);
 329  assertEquals(HOUR(0.8), 19);
 330  assertEquals(HOUR(0.5), 12);
 331  assertEquals(HOUR(0.25), 6);
 332  assertEquals(HOUR(0.125), 3);
 333  assertEquals(HOUR(0.0625), 1);
 334  assertEquals(HOUR(1.5), 12);
 335  assertEquals(HOUR(99.5), 12);
 336  assertEquals(HOUR("0.8"), 19);
 337  assertEquals(HOUR("0.5"), 12);
 338  assertEquals(HOUR("0.25"), 6);
 339  assertEquals(HOUR("0.125"), 3);
 340  assertEquals(HOUR("0.0625"), 1);
 341  assertEquals(HOUR("1969-7-6 5am"), 5);
 342  catchAndAssertEquals(function() {
 343    HOUR.apply(this, ["8:10", 5]);
 344  }, ERRORS.NA_ERROR);
 345  catchAndAssertEquals(function() {
 346    HOUR.apply(this, []);
 347  }, ERRORS.NA_ERROR);
 348  catchAndAssertEquals(function() {
 349    HOUR("str");
 350  }, ERRORS.VALUE_ERROR);
 351  catchAndAssertEquals(function() {
 352    HOUR(" ");
 353  }, ERRORS.VALUE_ERROR);
 354  catchAndAssertEquals(function() {
 355    HOUR([]);
 356  }, ERRORS.REF_ERROR);
 357});
 358
 359
 360test("TIMEVALUE", function() {
 361  assertEquals(TIMEVALUE("1969-7-6"), 0);
 362  assertEquals(TIMEVALUE("1969-7-6 8am"), 0.3333333333333333);
 363  assertEquals(TIMEVALUE("1969-7-28 8:10"), 0.3402777777777778);
 364  assertEquals(TIMEVALUE("2100-7-6 8:10pm"), 0.8402777777777778);
 365  assertEquals(TIMEVALUE("1999-1-1 8:10000pm"), 0.7777777777777778);
 366  assertEquals(TIMEVALUE("2012/1/1 28:10000"), 0.1111111111111111);
 367  assertEquals(TIMEVALUE("2012/1/1 14:23232:9999991"), 0.45730324074074075);
 368  assertEquals(TIMEVALUE(["2012/1/1 8:10"]), 0.3402777777777778);
 369  assertEquals(TIMEVALUE("2012/1/1 11:21222:2111pm"), 0.7202662037037038);
 370  assertEquals(TIMEVALUE("2012/1/1 11:21222:2111am"), 0.2202662037037037);
 371  assertEquals(TIMEVALUE("8am"), 0.3333333333333333);
 372  assertEquals(TIMEVALUE("8:10"), 0.3402777777777778);
 373  assertEquals(TIMEVALUE("8:10pm"), 0.8402777777777778);
 374  assertEquals(TIMEVALUE("8:10000pm"), 0.7777777777777778);
 375  assertEquals(TIMEVALUE("28:10000"), 0.1111111111111111);
 376  assertEquals(TIMEVALUE("14:23232:9999991"), 0.45730324074074075);
 377  assertEquals(TIMEVALUE(["8:10"]), 0.3402777777777778);
 378  assertEquals(TIMEVALUE("11:21222:2111pm"), 0.7202662037037038);
 379  assertEquals(TIMEVALUE("11:21222:2111am"), 0.2202662037037037);
 380  catchAndAssertEquals(function() {
 381    TIMEVALUE.apply(this, ["8:10", 5]);
 382  }, ERRORS.NA_ERROR);
 383  catchAndAssertEquals(function() {
 384    TIMEVALUE.apply(this, []);
 385  }, ERRORS.NA_ERROR);
 386  catchAndAssertEquals(function() {
 387    TIMEVALUE("str");
 388  }, ERRORS.VALUE_ERROR);
 389  catchAndAssertEquals(function() {
 390    TIMEVALUE([]);
 391  }, ERRORS.REF_ERROR);
 392});
 393
 394
 395test("YEARFRAC", function(){
 396  assertEquals(YEARFRAC(1, 1461, 2), 4.055555555555555);
 397  assertEquals(YEARFRAC(0, 365, 0), 1);
 398  assertEquals(YEARFRAC(0, 365, 1), 1);
 399  assertEquals(YEARFRAC(0, 365, 2), 1.0138888888888888);
 400  assertEquals(YEARFRAC(0, 365, 3), 1);
 401  assertEquals(YEARFRAC(0, 365, 4), 1);
 402  assertEquals(YEARFRAC(0, 1000, 0), 2.738888888888889);
 403  assertEquals(YEARFRAC(0, 1000, 1), 2.73972602739726);
 404  assertEquals(YEARFRAC(0, 1000, 2), 2.7777777777777777);
 405  assertEquals(YEARFRAC(0, 1000, 3), 2.73972602739726);
 406  assertEquals(YEARFRAC(0, 1000, 4), 2.738888888888889);
 407  assertEquals(YEARFRAC(10000, 20000, 0), 27.375);
 408  assertEquals(YEARFRAC(10000, 20000, 1), 27.378507871321013); // gs: 27.37808219, ms: 27.37850787
 409  assertEquals(YEARFRAC(10000, 20000, 2), 27.77777777777778);
 410  assertEquals(YEARFRAC(10000, 20000, 3), 27.397260273972602);
 411  assertEquals(YEARFRAC(10000, 20000, 4), 27.375);
 412  assertEquals(YEARFRAC(100000, 200000, 0), 273.7944444444444);
 413  assertEquals(YEARFRAC(100000, 200000, 1), 273.7925747453729); // gs: 273.7917808, ms: 273.7925747
 414  assertEquals(YEARFRAC(100000, 200000, 2), 277.77777777777777);
 415  assertEquals(YEARFRAC(100000, 200000, 3), 273.972602739726);
 416  assertEquals(YEARFRAC(100000, 200000, 4), 273.7944444444444);
 417  assertEquals(YEARFRAC("1969-7-6", "1988-7-4", 0), 18.994444444444444);
 418  assertEquals(YEARFRAC("1969-7-6", "1988-7-22", 0), 19.044444444444444);
 419  assertEquals(YEARFRAC("1992-1-6", "2191-7-22", 0), 199.544444444444444);
 420  assertEquals(YEARFRAC("1992-1-6", "2191-1-21", 0), 199.041666666666667);
 421  assertEquals(YEARFRAC("1992-1-6", "2144-1-22", 0), 152.044444444444444);
 422  assertEquals(YEARFRAC("1992-1-6", "1992-1-6", 0), 0);
 423  assertEquals(YEARFRAC("1992-1-6", "1992-1-1", 0), 0.013888888888888888);
 424  assertEquals(YEARFRAC("1992-1-6", "1993-1-6", 0), 1);
 425  assertEquals(YEARFRAC("1969-7-6", "1988-7-4", 1), 18.99520876112252);
 426  assertEquals(YEARFRAC("1969-7-6", "1988-7-22", 1), 19.044490075290895);
 427  assertEquals(YEARFRAC("1992-1-6", "2191-7-22", 1), 199.54003477118098);
 428  assertEquals(YEARFRAC("1992-1-6", "2191-1-21", 1), 199.04173910662706);
 429  assertEquals(YEARFRAC("1992-1-6", "2144-1-22", 1), 152.04174793765546);
 430  assertEquals(YEARFRAC("1992-1-6", "1992-1-6", 1), 0);
 431  assertEquals(YEARFRAC("1992-1-6", "1992-1-1", 1), 0.01366120218579235);
 432  assertEquals(YEARFRAC("1991-1-6", "1992-1-6", 1), 1);
 433  assertEquals(YEARFRAC("1992-1-6", "1993-1-6", 1), 1);
 434  assertEquals(YEARFRAC("1969-7-6", "1988-7-22", 2), 19.322222222222223);
 435  assertEquals(YEARFRAC("1992-1-6", "2191-7-22", 2), 202.44722222222222);
 436  assertEquals(YEARFRAC("1992-1-6", "2191-1-21", 2), 201.94166666666666);
 437  assertEquals(YEARFRAC("1992-1-6", "2144-1-22", 2), 154.25833333333333);
 438  assertEquals(YEARFRAC("1992-1-6", "1992-1-6", 2), 0);
 439  assertEquals(YEARFRAC("1992-1-6", "1992-1-1", 2), 0.013888888888888888);
 440  assertEquals(YEARFRAC("1991-1-6", "1992-1-6", 2), 1.0138888888888888);
 441  assertEquals(YEARFRAC("1992-1-6", "1993-1-6", 2), 1.0166666666666666);
 442  assertEquals(YEARFRAC("1969-7-6", "1988-7-22", 3), 19.057534246575344);
 443  assertEquals(YEARFRAC("1992-1-6", "2191-7-22", 3), 199.67397260273972);
 444  assertEquals(YEARFRAC("1992-1-6", "2191-1-21", 3), 199.17534246575343);
 445  assertEquals(YEARFRAC("1992-1-6", "2144-1-22", 3), 152.14520547945204);
 446  assertEquals(YEARFRAC("1992-1-6", "1992-1-6", 3), 0);
 447  assertEquals(YEARFRAC("1992-1-6", "1992-1-1", 3), 0.0136986301369863);
 448  assertEquals(YEARFRAC("1991-1-6", "1992-1-6", 3), 1);
 449  assertEquals(YEARFRAC("1992-1-6", "1993-1-6", 3), 1.0027397260273974);
 450  assertEquals(YEARFRAC("1969-7-6", "1988-7-22", 4), 19.044444444444444);
 451  assertEquals(YEARFRAC("1992-1-6", "2191-7-22", 4), 199.54444444444445);
 452  assertEquals(YEARFRAC("1992-1-6", "2191-1-21", 4), 199.04166666666666);
 453  assertEquals(YEARFRAC("1992-1-6", "2144-1-22", 4), 152.04444444444445);
 454  assertEquals(YEARFRAC("1992-1-6", "1992-1-6", 4), 0);
 455  assertEquals(YEARFRAC("1992-1-6", "1992-1-1", 4), 0.013888888888888888);
 456  assertEquals(YEARFRAC("1991-1-6", "1992-1-6", 4), 1);
 457  assertEquals(YEARFRAC("1992-1-6", "1993-1-6", 4), 1);
 458  assertEquals(YEARFRAC("1969-7-6", "1988-7-4", 2), 19.272222222222222);
 459  assertEquals(YEARFRAC("1969-7-6", "1988-7-4", 3), 19.008219178082193);
 460  assertEquals(YEARFRAC("1969-7-6", "1988-7-4", 4), 18.994444444444444);
 461  assertEquals(YEARFRAC(["1992-1-6", []], ["1993-1-6", "str"], [4]), 1);
 462  catchAndAssertEquals(function() {
 463    YEARFRAC("1996-6-19", "1992-6-19", 5);
 464  }, ERRORS.NUM_ERROR);
 465  catchAndAssertEquals(function() {
 466    YEARFRAC.apply(this, []);
 467  }, ERRORS.NA_ERROR);
 468  catchAndAssertEquals(function() {
 469    YEARFRAC.apply(this, ["1992-6-19", "1995-6-19", 1, 0]);
 470  }, ERRORS.NA_ERROR);
 471  catchAndAssertEquals(function() {
 472    YEARFRAC("str", "1995-6-19", 1);
 473  }, ERRORS.VALUE_ERROR);
 474  catchAndAssertEquals(function() {
 475    YEARFRAC([], "1995-6-19", 1);
 476  }, ERRORS.REF_ERROR);
 477});
 478
 479
 480test("DATEDIF", function(){
 481  assertEquals(DATEDIF("1992-6-19", "1996-6-19", "Y"), 4);
 482  assertEquals(DATEDIF("1992-6-19", "1996-6-0", "Y"), 3);
 483  assertEquals(DATEDIF("1992-6-19", "1992-8-1", "Y"), 0);
 484  assertEquals(DATEDIF("1992-6-19", "2199-8-1", "Y"), 207);
 485  assertEquals(DATEDIF("1992-6-19", "1996-6-19", "M"), 48);
 486  assertEquals(DATEDIF("1992-6-19", "1996-6-1", "M"), 47);
 487  assertEquals(DATEDIF("1992-6-19", "1992-8-1", "M"), 1);
 488  assertEquals(DATEDIF("1992-6-19", "2199-8-1", "M"), 2485);
 489  assertEquals(DATEDIF("1992-6-19", "1996-6-19", "D"), 1461);
 490  assertEquals(DATEDIF("1992-6-19", "1996-6-1", "D"), 1443);
 491  assertEquals(DATEDIF("1992-6-19", "1992-8-1", "D"), 43);
 492  assertEquals(DATEDIF("1992-6-19", "2199-8-1", "D"), 75648);
 493  assertEquals(DATEDIF("1992-6-19", "2199-8-1", "MD"), 13);
 494  assertEquals(DATEDIF("1992-6-19", "2012-7-22", "MD"), 3);
 495  assertEquals(DATEDIF("1992-6-19", "1993-8-1", "MD"), 13);
 496  assertEquals(DATEDIF("1992-6-19", "2000-1-19", "MD"), 0);
 497  assertEquals(DATEDIF("1992-6-19", "2000-1-20", "MD"), 1);
 498  assertEquals(DATEDIF("1992-6-19", "2000-1-21", "MD"), 2);
 499  assertEquals(DATEDIF("1992-6-19", "2000-1-22", "MD"), 3);
 500  assertEquals(DATEDIF("1992-6-19", "2000-1-23", "MD"), 4);
 501  assertEquals(DATEDIF("1992-6-19", "2000-1-24", "MD"), 5);
 502  assertEquals(DATEDIF("1992-6-19", "2000-1-25", "MD"), 6);
 503  assertEquals(DATEDIF("1992-6-20", "2000-1-25", "MD"), 5);
 504  assertEquals(DATEDIF("1992-6-19", "2199-8-1", "YM"), 1);
 505  assertEquals(DATEDIF("1992-6-19", "2012-7-22", "YM"), 1);
 506  assertEquals(DATEDIF("1992-6-19", "1993-8-1", "YM"), 1);
 507  assertEquals(DATEDIF("1992-6-19", "2000-1-19", "YM"), 7);
 508  assertEquals(DATEDIF("1992-6-19", "2000-1-20", "YM"), 7);
 509  assertEquals(DATEDIF("1992-6-19", "2000-1-21", "YM"), 7);
 510  assertEquals(DATEDIF("1992-6-19", "2000-1-22", "YM"), 7);
 511  assertEquals(DATEDIF("1992-6-19", "2000-1-23", "YM"), 7);
 512  assertEquals(DATEDIF("1992-6-19", "2000-1-24", "YM"), 7);
 513  assertEquals(DATEDIF("1992-6-19", "2000-1-25", "YM"), 7);
 514  assertEquals(DATEDIF("1992-6-20", "2000-1-25", "YM"), 7);
 515  assertEquals(DATEDIF("1992-6-19", "1992-6-19", "YM"), 0);
 516  assertEquals(DATEDIF("1992-6-19", "1992-7-19", "YM"), 1);
 517  assertEquals(DATEDIF("1992-6-19", "1993-7-19", "YM"), 1);
 518  assertEquals(DATEDIF("1992-6-19", "1993-6-19", "YM"), 0);
 519  assertEquals(DATEDIF("1992-6-19", "2199-8-1", "YD"), 43);
 520  assertEquals(DATEDIF("1992-6-19", "2012-7-22", "YD"), 33);
 521  assertEquals(DATEDIF("1992-6-19", "1993-8-1", "YD"), 43);
 522  assertEquals(DATEDIF("1992-6-19", "2000-1-19", "YD"), 214);
 523  assertEquals(DATEDIF("1992-6-19", "2000-1-20", "YD"), 215);
 524  assertEquals(DATEDIF("1992-6-19", "2000-1-21", "YD"), 216);
 525  assertEquals(DATEDIF("1992-6-19", "2000-1-22", "YD"), 217);
 526  assertEquals(DATEDIF("1992-6-19", "2000-1-23", "YD"), 218);
 527  assertEquals(DATEDIF("1992-6-19", "2000-1-24", "YD"), 219);
 528  assertEquals(DATEDIF("1992-6-19", "2000-1-25", "YD"), 220);
 529  assertEquals(DATEDIF("1992-6-19", "1992-6-19", "YD"), 0);
 530  assertEquals(DATEDIF("1992-6-19", "1992-7-19", "YD"), 30);
 531  assertEquals(DATEDIF("1992-6-19", "1993-7-19", "YD"), 30);
 532  assertEquals(DATEDIF("1992-6-19", "1993-6-19", "YD"), 0);
 533  assertEquals(DATEDIF("1992-6-19", "1993-6-19", "yd"), 0);
 534  assertEquals(DATEDIF(["1992-6-19", "str"], ["1993-6-19", []], ["yd"]), 0);
 535  catchAndAssertEquals(function() {
 536    DATEDIF("1996-6-19", "1992-6-19", "Y");
 537  }, ERRORS.NUM_ERROR);
 538  catchAndAssertEquals(function() {
 539    DATEDIF("1992-6-19", "1995-6-19", "Y ");
 540  }, ERRORS.NUM_ERROR);
 541  catchAndAssertEquals(function() {
 542    DATEDIF("1992-6-19", "1995-6-19", "mm");
 543  }, ERRORS.NUM_ERROR);
 544  catchAndAssertEquals(function() {
 545    DATEDIF.apply(this, []);
 546  }, ERRORS.NA_ERROR);
 547  catchAndAssertEquals(function() {
 548    DATEDIF.apply(this, ["1992-6-19", "1995-6-19", "mm", 0]);
 549  }, ERRORS.NA_ERROR);
 550  catchAndAssertEquals(function() {
 551    DATEDIF("str", "1995-6-19", "mm");
 552  }, ERRORS.VALUE_ERROR);
 553  catchAndAssertEquals(function() {
 554    DATEDIF([], "1995-6-19", "mm");
 555  }, ERRORS.REF_ERROR);
 556});
 557
 558
 559test("WEEKNUM", function(){
 560  assertEquals(WEEKNUM(DATE(1992, 6, 19)), 25);
 561  assertEquals(WEEKNUM(DATE(1992, 6, 20)), 25);
 562  assertEquals(WEEKNUM(DATE(1992, 6, 21)), 26);
 563  assertEquals(WEEKNUM(0), 52);
 564  assertEquals(WEEKNUM(false), 52);
 565  assertEquals(WEEKNUM(1), 53);
 566  assertEquals(WEEKNUM(true), 53);
 567  assertEquals(WEEKNUM(2), 1);
 568  assertEquals(WEEKNUM(3), 1);
 569  assertEquals(WEEKNUM(4), 1);
 570  assertEquals(WEEKNUM(5), 1);
 571  assertEquals(WEEKNUM(6), 1);
 572  assertEquals(WEEKNUM(7), 1);
 573  assertEquals(WEEKNUM(8), 2);
 574  assertEquals(WEEKNUM(9), 2);
 575  assertEquals(WEEKNUM(10), 2);
 576  assertEquals(WEEKNUM(11), 2);
 577  assertEquals(WEEKNUM(12), 2);
 578  assertEquals(WEEKNUM(13), 2);
 579  assertEquals(WEEKNUM(14), 2);
 580  assertEquals(WEEKNUM(15), 3);
 581  assertEquals(WEEKNUM(16), 3);
 582  assertEquals(WEEKNUM(17), 3);
 583  assertEquals(WEEKNUM(18), 3);
 584  assertEquals(WEEKNUM(23734), 52);
 585  assertEquals(WEEKNUM(23735), 52);
 586  assertEquals(WEEKNUM(23736), 52);
 587  assertEquals(WEEKNUM(23737), 52);
 588  assertEquals(WEEKNUM(23738), 53);
 589  assertEquals(WEEKNUM(23739), 53);
 590  assertEquals(WEEKNUM(23740), 53);
 591  assertEquals(WEEKNUM(23741), 53);
 592  assertEquals(WEEKNUM(23742), 53);
 593  assertEquals(WEEKNUM(23743), 1);
 594  assertEquals(WEEKNUM(23744), 1);
 595  assertEquals(WEEKNUM(23745), 2);
 596  assertEquals(WEEKNUM(23746), 2);
 597  assertEquals(WEEKNUM(23747), 2);
 598  assertEquals(WEEKNUM(23748), 2);
 599  assertEquals(WEEKNUM(23749), 2);
 600  assertEquals(WEEKNUM(23750), 2);
 601  assertEquals(WEEKNUM(23751), 2);
 602  assertEquals(WEEKNUM(23752), 3);
 603  // type=2
 604  assertEquals(WEEKNUM(23737, 2), 52);
 605  assertEquals(WEEKNUM(23738, 2), 52);
 606  assertEquals(WEEKNUM(23739, 2), 53);
 607  assertEquals(WEEKNUM(23740, 2), 53);
 608  assertEquals(WEEKNUM(23741, 2), 53);
 609  assertEquals(WEEKNUM(23742, 2), 53);
 610  assertEquals(WEEKNUM(23743, 2), 1);
 611  assertEquals(WEEKNUM(23744, 2), 1);
 612  assertEquals(WEEKNUM(23745, 2), 1);
 613  assertEquals(WEEKNUM(23746, 2), 2);
 614  assertEquals(WEEKNUM(23747, 2), 2);
 615  assertEquals(WEEKNUM(23748, 2), 2);
 616  assertEquals(WEEKNUM(23749, 2), 2);
 617  assertEquals(WEEKNUM(23750, 2), 2);
 618  assertEquals(WEEKNUM(23751, 2), 2);
 619  assertEquals(WEEKNUM(23752, 2), 2);
 620  assertEquals(WEEKNUM(23753, 2), 3);
 621  assertEquals(WEEKNUM(23754, 2), 3);
 622  assertEquals(WEEKNUM(23755, 2), 3);
 623  assertEquals(WEEKNUM(23756, 2), 3);
 624  assertEquals(WEEKNUM(23757, 2), 3);
 625  assertEquals(WEEKNUM(23758, 2), 3);
 626  assertEquals(WEEKNUM(23759, 2), 3);
 627  assertEquals(WEEKNUM(23760, 2), 4);
 628  //type=11
 629  assertEquals(WEEKNUM(23737, 11), 52);
 630  assertEquals(WEEKNUM(23738, 11), 52);
 631  assertEquals(WEEKNUM(23739, 11), 53);
 632  assertEquals(WEEKNUM(23740, 11), 53);
 633  assertEquals(WEEKNUM(23741, 11), 53);
 634  assertEquals(WEEKNUM(23742, 11), 53);
 635  assertEquals(WEEKNUM(23743, 11), 1);
 636  assertEquals(WEEKNUM(23744, 11), 1);
 637  assertEquals(WEEKNUM(23745, 11), 1);
 638  assertEquals(WEEKNUM(23746, 11), 2);
 639  assertEquals(WEEKNUM(23747, 11), 2);
 640  assertEquals(WEEKNUM(23748, 11), 2);
 641  assertEquals(WEEKNUM(23749, 11), 2);
 642  assertEquals(WEEKNUM(23750, 11), 2);
 643  assertEquals(WEEKNUM(23751, 11), 2);
 644  assertEquals(WEEKNUM(23752, 11), 2);
 645  assertEquals(WEEKNUM(23753, 11), 3);
 646  assertEquals(WEEKNUM(23754, 11), 3);
 647  assertEquals(WEEKNUM(23755, 11), 3);
 648  assertEquals(WEEKNUM(23756, 11), 3);
 649  assertEquals(WEEKNUM(23757, 11), 3);
 650  assertEquals(WEEKNUM(23758, 11), 3);
 651  assertEquals(WEEKNUM(23759, 11), 3);
 652  assertEquals(WEEKNUM(23760, 11), 4);
 653  //type=12
 654  assertEquals(WEEKNUM(23737, 12), 52);
 655  assertEquals(WEEKNUM(23738, 12), 52);
 656  assertEquals(WEEKNUM(23739, 12), 52);
 657  assertEquals(WEEKNUM(23740, 12), 53);
 658  assertEquals(WEEKNUM(23741, 12), 53);
 659  assertEquals(WEEKNUM(23742, 12), 53);
 660  assertEquals(WEEKNUM(23743, 12), 1);
 661  assertEquals(WEEKNUM(23744, 12), 1);
 662  assertEquals(WEEKNUM(23745, 12), 1);
 663  assertEquals(WEEKNUM(23746, 12), 1);
 664  assertEquals(WEEKNUM(23747, 12), 2);
 665  assertEquals(WEEKNUM(23748, 12), 2);
 666  assertEquals(WEEKNUM(23749, 12), 2);
 667  assertEquals(WEEKNUM(23750, 12), 2);
 668  assertEquals(WEEKNUM(23751, 12), 2);
 669  assertEquals(WEEKNUM(23752, 12), 2);
 670  assertEquals(WEEKNUM(23753, 12), 2);
 671  assertEquals(WEEKNUM(23754, 12), 3);
 672  assertEquals(WEEKNUM(23755, 12), 3);
 673  assertEquals(WEEKNUM(23756, 12), 3);
 674  assertEquals(WEEKNUM(23757, 12), 3);
 675  assertEquals(WEEKNUM(23758, 12), 3);
 676  assertEquals(WEEKNUM(23759, 12), 3);
 677  assertEquals(WEEKNUM(23760, 12), 3);
 678  //type=13
 679  assertEquals(WEEKNUM(23737, 13), 52);
 680  assertEquals(WEEKNUM(23738, 13), 52);
 681  assertEquals(WEEKNUM(23739, 13), 52);
 682  assertEquals(WEEKNUM(23740, 13), 52);
 683  assertEquals(WEEKNUM(23741, 13), 53);
 684  assertEquals(WEEKNUM(23742, 13), 53);
 685  assertEquals(WEEKNUM(23743, 13), 1);
 686  assertEquals(WEEKNUM(23744, 13), 1);
 687  assertEquals(WEEKNUM(23745, 13), 1);
 688  assertEquals(WEEKNUM(23746, 13), 1);
 689  assertEquals(WEEKNUM(23747, 13), 1);
 690  assertEquals(WEEKNUM(23748, 13), 2);
 691  assertEquals(WEEKNUM(23749, 13), 2);
 692  assertEquals(WEEKNUM(23750, 13), 2);
 693  assertEquals(WEEKNUM(23751, 13), 2);
 694  assertEquals(WEEKNUM(23752, 13), 2);
 695  assertEquals(WEEKNUM(23753, 13), 2);
 696  assertEquals(WEEKNUM(23754, 13), 2);
 697  assertEquals(WEEKNUM(23755, 13), 3);
 698  assertEquals(WEEKNUM(23756, 13), 3);
 699  assertEquals(WEEKNUM(23757, 13), 3);
 700  assertEquals(WEEKNUM(23758, 13), 3);
 701  assertEquals(WEEKNUM(23759, 13), 3);
 702  assertEquals(WEEKNUM(23760, 13), 3);
 703  //type=14
 704  assertEquals(WEEKNUM(23734, 14), 52);
 705  assertEquals(WEEKNUM(23735, 14), 53);
 706  assertEquals(WEEKNUM(23736, 14), 53);
 707  assertEquals(WEEKNUM(23737, 14), 53);
 708  assertEquals(WEEKNUM(23738, 14), 53);
 709  assertEquals(WEEKNUM(23739, 14), 53);
 710  assertEquals(WEEKNUM(23740, 14), 53);
 711  assertEquals(WEEKNUM(23741, 14), 53);
 712  assertEquals(WEEKNUM(23742, 14), 54);
 713  assertEquals(WEEKNUM(23743, 14), 1);
 714  assertEquals(WEEKNUM(23744, 14), 1);
 715  assertEquals(WEEKNUM(23745, 14), 1);
 716  assertEquals(WEEKNUM(23746, 14), 1);
 717  assertEquals(WEEKNUM(23747, 14), 1);
 718  assertEquals(WEEKNUM(23748, 14), 1);
 719  assertEquals(WEEKNUM(23749, 14), 2);
 720  assertEquals(WEEKNUM(23750, 14), 2);
 721  assertEquals(WEEKNUM(23751, 14), 2);
 722  assertEquals(WEEKNUM(23752, 14), 2);
 723  assertEquals(WEEKNUM(23753, 14), 2);
 724  assertEquals(WEEKNUM(23754, 14), 2);
 725  assertEquals(WEEKNUM(23755, 14), 2);
 726  assertEquals(WEEKNUM(23756, 14), 3);
 727  assertEquals(WEEKNUM(23757, 14), 3);
 728  assertEquals(WEEKNUM(23758, 14), 3);
 729  assertEquals(WEEKNUM(23759, 14), 3);
 730  assertEquals(WEEKNUM(23760, 14), 3);
 731  //type=14 again
 732  assertEquals(WEEKNUM(355, 14), 52);
 733  assertEquals(WEEKNUM(356, 14), 52);
 734  assertEquals(WEEKNUM(357, 14), 52);
 735  assertEquals(WEEKNUM(358, 14), 52);
 736  assertEquals(WEEKNUM(359, 14), 52);
 737  assertEquals(WEEKNUM(360, 14), 52);
 738  assertEquals(WEEKNUM(361, 14), 52);
 739  assertEquals(WEEKNUM(362, 14), 53);
 740  assertEquals(WEEKNUM(363, 14), 53);
 741  assertEquals(WEEKNUM(364, 14), 53);
 742  assertEquals(WEEKNUM(365, 14), 53);
 743  assertEquals(WEEKNUM(366, 14), 53);
 744  assertEquals(WEEKNUM(367, 14), 1);
 745  assertEquals(WEEKNUM(368, 14), 1);
 746  assertEquals(WEEKNUM(369, 14), 2);
 747  assertEquals(WEEKNUM(370, 14), 2);
 748  assertEquals(WEEKNUM(371, 14), 2);
 749  assertEquals(WEEKNUM(372, 14), 2);
 750  assertEquals(WEEKNUM(373, 14), 2);
 751  assertEquals(WEEKNUM(374, 14), 2);
 752  assertEquals(WEEKNUM(375, 14), 2);
 753  assertEquals(WEEKNUM(376, 14), 3);
 754  assertEquals(WEEKNUM(377, 14), 3);
 755  assertEquals(WEEKNUM(378, 14), 3);
 756  assertEquals(WEEKNUM(379, 14), 3);
 757  assertEquals(WEEKNUM(380, 14), 3);
 758  assertEquals(WEEKNUM(381, 14), 3);
 759  //type=14 again
 760  assertEquals(WEEKNUM(730, 14), 53);
 761  assertEquals(WEEKNUM(731, 14), 53);
 762  assertEquals(WEEKNUM(732, 14), 1);
 763  assertEquals(WEEKNUM(733, 14), 2);
 764  assertEquals(WEEKNUM(734, 14), 2);
 765  assertEquals(WEEKNUM(735, 14), 2);
 766  assertEquals(WEEKNUM(736, 14), 2);
 767  assertEquals(WEEKNUM(737, 14), 2);
 768  assertEquals(WEEKNUM(738, 14), 2);
 769  assertEquals(WEEKNUM(739, 14), 2);
 770  assertEquals(WEEKNUM(740, 14), 3);
 771  assertEquals(WEEKNUM(741, 14), 3);
 772  assertEquals(WEEKNUM(742, 14), 3);
 773  assertEquals(WEEKNUM(743, 14), 3);
 774  assertEquals(WEEKNUM(744, 14), 3);
 775  assertEquals(WEEKNUM(745, 14), 3);
 776  assertEquals(WEEKNUM(746, 14), 3);
 777  //type=15
 778  assertEquals(WEEKNUM(23734, 15), 52);
 779  assertEquals(WEEKNUM(23735, 15), 52);
 780  assertEquals(WEEKNUM(23736, 15), 53);
 781  assertEquals(WEEKNUM(23737, 15), 53);
 782  assertEquals(WEEKNUM(23738, 15), 53);
 783  assertEquals(WEEKNUM(23739, 15), 53);
 784  assertEquals(WEEKNUM(23740, 15), 53);
 785  assertEquals(WEEKNUM(23741, 15), 53);
 786  assertEquals(WEEKNUM(23742, 15), 53);
 787  assertEquals(WEEKNUM(23743, 15), 1);
 788  assertEquals(WEEKNUM(23744, 15), 1);
 789  assertEquals(WEEKNUM(23745, 15), 1);
 790  assertEquals(WEEKNUM(23746, 15), 1);
 791  assertEquals(WEEKNUM(23747, 15), 1);
 792  assertEquals(WEEKNUM(23748, 15), 1);
 793  assertEquals(WEEKNUM(23749, 15), 1);
 794  assertEquals(WEEKNUM(23750, 15), 2);
 795  assertEquals(WEEKNUM(23751, 15), 2);
 796  assertEquals(WEEKNUM(23752, 15), 2);
 797  assertEquals(WEEKNUM(23753, 15), 2);
 798  assertEquals(WEEKNUM(23754, 15), 2);
 799  assertEquals(WEEKNUM(23755, 15), 2);
 800  assertEquals(WEEKNUM(23756, 15), 2);
 801  assertEquals(WEEKNUM(23757, 15), 3);
 802  assertEquals(WEEKNUM(23758, 15), 3);
 803  assertEquals(WEEKNUM(23759, 15), 3);
 804  assertEquals(WEEKNUM(23760, 15), 3);
 805  //type=15 again
 806  assertEquals(WEEKNUM(355, 15), 51);
 807  assertEquals(WEEKNUM(356, 15), 52);
 808  assertEquals(WEEKNUM(357, 15), 52);
 809  assertEquals(WEEKNUM(358, 15), 52);
 810  assertEquals(WEEKNUM(359, 15), 52);
 811  assertEquals(WEEKNUM(360, 15), 52);
 812  assertEquals(WEEKNUM(361, 15), 52);
 813  assertEquals(WEEKNUM(362, 15), 52);
 814  assertEquals(WEEKNUM(363, 15), 53);
 815  assertEquals(WEEKNUM(364, 15), 53);
 816  assertEquals(WEEKNUM(365, 15), 53);
 817  assertEquals(WEEKNUM(366, 15), 53);
 818  assertEquals(WEEKNUM(367, 15), 1);
 819  assertEquals(WEEKNUM(368, 15), 1);
 820  assertEquals(WEEKNUM(369, 15), 1);
 821  assertEquals(WEEKNUM(370, 15), 2);
 822  assertEquals(WEEKNUM(371, 15), 2);
 823  assertEquals(WEEKNUM(372, 15), 2);
 824  assertEquals(WEEKNUM(373, 15), 2);
 825  assertEquals(WEEKNUM(374, 15), 2);
 826  assertEquals(WEEKNUM(375, 15), 2);
 827  assertEquals(WEEKNUM(376, 15), 2);
 828  assertEquals(WEEKNUM(377, 15), 3);
 829  assertEquals(WEEKNUM(378, 15), 3);
 830  assertEquals(WEEKNUM(379, 15), 3);
 831  assertEquals(WEEKNUM(380, 15), 3);
 832  assertEquals(WEEKNUM(381, 15), 3);
 833  //type=15 again
 834  assertEquals(WEEKNUM(730, 15), 53);
 835  assertEquals(WEEKNUM(731, 15), 53);
 836  assertEquals(WEEKNUM(732, 15), 1);
 837  assertEquals(WEEKNUM(733, 15), 1);
 838  assertEquals(WEEKNUM(734, 15), 2);
 839  assertEquals(WEEKNUM(735, 15), 2);
 840  assertEquals(WEEKNUM(736, 15), 2);
 841  assertEquals(WEEKNUM(737, 15), 2);
 842  assertEquals(WEEKNUM(738, 15), 2);
 843  assertEquals(WEEKNUM(739, 15), 2);
 844  assertEquals(WEEKNUM(740, 15), 2);
 845  assertEquals(WEEKNUM(741, 15), 3);
 846  assertEquals(WEEKNUM(742, 15), 3);
 847  assertEquals(WEEKNUM(743, 15), 3);
 848  assertEquals(WEEKNUM(744, 15), 3);
 849  assertEquals(WEEKNUM(745, 15), 3);
 850  assertEquals(WEEKNUM(746, 15), 3);
 851  //type=16
 852  assertEquals(WEEKNUM(23734, 16), 52);
 853  assertEquals(WEEKNUM(23735, 16), 52);
 854  assertEquals(WEEKNUM(23736, 16), 52);
 855  assertEquals(WEEKNUM(23737, 16), 53);
 856  assertEquals(WEEKNUM(23738, 16), 53);
 857  assertEquals(WEEKNUM(23739, 16), 53);
 858  assertEquals(WEEKNUM(23740, 16), 53);
 859  assertEquals(WEEKNUM(23741, 16), 53);
 860  assertEquals(WEEKNUM(23742, 16), 53);
 861  assertEquals(WEEKNUM(23743, 16), 1);
 862  assertEquals(WEEKNUM(23744, 16), 2);
 863  assertEquals(WEEKNUM(23745, 16), 2);
 864  assertEquals(WEEKNUM(23746, 16), 2);
 865  assertEquals(WEEKNUM(23747, 16), 2);
 866  assertEquals(WEEKNUM(23748, 16), 2);
 867  assertEquals(WEEKNUM(23749, 16), 2);
 868  assertEquals(WEEKNUM(23750, 16), 2);
 869  assertEquals(WEEKNUM(23751, 16), 3);
 870  assertEquals(WEEKNUM(23752, 16), 3);
 871  assertEquals(WEEKNUM(23753, 16), 3);
 872  assertEquals(WEEKNUM(23754, 16), 3);
 873  assertEquals(WEEKNUM(23755, 16), 3);
 874  assertEquals(WEEKNUM(23756, 16), 3);
 875  assertEquals(WEEKNUM(23757, 16), 3);
 876  assertEquals(WEEKNUM(23758, 16), 4);
 877  assertEquals(WEEKNUM(23759, 16), 4);
 878  assertEquals(WEEKNUM(23760, 16), 4);
 879  // //type=16 again
 880  assertEquals(WEEKNUM(355, 16), 51);
 881  assertEquals(WEEKNUM(356, 16), 51);
 882  assertEquals(WEEKNUM(357, 16), 52);
 883  assertEquals(WEEKNUM(358, 16), 52);
 884  assertEquals(WEEKNUM(359, 16), 52);
 885  assertEquals(WEEKNUM(360, 16), 52);
 886  assertEquals(WEEKNUM(361, 16), 52);
 887  assertEquals(WEEKNUM(362, 16), 52);
 888  assertEquals(WEEKNUM(363, 16), 52);
 889  assertEquals(WEEKNUM(364, 16), 53);
 890  assertEquals(WEEKNUM(365, 16), 53);
 891  assertEquals(WEEKNUM(366, 16), 53);
 892  assertEquals(WEEKNUM(367, 16), 1);
 893  assertEquals(WEEKNUM(368, 16), 1);
 894  assertEquals(WEEKNUM(369, 16), 1);
 895  assertEquals(WEEKNUM(370, 16), 1);
 896  assertEquals(WEEKNUM(371, 16), 2);
 897  assertEquals(WEEKNUM(372, 16), 2);
 898  assertEquals(WEEKNUM(373, 16), 2);
 899  assertEquals(WEEKNUM(374, 16), 2);
 900  assertEquals(WEEKNUM(375, 16), 2);
 901  assertEquals(WEEKNUM(376, 16), 2);
 902  assertEquals(WEEKNUM(377, 16), 2);
 903  assertEquals(WEEKNUM(378, 16), 3);
 904  assertEquals(WEEKNUM(379, 16), 3);
 905  assertEquals(WEEKNUM(380, 16), 3);
 906  assertEquals(WEEKNUM(381, 16), 3);
 907  //type=16 again
 908  assertEquals(WEEKNUM(730, 16), 53);
 909  assertEquals(WEEKNUM(731, 16), 53);
 910  assertEquals(WEEKNUM(732, 16), 1);
 911  assertEquals(WEEKNUM(733, 16), 1);
 912  assertEquals(WEEKNUM(734, 16), 1);
 913  assertEquals(WEEKNUM(735, 16), 2);
 914  assertEquals(WEEKNUM(736, 16), 2);
 915  assertEquals(WEEKNUM(737, 16), 2);
 916  assertEquals(WEEKNUM(738, 16), 2);
 917  assertEquals(WEEKNUM(739, 16), 2);
 918  assertEquals(WEEKNUM(740, 16), 2);
 919  assertEquals(WEEKNUM(741, 16), 2);
 920  assertEquals(WEEKNUM(742, 16), 3);
 921  assertEquals(WEEKNUM(743, 16), 3);
 922  assertEquals(WEEKNUM(744, 16), 3);
 923  assertEquals(WEEKNUM(745, 16), 3);
 924  assertEquals(WEEKNUM(746, 16), 3);
 925  //type=17
 926  assertEquals(WEEKNUM(23734, 17), 52);
 927  assertEquals(WEEKNUM(23735, 17), 52);
 928  assertEquals(WEEKNUM(23736, 17), 52);
 929  assertEquals(WEEKNUM(23737, 17), 52);
 930  assertEquals(WEEKNUM(23738, 17), 53);
 931  assertEquals(WEEKNUM(23739, 17), 53);
 932  assertEquals(WEEKNUM(23740, 17), 53);
 933  assertEquals(WEEKNUM(23741, 17), 53);
 934  assertEquals(WEEKNUM(23742, 17), 53);
 935  assertEquals(WEEKNUM(23743, 17), 1);
 936  assertEquals(WEEKNUM(23744, 17), 1);
 937  assertEquals(WEEKNUM(23745, 17), 2);
 938  assertEquals(WEEKNUM(23746, 17), 2);
 939  assertEquals(WEEKNUM(23747, 17), 2);
 940  assertEquals(WEEKNUM(23748, 17), 2);
 941  assertEquals(WEEKNUM(23749, 17), 2);
 942  assertEquals(WEEKNUM(23750, 17), 2);
 943  assertEquals(WEEKNUM(23751, 17), 2);
 944  assertEquals(WEEKNUM(23752, 17), 3);
 945  assertEquals(WEEKNUM(23753, 17), 3);
 946  assertEquals(WEEKNUM(23754, 17), 3);
 947  assertEquals(WEEKNUM(23755, 17), 3);
 948  assertEquals(WEEKNUM(23756, 17), 3);
 949  assertEquals(WEEKNUM(23757, 17), 3);
 950  assertEquals(WEEKNUM(23758, 17), 3);
 951  assertEquals(WEEKNUM(23759, 17), 4);
 952  assertEquals(WEEKNUM(23760, 17), 4);
 953  // //type=17 again
 954  assertEquals(WEEKNUM(355, 17), 51);
 955  assertEquals(WEEKNUM(356, 17), 51);
 956  assertEquals(WEEKNUM(357, 17), 51);
 957  assertEquals(WEEKNUM(358, 17), 52);
 958  assertEquals(WEEKNUM(359, 17), 52);
 959  assertEquals(WEEKNUM(360, 17), 52);
 960  assertEquals(WEEKNUM(361, 17), 52);
 961  assertEquals(WEEKNUM(362, 17), 52);
 962  assertEquals(WEEKNUM(363, 17), 52);
 963  assertEquals(WEEKNUM(364, 17), 52);
 964  assertEquals(WEEKNUM(365, 17), 53);
 965  assertEquals(WEEKNUM(366, 17), 53);
 966  assertEquals(WEEKNUM(367, 17), 1);
 967  assertEquals(WEEKNUM(368, 17), 1);
 968  assertEquals(WEEKNUM(369, 17), 1);
 969  assertEquals(WEEKNUM(370, 17), 1);
 970  assertEquals(WEEKNUM(371, 17), 1);
 971  assertEquals(WEEKNUM(372, 17), 2);
 972  assertEquals(WEEKNUM(373, 17), 2);
 973  assertEquals(WEEKNUM(374, 17), 2);
 974  assertEquals(WEEKNUM(375, 17), 2);
 975  assertEquals(WEEKNUM(376, 17), 2);
 976  assertEquals(WEEKNUM(377, 17), 2);
 977  assertEquals(WEEKNUM(378, 17), 2);
 978  assertEquals(WEEKNUM(379, 17), 3);
 979  assertEquals(WEEKNUM(380, 17), 3);
 980  assertEquals(WEEKNUM(381, 17), 3);
 981  //type=17 again
 982  assertEquals(WEEKNUM(730, 17), 53);
 983  assertEquals(WEEKNUM(731, 17), 53);
 984  assertEquals(WEEKNUM(732, 17), 1);
 985  assertEquals(WEEKNUM(733, 17), 1);
 986  assertEquals(WEEKNUM(734, 17), 1);
 987  assertEquals(WEEKNUM(735, 17), 1);
 988  assertEquals(WEEKNUM(736, 17), 2);
 989  assertEquals(WEEKNUM(737, 17), 2);
 990  assertEquals(WEEKNUM(738, 17), 2);
 991  assertEquals(WEEKNUM(739, 17), 2);
 992  assertEquals(WEEKNUM(740, 17), 2);
 993  assertEquals(WEEKNUM(741, 17), 2);
 994  assertEquals(WEEKNUM(742, 17), 2);
 995  assertEquals(WEEKNUM(743, 17), 3);
 996  assertEquals(WEEKNUM(744, 17), 3);
 997  assertEquals(WEEKNUM(745, 17), 3);
 998  assertEquals(WEEKNUM(746, 17), 3);
 999  //type=21
1000  assertEquals(WEEKNUM(23730, 21), 51);
1001  assertEquals(WEEKNUM(23731, 21), 51);
1002  assertEquals(WEEKNUM(23732, 21), 52);
1003  assertEquals(WEEKNUM(23733, 21), 52);
1004  assertEquals(WEEKNUM(23734, 21), 52);
1005  assertEquals(WEEKNUM(23735, 21), 52);
1006  assertEquals(WEEKNUM(23736, 21), 52);
1007  assertEquals(WEEKNUM(23737, 21), 52);
1008  assertEquals(WEEKNUM(23738, 21), 52);
1009  assertEquals(WEEKNUM(23739, 21), 53);
1010  assertEquals(WEEKNUM(23740, 21), 53);
1011  assertEquals(WEEKNUM(23741, 21), 53);
1012  assertEquals(WEEKNUM(23742, 21), 53);
1013  assertEquals(WEEKNUM(23743, 21), 53);
1014  assertEquals(WEEKNUM(23744, 21), 53);
1015  assertEquals(WEEKNUM(23745, 21), 53);
1016  assertEquals(WEEKNUM(23746, 21), 1);
1017  assertEquals(WEEKNUM(23747, 21), 1);
1018  assertEquals(WEEKNUM(23748, 21), 1);
1019  assertEquals(WEEKNUM(23749, 21), 1);
1020  assertEquals(WEEKNUM(23750, 21), 1);
1021  assertEquals(WEEKNUM(23751, 21), 1);
1022  assertEquals(WEEKNUM(23752, 21), 1);
1023  assertEquals(WEEKNUM(23753, 21), 2);
1024  assertEquals(WEEKNUM(23754, 21), 2);
1025  assertEquals(WEEKNUM(23755, 21), 2);
1026  assertEquals(WEEKNUM(23756, 21), 2);
1027  assertEquals(WEEKNUM(23757, 21), 2);
1028  assertEquals(WEEKNUM(23758, 21), 2);
1029  assertEquals(WEEKNUM(23759, 21), 2);
1030  assertEquals(WEEKNUM(23760, 21), 3);
1031  // //type=21 again
1032  assertEquals(WEEKNUM(355, 21), 51);
1033  assertEquals(WEEKNUM(356, 21), 51);
1034  assertEquals(WEEKNUM(357, 21), 51);
1035  assertEquals(WEEKNUM(358, 21), 51);
1036  assertEquals(WEEKNUM(359, 21), 52);
1037  assertEquals(WEEKNUM(360, 21), 52);
1038  assertEquals(WEEKNUM(361, 21), 52);
1039  assertEquals(WEEKNUM(362, 21), 52);
1040  assertEquals(WEEKNUM(363, 21), 52);
1041  assertEquals(WEEKNUM(364, 21), 52);
1042  assertEquals(WEEKNUM(365, 21), 52);
1043  assertEquals(WEEKNUM(366, 21), 1);
1044  assertEquals(WEEKNUM(367, 21), 1);
1045  assertEquals(WEEKNUM(368, 21), 1);
1046  assertEquals(WEEKNUM(369, 21), 1);
1047  assertEquals(WEEKNUM(370, 21), 1);
1048  assertEquals(WEEKNUM(371, 21), 1);
1049  assertEquals(WEEKNUM(372, 21), 1);
1050  assertEquals(WEEKNUM(373, 21), 2);
1051  assertEquals(WEEKNUM(374, 21), 2);
1052  assertEquals(WEEKNUM(375, 21), 2);
1053  assertEquals(WEEKNUM(376, 21), 2);
1054  assertEquals(WEEKNUM(377, 21), 2);
1055  assertEquals(WEEKNUM(378, 21), 2);
1056  assertEquals(WEEKNUM(379, 21), 2);
1057  assertEquals(WEEKNUM(380, 21), 3);
1058  assertEquals(WEEKNUM(381, 21), 3);
1059  // //type=21 again
1060  assertEquals(WEEKNUM(728, 21), 52);
1061  assertEquals(WEEKNUM(729, 21), 52);
1062  assertEquals(WEEKNUM(730, 21), 1);
1063  assertEquals(WEEKNUM(731, 21), 1);
1064  assertEquals(WEEKNUM(732, 21), 1);
1065  assertEquals(WEEKNUM(733, 21), 1);
1066  assertEquals(WEEKNUM(734, 21), 1);
1067  assertEquals(WEEKNUM(735, 21), 1);
1068  assertEquals(WEEKNUM(736, 21), 1);
1069  assertEquals(WEEKNUM(737, 21), 2);
1070  assertEquals(WEEKNUM(738, 21), 2);
1071  assertEquals(WEEKNUM(739, 21), 2);
1072  assertEquals(WEEKNUM(740, 21), 2);
1073  assertEquals(WEEKNUM(741, 21), 2);
1074  assertEquals(WEEKNUM(742, 21), 2);
1075  assertEquals(WEEKNUM(743, 21), 2);
1076  assertEquals(WEEKNUM(744, 21), 3);
1077  assertEquals(WEEKNUM(745, 21), 3);
1078  assertEquals(WEEKNUM(746, 21), 3);
1079  catchAndAssertEquals(function() {
1080    WEEKNUM.apply(this, []);
1081  }, ERRORS.NA_ERROR);
1082  catchAndAssertEquals(function() {
1083    WEEKNUM.apply(this, [213123, 1, 1]);
1084  }, ERRORS.NA_ERROR);
1085  catchAndAssertEquals(function() {
1086    WEEKNUM("str");
1087  }, ERRORS.VALUE_ERROR);
1088  catchAndAssertEquals(function() {
1089    WEEKNUM([]);
1090  }, ERRORS.REF_ERROR);
1091  catchAndAssertEquals(function() {
1092    WEEKNUM(-10);
1093  }, ERRORS.NUM_ERROR);
1094  catchAndAssertEquals(function() {
1095    WEEKNUM(10, 4);
1096  }, ERRORS.NUM_ERROR);
1097  catchAndAssertEquals(function() {
1098    WEEKNUM(10, 22);
1099  }, ERRORS.NUM_ERROR);
1100});
1101
1102
1103test("WEEKDAY", function(){
1104  assertEquals(WEEKDAY(DATE(1992, 6, 20)), 7);
1105  assertEquals(WEEKDAY(DATE(1992, 6, 21)), 1);
1106  assertEquals(WEEKDAY(DATE(1992, 6, 24)), 4);
1107  assertEquals(WEEKDAY(DATE(1992, 6, 25)), 5);
1108  assertEquals(WEEKDAY(1312211), 5);
1109  assertEquals(WEEKDAY(1312212), 6);
1110  assertEquals(WEEKDAY(1312213), 7);
1111  assertEquals(WEEKDAY(0), 7);
1112  assertEquals(WEEKDAY(false), 7);
1113  assertEquals(WEEKDAY(1), 1);
1114  assertEquals(WEEKDAY(true), 1);
1115  assertEquals(WEEKDAY(40909, 1), 1);
1116  assertEquals(WEEKDAY(40909, 2), 7);
1117  assertEquals(WEEKDAY(40909, 3), 6);
1118  assertEquals(WEEKDAY(411, 1), 5);
1119  assertEquals(WEEKDAY(411, 2), 4);
1120  assertEquals(WEEKDAY(411, 3), 3);
1121  assertEquals(WEEKDAY(40909, 1), 1);
1122  assertEquals(WEEKDAY(40910, 1), 2);
1123  assertEquals(WEEKDAY(40911, 1), 3);
1124  assertEquals(WEEKDAY(40912, 1), 4);
1125  assertEquals(WEEKDAY(40913, 1), 5);
1126  assertEquals(WEEKDAY(40914, 1), 6);
1127  assertEquals(WEEKDAY(40915, 1), 7);
1128  assertEquals(WEEKDAY(40916, 1), 1);
1129  assertEquals(WEEKDAY(40909, 2), 7);
1130  assertEquals(WEEKDAY(40910, 2), 1);
1131  assertEquals(WEEKDAY(40911, 2), 2);
1132  assertEquals(WEEKDAY(40912, 2), 3);
1133  assertEquals(WEEKDAY(40913, 2), 4);
1134  assertEquals(WEEKDAY(40914, 2), 5);
1135  assertEquals(WEEKDAY(40915, 2), 6);
1136  assertEquals(WEEKDAY(40916, 2), 7);
1137  assertEquals(WEEKDAY(40909, 3), 6);
1138  assertEquals(WEEKDAY(40910, 3), 0);
1139  assertEquals(WEEKDAY(40911, 3), 1);
1140  assertEquals(WEEKDAY(40912, 3), 2);
1141  assertEquals(WEEKDAY(40913, 3), 3);
1142  assertEquals(WEEKDAY(40914, 3), 4);
1143  assertEquals(WEEKDAY(40915, 3), 5);
1144  assertEquals(WEEKDAY(40916, 3), 6);
1145  catchAndAssertEquals(function() {
1146    WEEKDAY.apply(this, []);
1147  }, ERRORS.NA_ERROR);
1148  catchAndAssertEquals(function() {
1149    WEEKDAY.apply(this, [213123, 1, 1]);
1150  }, ERRORS.NA_ERROR);
1151  catchAndAssertEquals(function() {
1152    WEEKDAY("str");
1153  }, ERRORS.VALUE_ERROR);
1154  catchAndAssertEquals(function() {
1155    WEEKDAY([]);
1156  }, ERRORS.REF_ERROR);
1157  catchAndAssertEquals(function() {
1158    WEEKDAY(-10);
1159  }, ERRORS.NUM_ERROR);
1160  catchAndAssertEquals(function() {
1161    WEEKDAY(10, 4);
1162  }, ERRORS.NUM_ERROR);
1163});
1164
1165
1166test("YEAR", function(){
1167  assertEquals(YEAR(DATE(1992, 6, 24)), 1992);
1168  assertEquals(YEAR(DATE(2000, 6, 24)), 2000);
1169  assertEquals(YEAR(DATE(100, 6, 24)), 2000);
1170  assertEquals(YEAR(DATE(44, 6, 24)), 1944);
1171  assertEquals(YEAR(1312212), 5492);
1172  assertEquals(YEAR(9), 1900);
1173  assertEquals(YEAR(0), 1899);
1174  assertEquals(YEAR(false), 1899);
1175  assertEquals(YEAR(1), 1899);
1176  assertEquals(YEAR(true), 1899);
1177  assertEquals(YEAR([1, "str"]), 1899);
1178  catchAndAssertEquals(function() {
1179    YEAR.apply(this, []);
1180  }, ERRORS.NA_ERROR);
1181  catchAndAssertEquals(function() {
1182    YEAR.apply(this, [213123, 123123]);
1183  }, ERRORS.NA_ERROR);
1184  catchAndAssertEquals(function() {
1185    YEAR("str");
1186  }, ERRORS.VALUE_ERROR);
1187  catchAndAssertEquals(function() {
1188    YEAR([]);
1189  }, ERRORS.REF_ERROR);
1190  catchAndAssertEquals(function() {
1191    YEAR(-10);
1192  }, ERRORS.NUM_ERROR);
1193});
1194
1195
1196test("MONTH", function(){
1197  assertEquals(MONTH(DATE(1992, 6, 24)), 6);
1198  assertEquals(MONTH(1312212), 9);
1199  assertEquals(MONTH(13122121), 2);
1200  catchAndAssertEquals(function() {
1201    MONTH.apply(this, []);
1202  }, ERRORS.NA_ERROR);
1203  catchAndAssertEquals(function() {
1204    MONTH.apply(this, [213123, 123123]);
1205  }, ERRORS.NA_ERROR);
1206  catchAndAssertEquals(function() {
1207    MONTH("str");
1208  }, ERRORS.VALUE_ERROR);
1209  catchAndAssertEquals(function() {
1210    MONTH([]);
1211  }, ERRORS.REF_ERROR);
1212  catchAndAssertEquals(function() {
1213    MONTH(-10);
1214  }, ERRORS.NUM_ERROR);
1215});
1216
1217
1218test("DAYS360", function(){
1219  assertEquals(DAYS360(DATE(1992, 6, 24), DATE(1992, 6, 25)), 1);
1220  assertEquals(DAYS360(DATE(1992, 6, 25), DATE(1992, 6, 24)), -1);
1221  assertEquals(DAYS360(DATE(1992, 6, 25), DATE(1992, 6, 23)), -2);
1222  assertEquals(DAYS360(DATE(1992, 6, 24), DATE(1991, 6, 24)), -360);
1223  assertEquals(DAYS360(DATE(1993, 6, 24), DATE(1992, 6, 24)), -360);
1224  assertEquals(DAYS360(DATEVALUE("1993-6-24"), 1), -33653);
1225  assertEquals(DAYS360(DATEVALUE("1993-6-24"), true), -33653);
1226  assertEquals(DAYS360(DATEVALUE("1993-6-24"), 0), -33654);
1227  assertEquals(DAYS360(DATEVALUE("1993-6-24"), false), -33654);
1228  assertEquals(DAYS360("2191-6-24", "1992-6-24"), -71640);
1229  assertEquals(DAYS360("2191-6-24", "1992-6-24", true), -71640);
1230  assertEquals(DAYS360(1, 390, 1), 384);
1231  assertEquals(DAYS360(1, 390), 384);
1232  assertEquals(DAYS360(33779, 33780), 1);
1233  assertEquals(DAYS360([1, "str"], [390, "str"]), 384);
1234  catchAndAssertEquals(function() {
1235    DAYS360.apply(this, []);
1236  }, ERRORS.NA_ERROR);
1237  catchAndAssertEquals(function() {
1238    DAYS360.apply(this, [100]);
1239  }, ERRORS.NA_ERROR);
1240  catchAndAssertEquals(function() {
1241    DAYS360.apply(this, [100, 200, true, "str"]);
1242  }, ERRORS.NA_ERROR);
1243  catchAndAssertEquals(function() {
1244    DAYS360("str", 100);
1245  }, ERRORS.VALUE_ERROR);
1246  catchAndAssertEquals(function() {
1247    DAYS360("false", "true");
1248  }, ERRORS.VALUE_ERROR);
1249  catchAndAssertEquals(function() {
1250    DAYS360([[], 100], 22);
1251  }, ERRORS.REF_ERROR);
1252});
1253
1254
1255test("DAYS", function(){
1256  assertEquals(DAYS(DATE(1992, 6, 24), DATE(1992, 6, 25)), -1);
1257  assertEquals(DAYS(DATE(1992, 6, 25), DATE(1992, 6, 24)), 1);
1258  assertEquals(DAYS(DATE(1992, 6, 25), DATE(1992, 6, 23)), 2);
1259  assertEquals(DAYS(DATE(1992, 6, 24), DATE(1991, 6, 24)), 366);
1260  assertEquals(DAYS(DATE(1993, 6, 24), DATE(1992, 6, 24)), 365);
1261  assertEquals(DAYS("2191-6-24", "1992-6-24"), 72683);
1262  assertEquals(DAYS(0, 1), -1);
1263  assertEquals(DAYS(false, true), -1);
1264  assertEquals(DAYS(0, 100), -100);
1265  assertEquals(DAYS(-100, 100), -200);
1266  assertEquals(DAYS(100, -100), 200);
1267  assertEquals(DAYS(100, 0), 100);
1268  assertEquals(DAYS([0, "str"], [100, "str"]), -100);
1269  assertEquals(DAYS("1992, 6, 25", "1992, 6, 24"), 1);
1270  catchAndAssertEquals(function() {
1271    DAYS.apply(this, []);
1272  }, ERRORS.NA_ERROR);
1273  catchAndAssertEquals(function() {
1274    DAYS.apply(this, [100]);
1275  }, ERRORS.NA_ERROR);
1276  catchAndAssertEquals(function() {
1277    DAYS.apply(this, [100, 200, 300]);
1278  }, ERRORS.NA_ERROR);
1279  catchAndAssertEquals(function() {
1280    DAYS([[], 100], 22);
1281  }, ERRORS.REF_ERROR);
1282  catchAndAssertEquals(function() {
1283    DAYS("str", 100);
1284  }, ERRORS.VALUE_ERROR);
1285  catchAndAssertEquals(function() {
1286    DAYS("false", "true");
1287  }, ERRORS.VALUE_ERROR);
1288});
1289
1290
1291test("DAY", function(){
1292  assertEquals(DAY(DATE(1992, 6, 24)), 24);
1293  assertEquals(DAY(DATE(1992, 5, 10)), 10);
1294  assertEquals(DAY(DATE(1992, 5, 22)), 22);
1295  assertEquals(DAY(DATE(1992, 6, 1)), 1);
1296  assertEquals(DAY(DATE(2008, 1, 31)), 31);
1297  assertEquals(DAY("1992, 6, 24"), 24);
1298  assertEquals(DAY(["1992, 6, 24"]), 24);
1299  assertEquals(DAY(0), 30);
1300  assertEquals(DAY(false), 30);
1301  assertEquals(DAY(1), 31);
1302  assertEquals(DAY(true), 31);
1303  assertEquals(DAY(33779), 24);
1304  assertEquals(DAY([33779]), 24);
1305  assertEquals(DAY([33779, "str"]), 24);
1306  catchAndAssertEquals(function() {
1307    DAY("str");
1308  }, ERRORS.VALUE_ERROR);
1309  catchAndAssertEquals(function() {
1310    DAY.apply(this, []);
1311  }, ERRORS.NA_ERROR);
1312  catchAndAssertEquals(function() {
1313    DAY.apply(this, [DATE(1992, 6, 24), 4]);
1314  }, ERRORS.NA_ERROR);
1315  catchAndAssertEquals(function() {
1316    DAY(-1);
1317  }, ERRORS.NUM_ERROR);
1318});
1319
1320
1321test("EDATE", function(){
1322  assertEquals(EDATE(DATE(1992, 6, 24), 1), DATE(1992, 7, 24));
1323  assertEquals(EDATE(DATE(1992, 5, 24), 2), DATE(1992, 7, 24));
1324  assertEquals(EDATE(DATE(1992, 5, 24), 2.2), DATE(1992, 7, 24));
1325  assertEquals(EDATE(DATE(1992, 6, 24), 0), DATE(1992, 6, 24));
1326  assertEquals(EDATE(DATE(1992, 6, 24), false), DATE(1992, 6, 24));
1327  assertEquals(EDATE("1992, 5, 24", 2), DATE(1992, 7, 24));
1328  assertEquals(EDATE("6/24/92", 1), DATE(1992, 7, 24));
1329  assertEquals(EDATE([DATE(1992, 6, 24), "str"], [1, "str"]), DATE(1992, 7, 24));
1330  assertEquals(EDATE(0, 1), DATE(1900, 1, 30));
1331  assertEquals(EDATE(false, 1), DATE(1900, 1, 30));
1332  catchAndAssertEquals(function() {
1333    EDATE("str", 2);
1334  }, ERRORS.VALUE_ERROR);
1335  catchAndAssertEquals(function() {
1336    EDATE.apply(this, [DATE(1992, 6, 24)]);
1337  }, ERRORS.NA_ERROR);
1338  catchAndAssertEquals(function() {
1339    EDATE.apply(this, [DATE(1992, 6, 24), 4, 4]);
1340  }, ERRORS.NA_ERROR);
1341  catchAndAssertEquals(function() {
1342    EDATE(-1, 1);
1343  }, ERRORS.NUM_ERROR);
1344  catchAndAssertEquals(function() {
1345    EDATE(DATEVALUE("01/13/0101"), 1);
1346  }, ERRORS.NUM_ERROR);
1347});
1348
1349
1350test("EOMONTH", function(){
1351  assertEquals(EOMONTH(DATE(1992, 6, 24), 0), DATE(1992, 6, 30));
1352  assertEquals(EOMONTH(DATE(1992, 6, 24), false), DATE(1992, 6, 30));
1353  assertEquals(EOMONTH(DATE(1992, 6, 24), 1), DATE(1992, 7, 31));
1354  assertEquals(EOMONTH(DATE(1992, 6, 24), 2), DATE(1992, 8, 31));
1355  assertEquals(EOMONTH(DATE(2012, 6, 24), 2), DATE(2012, 8, 31));
1356  assertEquals(EOMONTH(DATE(2049, 1, 1), 2), DATE(2049, 3, 31));
1357  assertEquals(EOMONTH(DATE(1990, 2, 24), 400), DATE(2023, 6, 30));
1358  assertEquals(EOMONTH("1992, 6, 24", 2), DATE(1992, 8, 31));
1359  //leap years
1360  assertEquals(EOMONTH(DATE(2004, 2, 24), 0), DATE(2004, 2, 29));
1361  assertEquals(EOMONTH(DATE(2008, 2, 24), 0), DATE(2008, 2, 29));
1362  // misc.
1363  assertEquals(EOMONTH([DATE(1992, 6, 24), "str"], [2, "str"]), DATE(1992, 8, 31));
1364  assertEquals(EOMONTH(0, 1), DATE(1900, 1, 31));
1365  assertEquals(EOMONTH(false, 1), DATE(1900, 1, 31));
1366  assertEquals(EOMONTH(1, 1), DATE(1900, 1, 31));
1367  assertEquals(EOMONTH(true, 1), DATE(1900, 1, 31));
1368  catchAndAssertEquals(function() {
1369    EOMONTH.apply(this, []);
1370  }, ERRORS.NA_ERROR);
1371  catchAndAssertEquals(function() {
1372    EOMONTH.apply(this, [true, 1, 1]);
1373  }, ERRORS.NA_ERROR);
1374  catchAndAssertEquals(function() {
1375    EOMONTH("str", 2);
1376  }, ERRORS.VALUE_ERROR);
1377  catchAndAssertEquals(function() {
1378    EOMONTH(-1, 2);
1379  }, ERRORS.NUM_ERROR);
1380});
1381
1382
1383test("DATE", function(){
1384  assertEquals(DATE(1900, 1, 2), 3);
1385  assertEquals(DATE(1900, 1, 1), 2);
1386  assertEquals(DATE(1900, 1, 4), 5);
1387  catchAndAssertEquals(function() {
1388    DATE(1900, 0, 5);
1389  }, ERRORS.NUM_ERROR);
1390  catchAndAssertEquals(function() {
1391    DATE.apply(this, [1900, 0, 5, 22]);
1392  }, ERRORS.NA_ERROR);
1393  catchAndAssertEquals(function() {
1394    DATE.apply(this, [1900, 0]);
1395  }, ERRORS.NA_ERROR);
1396  assertEquals(DATE(1992, 6, 24), 33779);
1397  assertEquals(DATE(2017, 2, 26), 42792);
1398  assertEquals(DATE(1999, 1, 13), 36173);
1399  // Leap day stuff
1400  assertEquals(DATE(2004, 2, 28), 38045);
1401  assertEquals(DATE(2004, 2, 29), 38046);
1402  assertEquals(DATE(2004, 3, 1), 38047);
1403  // Overflow values
1404  assertEquals(DATE(1992, 6, 44), 33799);
1405  assertEquals(DATE(2, 33, 44), 1749);
1406  assertEquals(DATE(1777, 33, 44), 650055);
1407  assertEquals(DATE(1976, 2, -10), 27780);
1408  assertEquals(DATE(-1900, 1, 1), 2);
1409  assertEquals(DATE(1992, 1, 10), 33613);
1410});
1411
1412
1413test("DATEVALUE", function(){
1414  assertEquals(DATEVALUE("6/24/92"), 33779);
1415  assertEquals(DATEVALUE(["6/24/92", false]), 33779);
1416  assertEquals(DATEVALUE("6-24-92 10am"), 33779);
1417  assertEquals(DATEVALUE("1992/6/24 00:00"), 33779);
1418  assertEquals(DATEVALUE("4243/11/3 200000000:33:444"), 9189404);
1419  assertEquals(DATEVALUE("1992/1/13 6:22222222:44am"), 49048); // overload minutes
1420  assertEquals(DATEVALUE("1992/6/24"), 33779);
1421  assertEquals(DATEVALUE("Sunday 1992/6/24"), 33779);
1422  assertEquals(DATEVALUE("1992-6-24"), 33779);
1423  assertEquals(DATEVALUE("1992/6/24"), 33779);
1424  assertEquals(DATEVALUE("1992 6 24"), 33779);
1425  assertEquals(DATEVALUE("1992 6 24"), 33779);
1426  assertEquals(DATEVALUE("1992 . 6 . 24"), 33779);
1427  assertEquals(DATEVALUE("1992 / 6 / 24"), 33779);
1428  assertEquals(DATEVALUE("1992, 6, 24"), 33779);
1429  assertEquals(DATEVALUE("1992/6/24 00am"), 33779);
1430  assertEquals(DATEVALUE("1992/5/20 01am"), 33744);
1431  assertEquals(DATEVALUE("Sun 09 Feb 2017"), 42775);
1432  assertEquals(DATEVALUE("01 Jan 2017"), 42736);
1433  assertEquals(DATEVALUE("24/June/1992 10am"), 33779);
1434  assertEquals(DATEVALUE("24/June/1992 10:10"), 33779);
1435  assertEquals(DATEVALUE("24/June/1992 10:10am"), 33779);
1436  assertEquals(DATEVALUE("24/June/1992 10:10:10"), 33779);
1437  assertEquals(DATEVALUE("24/June/1992 10:10:10am"), 33779);
1438  assertEquals(DATEVALUE("Sun Feb 09 2017"), 42775);
1439  assertEquals(DATEVALUE("2017/01"), 42736);
1440  assertEquals(DATEVALUE("2017-01 10am"), 42736);
1441  assertEquals(DATEVALUE("01/2017"), 42736);
1442  assertEquals(DATEVALUE("01-2017 10am"), 42736);
1443  assertEquals(DATEVALUE("2017 January"), 42736);
1444  assertEquals(DATEVALUE("2017-January 10am"), 42736);
1445  assertEquals(DATEVALUE("2017-January 10:10"), 42736);
1446  assertEquals(DATEVALUE("2017-January 10:10am"), 42736);
1447  assertEquals(DATEVALUE("2017-January 10:10:10"), 42736);
1448  assertEquals(DATEVALUE("2017-January 10:10:10am"), 42736);
1449  assertEquals(DATEVALUE("January 2017"), 42736);
1450  assertEquals(DATEVALUE("January 0030"), 10959);
1451  assertEquals(DATEVALUE("November 4243"), 856069);
1452  assertEquals(DATEVALUE("December 0100"), -657100);
1453  assertEquals(DATEVALUE("Jan 2017"), 42736);
1454  assertEquals(DATEVALUE("January-2017 10am"), 42736);
1455  assertEquals(DATEVALUE("January-2017 10:10"), 42736);
1456  assertEquals(DATEVALUE("January-2017 10:10am"), 42736);
1457  assertEquals(DATEVALUE("January-2017 10:10:10"), 42736);
1458  assertEquals(DATEVALUE("January-2017 10:10:10am"), 42736);
1459  catchAndAssertEquals(function() {
1460    DATEVALUE.apply(this, ["6/24/92", 10]);
1461  }, ERRORS.NA_ERROR);
1462  catchAndAssertEquals(function() {
1463    DATEVALUE.apply(this, []);
1464  }, ERRORS.NA_ERROR);
1465  catchAndAssertEquals(function() {
1466    DATEVALUE(false);
1467  }, ERRORS.VALUE_ERROR);
1468  catchAndAssertEquals(function() {
1469    DATEVALUE("Sunday,1992/6/24");
1470  }, ERRORS.VALUE_ERROR);
1471  catchAndAssertEquals(function() {
1472    DATEVALUE("2005/2/29");
1473  }, ERRORS.VALUE_ERROR);
1474  catchAndAssertEquals(function() {
1475    DATEVALUE("2001/2/29");
1476  }, ERRORS.VALUE_ERROR);
1477  catchAndAssertEquals(function() {
1478    DATEVALUE("2005/1/44");
1479  }, ERRORS.VALUE_ERROR);
1480});