@ohos-ports/flowbite-datepicker 2.0.0-beta.0

package/test/options/format.js

@@ -0,0 +1,281 @@
+describe('options - format & language', function () {
+  let clock;
+  let input;
+
+  beforeEach(function () {
+    clock = sinon.useFakeTimers({now: new Date(2020, 1, 14)});
+    input = document.createElement('input');
+    testContainer.appendChild(input);
+  });
+
+  afterEach(function () {
+    testContainer.removeChild(input);
+    clock.restore();
+  });
+
+  describe('format', function () {
+    it('specifies the date format used to parse/format the date string in input', function () {
+      const dp = new Datepicker(input, {format: 'yyyy-mm-dd'});
+
+      dp.setDate(new Date(2020, 1, 14));
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 14)]);
+      expect(input.value, 'to be', '2020-02-14');
+
+      input.value = '2020/4/22';
+      dp.update();
+      expect(dp.dates, 'to equal', [dateValue(2020, 3, 22)]);
+      expect(input.value, 'to be', '2020-04-22');
+
+      // when a date in a wrong format is given...
+      dp.setDate('2/14/2020');
+      expect(dp.dates, 'to equal', [dateValue(2, 13, 2020)]);
+      expect(input.value, 'to be', '0008-08-12');
+
+      input.value = '22/4/2020';
+      dp.update();
+      expect(dp.dates, 'to equal', [dateValue(22, 3, 2020)]);
+      expect(input.value, 'to be', '0027-10-11');
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('custom parser/fomatter can be used by providing them as toValue/toDisplay of an object', function () {
+      const dp = new Datepicker(input, {
+        format: {
+          toDisplay(date) {
+            return new Date(date.getTime() - date.getTimezoneOffset() * 60000).toISOString()
+              .slice(0, 10)
+              .replace(/-/g, '');
+          },
+          toValue(date) {
+            const parts = [
+              parseInt(date.slice(0, 4), 10),
+              parseInt(date.slice(4, 6), 10) - 1,
+              parseInt(date.slice(6, 8), 10),
+            ];
+            return dateValue(...parts);
+          },
+        },
+      });
+
+      dp.setDate(new Date(2020, 1, 14));
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 14)]);
+      expect(input.value, 'to be', '20200214');
+
+      input.value = '20200422';
+      dp.update();
+      expect(dp.dates, 'to equal', [dateValue(2020, 3, 22)]);
+      expect(input.value, 'to be', '20200422');
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('can be updated with setOptions()', function () {
+      const dp = new Datepicker(input);
+      dp.setOptions({format: 'd M, \'yy'});
+
+      dp.setDate('14/2/2020');
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 14)]);
+      expect(input.value, 'to be', '14 Feb, \'20');
+
+      dp.setOptions({format: 'mm/dd/yyyy'});
+      expect(input.value, 'to be', '02/14/2020');
+      input.value = '4/22/2020';
+      dp.update();
+      expect(dp.dates, 'to equal', [dateValue(2020, 3, 22)]);
+      expect(input.value, 'to be', '04/22/2020');
+
+      dp.destroy();
+      input.value = '';
+    });
+  });
+
+  describe('language', function () {
+    const getDayNames = picker => Array.from(picker.querySelectorAll('.dow')).map(el => el.textContent);
+
+    it('specifies the language used for the month/day names, today/clear buttons and the default format/weekStart', function () {
+      const locale = Datepicker.locales['zh-CN'];
+      const {dp, picker} = createDP(input, {language: 'zh-CN', todayBtn: true, clearBtn: true});
+      const viewSwitch = getViewSwitch(picker);
+      dp.setDate(new Date(2020, 1, 14));
+      dp.show();
+
+      expect(viewSwitch.textContent, 'to be', '2020年02月');
+      expect(input.value, 'to be', '2020-02-14');
+      expect(picker.querySelector('.today-btn').textContent, 'to be', locale.today);
+      expect(picker.querySelector('.clear-btn').textContent, 'to be', locale.clear);
+
+      const dayNames = locale.daysMin.slice(1);
+      dayNames.push(locale.daysMin[0]);
+      expect(getDayNames(picker), 'to equal', dayNames);
+
+      let cells = getCells(picker);
+      expect(cells[0].textContent, 'to be', '27');
+      expect(cells[5].textContent, 'to be', '1');
+      expect(cells[33].textContent, 'to be', '29');
+      expect(cells[41].textContent, 'to be', '8');
+
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[18]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[18]]);
+      expect(cells[18].textContent, 'to be', '14');
+
+      viewSwitch.click();
+      expect(viewSwitch.textContent, 'to be', '2020');
+
+      cells = getCells(picker);
+      expect(Array.from(cells).map(el => el.textContent), 'to equal', locale.monthsShort);
+      cells[1].click();
+
+      input.value = '2020-4-22';
+      dp.update();
+      expect(viewSwitch.textContent, 'to be', '2020年04月');
+      expect(input.value, 'to be', '2020-04-22');
+
+      cells = getCells(picker);
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[23]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[23]]);
+      expect(cells[23].textContent, 'to be', '22');
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('default format/weekStart in the locale are overriden by user-specified ones', function () {
+      const locale = Datepicker.locales['zh-CN'];
+      const {dp, picker} = createDP(input, {language: 'zh-CN', format: 'yyyy年mm月dd日', weekStart: 0});
+      const viewSwitch = getViewSwitch(picker);
+      dp.setDate(new Date(2020, 1, 14));
+      dp.show();
+
+      expect(viewSwitch.textContent, 'to be', '2020年02月');
+      expect(input.value, 'to be', '2020年02月14日');
+      expect(getDayNames(picker), 'to equal', locale.daysMin);
+
+      let cells = getCells(picker);
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[19]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
+      expect(cells[19].textContent, 'to be', '14');
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('language code + tag not installed falls back to the language code without tag', function () {
+      const locale = Datepicker.locales.fr;
+      const {dp, picker} = createDP(input, {language: 'fr-CA', todayBtn: true, clearBtn: true});
+      const viewSwitch = getViewSwitch(picker);
+      dp.setDate(new Date(2020, 1, 14));
+      dp.show();
+
+      expect(viewSwitch.textContent, 'to be', 'février 2020');
+      expect(input.value, 'to be', '14/02/2020');
+      expect(picker.querySelector('.today-btn').textContent, 'to be', locale.today);
+      expect(picker.querySelector('.clear-btn').textContent, 'to be', locale.clear);
+
+      const dayNames = locale.daysMin.slice(1);
+      dayNames.push(locale.daysMin[0]);
+      expect(getDayNames(picker), 'to equal', dayNames);
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('language code not installed falls back to "en"', function () {
+      const locale = Datepicker.locales.en;
+      const {dp, picker} = createDP(input, {language: 'it', todayBtn: true, clearBtn: true});
+      const viewSwitch = getViewSwitch(picker);
+      dp.setDate(new Date(2020, 1, 14));
+      dp.show();
+
+      expect(viewSwitch.textContent, 'to be', 'February 2020');
+      expect(input.value, 'to be', '02/14/2020');
+      expect(picker.querySelector('.today-btn').textContent, 'to be', locale.today);
+      expect(picker.querySelector('.clear-btn').textContent, 'to be', locale.clear);
+
+      expect(getDayNames(picker), 'to equal', locale.daysMin);
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('can be updated with setOptions()', function () {
+      const {dp, picker} = createDP(input, {todayBtn: true, clearBtn: true});
+      const viewSwitch = getViewSwitch(picker);
+      let locale = Datepicker.locales['zh-CN'];
+      dp.setDate(new Date(2020, 1, 14));
+      dp.setOptions({language: 'zh-CN'});
+      dp.show();
+
+      expect(viewSwitch.textContent, 'to be', '2020年02月');
+      expect(input.value, 'to be', '2020-02-14');
+      expect(picker.querySelector('.today-btn').textContent, 'to be', locale.today);
+      expect(picker.querySelector('.clear-btn').textContent, 'to be', locale.clear);
+
+      let dayNames = locale.daysMin.slice(1);
+      dayNames.push(locale.daysMin[0]);
+      expect(getDayNames(picker), 'to equal', dayNames);
+
+      let cells = getCells(picker);
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[18]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[18]]);
+      expect(cells[18].textContent, 'to be', '14');
+
+      locale = Datepicker.locales.fr;
+      dp.setOptions({language: 'fr'});
+
+      expect(viewSwitch.textContent, 'to be', 'février 2020');
+      expect(input.value, 'to be', '14/02/2020');
+      expect(picker.querySelector('.today-btn').textContent, 'to be', locale.today);
+      expect(picker.querySelector('.clear-btn').textContent, 'to be', locale.clear);
+
+      dayNames = locale.daysMin.slice(1);
+      dayNames.push(locale.daysMin[0]);
+      expect(getDayNames(picker), 'to equal', dayNames);
+
+      cells = getCells(picker);
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[18]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[18]]);
+      expect(cells[18].textContent, 'to be', '14');
+
+      locale = Datepicker.locales.en;
+      dp.setOptions({language: 'en'});
+
+      expect(viewSwitch.textContent, 'to be', 'February 2020');
+      expect(input.value, 'to be', '02/14/2020');
+      expect(picker.querySelector('.today-btn').textContent, 'to be', locale.today);
+      expect(picker.querySelector('.clear-btn').textContent, 'to be', locale.clear);
+
+      expect(getDayNames(picker), 'to equal', locale.daysMin);
+
+      cells = getCells(picker);
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[19]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
+      expect(cells[19].textContent, 'to be', '14');
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('user-specified format/weekStart other than old language\'s default are kept on being updated dynamically', function () {
+      const {dp, picker} = createDP(input, {language: 'zh-CN', format: 'yyyy/mm/dd', weekStart: 0});
+      dp.setDate(new Date(2020, 1, 14));
+      dp.show();
+
+      let locale = Datepicker.locales.fr;
+      dp.setOptions({language: 'fr'});
+
+      expect(input.value, 'to be', '2020/02/14');
+      expect(getDayNames(picker), 'to equal', locale.daysMin);
+
+      let cells = getCells(picker);
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[19]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
+      expect(cells[19].textContent, 'to be', '14');
+
+      dp.destroy();
+      input.value = '';
+    });
+  });
+});

