react-native-ui-lib 8.1.1 → 8.1.5

package/src/incubator/calendar/__tests__/DateUtils.spec.js

@@ -1,367 +0,0 @@
-import * as DateUtils from "../helpers/DateUtils";
-import { FirstDayOfWeek, DayNamesFormat } from "../types";
-describe('Calendar/DateUtils', () => {
-  describe('getWeekNumbersOfMonth', () => {
-    it('should return week numbers of first month in a year', () => {
-      let weekNumbers = DateUtils.getWeekNumbersOfMonth(2023, 0, FirstDayOfWeek.MONDAY);
-      expect(weekNumbers).toEqual([1, 2, 3, 4, 5, 6]);
-      weekNumbers = DateUtils.getWeekNumbersOfMonth(2023, 0, FirstDayOfWeek.SUNDAY);
-      expect(weekNumbers).toEqual([1, 2, 3, 4, 5]);
-      weekNumbers = DateUtils.getWeekNumbersOfMonth(2022, 0, FirstDayOfWeek.MONDAY);
-      expect(weekNumbers).toEqual([1, 2, 3, 4, 5, 6]);
-      weekNumbers = DateUtils.getWeekNumbersOfMonth(2022, 0, FirstDayOfWeek.SUNDAY);
-      expect(weekNumbers).toEqual([1, 2, 3, 4, 5, 6]);
-      weekNumbers = DateUtils.getWeekNumbersOfMonth(2018, 0, FirstDayOfWeek.MONDAY);
-      expect(weekNumbers).toEqual([1, 2, 3, 4, 5]);
-      weekNumbers = DateUtils.getWeekNumbersOfMonth(2018, 0, FirstDayOfWeek.SUNDAY);
-      expect(weekNumbers).toEqual([1, 2, 3, 4, 5]);
-    });
-    it('should return week numbers of last month in a year', () => {
-      let weekNumbers = DateUtils.getWeekNumbersOfMonth(2022, 11, FirstDayOfWeek.MONDAY);
-      expect(weekNumbers).toEqual([49, 50, 51, 52, 53]);
-      weekNumbers = DateUtils.getWeekNumbersOfMonth(2018, 11, FirstDayOfWeek.MONDAY);
-      expect(weekNumbers).toEqual([48, 49, 50, 51, 52, 53]);
-    });
-    it('should return week numbers of a month with 6 weeks', () => {
-      let weekNumbers = DateUtils.getWeekNumbersOfMonth(2018, 3, FirstDayOfWeek.MONDAY);
-      expect(weekNumbers).toEqual([13, 14, 15, 16, 17, 18]);
-      weekNumbers = DateUtils.getWeekNumbersOfMonth(2018, 8, FirstDayOfWeek.SUNDAY);
-      expect(weekNumbers).toEqual([35, 36, 37, 38, 39, 40]);
-    });
-    it('should throw error when passing invalid month', () => {
-      expect(() => DateUtils.getWeekNumbersOfMonth(2022, 12, FirstDayOfWeek.MONDAY)).toThrowError('getWeekNumbersOfMonth util received an invalid month');
-    });
-  });
-  describe('getFirstDayInTheYear', () => {
-    describe('2020', () => {
-      it('2020 When Saturday is first day of the week - should return Saturday Dec 28th', () => {
-        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2020, FirstDayOfWeek.SATURDAY);
-        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
-        expect(dayObject.day).toBe(28);
-        expect(dayObject.month).toBe(11);
-        expect(dayObject.dayOfTheWeek).toBe(6);
-      });
-      it('2020 When Sunday is first day of the week - should return Sunday Dec 29th', () => {
-        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2020, FirstDayOfWeek.SUNDAY);
-        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
-        expect(dayObject.day).toBe(29);
-        expect(dayObject.month).toBe(11);
-        expect(dayObject.dayOfTheWeek).toBe(0);
-      });
-      it('2020 When Monday is first day of the week - should return Monday Dec 30th', () => {
-        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2020, FirstDayOfWeek.MONDAY);
-        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
-        expect(dayObject.day).toBe(30);
-        expect(dayObject.month).toBe(11);
-        expect(dayObject.dayOfTheWeek).toBe(1);
-      });
-    });
-    describe('2021', () => {
-      it('2021 When Saturday is first day of the week - should return Saturday Dec 26th', () => {
-        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2021, FirstDayOfWeek.SATURDAY);
-        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
-        expect(dayObject.day).toBe(26);
-        expect(dayObject.month).toBe(11);
-        expect(dayObject.dayOfTheWeek).toBe(6);
-      });
-      it('2021 When Sunday is first day of the week - should return Sunday Dec 27th', () => {
-        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2021, FirstDayOfWeek.SUNDAY);
-        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
-        expect(dayObject.day).toBe(27);
-        expect(dayObject.month).toBe(11);
-        expect(dayObject.dayOfTheWeek).toBe(0);
-      });
-      it('2021 When Monday is first day of the week - should return Monday Dec 28th', () => {
-        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2021, FirstDayOfWeek.MONDAY);
-        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
-        expect(dayObject.day).toBe(28);
-        expect(dayObject.month).toBe(11);
-        expect(dayObject.dayOfTheWeek).toBe(1);
-      });
-    });
-    describe('2022', () => {
-      it('2022 When Saturday is first day of the week - should return Saturday Jan 1st', () => {
-        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2022, FirstDayOfWeek.SATURDAY);
-        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
-        expect(dayObject.day).toBe(1);
-        expect(dayObject.month).toBe(0);
-        expect(dayObject.dayOfTheWeek).toBe(6);
-      });
-      it('2022 When Sunday is first day of the week - should return Sunday Dec 26th', () => {
-        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2022, FirstDayOfWeek.SUNDAY);
-        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
-        expect(dayObject.day).toBe(26);
-        expect(dayObject.month).toBe(11);
-        expect(dayObject.dayOfTheWeek).toBe(0);
-      });
-      it('2022 When Monday is first day of the week - should return Monday Dec 27th', () => {
-        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2022, FirstDayOfWeek.MONDAY);
-        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
-        expect(dayObject.day).toBe(27);
-        expect(dayObject.month).toBe(11);
-        expect(dayObject.dayOfTheWeek).toBe(1);
-      });
-    });
-    describe('2023', () => {
-      it('2023 When Saturday is first day of the week - should return Saturday Dec 31st', () => {
-        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2023, FirstDayOfWeek.SATURDAY);
-        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
-        expect(dayObject.day).toBe(31);
-        expect(dayObject.month).toBe(11);
-        expect(dayObject.dayOfTheWeek).toBe(6);
-      });
-      it('2023 When Sunday is first day of the week - should return Sunday Jan 1st', () => {
-        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2023, FirstDayOfWeek.SUNDAY);
-        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
-        expect(dayObject.day).toBe(1);
-        expect(dayObject.month).toBe(0);
-        expect(dayObject.dayOfTheWeek).toBe(0);
-      });
-      it('2023 When Monday is first day of the week - should return Monday Dec 26th', () => {
-        const firstDayInTheYear = DateUtils._forTesting.getFirstDayInTheYear(2023, FirstDayOfWeek.MONDAY);
-        const dayObject = DateUtils.getDateObject(firstDayInTheYear);
-        expect(dayObject.day).toBe(26);
-        expect(dayObject.month).toBe(11);
-        expect(dayObject.dayOfTheWeek).toBe(1);
-      });
-    });
-  });
-  describe('getDaysOfWeekNumber', () => {
-    it('should return array of 7 items', () => {
-      const daysInWeek = DateUtils.getDaysOfWeekNumber(2022, 11, FirstDayOfWeek.MONDAY);
-      expect(daysInWeek.length).toBe(7);
-    });
-    it('should return the right days at the first week of year - FirstDayOfWeek.SUNDAY', () => {
-      const daysInWeek = DateUtils.getDaysOfWeekNumber(2023, 1, FirstDayOfWeek.SUNDAY);
-      const firstDay = daysInWeek[0];
-      const lastDay = daysInWeek[6];
-      const firstDayObject = DateUtils.getDateObject(firstDay);
-      expect(firstDayObject.day).toBe(1);
-      expect(firstDayObject.month).toBe(0);
-      expect(firstDayObject.year).toBe(2023);
-      const lastDayObject = DateUtils.getDateObject(lastDay);
-      expect(lastDayObject.day).toBe(7);
-      expect(lastDayObject.month).toBe(0);
-      expect(lastDayObject.year).toBe(2023);
-    });
-
-    // TODO: We need to fix this test
-    it('should return the right days at the first week of year - FirstDayOfWeek.MONDAY', () => {
-      const daysInWeek = DateUtils.getDaysOfWeekNumber(2023, 1, FirstDayOfWeek.MONDAY);
-      const firstDay = daysInWeek[0];
-      const lastDay = daysInWeek[6];
-      const firstDayObject = DateUtils.getDateObject(firstDay);
-      expect(firstDayObject.day).toBe(26);
-      expect(firstDayObject.month).toBe(11);
-      expect(firstDayObject.year).toBe(2022);
-      const lastDayObject = DateUtils.getDateObject(lastDay);
-      expect(lastDayObject.day).toBe(1);
-      expect(lastDayObject.month).toBe(0);
-      expect(lastDayObject.year).toBe(2023);
-    });
-  });
-  describe('addMonths', () => {
-    it('should return the date timestamp for the next (1) months in the next (1) years', () => {
-      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), 1);
-      const dayObject = DateUtils.getDateObject(date);
-      expect(dayObject.day).toBe(26);
-      expect(dayObject.month).toBe(0);
-      expect(dayObject.year).toBe(2023);
-    });
-    it('should return the date timestamp for the next (5) months in the same year', () => {
-      const date = DateUtils.addMonths(new Date(2023, 0, 26).getTime(), 5);
-      const dayObject = DateUtils.getDateObject(date);
-      expect(dayObject.day).toBe(26);
-      expect(dayObject.month).toBe(5);
-      expect(dayObject.year).toBe(2023);
-    });
-    it('should return the date timestamp for the next (13) months in the next (2) years', () => {
-      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), 13);
-      const dayObject = DateUtils.getDateObject(date);
-      expect(dayObject.day).toBe(26);
-      expect(dayObject.month).toBe(0);
-      expect(dayObject.year).toBe(2024);
-    });
-    it('should return the date timestamp for the next (24) months in the next (2) years', () => {
-      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), 24);
-      const dayObject = DateUtils.getDateObject(date);
-      expect(dayObject.day).toBe(26);
-      expect(dayObject.month).toBe(11);
-      expect(dayObject.year).toBe(2024);
-    });
-
-    // subtract
-    it('should return the date timestamp for the previous (-1) months in the previous (1) years', () => {
-      const date = DateUtils.addMonths(new Date(2023, 0, 26).getTime(), -1);
-      const dayObject = DateUtils.getDateObject(date);
-      expect(dayObject.day).toBe(26);
-      expect(dayObject.month).toBe(11);
-      expect(dayObject.year).toBe(2022);
-    });
-    it('should return the date timestamp for the previous (-5) months in the same year', () => {
-      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), -5);
-      const dayObject = DateUtils.getDateObject(date);
-      expect(dayObject.day).toBe(26);
-      expect(dayObject.month).toBe(6);
-      expect(dayObject.year).toBe(2022);
-    });
-    it('should return the date timestamp for the previous (-13) months in the previous (2) years', () => {
-      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), -13);
-      const dayObject = DateUtils.getDateObject(date);
-      expect(dayObject.day).toBe(26);
-      expect(dayObject.month).toBe(10);
-      expect(dayObject.year).toBe(2021);
-    });
-    it('should return the date timestamp for the previous (-24) months in the previous (2) years', () => {
-      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), -24);
-      const dayObject = DateUtils.getDateObject(date);
-      expect(dayObject.day).toBe(26);
-      expect(dayObject.month).toBe(11);
-      expect(dayObject.year).toBe(2020);
-    });
-
-    // useFirstDay
-    it('should return the date timestamp for the 1st day of the next (1) months in the next (1) years', () => {
-      const date = DateUtils.addMonths(new Date(2022, 11, 26).getTime(), 1, true);
-      const dayObject = DateUtils.getDateObject(date);
-      expect(dayObject.day).toBe(1);
-      expect(dayObject.month).toBe(0);
-      expect(dayObject.year).toBe(2023);
-    });
-  });
-  describe('addYears', () => {
-    it('should return the date timestamp for the next (1) year in the same month', () => {
-      const date = DateUtils.addYears(new Date(2022, 11, 26).getTime(), 1);
-      const dayObject = DateUtils.getDateObject(date);
-      expect(dayObject.day).toBe(26);
-      expect(dayObject.month).toBe(11);
-      expect(dayObject.year).toBe(2023);
-    });
-    it('should return the date timestamp for the previous (-1) year in the same month', () => {
-      const date = DateUtils.addYears(new Date(2022, 11, 26).getTime(), -1);
-      const dayObject = DateUtils.getDateObject(date);
-      expect(dayObject.day).toBe(26);
-      expect(dayObject.month).toBe(11);
-      expect(dayObject.year).toBe(2021);
-    });
-  });
-  describe('getWeekDayNames', () => {
-    it('should return the week days names for first day = Sunday', () => {
-      const weekDaysNames = DateUtils.getWeekDayNames();
-      expect(weekDaysNames[0]).toBe('Sunday');
-    });
-    it('should return the week days names for first day = Monday', () => {
-      const weekDaysNames = DateUtils.getWeekDayNames(FirstDayOfWeek.MONDAY);
-      expect(weekDaysNames[0]).toBe('Monday');
-    });
-    it('should return the week days names for first day = Saturday', () => {
-      const weekDaysNames = DateUtils.getWeekDayNames(FirstDayOfWeek.SATURDAY);
-      expect(weekDaysNames[0]).toBe('Saturday');
-    });
-    it('should return the week days names for long abbreviation format', () => {
-      const weekDaysNames = DateUtils.getWeekDayNames(FirstDayOfWeek.SUNDAY, DayNamesFormat.LONG_ABBREVIATION);
-      expect(weekDaysNames[0]).toBe('Sun');
-    });
-    it('should return the week days names for first day = Sunday', () => {
-      const weekDaysNames = DateUtils.getWeekDayNames(FirstDayOfWeek.SUNDAY, DayNamesFormat.SHORT_ABBREVIATION);
-      expect(weekDaysNames[0]).toBe('S');
-    });
-  });
-  describe('isPastDate', () => {
-    it('should return true for a past date', () => {
-      expect(DateUtils.isPastDate(new Date('2022-12-26').getTime())).toBe(true);
-    });
-    it('should return false for a future date', () => {
-      expect(DateUtils.isPastDate(new Date('2222-12-26').getTime())).toBe(false);
-    });
-  });
-  describe('isSameDay', () => {
-    it('should return true for same dates using Date objects', () => {
-      expect(DateUtils.isSameDay(new Date().getTime(), Date.now())).toBe(true);
-    });
-    it('should return true for same dates using timestamps', () => {
-      expect(DateUtils.isSameDay(1673442316000, 1673463916000)).toBe(true);
-    });
-    it('should return false for different dates using Date objects', () => {
-      expect(DateUtils.isSameDay(new Date('2022-12-26').getTime(), new Date('2022-12-27').getTime())).toBe(false);
-    });
-    it('should return false for different dates using timestamps', () => {
-      expect(DateUtils.isSameDay(1673442316000, 1674327916)).toBe(false);
-    });
-  });
-  describe('isSameMonth', () => {
-    it('should return true for same months using Date objects', () => {
-      expect(DateUtils.isSameMonth(new Date().getTime(), Date.now())).toBe(true);
-    });
-    it('should return true for same months using timestamps', () => {
-      expect(DateUtils.isSameMonth(1673950085000, 1674122885000)).toBe(true);
-    });
-    it('should return false for different months using Date objects', () => {
-      expect(DateUtils.isSameMonth(new Date('2023-12-27').getTime(), new Date('2023-11-27').getTime())).toBe(false);
-    });
-    it('should return false for different years using Date objects', () => {
-      expect(DateUtils.isSameMonth(new Date('2023-12-27').getTime(), new Date('2022-12-27').getTime())).toBe(false);
-    });
-    it('should return false for different months using timestamps', () => {
-      expect(DateUtils.isSameMonth(1673949947000, 1676628347000)).toBe(false);
-    });
-    it('should return true for different years using timestamps', () => {
-      expect(DateUtils.isSameMonth(1673949947000, 1705485947000)).toBe(false);
-    });
-    it('should return false for same month in MonthProps date format', () => {
-      expect(DateUtils.isSameMonth({
-        month: 11,
-        year: 2026,
-        timestamp: new Date(2026, 11, 1).getTime()
-      }, {
-        month: 10,
-        year: 2026,
-        timestamp: new Date(2026, 10, 1).getTime()
-      })).toBe(false);
-    });
-    it('should return false for same month in MonthProps date format', () => {
-      expect(DateUtils.isSameMonth({
-        month: 10,
-        year: 2023,
-        timestamp: new Date(2023, 10, 1).getTime()
-      }, {
-        month: 10,
-        year: 2026,
-        timestamp: new Date(2026, 10, 1).getTime()
-      })).toBe(false);
-    });
-    it('should return true for same month in MonthProps date format', () => {
-      expect(DateUtils.isSameMonth({
-        month: 10,
-        year: 2026,
-        timestamp: new Date(2026, 10, 1).getTime()
-      }, {
-        month: 10,
-        year: 2026,
-        timestamp: new Date(2026, 10, 1).getTime()
-      })).toBe(true);
-    });
-    it('should return true for same month in different date format', () => {
-      expect(DateUtils.isSameMonth({
-        month: 0,
-        year: 2022,
-        timestamp: new Date(2022, 0, 1).getTime()
-      }, new Date('2022-01-27').getTime())).toBe(true);
-    });
-    it('should return true for same month in different date format', () => {
-      expect(DateUtils.isSameMonth(new Date('2026-11-27').getTime(), {
-        month: 10,
-        year: 2026,
-        timestamp: new Date(2026, 10, 1).getTime()
-      })).toBe(true);
-    });
-  });
-  describe('getMonthForIndex', () => {
-    it('should return January for index 0 ', () => {
-      expect(DateUtils.getMonthForIndex(0)).toBe('January');
-    });
-    it('should return December for index 11 ', () => {
-      expect(DateUtils.getMonthForIndex(11)).toBe('December');
-    });
-  });
-});

