@ionic/core 7.5.6-dev.11700169088.140f3e6a → 7.5.6-dev.11700492285.1581ed02

package/dist/collection/components/datetime/test/comparison.spec.js

@@ -0,0 +1,43 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { isSameDay, isBefore, isAfter } from "../utils/comparison";
+describe('isSameDay()', () => {
+  it('should return correct results for month, day, and year', () => {
+    const reference = { month: 1, day: 1, year: 2021 };
+    expect(isSameDay(reference, { month: 1, day: 1, year: 2021 })).toEqual(true);
+    expect(isSameDay(reference, { month: 2, day: 1, year: 2021 })).toEqual(false);
+    expect(isSameDay(reference, { month: 1, day: 2, year: 2021 })).toEqual(false);
+    expect(isSameDay(reference, { month: 1, day: 1, year: 2022 })).toEqual(false);
+    expect(isSameDay(reference, { month: 0, day: 0, year: 0 })).toEqual(false);
+    expect(isSameDay(reference, { month: null, day: null, year: null })).toEqual(false);
+  });
+});
+describe('isBefore()', () => {
+  it('should return correct results for month, day, and year', () => {
+    const reference = { month: 1, day: 1, year: 2021 };
+    expect(isBefore(reference, { month: 1, day: 1, year: 2021 })).toEqual(false);
+    expect(isBefore(reference, { month: 2, day: 1, year: 2021 })).toEqual(true);
+    expect(isBefore(reference, { month: 1, day: 2, year: 2021 })).toEqual(true);
+    expect(isBefore(reference, { month: 1, day: 1, year: 2022 })).toEqual(true);
+    expect(isBefore(reference, { month: 1, day: 1, year: 2020 })).toEqual(false);
+    expect(isBefore(reference, { month: 0, day: 0, year: 0 })).toEqual(false);
+    expect(isBefore(reference, { month: null, day: null, year: null })).toEqual(false);
+  });
+});
+describe('isAfter()', () => {
+  it('should return correct results for month, day, and year', () => {
+    const reference = { month: 2, day: 2, year: 2021 };
+    expect(isAfter(reference, { month: 2, day: 2, year: 2021 })).toEqual(false);
+    expect(isAfter(reference, { month: 2, day: 1, year: 2021 })).toEqual(true);
+    expect(isAfter(reference, { month: 1, day: 2, year: 2021 })).toEqual(true);
+    expect(isAfter(reference, { month: 1, day: 1, year: 2020 })).toEqual(true);
+    expect(isAfter(reference, { month: 1, day: 1, year: 2022 })).toEqual(false);
+    expect(isAfter(reference, { month: 0, day: 0, year: 0 })).toEqual(true);
+    /**
+     * 2021 > undefined === false
+     * 2021 > null === true
+     */
+    expect(isAfter(reference, { month: null, day: null, year: null })).toEqual(true);
+  });
+});

package/dist/collection/components/datetime/test/data.spec.js

