@oracle/oraclejet-preact 14.0.6 → 14.1.0

package/cjs/UNSAFE_RatingGauge/__tests__/RatingGauge.spec.js

@@ -0,0 +1,732 @@
+/* @oracle/oraclejet-preact: 14.1.0 */
+'use strict';
+
+var jsxRuntime = require('preact/jsx-runtime');
+var preact = require('@testing-library/preact');
+var chai = require('chai');
+var UNSAFE_RatingGauge = require('../../UNSAFE_RatingGauge.js');
+var utils_UNSAFE_matchTranslationBundle = require('../../utils/UNSAFE_matchTranslationBundle.js');
+var UNSAFE_Environment = require('../../UNSAFE_Environment.js');
+var userEvent = require('@testing-library/user-event');
+var utils_PRIVATE_dvtTestUtils = require('../../utils/PRIVATE_dvtTestUtils.js');
+require('../../utils/PRIVATE_clientHints.js');
+var clientHints = require('../../clientHints-e821b5ee.js');
+require('../../tslib.es6-6f60dd09.js');
+require('preact');
+require('preact/hooks');
+require("identity-obj-proxy");
+require('../../utils/UNSAFE_classNames.js');
+require('../../classNames-55bceee6.js');
+require('../../utils/PRIVATE_meterUtils.js');
+require('../../utils/UNSAFE_dvtCommonUtils.js');
+require('../../hooks/UNSAFE_useUser.js');
+require('../../UNSAFE_Layer.js');
+require('preact/compat');
+require('../../hooks/UNSAFE_useTooltip.js');
+require('../../hooks/UNSAFE_useId.js');
+require('../../UNSAFE_Floating.js');
+require('../../Floating-48167355.js');
+require('../../index-55dfe40c.js');
+require('../../utils/PRIVATE_floatingUtils.js');
+require('../../utils/PRIVATE_refUtils.js');
+require('../../hooks/UNSAFE_useOutsideClick.js');
+require('../../utils/UNSAFE_arrayUtils.js');
+require('../../hooks/UNSAFE_useHover.js');
+require('../../hooks/UNSAFE_useToggle.js');
+require('../../hooks/UNSAFE_useFocus.js');
+require('../../hooks/UNSAFE_useTouch.js');
+require('../../utils/UNSAFE_mergeProps.js');
+require('../../hooks/UNSAFE_useAnimation.js');
+require('../../useAnimation-576ef8bc.js');
+require('../../hooks/UNSAFE_useTabbableMode.js');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var userEvent__default = /*#__PURE__*/_interopDefaultLegacy(userEvent);
+
+function __variableDynamicImportRuntime0__(path) {
+  switch (path) {
+    case '../../resources/nls/ar/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/ar/bundle.js'); });
+    case '../../resources/nls/ar-XB/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/ar-XB/bundle.js'); });
+    case '../../resources/nls/bg/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/bg/bundle.js'); });
+    case '../../resources/nls/bs/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/bs/bundle.js'); });
+    case '../../resources/nls/bs-Cyrl/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/bs-Cyrl/bundle.js'); });
+    case '../../resources/nls/cs/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/cs/bundle.js'); });
+    case '../../resources/nls/da/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/da/bundle.js'); });
+    case '../../resources/nls/de/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/de/bundle.js'); });
+    case '../../resources/nls/el/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/el/bundle.js'); });
+    case '../../resources/nls/en/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/en/bundle.js'); });
+    case '../../resources/nls/en-XA/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/en-XA/bundle.js'); });
+    case '../../resources/nls/en-XC/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/en-XC/bundle.js'); });
+    case '../../resources/nls/es/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/es/bundle.js'); });
+    case '../../resources/nls/et/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/et/bundle.js'); });
+    case '../../resources/nls/fi/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/fi/bundle.js'); });
+    case '../../resources/nls/fr/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/fr/bundle.js'); });
+    case '../../resources/nls/fr-CA/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/fr-CA/bundle.js'); });
+    case '../../resources/nls/he/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/he/bundle.js'); });
+    case '../../resources/nls/hr/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/hr/bundle.js'); });
+    case '../../resources/nls/hu/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/hu/bundle.js'); });
+    case '../../resources/nls/is/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/is/bundle.js'); });
+    case '../../resources/nls/it/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/it/bundle.js'); });
+    case '../../resources/nls/ja/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/ja/bundle.js'); });
+    case '../../resources/nls/ko/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/ko/bundle.js'); });
+    case '../../resources/nls/lt/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/lt/bundle.js'); });
+    case '../../resources/nls/lv/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/lv/bundle.js'); });
+    case '../../resources/nls/ms/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/ms/bundle.js'); });
+    case '../../resources/nls/nl/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/nl/bundle.js'); });
+    case '../../resources/nls/no/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/no/bundle.js'); });
+    case '../../resources/nls/pl/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/pl/bundle.js'); });
+    case '../../resources/nls/pt/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/pt/bundle.js'); });
+    case '../../resources/nls/pt-PT/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/pt-PT/bundle.js'); });
+    case '../../resources/nls/ro/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/ro/bundle.js'); });
+    case '../../resources/nls/ru/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/ru/bundle.js'); });
+    case '../../resources/nls/sk/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/sk/bundle.js'); });
+    case '../../resources/nls/sl/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/sl/bundle.js'); });
+    case '../../resources/nls/sr/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/sr/bundle.js'); });
+    case '../../resources/nls/sr-Latn/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/sr-Latn/bundle.js'); });
+    case '../../resources/nls/sv/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/sv/bundle.js'); });
+    case '../../resources/nls/th/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/th/bundle.js'); });
+    case '../../resources/nls/tr/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/tr/bundle.js'); });
+    case '../../resources/nls/uk/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/uk/bundle.js'); });
+    case '../../resources/nls/vi/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/vi/bundle.js'); });
+    case '../../resources/nls/zh-Hans/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/zh-Hans/bundle.js'); });
+    case '../../resources/nls/zh-Hant/bundle.ts': return Promise.resolve().then(function () { return require('../../resources/nls/zh-Hant/bundle.js'); });
+    default: return new Promise(function(resolve, reject) {
+      (typeof queueMicrotask === 'function' ? queueMicrotask : setTimeout)(
+        reject.bind(null, new Error("Unknown variable dynamic import: " + path))
+      );
+    })
+   }
+ }
+const TOOLTIP_TEST_TIMEOUT = 3000;
+const TOOLTIP_TEXT = 'Readonly rating gauge';
+const DATATIP_TEXT = '3 star(s)';
+describe('Test Rating component', () => {
+    it('render', async function () {
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 2, accessibleLabel: "ariaText" }));
+        const ariaText = await content.getAllByLabelText('ariaText');
+        chai.expect(ariaText).not.null;
+    });
+    it('applies Linaria CSS classes', async () => {
+        const locale = utils_UNSAFE_matchTranslationBundle.matchTranslationBundle(['en'], new Set(['en-US', 'en']));
+        const { default: translations } = await __variableDynamicImportRuntime0__(`../../resources/nls/${locale}/bundle.ts`);
+        const env = {
+            translations: { '@oracle/oraclejet-preact': translations }
+        };
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 2 }) })));
+        const ratingGaugeElement = content.container.firstElementChild;
+        const classList = ratingGaugeElement.classList;
+        chai.expect(classList.length).equals(2);
+    });
+});
+describe('Classlist test the various states Rating Gauge', () => {
+    it('Test readonly Rating Gauge', async function () {
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 2, isReadonly: true }));
+        const ratingGaugeElement = content.container.firstElementChild;
+        const classList = ratingGaugeElement.classList;
+        chai.expect(classList.length).equals(1);
+        chai.expect(ratingGaugeElement.getAttribute('aria-readonly')).equals('true');
+        chai.expect(ratingGaugeElement.getAttribute('aria-disabled')).null;
+    });
+    it('Test disabled Rating Gauge', async function () {
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 2, isDisabled: true }));
+        const ratingGaugeElement = content.container.firstElementChild;
+        const classList = ratingGaugeElement.classList;
+        chai.expect(classList.length).equals(1);
+        chai.expect(ratingGaugeElement.getAttribute('aria-readonly')).null;
+        chai.expect(ratingGaugeElement.getAttribute('aria-disabled')).equals('true');
+    });
+    it('Test editable Rating Gauge', async function () {
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3 }));
+        const ratingGaugeElement = content.container.firstElementChild;
+        const classList = ratingGaugeElement.classList;
+        chai.expect(classList.length).equals(2);
+        chai.expect(ratingGaugeElement.getAttribute('aria-readonly')).null;
+        chai.expect(ratingGaugeElement.getAttribute('aria-disabled')).null;
+    });
+    it('Test readonly and disabled both of Rating Gauge', async () => {
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, isDisabled: true, isReadonly: true }));
+        const ratingGaugeElement = content.container.firstElementChild;
+        chai.expect(ratingGaugeElement.getAttribute('aria-disabled')).equals('true');
+        chai.expect(ratingGaugeElement.getAttribute('aria-readonly')).null;
+    });
+});
+describe('Test Rating Gauge ARIA props', () => {
+    it('Default value verification using ARIA attributes', async () => {
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, {}));
+        const ratingGaugeElement = content.container.firstElementChild;
+        chai.expect(ratingGaugeElement.getAttribute('aria-valuemin')).equals('0');
+        chai.expect(ratingGaugeElement.getAttribute('aria-valuemax')).equals('5');
+        chai.expect(ratingGaugeElement.getAttribute('aria-valuenow')).equals('0');
+    });
+    it('Test value and max property of Rating Gauge', async function () {
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, max: 5 }));
+        const ratingGaugeElement = content.container.firstElementChild;
+        chai.expect(ratingGaugeElement.getAttribute('aria-valuemax')).equals('5');
+        chai.expect(ratingGaugeElement.getAttribute('aria-valuenow')).equals('3');
+        chai.expect(ratingGaugeElement.getAttribute('aria-valuemin')).equals('0');
+        chai.expect(ratingGaugeElement.getAttribute('aria-valuetext')).equals('3');
+        chai.expect(ratingGaugeElement.getAttribute('role')).equals('slider');
+        chai.expect(ratingGaugeElement.getAttribute('aria-labelledby')).null;
+        //expect(ratingGaugeElement.getAttribute('aria-describedby')).null; TO-DO : https://jira.oraclecorp.com/jira/browse/JET-52220
+    });
+    it('Test tooltip as aria label of Rating Gauge', async () => {
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, isReadonly: true, tooltip: TOOLTIP_TEXT }));
+        const ratingGaugeElement = content.container.firstElementChild;
+        chai.expect(ratingGaugeElement.getAttribute('aria-describedby')).not.null;
+        chai.expect(ratingGaugeElement.getAttribute('aria-label')).equals(TOOLTIP_TEXT);
+    });
+    it('Test accesssibleLabel of Rating Gauge', async () => {
+        const testAccessibleLabel = 'TEST-ACCESSIBLE-LABEL';
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 2, accessibleLabel: testAccessibleLabel }));
+        const ratingGaugeElement = content.container.firstElementChild;
+        chai.expect(ratingGaugeElement.getAttribute('aria-label')).equals(testAccessibleLabel);
+    });
+});
+describe('Test describedby and labelledby of Rating Gauge', () => {
+    it('Test describedby of Rating Gauge', async function () {
+        const testAriaDescribedBy = 'TEST ARIA-DESCRIBED-BY';
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, ariaDescribedBy: testAriaDescribedBy }));
+        const ratingGaugeElement = content.container.firstElementChild;
+        chai.expect(ratingGaugeElement.getAttribute('aria-describedby')).equals(testAriaDescribedBy);
+    });
+    it('Test labelledby of Rating Gauge', async function () {
+        const testAriaLabeledBy = 'TEST ARIA-LABELLED-BY';
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, ariaLabelledBy: testAriaLabeledBy }));
+        const ratingGaugeElement = content.container.firstElementChild;
+        chai.expect(ratingGaugeElement.getAttribute('aria-labelledby')).equals(testAriaLabeledBy);
+    });
+    it('Test aria-describedby concatenation for tooltip', async function () {
+        const testAriaDescribedBy = 'TEST ARIA-DESCRIBED-BY';
+        const testTooltip = 'TEST-TOOLTIP';
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, ariaDescribedBy: testAriaDescribedBy, isReadonly: true, tooltip: testTooltip }));
+        const ratingGaugeElement = content.container.firstElementChild;
+        const ratingDescribedBy = ratingGaugeElement.getAttribute('aria-describedby');
+        const describedByIds = ratingDescribedBy === null || ratingDescribedBy === void 0 ? void 0 : ratingDescribedBy.split(' ');
+        chai.expect(describedByIds === null || describedByIds === void 0 ? void 0 : describedByIds.length).equals(3);
+        chai.expect(describedByIds ? describedByIds[0] : '').equals('TEST');
+        chai.expect(describedByIds ? describedByIds[1] : '').equals('ARIA-DESCRIBED-BY');
+    });
+    it('Test aria-describedby concatenation for datatip', async function () {
+        const testAriaDescribedBy = 'TEST ARIA-DESCRIBED-BY';
+        const testDatatip = 'TEST-DATATIP';
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, ariaDescribedBy: testAriaDescribedBy, datatip: testDatatip }));
+        const ratingGaugeElement = content.container.firstElementChild;
+        const ratingDescribedBy = ratingGaugeElement.getAttribute('aria-describedby');
+        const describedByIds = ratingDescribedBy === null || ratingDescribedBy === void 0 ? void 0 : ratingDescribedBy.split(' ');
+        chai.expect(describedByIds === null || describedByIds === void 0 ? void 0 : describedByIds.length).equals(3); // including aria describedby for datatip
+        chai.expect(describedByIds ? describedByIds[0] : '').equals('TEST');
+        chai.expect(describedByIds ? describedByIds[1] : '').equals('ARIA-DESCRIBED-BY');
+    });
+});
+describe('Test "Size" property of Rating Gauge ', () => {
+    if (typeof jest === 'undefined') {
+        it('Test default size', async function () {
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 5 }));
+            const ratingGaugeElement = content.container.firstElementChild;
+            chai.expect(window.getComputedStyle(ratingGaugeElement).getPropertyValue('height')).equals('20px');
+        });
+        it('Test "size = large"', async function () {
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 5, size: "lg" }));
+            const ratingGaugeElement = content.container.firstElementChild;
+            chai.expect(window.getComputedStyle(ratingGaugeElement).getPropertyValue('height')).equals('36px');
+        });
+        it('Test "size = medium"', async function () {
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 10, size: "md" }));
+            const ratingGaugeElement = content.container.firstElementChild;
+            chai.expect(window.getComputedStyle(ratingGaugeElement).getPropertyValue('height')).equals('20px');
+        });
+        it('Test "size = small"', async function () {
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 10, size: "sm" }));
+            const ratingGaugeElement = content.container.firstElementChild;
+            chai.expect(window.getComputedStyle(ratingGaugeElement).getPropertyValue('height')).equals('16px');
+        });
+    }
+});
+describe('Mouse Interaction', () => {
+    const clientHints$1 = clientHints.getClientHints();
+    if (typeof jest === 'undefined' && clientHints$1.browser === 'chrome') {
+        mocha.timeout(TOOLTIP_TEST_TIMEOUT);
+        it('check toooltip correctly triggered with mouse interaction', async () => {
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, isReadonly: true, tooltip: TOOLTIP_TEXT }) }));
+            const ratingGaugeElement = content.container.firstElementChild;
+            userEvent__default["default"].hover(ratingGaugeElement);
+            await preact.waitFor(() => checkTooltipDatatipText(TOOLTIP_TEXT), {
+                timeout: TOOLTIP_TEST_TIMEOUT
+            });
+        }, TOOLTIP_TEST_TIMEOUT);
+        it('check datatip correctly triggered with mouse interaction', async () => {
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, datatip: DATATIP_TEXT }) }));
+            const ratingGaugeElement = content.container.firstElementChild;
+            userEvent__default["default"].hover(ratingGaugeElement);
+            await preact.waitFor(() => checkTooltipDatatipText(DATATIP_TEXT), {
+                timeout: TOOLTIP_TEST_TIMEOUT
+            });
+        }, TOOLTIP_TEST_TIMEOUT);
+        it('check onCommit event is correctly triggered with mouse interaction', async () => {
+            var _a;
+            const clickListenerObj = { clicked: false };
+            const handleOnCommit = (detail) => {
+                if (detail.value != null && detail.value == 3)
+                    clickListenerObj.clicked = true;
+            };
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { onCommit: handleOnCommit }) }));
+            const thirdStarElement = (_a = content.container.firstElementChild) === null || _a === void 0 ? void 0 : _a.children.item(2);
+            const clientX = getClientX(thirdStarElement);
+            userEvent__default["default"].click(thirdStarElement, { clientX: clientX });
+            await preact.waitFor(() => chai.expect(clickListenerObj.clicked).equals(true));
+        });
+        it('check onInput event is correctly triggered with mouse interaction', async () => {
+            var _a;
+            const hoverListenerObj = { hovered: false };
+            const handleOnInput = (detail) => {
+                if (detail.value != null && detail.value == 3)
+                    hoverListenerObj.hovered = true;
+            };
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { onInput: handleOnInput }) }));
+            const thirdStarElement = (_a = content.container.firstElementChild) === null || _a === void 0 ? void 0 : _a.children.item(2);
+            const clientX = getClientX(thirdStarElement);
+            userEvent__default["default"].hover(thirdStarElement, { clientX: clientX });
+            await preact.waitFor(() => chai.expect(hoverListenerObj.hovered).equals(true));
+        });
+    }
+});
+describe('Mouse Interaction in RTL mode', () => {
+    const clientHints$1 = clientHints.getClientHints();
+    if (typeof jest === 'undefined' && clientHints$1.browser === 'chrome') {
+        mocha.timeout(TOOLTIP_TEST_TIMEOUT);
+        it('check toooltip correctly triggered with mouse interaction', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, isReadonly: true, tooltip: TOOLTIP_TEXT }) })));
+            const ratingGaugeElement = content.container.firstElementChild;
+            userEvent__default["default"].hover(ratingGaugeElement);
+            await preact.waitFor(() => checkTooltipDatatipText(TOOLTIP_TEXT), {
+                timeout: TOOLTIP_TEST_TIMEOUT
+            });
+        }, TOOLTIP_TEST_TIMEOUT);
+        it('check datatip correctly triggered with mouse interaction', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, datatip: DATATIP_TEXT }) })));
+            const ratingGaugeElement = content.container.firstElementChild;
+            userEvent__default["default"].hover(ratingGaugeElement);
+            await preact.waitFor(() => checkTooltipDatatipText(DATATIP_TEXT), {
+                timeout: TOOLTIP_TEST_TIMEOUT
+            });
+        }, TOOLTIP_TEST_TIMEOUT);
+        it('check onCommit event is correctly triggered with mouse interaction', async () => {
+            var _a;
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            const clickListenerObj = { clicked: false };
+            const handleOnCommit = (detail) => {
+                if (detail.value != null && detail.value == 4)
+                    clickListenerObj.clicked = true;
+            };
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { onCommit: handleOnCommit }) })));
+            const secondStarElement = (_a = content.container.firstElementChild) === null || _a === void 0 ? void 0 : _a.children.item(1);
+            const clientX = getClientX(secondStarElement);
+            userEvent__default["default"].click(secondStarElement, { clientX: clientX });
+            await preact.waitFor(() => chai.expect(clickListenerObj.clicked).equals(true));
+        });
+        it('check onInput event is correctly triggered with mouse interaction', async () => {
+            var _a;
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            const hoverListenerObj = { hovered: false };
+            const handleOnInput = (detail) => {
+                if (detail.value != null && detail.value == 4)
+                    hoverListenerObj.hovered = true;
+            };
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { onInput: handleOnInput }) })));
+            const secondStarElement = (_a = content.container.firstElementChild) === null || _a === void 0 ? void 0 : _a.children.item(1);
+            const clientX = getClientX(secondStarElement);
+            userEvent__default["default"].hover(secondStarElement, { clientX: clientX });
+            await preact.waitFor(() => chai.expect(hoverListenerObj.hovered).equals(true));
+        });
+    }
+});
+describe('Keyboard Interaction', () => {
+    const clientHints$1 = clientHints.getClientHints();
+    if (typeof jest === 'undefined' && clientHints$1.browser === 'chrome') {
+        mocha.timeout(TOOLTIP_TEST_TIMEOUT);
+        it('check toooltip correctly triggered with keyboard interaction', async () => {
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, isReadonly: true, tooltip: TOOLTIP_TEXT }) }));
+            userEvent__default["default"].tab();
+            await preact.waitFor(() => checkTooltipDatatipText(TOOLTIP_TEXT), {
+                timeout: TOOLTIP_TEST_TIMEOUT
+            });
+        }, TOOLTIP_TEST_TIMEOUT);
+        it('check datatip correctly triggered with keyboard interaction', async () => {
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, datatip: DATATIP_TEXT }) }));
+            userEvent__default["default"].tab();
+            await preact.waitFor(() => checkTooltipDatatipText(DATATIP_TEXT), {
+                timeout: TOOLTIP_TEST_TIMEOUT
+            });
+        }, TOOLTIP_TEST_TIMEOUT);
+        it('check step is correctly triggered with default value using right arrow key by keyboard interaction ', async () => {
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) }));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ARROWRIGHT]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(3));
+        });
+        it('check step is correctly triggered with default value using up arrow key by keyboard interaction ', async () => {
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) }));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ARROWUP]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(3));
+        });
+        it('check step is correctly triggered using right arrow key with keyboard interaction', async () => {
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { step: 0.5, value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) }));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ARROWRIGHT]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(2.5));
+        });
+        it('check step is correctly triggered using up arrow key with keyboard interaction', async () => {
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { step: 0.5, value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) }));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ARROWUP]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(2.5));
+        });
+        it('check step is correctly triggered using left arrow key with keyboard interaction', async () => {
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { step: 0.5, value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) }));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ARROWLEFT]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(1.5));
+        });
+        it('check step is correctly triggered using down arrow key with keyboard interaction', async () => {
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { step: 0.5, value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) }));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ARROWDOWN]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(1.5));
+        });
+        it('check onInput event is correctly triggered with keyboard interaction', async () => {
+            const calledListenerObj = { called: false };
+            const handleOnInput = (detail) => {
+                if (detail.value != null && detail.value == 0)
+                    calledListenerObj.called = true;
+            };
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { onInput: handleOnInput }) }));
+            userEvent__default["default"].tab();
+            await preact.waitFor(() => chai.expect(calledListenerObj.called).equals(true));
+        });
+        it('check onInput is correctly triggered with HOME key by keyboard interaction ', async () => {
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) }));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[HOME]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(0));
+        });
+        it('check onInput is correctly triggered with END key by keyboard interaction ', async () => {
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) }));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[END]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(5));
+        });
+        it('check onCommit event is correctly triggered with keyboard interaction', async () => {
+            const calledListenerObj = { called: false };
+            const handleOnCommit = (detail) => {
+                if (detail.value != null && detail.value == 0)
+                    calledListenerObj.called = true;
+            };
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { onCommit: handleOnCommit }) }));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ENTER]');
+            await preact.waitFor(() => chai.expect(calledListenerObj.called).equals(true));
+        });
+    }
+});
+describe('Keyboard Interaction in RTL mode', () => {
+    const clientHints$1 = clientHints.getClientHints();
+    if (typeof jest === 'undefined' && clientHints$1.browser === 'chrome') {
+        mocha.timeout(TOOLTIP_TEST_TIMEOUT);
+        it('check toooltip correctly triggered with keyboard interaction', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, isReadonly: true, tooltip: TOOLTIP_TEXT }) })));
+            userEvent__default["default"].tab();
+            await preact.waitFor(() => checkTooltipDatatipText(TOOLTIP_TEXT), {
+                timeout: TOOLTIP_TEST_TIMEOUT
+            });
+        }, TOOLTIP_TEST_TIMEOUT);
+        it('check datatip correctly triggered with keyboard interaction', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, datatip: DATATIP_TEXT }) })));
+            userEvent__default["default"].tab();
+            await preact.waitFor(() => checkTooltipDatatipText(DATATIP_TEXT), {
+                timeout: TOOLTIP_TEST_TIMEOUT
+            });
+        }, TOOLTIP_TEST_TIMEOUT);
+        it('check step is correctly triggered with default value using right arrow by keyboard interaction ', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) })));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ARROWRIGHT]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(1));
+        });
+        it('check step is correctly triggered with default value using up arrow by keyboard interaction ', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) })));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ARROWUP]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(3));
+        });
+        it('check step is correctly triggered using right arrow key with keyboard interaction', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { step: 0.5, value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) })));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ARROWRIGHT]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(1.5));
+        });
+        it('check step is correctly triggered using up arrow key with keyboard interaction', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { step: 0.5, value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) })));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ARROWUP]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(2.5));
+        });
+        it('check step is correctly triggered using left arrow key with keyboard interaction', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { step: 0.5, value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) })));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ARROWLEFT]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(2.5));
+        });
+        it('check step is correctly triggered using up down arrow key with keyboard interaction', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { step: 0.5, value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) })));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ARROWDOWN]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(1.5));
+        });
+        it('check onInput event is correctly triggered with keyboard interaction', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            const calledListenerObj = { called: false };
+            const handleOnInput = (detail) => {
+                if (detail.value != null && detail.value == 0)
+                    calledListenerObj.called = true;
+            };
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { onInput: handleOnInput }) })));
+            userEvent__default["default"].tab();
+            await preact.waitFor(() => chai.expect(calledListenerObj.called).equals(true));
+        });
+        it('check onInput is correctly triggered with HOME key by keyboard interaction ', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) })));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[HOME]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(0));
+        });
+        it('check onInput is correctly triggered with END key by keyboard interaction ', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            let inputValue = 2;
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: inputValue, onInput: (detail) => {
+                        inputValue = detail.value;
+                    } }) })));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[END]');
+            await preact.waitFor(() => chai.expect(inputValue).equals(5));
+        });
+        it('check onCommit event is correctly triggered with keyboard interaction', async () => {
+            const env = {
+                user: { direction: 'rtl' }
+            };
+            const calledListenerObj = { called: false };
+            const handleOnCommit = (detail) => {
+                if (detail.value != null && detail.value == 0)
+                    calledListenerObj.called = true;
+            };
+            preact.render(jsxRuntime.jsx(UNSAFE_Environment.RootEnvironmentProvider, Object.assign({ environment: env }, { children: jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { onCommit: handleOnCommit }) })));
+            userEvent__default["default"].tab();
+            userEvent__default["default"].keyboard('[ENTER]');
+            await preact.waitFor(() => chai.expect(calledListenerObj.called).equals(true));
+        });
+    }
+});
+describe('Rating Gauge - TabbableModeContext', () => {
+    it('RootEnvironmentProvider is not present', async () => {
+        const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, {}));
+        const firstElement = content.container.firstElementChild;
+        const tabindex = firstElement === null || firstElement === void 0 ? void 0 : firstElement.getAttribute('tabindex');
+        chai.expect(tabindex).to.equal('0');
+    });
+    it('TabbableModeContext isTabbable=true', async () => {
+        const ratingGauge = jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, {});
+        const content = await utils_PRIVATE_dvtTestUtils["default"](ratingGauge, true);
+        const firstElement = content.container.firstElementChild;
+        const tabindex = firstElement === null || firstElement === void 0 ? void 0 : firstElement.getAttribute('tabindex');
+        chai.expect(tabindex).to.equal('0');
+    });
+    it('TabbableModeContext isTabbable=false', async () => {
+        const ratingGauge = jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, {});
+        const content = await utils_PRIVATE_dvtTestUtils["default"](ratingGauge, false);
+        const firstElement = content.container.firstElementChild;
+        const tabindex = firstElement === null || firstElement === void 0 ? void 0 : firstElement.getAttribute('tabindex');
+        chai.expect(tabindex).to.equal('-1');
+    });
+    it('TabbableModeContext not provided', async () => {
+        const ratingGauge = jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, {});
+        const content = await utils_PRIVATE_dvtTestUtils["default"](ratingGauge);
+        const firstElement = content.container;
+        const tabindex = firstElement === null || firstElement === void 0 ? void 0 : firstElement.getAttribute('tabindex');
+        chai.expect(tabindex).to.be.null;
+    });
+});
+describe('Test "color" property of Rating Gauge ', () => {
+    if (typeof jest === 'undefined') {
+        it('Test default color', async function () {
+            var _a, _b;
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 5 }));
+            const ratingGaugeElement = content.container.firstElementChild;
+            chai.expect((_b = (_a = ratingGaugeElement.firstElementChild) === null || _a === void 0 ? void 0 : _a.firstElementChild) === null || _b === void 0 ? void 0 : _b.classList.contains('oj-c-rating-gauge-neutral')).equals(true);
+        });
+        it('Test gold color', async function () {
+            var _a, _b;
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 5, color: "gold" }));
+            const ratingGaugeElement = content.container.firstElementChild;
+            chai.expect((_b = (_a = ratingGaugeElement.firstElementChild) === null || _a === void 0 ? void 0 : _a.firstElementChild) === null || _b === void 0 ? void 0 : _b.classList.contains('oj-c-rating-gauge-gold')).equals(true);
+        });
+        it('Test neutral color', async function () {
+            var _a, _b;
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 5, color: "neutral" }));
+            const ratingGaugeElement = content.container.firstElementChild;
+            chai.expect((_b = (_a = ratingGaugeElement.firstElementChild) === null || _a === void 0 ? void 0 : _a.firstElementChild) === null || _b === void 0 ? void 0 : _b.classList.contains('oj-c-rating-gauge-neutral')).equals(true);
+        });
+    }
+});
+describe('Test "thresholds" property of Rating Gauge ', () => {
+    if (typeof jest === 'undefined') {
+        const thresholdValues = [
+            { max: 1, color: 'danger', accessibleLabel: 'Poor' },
+            { max: 2, accessibleLabel: 'Needs Improvement' },
+            { max: 3, color: 'warning', accessibleLabel: 'Satisfactory' },
+            { max: 4, color: 'success', accessibleLabel: 'Exceeds Expectations' },
+            { max: 5, color: '#508223', accessibleLabel: 'Outstanding' }
+        ];
+        it('Test thresholds danger color', async function () {
+            var _a, _b;
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 1, thresholds: thresholdValues }));
+            const ratingGaugeElement = (_b = (_a = content.container.firstElementChild) === null || _a === void 0 ? void 0 : _a.firstElementChild) === null || _b === void 0 ? void 0 : _b.firstElementChild;
+            chai.expect(ratingGaugeElement.classList.length).equals(2);
+            chai.expect(ratingGaugeElement.classList.contains('oj-c-rating-gauge-danger')).equals(true);
+        });
+        it('Test thresholds no color', async function () {
+            var _a, _b;
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 2, thresholds: thresholdValues }));
+            const ratingGaugeElement = (_b = (_a = content.container.firstElementChild) === null || _a === void 0 ? void 0 : _a.firstElementChild) === null || _b === void 0 ? void 0 : _b.firstElementChild;
+            chai.expect(ratingGaugeElement.classList.length).equals(2);
+            chai.expect(ratingGaugeElement.classList.contains('oj-c-rating-gauge-neutral')).equals(true);
+        });
+        it('Test thresholds warning color', async function () {
+            var _a, _b;
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 3, thresholds: thresholdValues }));
+            const ratingGaugeElement = (_b = (_a = content.container.firstElementChild) === null || _a === void 0 ? void 0 : _a.firstElementChild) === null || _b === void 0 ? void 0 : _b.firstElementChild;
+            chai.expect(ratingGaugeElement.classList.length).equals(2);
+            chai.expect(ratingGaugeElement.classList.contains('oj-c-rating-gauge-warning')).equals(true);
+        });
+        it('Test thresholds success color', async function () {
+            var _a, _b;
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 4, thresholds: thresholdValues }));
+            const ratingGaugeElement = (_b = (_a = content.container.firstElementChild) === null || _a === void 0 ? void 0 : _a.firstElementChild) === null || _b === void 0 ? void 0 : _b.firstElementChild;
+            chai.expect(ratingGaugeElement.classList.length).equals(2);
+            chai.expect(ratingGaugeElement.classList.contains('oj-c-rating-gauge-success')).equals(true);
+        });
+        it('Test thresholds custom color', async function () {
+            var _a, _b;
+            const CUSTOM_COLOR = '#508223';
+            const content = preact.render(jsxRuntime.jsx(UNSAFE_RatingGauge.RatingGauge, { value: 5, thresholds: thresholdValues }));
+            const ratingGaugeElement = (_b = (_a = content.container.firstElementChild) === null || _a === void 0 ? void 0 : _a.firstElementChild) === null || _b === void 0 ? void 0 : _b.firstElementChild;
+            chai.expect(ratingGaugeElement.classList.length).equals(1);
+            chai.expect(ratingGaugeElement.style.cssText.split(CUSTOM_COLOR).length).equals(4);
+        });
+    }
+});
+const checkTooltipDatatipText = (content) => {
+    var _a;
+    const targetElements = document.querySelectorAll('[role="tooltip"]');
+    const targetElementItem = targetElements.item(0);
+    const tooltipContainer = targetElementItem === null || targetElementItem === void 0 ? void 0 : targetElementItem.firstElementChild;
+    chai.expect(tooltipContainer === null || tooltipContainer === void 0 ? void 0 : tooltipContainer.style.opacity).not.equals('');
+    chai.expect(tooltipContainer === null || tooltipContainer === void 0 ? void 0 : tooltipContainer.style.opacity).not.equals('0');
+    chai.expect(tooltipContainer === null || tooltipContainer === void 0 ? void 0 : tooltipContainer.style.maxHeight).not.equals('');
+    chai.expect(tooltipContainer === null || tooltipContainer === void 0 ? void 0 : tooltipContainer.style.maxHeight).not.equals('0');
+    const innerHTML = (_a = tooltipContainer === null || tooltipContainer === void 0 ? void 0 : tooltipContainer.firstElementChild) === null || _a === void 0 ? void 0 : _a.innerHTML;
+    chai.expect(innerHTML).equals(content);
+};
+const getClientX = (element) => {
+    const dim = element.getBoundingClientRect();
+    const clientX = dim.x + dim.width / 2;
+    return clientX;
+};
+/*  */
+//# sourceMappingURL=RatingGauge.spec.js.map