package/src/incubator/expandableOverlay/__tests__/index.spec.js

@@ -1,114 +0,0 @@
-import React from 'react';
-import { render } from '@testing-library/react-native';
-import ExpandableOverlay from "../index";
-import View from "../../../components/view";
-import Text from "../../../components/text";
-import { ExpandableOverlayDriver } from "../ExpandableOverlay.driver";
-
-// What we want to test:
-/**
- * 1. Sanity - it renders.
- * 2. Clicking opens the modal/dialog.
- */
-
-const testID = 'expandableOverylayTest';
-const helloWorld = 'Hello World';
-const universe = 'Hello Universe';
-const TestCase = props => {
-  return <ExpandableOverlay expandableContent={<Text>{universe}</Text>} {...props} testID={testID}>
-      <View>
-        <Text>{helloWorld}</Text>
-      </View>
-    </ExpandableOverlay>;
-};
-const getDriver = props => {
-  const renderTree = render(<TestCase {...props} />);
-  const driver = ExpandableOverlayDriver({
-    renderTree,
-    testID
-  }, props.useDialog ?? false);
-  return {
-    driver,
-    renderTree
-  };
-};
-describe('ExpandableOverlay', () => {
-  describe('With Dialog (useDialog)', () => {
-    it('Sanity', () => {
-      const {
-        driver
-      } = getDriver({
-        useDialog: true
-      });
-      expect(driver.exists()).toBeFalsy();
-    });
-    it('Test open', () => {
-      const {
-        driver
-      } = getDriver({
-        useDialog: true
-      });
-      expect(driver.isOpen()).toBeFalsy();
-      driver.open();
-      expect(driver.isOpen()).toBeTruthy();
-    });
-    it('Test pressOnBackground', () => {
-      const {
-        driver
-      } = getDriver({
-        useDialog: true
-      });
-      driver.open();
-      expect(driver.isOpen()).toBeTruthy();
-      driver.pressOnBackground();
-      expect(driver.isOpen()).toBeFalsy();
-    });
-    it(`should render ${helloWorld} on starting view and ${universe} in the dialog only after pressing`, () => {
-      const {
-        driver,
-        renderTree
-      } = getDriver({
-        useDialog: true
-      });
-      expect(renderTree.queryByText(helloWorld)).toBeTruthy();
-      expect(renderTree.queryByText(universe)).toBeFalsy();
-      driver.open();
-      expect(renderTree.queryByText(universe)).toBeTruthy();
-    });
-  });
-  describe('With Modal', () => {
-    it('Sanity', () => {
-      const {
-        driver
-      } = getDriver({});
-      expect(driver.exists()).toBeFalsy();
-    });
-    it('Test open', () => {
-      const {
-        driver
-      } = getDriver({});
-      expect(driver.isOpen()).toBeFalsy();
-      driver.open();
-      expect(driver.isOpen()).toBeTruthy();
-    });
-    it('Test pressOnBackground', () => {
-      const {
-        driver
-      } = getDriver({});
-      driver.open();
-      expect(driver.isOpen()).toBeTruthy();
-      driver.pressOnBackground();
-      expect(driver.isOpen()).toBeFalsy();
-    });
-    it(`should render ${helloWorld} on starting view and ${universe} in the dialog only after pressing`, () => {
-      const {
-        driver,
-        renderTree
-      } = getDriver({});
-      expect(renderTree.queryByText(helloWorld)).toBeTruthy();
-      expect(renderTree.queryByText(universe)).toBeFalsy();
-      driver.open();
-      expect(renderTree.queryByText(universe)).toBeTruthy();
-    });
-  });
-});