@@ -0,0 +1,456 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { generateMonths, getDaysOfWeek, generateTime, getToday, getCombinedDateColumnData, getTimeColumnsData, } from "../utils/data";
+// The minutes are the same across all hour cycles, so we don't check those
+describe('getTimeColumnsData()', () => {
+  it('should generate formatted h12 hours and AM/PM data data', () => {
+    const refParts = { month: 5, year: 2021, day: 1, hour: 4, minute: 30 };
+    const results = getTimeColumnsData('en-US', refParts, 'h12');
+    expect(results.hoursData).toEqual([
+      { text: '12', value: 0 },
+      { text: '1', value: 1 },
+      { text: '2', value: 2 },
+      { text: '3', value: 3 },
+      { text: '4', value: 4 },
+      { text: '5', value: 5 },
+      { text: '6', value: 6 },
+      { text: '7', value: 7 },
+      { text: '8', value: 8 },
+      { text: '9', value: 9 },
+      { text: '10', value: 10 },
+      { text: '11', value: 11 },
+    ]);
+    expect(results.dayPeriodData).toEqual([
+      { text: 'AM', value: 'am' },
+      { text: 'PM', value: 'pm' },
+    ]);
+  });
+  it('should generate formatted h23 hours and AM/PM data data', () => {
+    const refParts = { month: 5, year: 2021, day: 1, hour: 4, minute: 30 };
+    const results = getTimeColumnsData('en-US', refParts, 'h23');
+    expect(results.hoursData).toEqual([
+      { text: '00', value: 0 },
+      { text: '01', value: 1 },
+      { text: '02', value: 2 },
+      { text: '03', value: 3 },
+      { text: '04', value: 4 },
+      { text: '05', value: 5 },
+      { text: '06', value: 6 },
+      { text: '07', value: 7 },
+      { text: '08', value: 8 },
+      { text: '09', value: 9 },
+      { text: '10', value: 10 },
+      { text: '11', value: 11 },
+      { text: '12', value: 12 },
+      { text: '13', value: 13 },
+      { text: '14', value: 14 },
+      { text: '15', value: 15 },
+      { text: '16', value: 16 },
+      { text: '17', value: 17 },
+      { text: '18', value: 18 },
+      { text: '19', value: 19 },
+      { text: '20', value: 20 },
+      { text: '21', value: 21 },
+      { text: '22', value: 22 },
+      { text: '23', value: 23 },
+    ]);
+    expect(results.dayPeriodData).toEqual([]);
+  });
+  it('should generate formatted h11 hours and AM/PM data data', () => {
+    const refParts = { month: 5, year: 2021, day: 1, hour: 4, minute: 30 };
+    const results = getTimeColumnsData('en-US', refParts, 'h11');
+    expect(results.hoursData).toEqual([
+      { text: '0', value: 0 },
+      { text: '1', value: 1 },
+      { text: '2', value: 2 },
+      { text: '3', value: 3 },
+      { text: '4', value: 4 },
+      { text: '5', value: 5 },
+      { text: '6', value: 6 },
+      { text: '7', value: 7 },
+      { text: '8', value: 8 },
+      { text: '9', value: 9 },
+      { text: '10', value: 10 },
+      { text: '11', value: 11 },
+    ]);
+    expect(results.dayPeriodData).toEqual([
+      { text: 'AM', value: 'am' },
+      { text: 'PM', value: 'pm' },
+    ]);
+  });
+  it('should generate formatted h24 hours and AM/PM data data', () => {
+    const refParts = { month: 5, year: 2021, day: 1, hour: 4, minute: 30 };
+    const results = getTimeColumnsData('en-US', refParts, 'h24');
+    expect(results.hoursData).toEqual([
+      { text: '01', value: 1 },
+      { text: '02', value: 2 },
+      { text: '03', value: 3 },
+      { text: '04', value: 4 },
+      { text: '05', value: 5 },
+      { text: '06', value: 6 },
+      { text: '07', value: 7 },
+      { text: '08', value: 8 },
+      { text: '09', value: 9 },
+      { text: '10', value: 10 },
+      { text: '11', value: 11 },
+      { text: '12', value: 12 },
+      { text: '13', value: 13 },
+      { text: '14', value: 14 },
+      { text: '15', value: 15 },
+      { text: '16', value: 16 },
+      { text: '17', value: 17 },
+      { text: '18', value: 18 },
+      { text: '19', value: 19 },
+      { text: '20', value: 20 },
+      { text: '21', value: 21 },
+      { text: '22', value: 22 },
+      { text: '23', value: 23 },
+      { text: '24', value: 0 },
+    ]);
+    expect(results.dayPeriodData).toEqual([]);
+  });
+});
+describe('generateMonths()', () => {
+  it('should generate correct month data', () => {
+    expect(generateMonths({ month: 5, year: 2021, day: 1 })).toEqual([
+      { month: 4, year: 2021, day: 1 },
+      { month: 5, year: 2021, day: 1 },
+      { month: 6, year: 2021, day: 1 },
+    ]);
+  });
+});
+describe('getDaysOfWeek()', () => {
+  it('should return English short names given a locale and mode', () => {
+    expect(getDaysOfWeek('en-US', 'ios')).toEqual(['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']);
+  });
+  it('should return English narrow names given a locale and mode', () => {
+    expect(getDaysOfWeek('en-US', 'md')).toEqual(['S', 'M', 'T', 'W', 'T', 'F', 'S']);
+  });
+  it('should return Spanish short names given a locale and mode', () => {
+    expect(getDaysOfWeek('es-ES', 'ios')).toEqual(['dom', 'lun', 'mar', 'mié', 'jue', 'vie', 'sáb']);
+  });
+  it('should return Spanish narrow names given a locale and mode', () => {
+    expect(getDaysOfWeek('es-ES', 'md')).toEqual(['D', 'L', 'M', 'X', 'J', 'V', 'S']);
+  });
+  it('should return English short names given a locale, mode and startOfWeek', () => {
+    expect(getDaysOfWeek('en-US', 'ios', 1)).toEqual(['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']);
+  });
+});
+describe('generateTime()', () => {
+  it('should not filter and hours/minutes when no bounds set', () => {
+    const today = {
+      day: 19,
+      month: 5,
+      year: 2021,
+      hour: 5,
+      minute: 43,
+    };
+    const { hours, minutes } = generateTime('en-US', today);
+    expect(hours.length).toEqual(12);
+    expect(minutes.length).toEqual(60);
+  });
+  it('should filter according to min', () => {
+    const today = {
+      day: 19,
+      month: 5,
+      year: 2021,
+      hour: 5,
+      minute: 43,
+    };
+    const min = {
+      day: 19,
+      month: 5,
+      year: 2021,
+      hour: 2,
+      minute: 40,
+    };
+    const { hours, minutes } = generateTime('en-US', today, 'h12', min);
+    expect(hours.length).toEqual(10);
+    expect(minutes.length).toEqual(60);
+  });
+  it('should not filter according to min if not on reference day', () => {
+    const today = {
+      day: 20,
+      month: 5,
+      year: 2021,
+      hour: 5,
+      minute: 43,
+    };
+    const min = {
+      day: 19,
+      month: 5,
+      year: 2021,
+      hour: 2,
+      minute: 40,
+    };
+    const { hours, minutes } = generateTime('en-US', today, 'h12', min);
+    expect(hours.length).toEqual(12);
+    expect(minutes.length).toEqual(60);
+  });
+  it('should filter according to max', () => {
+    const today = {
+      day: 19,
+      month: 5,
+      year: 2021,
+      hour: 7,
+      minute: 43,
+    };
+    const max = {
+      day: 19,
+      month: 5,
+      year: 2021,
+      hour: 7,
+      minute: 44,
+    };
+    const { hours, minutes } = generateTime('en-US', today, 'h12', undefined, max);
+    expect(hours.length).toEqual(8);
+    expect(minutes.length).toEqual(45);
+  });
+  it('should not filter according to min if not on reference day', () => {
+    const today = {
+      day: 20,
+      month: 5,
+      year: 2021,
+      hour: 5,
+      minute: 43,
+    };
+    const max = {
+      day: 21,
+      month: 5,
+      year: 2021,
+      hour: 2,
+      minute: 40,
+    };
+    const { hours, minutes } = generateTime('en-US', today, 'h12', undefined, max);
+    expect(hours.length).toEqual(12);
+    expect(minutes.length).toEqual(60);
+  });
+  it('should return no values for a day less than the min', () => {
+    const today = {
+      day: 20,
+      month: 5,
+      year: 2021,
+      hour: 5,
+      minute: 43,
+    };
+    const min = {
+      day: 21,
+      month: 5,
+      year: 2021,
+      hour: 2,
+      minute: 40,
+    };
+    const { hours, minutes } = generateTime('en-US', today, 'h12', min);
+    expect(hours.length).toEqual(0);
+    expect(minutes.length).toEqual(0);
+  });
+  it('should return no values for a day greater than the max', () => {
+    const today = {
+      day: 22,
+      month: 5,
+      year: 2021,
+      hour: 5,
+      minute: 43,
+    };
+    const max = {
+      day: 21,
+      month: 5,
+      year: 2021,
+      hour: 2,
+      minute: 40,
+    };
+    const { hours, minutes } = generateTime('en-US', today, 'h12', undefined, max);
+    expect(hours.length).toEqual(0);
+    expect(minutes.length).toEqual(0);
+  });
+  it('should allow all hours and minutes if not set in min/max', () => {
+    const today = {
+      day: 22,
+      month: 5,
+      year: 2021,
+      hour: 5,
+      minute: 43,
+    };
+    const min = {
+      day: 22,
+      month: 5,
+      year: 2021,
+    };
+    const max = {
+      day: 22,
+      month: 5,
+      year: 2021,
+    };
+    const { hours, minutes } = generateTime('en-US', today, 'h12', min, max);
+    expect(hours.length).toEqual(12);
+    expect(minutes.length).toEqual(60);
+  });
+  it('should allow certain hours and minutes based on minuteValues and hourValues', () => {
+    const today = {
+      day: 22,
+      month: 5,
+      year: 2021,
+      hour: 5,
+      minute: 43,
+    };
+    const { hours, minutes } = generateTime('en-US', today, 'h12', undefined, undefined, [1, 2, 3], [10, 15, 20]);
+    expect(hours).toStrictEqual([1, 2, 3]);
+    expect(minutes).toStrictEqual([10, 15, 20]);
+  });
+  it('should allow both am/pm when min is am and max is pm', () => {
+    // https://github.com/ionic-team/ionic-framework/issues/26216
+    const today = {
+      day: 22,
+      month: 5,
+      year: 2021,
+      hour: 5,
+      minute: 43,
+    };
+    const min = {
+      day: 22,
+      month: 5,
+      year: 2021,
+      hour: 11,
+      minute: 14,
+    };
+    const max = {
+      day: 22,
+      month: 5,
+      year: 2021,
+      hour: 12,
+      minute: 14,
+    };
+    const { am, pm } = generateTime('en-US', today, 'h12', min, max);
+    expect(am).toBe(true);
+    expect(pm).toBe(true);
+  });
+  describe('hourCycle is 23', () => {
+    it('should return hours in 24 hour format', () => {
+      const refValue = {
+        day: undefined,
+        month: undefined,
+        year: undefined,
+        hour: 19,
+        minute: 50,
+      };
+      const minParts = {
+        day: undefined,
+        month: undefined,
+        year: undefined,
+        hour: 19,
+        minute: 50,
+      };
+      const { hours } = generateTime('en-US', refValue, 'h23', minParts);
+      expect(hours).toStrictEqual([19, 20, 21, 22, 23]);
+    });
+    describe('current hour is above min hour range', () => {
+      it('should return minutes above the min minute range', () => {
+        const refValue = {
+          day: undefined,
+          month: undefined,
+          year: undefined,
+          hour: 20,
+          minute: 22,
+        };
+        const minParts = {
+          day: undefined,
+          month: undefined,
+          year: undefined,
+          hour: 19,
+          minute: 30,
+        };
+        const { hours, minutes } = generateTime('en-US', refValue, 'h23', minParts);
+        expect(hours).toStrictEqual([19, 20, 21, 22, 23]);
+        expect(minutes.length).toEqual(60);
+      });
+    });
+    it('should respect the min & max bounds', () => {
+      const refValue = {
+        day: undefined,
+        month: undefined,
+        year: undefined,
+        hour: 20,
+        minute: 30,
+      };
+      const minParts = {
+        day: undefined,
+        month: undefined,
+        year: undefined,
+        hour: 19,
+        minute: 30,
+      };
+      const maxParts = {
+        day: undefined,
+        month: undefined,
+        year: undefined,
+        hour: 20,
+        minute: 40,
+      };
+      const { hours } = generateTime('en-US', refValue, 'h23', minParts, maxParts);
+      expect(hours).toStrictEqual([19, 20]);
+    });
+    it('should return the filtered minutes when the max bound is set', () => {
+      const refValue = {
+        day: undefined,
+        month: undefined,
+        year: undefined,
+        hour: 13,
+        minute: 0,
+      };
+      const maxParts = {
+        day: undefined,
+        month: undefined,
+        year: undefined,
+        hour: 13,
+        minute: 2,
+      };
+      const { minutes } = generateTime('en-US', refValue, 'h23', undefined, maxParts);
+      expect(minutes).toStrictEqual([0, 1, 2]);
+    });
+    it('should not filter minutes when the current hour is less than the max hour bound', () => {
+      const refValue = {
+        day: undefined,
+        month: undefined,
+        year: undefined,
+        hour: 12,
+        minute: 0,
+      };
+      const maxParts = {
+        day: undefined,
+        month: undefined,
+        year: undefined,
+        hour: 13,
+        minute: 2,
+      };
+      const { minutes } = generateTime('en-US', refValue, 'h23', undefined, maxParts);
+      expect(minutes.length).toEqual(60);
+    });
+  });
+});
+describe('getToday', () => {
+  beforeAll(() => {
+    jest.useFakeTimers();
+    // System time is zero based, 1 = February
+    jest.setSystemTime(new Date(2022, 1, 21, 18, 30));
+  });
+  it('should return today without converting to UTC time', () => {
+    const res = getToday();
+    expect(res).toEqual('2022-02-21T18:30:00.000Z');
+  });
+});
+describe('getCombinedDateColumnData', () => {
+  it('should return correct data with dates across years', () => {
+    const { parts, items } = getCombinedDateColumnData('en-US', { day: 1, month: 1, year: 2021 }, { day: 31, month: 12, year: 2020 }, { day: 2, month: 1, year: 2021 });
+    expect(parts).toEqual([
+      { month: 12, year: 2020, day: 31 },
+      { month: 1, year: 2021, day: 1 },
+      { month: 1, year: 2021, day: 2 },
+    ]);
+    expect(items).toEqual([
+      { text: 'Thu, Dec 31', value: '2020-12-31' },
+      { text: 'Today', value: '2021-1-1' },
+      { text: 'Sat, Jan 2', value: '2021-1-2' },
+    ]);
+  });
+});