package/test/options/multidate.js

@@ -0,0 +1,380 @@
+describe('options - multi date', function () {
+  let clock;
+  let input;
+
+  beforeEach(function () {
+    clock = sinon.useFakeTimers({now: new Date(2020, 1, 14)});
+    input = document.createElement('input');
+    testContainer.appendChild(input);
+  });
+
+  afterEach(function () {
+    testContainer.removeChild(input);
+    clock.restore();
+  });
+
+  describe('maxNumberOfDates', function () {
+    it('specifies the muximum number of dates the datepicker accepts for the selection', function () {
+      let {dp, picker} = createDP(input, {maxNumberOfDates: 2});
+
+      dp.setDate('2/14/2020', '4/22/2020');
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 14), dateValue(2020, 3, 22)]);
+      expect(input.value, 'to be', '02/14/2020,04/22/2020');
+
+      // the dates come later win
+      dp.setDate('1/4/2020', '2/22/2020', '3/21/2020');
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 22), dateValue(2020, 2, 21)]);
+      expect(input.value, 'to be', '02/22/2020,03/21/2020');
+
+      // repeated dates are eliminated
+      dp.setDate('4/22/2020', '7/14/2020', '5/5/2020', '7/14/2020');
+      expect(dp.dates, 'to equal', [dateValue(2020, 6, 14), dateValue(2020, 4, 5)]);
+      expect(input.value, 'to be', '07/14/2020,05/05/2020');
+
+      dp.destroy();
+      input.value = '';
+      ({dp, picker} = createDP(input, {maxNumberOfDates: 3}));
+      dp.show();
+
+      let cells = getCells(picker);
+      cells[19].click();
+      cells[9].click();
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 14), dateValue(2020, 1, 4)]);
+      expect(input.value, 'to be', '02/14/2020,02/04/2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[19], cells[9]]);
+      // view date is changed co the last selected item
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[9]]);
+
+      input.value = '2/3/2020,2/22/2020';
+      dp.update();
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 3), dateValue(2020, 1, 22)]);
+      expect(input.value, 'to be', '02/03/2020,02/22/2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[8], cells[27]]);
+      // view date is changed co the last item of the selection
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[27]]);
+
+      dp.destroy();
+      input.value = '';
+      ({dp, picker} = createDP(input, {maxNumberOfDates: 3}));
+
+      dp.setDate('2/14/2020', '4/22/2020', '3/21/2020');
+      expect(dp.dates, 'to equal', [
+        dateValue(2020, 1, 14),
+        dateValue(2020, 3, 22),
+        dateValue(2020, 2, 21),
+      ]);
+      expect(input.value, 'to be', '02/14/2020,04/22/2020,03/21/2020');
+
+      dp.destroy();
+      input.value = '';
+      ({dp, picker} = createDP(input, {maxNumberOfDates: 3}));
+      dp.show();
+
+      getCells(picker)[1].click();
+      getCells(picker)[40].click();
+      cells = getCells(picker);
+      cells[19].click();
+      expect(dp.dates, 'to equal', [
+        dateValue(2020, 0, 27),
+        dateValue(2020, 1, 7),
+        dateValue(2020, 1, 14),
+      ]);
+      expect(input.value, 'to be', '01/27/2020,02/07/2020,02/14/2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[1], cells[12], cells[19]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
+
+      input.value = '2/3/2020,2/22/2020';
+      dp.update();
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 3), dateValue(2020, 1, 22)]);
+      expect(input.value, 'to be', '02/03/2020,02/22/2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[8], cells[27]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[27]]);
+
+      // setting initial dates does not cuase error
+      // (issue #51)
+      dp.destroy();
+      input.value = '02/14/2020,04/22/2020,03/21/2020';
+      ({dp, picker} = createDP(input, {maxNumberOfDates: 2}));
+
+      expect(dp.dates, 'to equal', [
+        dateValue(2020, 3, 22),
+        dateValue(2020, 2, 21),
+      ]);
+      expect(input.value, 'to be', '04/22/2020,03/21/2020');
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('makes the picker deselect the date when a selected date is clicked if value != 1', function () {
+      const {dp, picker} = createDP(input, {maxNumberOfDates: 3});
+      dp.show();
+
+      let cells = getCells(picker);
+      cells[19].click();
+      cells[12].click();
+
+      cells[19].click();
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 7)]);
+      expect(input.value, 'to be', '02/07/2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[12]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[12]]);
+
+      cells[12].click();
+      expect(dp.dates, 'to equal', []);
+      expect(input.value, 'to be', '');
+      expect(filterCells(cells, '.selected'), 'to equal', []);
+      // view date is changed to the default view date
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('makes the picker deselect the date when a selected date is clicked if value != 1', function () {
+      const {dp, picker} = createDP(input, {maxNumberOfDates: 3});
+      const cells = getCells(picker);
+      dp.setDate('2/14/2020', '2/7/2020');
+      dp.show();
+
+      dp.setDate('2/14/2020');
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 7)]);
+      expect(input.value, 'to be', '02/07/2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[12]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[12]]);
+
+      dp.setDate('2/11/2020', '2/7/2020', '2/14/2020');
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 11), dateValue(2020, 1, 14)]);
+      expect(input.value, 'to be', '02/11/2020,02/14/2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[16], cells[19]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('setDate() replaces the selection instead of deselect/merg-ing if clear: true option is passed', function () {
+      const {dp, picker} = createDP(input, {maxNumberOfDates: 3});
+      const cells = getCells(picker);
+      dp.setDate('2/14/2020', '2/7/2020');
+      dp.show();
+
+      dp.setDate('2/14/2020', {clear: true});
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 14)]);
+      expect(input.value, 'to be', '02/14/2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[19]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
+
+      dp.setDate('2/11/2020', '2/7/2020', '2/14/2020', {clear: true});
+      expect(dp.dates, 'to equal', [
+        dateValue(2020, 1, 11),
+        dateValue(2020, 1, 7),
+        dateValue(2020, 1, 14),
+      ]);
+      expect(input.value, 'to be', '02/11/2020,02/07/2020,02/14/2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[16], cells[12], cells[19]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('setDate() does nothing if no dates or all-invalid dates are passed', function () {
+      const dp = new Datepicker(input, {maxNumberOfDates: 3});
+      dp.setDate('2/14/2020', '2/7/2020');
+      dp.show();
+
+      const origDates = [...dp.dates];
+      dp.setDate([]);
+      expect(dp.dates, 'to equal', origDates);
+      expect(input.value, 'to be', '02/14/2020,02/07/2020');
+
+      dp.setDate();
+      expect(dp.dates, 'to equal', origDates);
+      expect(input.value, 'to be', '02/14/2020,02/07/2020');
+
+      dp.setDate([false, NaN], {clear: true});
+      expect(dp.dates, 'to equal', origDates);
+      expect(input.value, 'to be', '02/14/2020,02/07/2020');
+
+      dp.setDate('', null);
+      expect(dp.dates, 'to equal', origDates);
+      expect(input.value, 'to be', '02/14/2020,02/07/2020');
+
+      dp.destroy();
+    });
+
+    it('setDate() clears all selected dates if no dates + clear: true option are passed', function () {
+      const dp = new Datepicker(input, {maxNumberOfDates: 3});
+      dp.setDate('2/14/2020', '2/7/2020');
+      dp.show();
+
+      dp.setDate([], {clear: true});
+      expect(dp.dates, 'to equal', []);
+      expect(input.value, 'to be', '');
+
+      dp.setDate('2/14/2020', '2/7/2020');
+
+      dp.setDate({clear: true});
+      expect(dp.dates, 'to equal', []);
+      expect(input.value, 'to be', '');
+
+      dp.destroy();
+    });
+
+    it('setDate() does nothing if all-invalid dates + clear: true option are passed', function () {
+      const dp = new Datepicker(input, {maxNumberOfDates: 3});
+      dp.setDate('2/14/2020', '2/7/2020');
+      dp.show();
+
+      const origDates = [...dp.dates];
+      dp.setDate([false, NaN], {clear: true});
+      expect(dp.dates, 'to equal', origDates);
+      expect(input.value, 'to be', '02/14/2020,02/07/2020');
+
+      dp.setDate('', null, {clear: true});
+      expect(dp.dates, 'to equal', origDates);
+      expect(input.value, 'to be', '02/14/2020,02/07/2020');
+
+      dp.destroy();
+    });
+
+    it('does not apply deselecting behavior to update()', function () {
+      const {dp, picker} = createDP(input, {maxNumberOfDates: 3});
+      const cells = getCells(picker);
+      dp.setDate('2/14/2020', '2/7/2020');
+      dp.show();
+
+      input.value = '2/14/2020';
+      dp.update();
+      expect(dp.dates, 'to equal', [dateValue(2020, 1, 14)]);
+      expect(input.value, 'to be', '02/14/2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[19]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
+
+      input.value = '2/11/2020,2/7/2020,2/14/2020';
+      dp.update();
+      expect(dp.dates, 'to equal', [
+        dateValue(2020, 1, 11),
+        dateValue(2020, 1, 7),
+        dateValue(2020, 1, 14),
+      ]);
+      expect(input.value, 'to be', '02/11/2020,02/07/2020,02/14/2020');
+      expect(filterCells(cells, '.selected'), 'to equal', [cells[16], cells[12], cells[19]]);
+      expect(filterCells(cells, '.focused'), 'to equal', [cells[19]]);
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('makes getDate() return array of dates if value != 1', function () {
+      const dp = new Datepicker(input, {maxNumberOfDates: 3});
+
+      expect(dp.getDate(), 'to equal', []);
+      expect(dp.getDate('yyyy-mm-dd'), 'to equal', []);
+
+      dp.setDate('2/11/2020', '2/7/2020', '2/14/2020');
+      expect(dp.getDate(), 'to equal', [new Date(2020, 1, 11), new Date(2020, 1, 7), new Date(2020, 1, 14)]);
+      expect(dp.getDate('yyyy-mm-dd'), 'to equal', ['2020-02-11', '2020-02-07', '2020-02-14']);
+
+      dp.setDate('2/7/2020', {clear: true});
+      expect(dp.getDate(), 'to equal', [new Date(2020, 1, 7)]);
+      expect(dp.getDate('d M, yyyy'), 'to equal', ['7 Feb, 2020']);
+
+      const changeDateListener = (e) => {
+        evt = e;
+      };
+      let evt;
+      input.addEventListener('changeDate', changeDateListener);
+
+      dp.setDate('7/4/2020', '7/14/2020');
+      expect(evt.detail.date, 'to equal', dp.getDate());
+
+      input.removeEventListener('changeDate', changeDateListener);
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('value 0 is considered unlimited', function () {
+      if (window.navigator.userAgent.indexOf('Edge') > -1) {
+        this.timeout(5000);
+      }
+
+      const max = new Date(2100, 0, 1).getTime();
+      const generateDates = (dates, length, index = 0) => {
+        const date = dateUtils.stripTime(Math.floor(Math.random() * max));
+        if (dates.includes(date)) {
+          return generateDates(dates, length, index);
+        } else {
+          dates.push(date);
+          return index <= length
+            ? generateDates(dates, length, index + 1)
+            : dates;
+        }
+      };
+      const dates = generateDates([], 3000);
+
+      const dp = new Datepicker(input, {maxNumberOfDates: 0});
+      dp.setDate(dates);
+      expect(dp.dates, 'to equal', dates);
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('can be updated with setOptions()', function () {
+      const dp = new Datepicker(input);
+      dp.setOptions({maxNumberOfDates: 3});
+
+      dp.setDate('2/11/2020', '2/7/2020', '2/14/2020');
+      expect(dp.dates, 'to equal', [
+        dateValue(2020, 1, 11),
+        dateValue(2020, 1, 7),
+        dateValue(2020, 1, 14),
+      ]);
+
+      dp.setOptions({maxNumberOfDates: 1});
+      dp.setDate('7/4/2020', '4/22/2020');
+      expect(dp.dates, 'to equal', [dateValue(2020, 3, 22)]);
+      expect(dp.getDate(), 'to be a date');
+
+      dp.destroy();
+      input.value = '';
+    });
+  });
+
+  describe('dateDelimiter', function () {
+    it('specifies the date delemiter for the input string', function () {
+      const dp = new Datepicker(input, {maxNumberOfDates: 3, dateDelimiter: '|'});
+
+      dp.setDate('2/14/2020', '4/22/2020');
+      expect(input.value, 'to be', '02/14/2020|04/22/2020');
+
+      input.value = '2/11/2020|2/7/2020|2/14/2020';
+      dp.update();
+      expect(dp.dates, 'to equal', [
+        dateValue(2020, 1, 11),
+        dateValue(2020, 1, 7),
+        dateValue(2020, 1, 14),
+      ]);
+
+      dp.destroy();
+      input.value = '';
+    });
+
+    it('can be updated with setOptions()', function () {
+      const dp = new Datepicker(input, {maxNumberOfDates: 3});
+      dp.setOptions({dateDelimiter: '_'});
+      dp.setDate('2/11/2020', '2/7/2020', '2/14/2020');
+
+      dp.setOptions({dateDelimiter: ' - '});
+      expect(input.value, 'to be', '02/11/2020 - 02/07/2020 - 02/14/2020');
+
+      dp.setOptions({dateDelimiter: ','});
+      expect(input.value, 'to be', '02/11/2020,02/07/2020,02/14/2020');
+
+      dp.destroy();
+      input.value = '';
+    });
+  });
+});