package/src/incubator/gradient/__tests__/useAngleTransform.spec.js

@@ -1,126 +0,0 @@
-import { _forTesting } from "../useAngleTransform";
-const {
-  getStartEndFromAngle
-} = _forTesting;
-describe('useAngleTransform', () => {
-  it('getStartEndFromAngle - default', () => {
-    expect(getStartEndFromAngle()).toEqual({
-      start: {
-        x: 0.5,
-        y: 1.0
-      },
-      end: {
-        x: 0.5,
-        y: 0.0
-      }
-    });
-  });
-  it('getStartEndFromAngle - 0', () => {
-    expect(getStartEndFromAngle(0)).toEqual({
-      start: {
-        x: 0.5,
-        y: 1.0
-      },
-      end: {
-        x: 0.5,
-        y: 0.0
-      }
-    });
-  });
-  it('getStartEndFromAngle - 45', () => {
-    expect(getStartEndFromAngle(45)).toEqual({
-      start: {
-        x: 0.0,
-        y: 1.0
-      },
-      end: {
-        x: 1.0,
-        y: 0.0
-      }
-    });
-  });
-  it('getStartEndFromAngle - 90', () => {
-    expect(getStartEndFromAngle(90)).toEqual({
-      start: {
-        x: 0.0,
-        y: 0.5
-      },
-      end: {
-        x: 1.0,
-        y: 0.5
-      }
-    });
-  });
-  it('getStartEndFromAngle - 135', () => {
-    expect(getStartEndFromAngle(135)).toEqual({
-      start: {
-        x: 0.0,
-        y: 0.0
-      },
-      end: {
-        x: 1.0,
-        y: 1.0
-      }
-    });
-  });
-  it('getStartEndFromAngle - 180', () => {
-    expect(getStartEndFromAngle(180)).toEqual({
-      start: {
-        x: 0.5,
-        y: 0.0
-      },
-      end: {
-        x: 0.5,
-        y: 1.0
-      }
-    });
-  });
-  it('getStartEndFromAngle - 225', () => {
-    expect(getStartEndFromAngle(225)).toEqual({
-      start: {
-        x: 1.0,
-        y: 0.0
-      },
-      end: {
-        x: 0.0,
-        y: 1.0
-      }
-    });
-  });
-  it('getStartEndFromAngle - 270', () => {
-    expect(getStartEndFromAngle(270)).toEqual({
-      start: {
-        x: 1.0,
-        y: 0.5
-      },
-      end: {
-        x: 0.0,
-        y: 0.5
-      }
-    });
-  });
-  it('getStartEndFromAngle - 315', () => {
-    expect(getStartEndFromAngle(315)).toEqual({
-      start: {
-        x: 1.0,
-        y: 1.0
-      },
-      end: {
-        x: 0.0,
-        y: 0.0
-      }
-    });
-  });
-  it('getStartEndFromAngle - 360', () => {
-    expect(getStartEndFromAngle(360)).toEqual({
-      start: {
-        x: 0.5,
-        y: 1.0
-      },
-      end: {
-        x: 0.5,
-        y: 0.0
-      }
-    });
-  });
-});