package/dist/collection/components/datetime/test/format.spec.js

@@ -0,0 +1,124 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { generateDayAriaLabel, getMonthAndDay, getFormattedHour, addTimePadding, getMonthAndYear, getLocalizedDayPeriod, getLocalizedTime, } from "../utils/format";
+describe('generateDayAriaLabel()', () => {
+  it('should return Wednesday, May 12', () => {
+    const reference = { month: 5, day: 12, year: 2021 };
+    expect(generateDayAriaLabel('en-US', false, reference)).toEqual('Wednesday, May 12');
+  });
+  it('should return Today, Wednesday, May 12', () => {
+    const reference = { month: 5, day: 12, year: 2021 };
+    expect(generateDayAriaLabel('en-US', true, reference)).toEqual('Today, Wednesday, May 12');
+  });
+  it('should return Saturday, May 1', () => {
+    const reference = { month: 5, day: 1, year: 2021 };
+    expect(generateDayAriaLabel('en-US', false, reference)).toEqual('Saturday, May 1');
+  });
+  it('should return Monday, May 31', () => {
+    const reference = { month: 5, day: 31, year: 2021 };
+    expect(generateDayAriaLabel('en-US', false, reference)).toEqual('Monday, May 31');
+  });
+  it('should return Saturday, April 1', () => {
+    const reference = { month: 4, day: 1, year: 2006 };
+    expect(generateDayAriaLabel('en-US', false, reference)).toEqual('Saturday, April 1');
+  });
+});
+describe('getMonthAndDay()', () => {
+  it('should return Tue, May 11', () => {
+    expect(getMonthAndDay('en-US', { month: 5, day: 11, year: 2021 })).toEqual('Tue, May 11');
+  });
+  it('should return mar, 11 may', () => {
+    expect(getMonthAndDay('es-ES', { month: 5, day: 11, year: 2021 })).toEqual('mar, 11 may');
+  });
+  it('should return Sat, Apr 1', () => {
+    expect(getMonthAndDay('en-US', { month: 4, day: 1, year: 2006 })).toEqual('Sat, Apr 1');
+  });
+  it('should return sáb, 1 abr', () => {
+    expect(getMonthAndDay('es-ES', { month: 4, day: 1, year: 2006 })).toEqual('sáb, 1 abr');
+  });
+});
+describe('getFormattedHour()', () => {
+  it('should only add padding if using 24 hour time', () => {
+    expect(getFormattedHour(1, 'h11')).toEqual('1');
+    expect(getFormattedHour(1, 'h12')).toEqual('1');
+    expect(getFormattedHour(1, 'h23')).toEqual('01');
+    expect(getFormattedHour(1, 'h24')).toEqual('01');
+  });
+  it('should return correct hour value for hour cycle', () => {
+    expect(getFormattedHour(0, 'h11')).toEqual('0');
+    expect(getFormattedHour(0, 'h12')).toEqual('12');
+    expect(getFormattedHour(0, 'h23')).toEqual('00');
+    expect(getFormattedHour(0, 'h24')).toEqual('24');
+  });
+});
+describe('addTimePadding()', () => {
+  it('should add correct amount of padding', () => {
+    expect(addTimePadding(0)).toEqual('00');
+    expect(addTimePadding(9)).toEqual('09');
+    expect(addTimePadding(10)).toEqual('10');
+    expect(addTimePadding(100)).toEqual('100');
+  });
+});
+describe('getMonthAndYear()', () => {
+  it('should return May 2021', () => {
+    expect(getMonthAndYear('en-US', { month: 5, day: 11, year: 2021 })).toEqual('May 2021');
+  });
+  it('should return mayo de 2021', () => {
+    expect(getMonthAndYear('es-ES', { month: 5, day: 11, year: 2021 })).toEqual('mayo de 2021');
+  });
+  it('should return April 2006', () => {
+    expect(getMonthAndYear('en-US', { month: 4, day: 1, year: 2006 })).toEqual('April 2006');
+  });
+  it('should return abril de 2006', () => {
+    expect(getMonthAndYear('es-ES', { month: 4, day: 1, year: 2006 })).toEqual('abril de 2006');
+  });
+});
+describe('getLocalizedDayPeriod', () => {
+  it('should return AM when the date is in the morning', () => {
+    expect(getLocalizedDayPeriod('en-US', 'am'));
+  });
+  it('should return PM when the date is in the afternoon', () => {
+    expect(getLocalizedDayPeriod('en-US', 'pm'));
+  });
+});
+describe('getLocalizedTime', () => {
+  it('should localize the time to PM', () => {
+    const datetimeParts = {
+      day: 1,
+      month: 1,
+      year: 2022,
+      hour: 13,
+      minute: 40,
+    };
+    expect(getLocalizedTime('en-US', datetimeParts, 'h12')).toEqual('1:40 PM');
+  });
+  it('should localize the time to AM', () => {
+    const datetimeParts = {
+      day: 1,
+      month: 1,
+      year: 2022,
+      hour: 9,
+      minute: 40,
+    };
+    expect(getLocalizedTime('en-US', datetimeParts, 'h12')).toEqual('9:40 AM');
+  });
+  it('should avoid Chromium bug when using 12 hour time in a 24 hour locale', () => {
+    const datetimeParts = {
+      day: 1,
+      month: 1,
+      year: 2022,
+      hour: 0,
+      minute: 0,
+    };
+    expect(getLocalizedTime('en-GB', datetimeParts, 'h12')).toEqual('12:00 am');
+  });
+  it('should parse time-only values correctly', () => {
+    const datetimeParts = {
+      hour: 22,
+      minute: 40,
+    };
+    expect(getLocalizedTime('en-US', datetimeParts, 'h12')).toEqual('10:40 PM');
+    expect(getLocalizedTime('en-US', datetimeParts, 'h23')).toEqual('22:40');
+  });
+});

package/dist/collection/components/datetime/test/helpers.spec.js

@@ -0,0 +1,72 @@
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+import { isLeapYear, getNumDaysInMonth, is24Hour, isMonthFirstLocale, getHourCycle } from "../utils/helpers";
+describe('daysInMonth()', () => {
+  it('should return correct days in month for month and year', () => {
+    expect(getNumDaysInMonth(1, 2019)).toBe(31);
+    expect(getNumDaysInMonth(2, 2019)).toBe(28);
+    expect(getNumDaysInMonth(3, 2019)).toBe(31);
+    expect(getNumDaysInMonth(4, 2019)).toBe(30);
+    expect(getNumDaysInMonth(5, 2019)).toBe(31);
+    expect(getNumDaysInMonth(6, 2019)).toBe(30);
+    expect(getNumDaysInMonth(7, 2019)).toBe(31);
+    expect(getNumDaysInMonth(8, 2019)).toBe(31);
+    expect(getNumDaysInMonth(9, 2019)).toBe(30);
+    expect(getNumDaysInMonth(10, 2019)).toBe(31);
+    expect(getNumDaysInMonth(11, 2019)).toBe(30);
+    expect(getNumDaysInMonth(12, 2019)).toBe(31);
+    expect(getNumDaysInMonth(2, 2020)).toBe(29);
+    expect(getNumDaysInMonth(2, 2021)).toBe(28);
+    expect(getNumDaysInMonth(2, 1900)).toBe(28);
+    expect(getNumDaysInMonth(2, 1800)).toBe(28);
+    expect(getNumDaysInMonth(2, 2400)).toBe(29);
+  });
+});
+describe('isLeapYear()', () => {
+  it('should return true if year is leapyear', () => {
+    expect(isLeapYear(2096)).toBe(true);
+    expect(isLeapYear(2021)).toBe(false);
+    expect(isLeapYear(2012)).toBe(true);
+    expect(isLeapYear(2000)).toBe(true);
+    expect(isLeapYear(1900)).toBe(false);
+    expect(isLeapYear(1800)).toBe(false);
+  });
+});
+describe('is24Hour()', () => {
+  it('should return true if the locale uses 24 hour time', () => {
+    expect(is24Hour('h11')).toBe(false);
+    expect(is24Hour('h12')).toBe(false);
+    expect(is24Hour('h23')).toBe(true);
+    expect(is24Hour('h24')).toBe(true);
+  });
+});
+describe('getHourCycle()', () => {
+  it('should return the correct hour cycle', () => {
+    expect(getHourCycle('en-US')).toBe('h12');
+    expect(getHourCycle('en-US', 'h23')).toBe('h23');
+    expect(getHourCycle('en-US', 'h12')).toBe('h12');
+    expect(getHourCycle('en-US-u-hc-h23')).toBe('h23');
+    expect(getHourCycle('en-GB')).toBe('h23');
+    expect(getHourCycle('en-GB', 'h23')).toBe('h23');
+    expect(getHourCycle('en-GB', 'h12')).toBe('h12');
+    expect(getHourCycle('en-GB-u-hc-h12')).toBe('h12');
+    expect(getHourCycle('en-GB', 'h11')).toBe('h11');
+    expect(getHourCycle('en-GB-u-hc-h11')).toBe('h11');
+    expect(getHourCycle('en-GB', 'h24')).toBe('h24');
+    expect(getHourCycle('en-GB-u-hc-h24')).toBe('h24');
+  });
+});
+describe('isMonthFirstLocale()', () => {
+  it('should return true if the locale shows months first', () => {
+    expect(isMonthFirstLocale('en-US')).toBe(true);
+    expect(isMonthFirstLocale('en-GB')).toBe(true);
+    expect(isMonthFirstLocale('es-ES')).toBe(true);
+    expect(isMonthFirstLocale('ro-RO')).toBe(true);
+  });
+  it('should return false if the locale shows years first', () => {
+    expect(isMonthFirstLocale('zh-CN')).toBe(false);
+    expect(isMonthFirstLocale('ja-JP')).toBe(false);
+    expect(isMonthFirstLocale('ko-KR')).toBe(false);
+  });
+});