package/src/incubator/slider/__tests__/SliderPresenter.spec.js

@@ -1,43 +0,0 @@
-import * as uut from "../SliderPresenter";
-const trackWidth = 350;
-const minimum = 0;
-const maximum = 100;
-describe('Slider:Presenter', () => {
-  describe('getOffsetForValue', () => {
-    it('should return 0 for 0', () => {
-      expect(uut.getOffsetForValue(0, trackWidth)).toEqual(0);
-    });
-    it('should return 350 for 1', () => {
-      expect(uut.getOffsetForValue(1, trackWidth)).toEqual(350);
-    });
-    it('should return 175 for 0.5', () => {
-      expect(uut.getOffsetForValue(0.5, trackWidth)).toEqual(175);
-    });
-    it('should return 175 for 50, when minimumValue = 0 and maximumValue = 100', () => {
-      expect(uut.getOffsetForValue(50, trackWidth, minimum, maximum)).toEqual(175);
-    });
-    it('should return 175 for 60, when minimumValue = 20 and maximumValue = 100', () => {
-      expect(uut.getOffsetForValue(60, trackWidth, 20, maximum)).toEqual(175);
-    });
-    it('should return 175 for 60, when minimumValue = 0 and maximumValue = 80', () => {
-      expect(uut.getOffsetForValue(40, trackWidth, minimum, 80)).toEqual(175);
-    });
-  });
-  describe('getValueForOffset', () => {
-    it('should return 0 for 0', () => {
-      expect(uut.getValueForOffset(0, trackWidth)).toEqual(0);
-    });
-    it('should return 1 for 350', () => {
-      expect(uut.getValueForOffset(350, trackWidth)).toEqual(1);
-    });
-    it('should return 0.5 for 175', () => {
-      expect(uut.getValueForOffset(175, trackWidth)).toEqual(0.5);
-    });
-    it('should return 50 for 175, when minimumValue = 0 and maximumValue = 100', () => {
-      expect(uut.getValueForOffset(175, trackWidth, minimum, maximum)).toEqual(50);
-    });
-    it('should return 60 for 175, when minimumValue = 0 and maximumValue = 100 and step = 20', () => {
-      expect(uut.getValueForOffset(175, trackWidth, minimum, maximum, 20)).toEqual(60);
-    });
-  });
-});

package/src/incubator/slider/__tests__/index.spec.js

@@ -1,34 +0,0 @@
-import React from 'react';
-import Slider from "../index";
-import { SliderDriver } from "../Slider.driver";
-describe('Slider', () => {
-  afterEach(() => {
-    SliderDriver.clear();
-  });
-  const sliderDriver = (testID, props) => {
-    const defaultProps = {
-      testID,
-      onValueChange: jest.fn(),
-      disabled: false
-    };
-    const component = <Slider {...defaultProps} {...props} />;
-    return new SliderDriver({
-      component,
-      testID
-    });
-  };
-  it('Should be disabled', async () => {
-    const testId = 'slider-comp';
-    const driver = await sliderDriver(testId, {
-      disabled: true
-    });
-    expect(await driver.isDisabled()).toBe(true);
-  });
-  it('Should be disabled', async () => {
-    const testId = 'slider-comp';
-    const driver = await sliderDriver(testId, {
-      disabled: false
-    });
-    expect(await driver.isDisabled()).toBe(false);
-  });
-});