dimsum-e2e-tests 3.70.0-next.7 → 3.70.0-next.71

package/ds-data-table-async/helpers/getInputSelection.js

@@ -0,0 +1,6 @@
+/**
+ * Reads an input's native text-selection state. Used to prove the browser's own caret-placement
+ * and word-selection defaults survive on the filter combobox input (PUI-15851).
+ */
+export const getInputSelection = (element) =>
+  browser.execute((el) => ({ start: el.selectionStart, end: el.selectionEnd, value: el.value }), element);

package/ds-data-table-async/helpers/index.js

@@ -3,5 +3,6 @@ export * from './getElementDragHandler';
 export * from './asyncFilter';
 export * from './getRadioValue';
 export * from './getElementBoundingRect';
+export * from './getInputSelection';
 export * from './throttleTyping';
 export * from './asyncShiftPress';

package/ds-data-table-async/keyboard-scroll/DSDataTable.keyboard-scroll.func.spec.js

@@ -0,0 +1,39 @@
+import DSDataTableCO from '../DSDataTableCO';
+
+// Tests for the fix introduced in PUI-18626 (focused row clipped behind the sticky header on
+// upward keyboard navigation). The fix applies scroll-padding-top = header height to the scroll
+// container, so the browser-native focus scroll lands the focused row below the sticky header.
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-18709 - DSDataTable:: focused row visible below sticky header on ArrowUp nav - Func', () => {
+    before(async () => {
+      const errorOnGo = await DSDataTableCO.keyboardScrollIntoView.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: focused row lands below sticky header after upward keyboard navigation', async () => {
+      // Place focus inside the table, then scroll well past the fold and navigate back up.
+      await (await DSDataTableCO.getFirstRow()).click();
+      await DSDataTableCO.pressArrow('down', 20);
+      await DSDataTableCO.pressArrow('up', 8);
+
+      const geometry = await DSDataTableCO.getUpwardNavGeometry();
+      // Focus must be on a row, and the row must clear the sticky header (not clipped behind it)
+      // while staying inside the scroll viewport.
+      await expect(geometry.hasRow).toBe(true);
+      await expect(geometry.rowTop).toBeGreaterThanOrEqual(geometry.headerBottom - 1);
+      await expect(geometry.rowTop).toBeGreaterThanOrEqual(geometry.containerTop - 1);
+    });
+
+    it('02: first row fully visible below header when reached via upward nav', async () => {
+      // Continue upward past the top; extra presses at the first row are no-ops.
+      await DSDataTableCO.pressArrow('up', 30);
+
+      const geometry = await DSDataTableCO.getUpwardNavGeometry();
+      // The scroll container is at the very top, yet the focused first row still clears the header.
+      await expect(geometry.hasRow).toBe(true);
+      await expect(geometry.scrollTop).toBeLessThanOrEqual(1);
+      await expect(geometry.rowTop).toBeGreaterThanOrEqual(geometry.headerBottom - 1);
+    });
+  });
+}

package/ds-data-table-async/menubutton/DSDataTable.MenuButton.keyboard.func.spec.js

@@ -1,7 +1,6 @@
 import { Key } from 'webdriverio';
 import DSDataTableCO from '../DSDataTableCO';
 import DSMenuButtonCO from '../../ds-menu-button/DSMenuButtonCO';
-import { safeDismissAlert } from '../../helpers';
 
 if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
   describe('PUI-16414 - DataTable, MenuButton (keyboard) - Functional Test', async () => {
@@ -29,12 +28,14 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
     it('03: should trigger menuButton item with keyboard', async () => {
       await browser.keys(Key.ArrowUp);
       await browser.keys(Key.Return);
-      const alertText = await browser.getAlertText();
-      await expect(alertText).toEqual('item selected: log actions - undefined');
+      const result = await DSDataTableCO.getRowActionResult();
+      await result.waitForDisplayed();
+      await expect(result).toHaveText('item selected: log actions');
     });
     it('03: should expand menuButton submenu for datatable row with keyboard', async () => {
-      await safeDismissAlert();
       await browser.keys(Key.Return);
+      const menuRoot = await DSMenuButtonCO.getMenuRoot();
+      await menuRoot.waitForDisplayed();
       await browser.keys(Key.ArrowDown);
       const menuItems = (await DSMenuButtonCO.getMenuItems()).length;
       await expect(menuItems).toEqual(6);
@@ -42,11 +43,11 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
     it('04: should trigger menuButton submenu item with keyboard', async () => {
       await browser.keys(Key.ArrowRight);
       await browser.keys(Key.Return);
-      const alertText = await browser.getAlertText();
-      await expect(alertText).toEqual('item selected: Realtor Phone - (424) 000-0000');
+      const result = await DSDataTableCO.getRowActionResult();
+      await result.waitForDisplayed();
+      await expect(result).toHaveText('item selected: Realtor Phone - (424) 000-0000');
     });
     it('05: should close menuButton menu with keyboard', async () => {
-      await safeDismissAlert();
       await browser.keys(Key.Return);
       const menu = await DSMenuButtonCO.getMenuRoot();
       await menu.waitForDisplayed();

package/ds-data-table-async/menubutton/DSDataTable.MenuButton.mouse.func.spec.js

@@ -1,5 +1,4 @@
 import DSDataTableCO from '../DSDataTableCO';
-import { safeDismissAlert } from '../../helpers';
 import CellCO from '../components/CellCO';
 import DSMenuButtonCO from '../../ds-menu-button/DSMenuButtonCO';
 
@@ -21,11 +20,11 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
     it('02: should trigger menuButton item', async () => {
       const thirdItem = await DSMenuButtonCO.getMenuItemWrapper(2);
       await thirdItem.click();
-      const alertText = await browser.getAlertText();
-      await expect(alertText).toEqual('item selected: sms - undefined');
+      const result = await DSDataTableCO.getRowActionResult();
+      await result.waitForDisplayed();
+      await expect(result).toHaveText('item selected: sms');
     });
     it('03: should expand menuButton submenu for datatable row', async () => {
-      await safeDismissAlert();
       const menuButtonTrigger = await DSDataTableCO.getButtons(2);
       await menuButtonTrigger.click();
       const submenuTriggerItem = await DSMenuButtonCO.getMenuItemWrapper(1);
@@ -39,11 +38,11 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
     it('04: should trigger menuButton submenu item', async () => {
       const submenuItem = await DSMenuButtonCO.getMenuItemWrapper(5);
       await submenuItem.click();
-      const alertText = await browser.getAlertText();
-      await expect(alertText).toEqual('item selected: Realtor Phone - (424) 000-0000');
+      const result = await DSDataTableCO.getRowActionResult();
+      await result.waitForDisplayed();
+      await expect(result).toHaveText('item selected: Realtor Phone - (424) 000-0000');
     });
     it('05: should close menuButton flyout clicking outside the menu (cell for example)', async () => {
-      await safeDismissAlert();
       const menuButtonTrigger = await DSDataTableCO.getButtons(2);
       await menuButtonTrigger.click();
       const menu = await DSMenuButtonCO.getMenuRoot();

package/ds-data-table-async/pagination/DSDataTable.pagination.func.spec.js

@@ -14,8 +14,9 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
     });
     it('01: should have the previous page button disabled', async () => {
       const prevPageBt = await PaginationNavCO.getPrevPageBt();
-      const disabled = await prevPageBt.getAttribute('aria-disabled');
-      await expect(disabled).toBe('true');
+      // DSButtonV3 renders the native `disabled` attribute and intentionally omits aria-disabled
+      // (that is reserved for applyAriaDisabled/readOnly), so assert the native disabled state.
+      await expect(prevPageBt).toBeDisabled();
     });
     it('02: should expand the dropdown menu of the pages per component when clicking its button', async () => {
       const elemsPerPage = await PaginationNavCO.getElemsPerPageMenu();

package/ds-data-table-async/resizable/DSDataTable.resize-min-clamp.func.spec.js

@@ -0,0 +1,72 @@
+import { Key } from 'webdriverio';
+import { sendKeyRepeat } from '../../helpers';
+import DSDataTableCO from '../DSDataTableCO';
+import { HeaderCO } from '../components';
+
+// Coverage for PUI-12696 (fixed): a keyboard double-delta commit in useHeaderResizer let the last
+// column resize below its declared minWidth, so the resize handle overlapped the header title.
+// The resizableWithConstrains story sets minWidth: 100 / maxWidth: 300 on all 7 columns, so the
+// last column (dateRange, index 6) must clamp at 100 no matter how hard it is shrunk.
+const LAST_COLUMN_INDEX = 6;
+
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-18764 - DSDataTable:: last column resize clamps at minWidth - Func', () => {
+    before(async () => {
+      const errorOnGo = await DSDataTableCO.resizableWithConstrains.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: keyboard Shift+Alt+ArrowLeft should not shrink last column below minWidth', async () => {
+      // Focus the last column's resize handle: click its header, then Return focuses the handle
+      // directly (no drag/filter/sort child precedes it on this story) — same flow as PUI-11345.
+      const lastHeader = await HeaderCO.getHeaderCellByIndex(LAST_COLUMN_INDEX);
+      await lastHeader.click();
+      await browser.keys(Key.Return);
+      await expect(await HeaderCO.getLastResizeHandler()).toBeFocused();
+
+      // Each Shift+Alt+ArrowLeft is -50px; 6 presses drives well past the 100px floor.
+      await sendKeyRepeat([Key.Shift, Key.Alt, Key.ArrowLeft], 6);
+
+      await browser.waitUntil(
+        async () => {
+          const resizer = await HeaderCO.getLastResizeHandler();
+          const valueNow = Number(await resizer.getAttribute('aria-valuenow'));
+          const valueMin = Number(await resizer.getAttribute('aria-valuemin'));
+          return valueNow === valueMin;
+        },
+        { timeout: 5000, timeoutMsg: 'last column did not clamp at minWidth after keyboard shrink' },
+      );
+
+      const resizer = await HeaderCO.getLastResizeHandler();
+      const valueNow = Number(await resizer.getAttribute('aria-valuenow'));
+      const valueMin = Number(await resizer.getAttribute('aria-valuemin'));
+      // aria-valuenow mirrors the committed column width, so clamping at aria-valuemin (100) is the
+      // deterministic guard that the width was NOT reduced beyond its minimum limit (PUI-12696).
+      expect(valueNow).toBe(valueMin); // committed width clamped exactly at the floor
+      expect(valueNow).toBeGreaterThanOrEqual(100); // never below the declared minWidth
+    });
+
+    it('02: mouse drag should not shrink last column below minWidth', async () => {
+      // Widen first so the following shrink is a real reduction, then drag well past the floor.
+      await (await HeaderCO.getLastResizeHandler()).dragAndDrop({ x: 120, y: 0 });
+      await (await HeaderCO.getLastResizeHandler()).dragAndDrop({ x: -400, y: 0 });
+
+      await browser.waitUntil(
+        async () => {
+          const resizer = await HeaderCO.getLastResizeHandler();
+          const valueNow = Number(await resizer.getAttribute('aria-valuenow'));
+          const valueMin = Number(await resizer.getAttribute('aria-valuemin'));
+          return valueNow === valueMin;
+        },
+        { timeout: 5000, timeoutMsg: 'last column did not clamp at minWidth after mouse shrink' },
+      );
+
+      const resizer = await HeaderCO.getLastResizeHandler();
+      const valueNow = Number(await resizer.getAttribute('aria-valuenow'));
+      const valueMin = Number(await resizer.getAttribute('aria-valuemin'));
+      expect(valueNow).toBe(valueMin);
+      expect(valueNow).toBeGreaterThanOrEqual(100);
+    });
+  });
+}

package/ds-data-table-async/resizable/DSDataTable.resizerA11y.axe-core.func.spec.js

@@ -0,0 +1,42 @@
+import { Key } from 'webdriverio';
+import DSDataTableCO from '../DSDataTableCO';
+import { HeaderCO } from '../components';
+import { axeCoreCheck } from '../../helpers';
+
+// Axe-core for the resizable-column a11y contract (final shape in PUI-18812, was PUI-17786 /
+// PUI-17784). The resize handle is aria-hidden until its header is "entered" (child-navigation
+// mode), so the test enters the header first to expose the resizer to the accessibility tree before
+// scanning — an idle, aria-hidden handle would be skipped by axe and the scan would prove nothing.
+// The scan is what guards the bounded aria-value* set: a native range input whose aria-valuenow
+// fell outside aria-valuemin/aria-valuemax would trip aria-valid-attr-value.
+// PUI-18812 removed the resizerA11yMode prop, so there is a single resizer shape to scan.
+//
+// PUI-18885: this describe was temporarily describe.skip'd. Making the handle a form element
+// (PUI-18812) exposed it to axe's form rules, and naming it via aria-labelledby -> a display:none
+// span left no labelText axe could resolve; with aria-describedby also present, that tripped
+// label-title-only ("Form elements should have a visible label", serious / best-practice). The fix
+// names the handle directly with aria-label, so the rule no longer applies and the scan is live
+// again. It was never silenced via extraDisabledRules — that would have hidden the regression this
+// scan exists to catch.
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  describe('PUI-18750 - DSDataTable:: resizer native range input a11y contract - Axe-Core', () => {
+    before(async () => {
+      const errorOnGo = await DSDataTableCO.resizerSeparatorMode.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: should have no accessibility violations with the resizer exposed', async () => {
+      const header = await HeaderCO.getHeaderCellByIndex(1);
+      await header.click();
+      await browser.keys(Key.Return);
+      const result = await axeCoreCheck();
+      expect(result.length).toBe(0);
+    });
+  });
+}

package/ds-data-table-async/resizable/DSDataTable.resizerA11y.func.spec.js

@@ -0,0 +1,98 @@
+import { Key } from 'webdriverio';
+import DSDataTableCO from '../DSDataTableCO';
+import { HeaderCO } from '../components';
+
+// Tests for the resizable-column a11y contract, final shape landed in PUI-18812 (was PUI-17786 /
+// PUI-17784). The "50" bug (PUI-15786): the resizer was an <input type="range"> whose *default*
+// value (50) was announced next to the column name. PUI-18812 keeps the native range element — the
+// a11y-approved semantics — but drives it through DSInputText with a bounded aria-value* set and an
+// accessible name "Resize {Header} column", so no stray "50" is ever announced.
+// PUI-18812 also removed the resizerA11yMode prop: there is no longer a separator/slider choice, so
+// the ARIA contract below is the single shape for every resizer.
+// PUI-18885 changed how that name is supplied — aria-label on the handle itself instead of
+// aria-labelledby pointing at a display:none span — because the indirection through a hidden node
+// gave axe no resolvable labelText and tripped label-title-only on the native range input.
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'chrome') ||
+  browser.capabilities.browserName === 'Chrome'
+) {
+  describe('PUI-18748 - DSDataTable:: resizer native range input a11y contract - Func', () => {
+    before(async () => {
+      const errorOnGo = await DSDataTableCO.resizerSeparatorMode.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: should expose a native range input with bounded value and accessible name', async () => {
+      const resizer = await HeaderCO.getResizer(1);
+      await expect(resizer).toBeExisting();
+
+      // PUI-18812: the handle is a native <input type="range"> rendered through DSInputText. The
+      // data-testid lands on that inner input, so this element IS the range control. Native range
+      // semantics are relied on deliberately — no role override, which is why role must be absent
+      // (a hardcoded role here would shadow the native one).
+      expect((await resizer.getTagName()).toLowerCase()).toBe('input');
+      await expect(resizer).toHaveAttribute('type', 'range');
+      expect(await resizer.getAttribute('role')).toBe(null);
+      expect(await resizer.getAttribute('aria-roledescription')).toBe(null);
+
+      await expect(resizer).toHaveAttribute('aria-valuemin', '70');
+      await expect(resizer).toHaveAttribute('aria-valuemax', '600');
+
+      // Validate the value by SHAPE, not a fixed number: the width is not deterministic across
+      // layouts. The point is that it is a real, bounded width (the fix) and NOT the stray "50"
+      // the range input's *default* value announced before PUI-15786.
+      const valueNow = await resizer.getAttribute('aria-valuenow'); // current width as string, e.g. "150"
+      expect(/^\d+$/.test(valueNow)).toBe(true); // digits only: a real value, not empty/null/"150px"
+      expect(Number(valueNow)).toBeGreaterThanOrEqual(70); // >= aria-valuemin (70): the "50" guard
+      const valueText = await resizer.getAttribute('aria-valuetext'); // SR text, e.g. "150 pixels"
+      expect(/^\d+ pixels$/.test(valueText)).toBe(true); // must read "<width> pixels"
+
+      // PUI-18885: the name is supplied directly via aria-label. It used to be wired through
+      // aria-labelledby -> a display:none span, which left axe unable to resolve a labelText and
+      // tripped label-title-only on this form element (see the axe-core sibling spec). aria-labelledby
+      // must stay absent: reintroducing it would both shadow this name and bring the violation back.
+      // This asserts the attribute VALUE only; whether the browser computes a name from it is asserted
+      // in test 02, where the handle is exposed to the accessibility tree. It cannot be asserted here:
+      // at rest the handle is aria-hidden, so it has no computed name by design and a computed-name
+      // check would fail for the wrong reason.
+      expect(await resizer.getAttribute('aria-labelledby')).toBe(null);
+      await expect(resizer).toHaveAttribute('aria-label', 'Resize Name column');
+    });
+
+    it('02: should update aria-valuenow when resizing with the keyboard', async () => {
+      const nameHeader = await HeaderCO.getHeaderCellByIndex(1);
+      await nameHeader.click();
+      // Enter on the header focuses its resize handle directly (no drag/filter/sort child to precede it).
+      await browser.keys(Key.Return);
+      const resizer = await HeaderCO.getResizer(1);
+      await expect(resizer).toBeFocused();
+
+      // Disclosure guard. At rest every handle is tabindex="-1" + aria-hidden="true" (isReachable
+      // false), so the ARIA contract test 01 asserts is correct but not yet perceivable — by design,
+      // to keep idle resizers out of the AT tree. Once focused the handle must be exposed: a focused
+      // element left aria-hidden is a real a11y defect, and toBeFocused() alone would still pass.
+      await expect(resizer).toHaveAttribute('tabindex', '0');
+      expect(await resizer.getAttribute('aria-hidden')).toBe(null);
+
+      // The accessible name the browser actually computes, now that the handle is in the
+      // accessibility tree. This is the assertion that matters: test 01 only proves the aria-label
+      // attribute is present with the right text, which would still pass if something else (a
+      // reintroduced aria-labelledby, a native label association) shadowed it in the accname
+      // algorithm. A focused control with no computed name is a WCAG 4.1.2 failure, so it is asserted
+      // against the browser's own computation via WebDriver's Get Computed Label, not re-derived from
+      // the DOM.
+      const computedName = await HeaderCO.getResizerComputedName(resizer);
+      expect(computedName).toContain('Resize Name column');
+
+      const before = Number(await resizer.getAttribute('aria-valuenow'));
+      await browser.keys(Key.ArrowRight);
+      await browser.waitUntil(async () => Number(await resizer.getAttribute('aria-valuenow')) > before, {
+        timeout: 5000,
+        timeoutMsg: 'aria-valuenow did not increase after ArrowRight',
+      });
+    });
+  });
+}

package/ds-data-table-async/textwrapping/DSDataTable.header-wrap-alignment.axe-core.func.spec.js

@@ -0,0 +1,23 @@
+import DSDataTableCO from '../DSDataTableCO';
+import { axeCoreCheck } from '../../helpers';
+
+// Accessibility coverage for the PUI-17819 header wrap/alignment showcase.
+if (
+  (!browser.capabilities['ice:options'].isPhone &&
+    !browser.capabilities['ice:options'].isTablet &&
+    browser.capabilities.browserName === 'Chrome') ||
+  browser.capabilities.browserName === 'chrome'
+) {
+  describe('PUI-18681 - DSDataTable:: header text wrap rules and alignment - axe-core', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.headerWrapAlignment.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: should have no accessibility violations', async () => {
+      const result = await axeCoreCheck();
+      await expect(result.length).toBe(0);
+    });
+  });
+}

package/ds-data-table-async/textwrapping/DSDataTable.header-wrap-alignment.visual.spec.js

@@ -0,0 +1,106 @@
+import { Key } from 'webdriverio';
+import DSDataTableCO from '../DSDataTableCO';
+import { HeaderCO, RowCO } from '../components';
+
+// Column indices in the HeaderWrapAlignment story:
+// 0=id, 1=name, 2=wrap ('wrap'), 3=wrapAll ('wrap-all'), 4=truncate ('truncate')
+const WRAP_ALL_COL = 3;
+// Filter buttons render only on searchable columns (wrap, wrapAll, truncate) → wrapAll is index 1
+const WRAP_ALL_FILTER = 1;
+
+// Header control focus order (Enter on the focused header → then Tab):
+//   1. DnD handle  2. search/filter button  3. sort caret  4. resize handle
+// Tests for PUI-17819 (header wrap rules + alignment fix). Unblocks PUI-17814 (name/search-icon overlap).
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-18680 - DSDataTable:: header text wrap rules and alignment - visual', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.headerWrapAlignment.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: should render wrap / wrap-all / truncate headers top-aligned', async () => {
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('02: should keep header title top-aligned with revealed icons on hover', async () => {
+      const wrapAllHeader = await HeaderCO.getHeaderCellByIndex(WRAP_ALL_COL);
+      await wrapAllHeader.moveTo();
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('03: should keep wrapped header aligned after clicking the column to sort it', async () => {
+      // sort by clicking the column header itself (not the sort caret) — the realistic interaction.
+      // The click also focuses the header, which sets up the focus walk in the next steps.
+      const wrapAllHeader = await HeaderCO.getHeaderCellByIndex(WRAP_ALL_COL);
+      await wrapAllHeader.click();
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('04: should focus the drag-and-drop handle first when entering the header', async () => {
+      // Enter activates the header tab stops and focuses the first control (the DnD handle)
+      await browser.keys(Key.Return);
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('05: should move focus to the search/filter button on Tab', async () => {
+      await browser.keys(Key.Tab);
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('06: should move focus to the sort caret on Tab', async () => {
+      await browser.keys(Key.Tab);
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('07: should move focus to the resize handle on Tab', async () => {
+      await browser.keys(Key.Tab);
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('08: should keep wrapped header aligned while the filter/search is open', async () => {
+      const filterBtn = await HeaderCO.getFilterBtnByIndex(WRAP_ALL_FILTER);
+      await filterBtn.click();
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+      await browser.keys(Key.Escape);
+    });
+
+    it('09: should keep wrapped header aligned while the DnD handle is engaged', async () => {
+      const wrapAllHeader = await HeaderCO.getHeaderCellByIndex(WRAP_ALL_COL);
+      const dragHandle = await HeaderCO.getHeaderCellDragHandler(wrapAllHeader);
+      await dragHandle.click();
+      // keyboard pick-up renders a deterministic drag overlay (dnd-kit)
+      await browser.keys(Key.Space);
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+      await browser.keys(Key.Escape);
+    });
+
+    it('10: should keep wrapped headers intact with a row toolbar menu open', async () => {
+      const toolbarTrigger = await RowCO.getRowToolbarTriggerByIndex(0);
+      await toolbarTrigger.click();
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+      await browser.keys(Key.Escape);
+    });
+
+    it('11: should keep wrapped header aligned while a column is resized narrower', async () => {
+      // PUI-12696 (open): resizing a column below its min makes the resize handler overlap the
+      // header title. This captures current behavior; update the baseline when PUI-12696 lands.
+      // Kept last: the extra-tall header it produces would otherwise obscure the row toolbar
+      // trigger and break the coordinate-based click in the toolbar step.
+      const resizeHandler = await HeaderCO.getResizeHandler(WRAP_ALL_COL);
+      await resizeHandler.dragAndDrop({ x: -150, y: 0 });
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-data-table-async/textwrapping/DSDataTable.text-wrap-toolbar.visual.spec.js

@@ -0,0 +1,27 @@
+import DSDataTableCO from '../DSDataTableCO';
+import { RowCO } from '../components';
+
+// Global textWrap='wrap' together with a row-actions (toolbar) column — mirrors the
+// Components/DataTable/Features/Text Wrapping > Text Wrap Global showcase.
+// Tests for PUI-17819 (header wrap rules + alignment fix).
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-18682 - DSDataTable:: text wrap with row toolbar column - visual', () => {
+    before('loading page', async () => {
+      const errorOnGo = await DSDataTableCO.textWrapGlobalWithToolbar.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: should wrap all columns with the row toolbar column present', async () => {
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+    });
+
+    it('02: should keep cells wrapped while a row toolbar menu is open', async () => {
+      const toolbarTrigger = await RowCO.getRowToolbarTriggerByIndex(0);
+      await toolbarTrigger.click();
+      const snapshot = await browser.percyCheckScreenshot();
+      await expect(snapshot).toEqual(0);
+    });
+  });
+}

package/ds-data-table-async/toggle-cell-focus/DSDataTable.toggle-cell-enter-focus.func.spec.js

@@ -0,0 +1,31 @@
+import { Key } from 'webdriverio';
+import DSDataTableCO from '../DSDataTableCO';
+import { RowCO, CellCO } from '../components';
+import DSToggleCO from '../../ds-form-toggle/DSToggleCO';
+
+// Coverage for PUI-14730 (fixed): a toggle (DSControlledToggle) used as a custom cell did not
+// receive focus on the first Enter — it dropped its ref (containerProps only reached the wrapper
+// div; innerRef was discarded). Fixed in ds-form-toggle by forwarding innerRef to the underlying
+// <button role="switch">. The story renders the toggle as the FIRST focusable cell, so Enter on a
+// focused row must land focus on the toggle button (row.cells.find(c => c.ref.current).focus()).
+if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:options'].isTablet) {
+  describe('PUI-18783 - DSDataTable:: toggle custom cell focus on row Enter - Func', () => {
+    before(async () => {
+      const errorOnGo = await DSDataTableCO.toggleCellEnterFocus.go();
+      if (errorOnGo) throw errorOnGo;
+      await DSDataTableCO.waitForDataTable();
+    });
+
+    it('01: pressing Enter on a focused row moves focus to the toggle custom cell', async () => {
+      // Focus the row by clicking its first cell (the focusable row-content, role="row", receives
+      // focus), then press Enter — matches the editable-cell Enter-to-first-cell pattern.
+      const row = await RowCO.getRowByIndex(0);
+      const firstCell = await CellCO.getRowCellByIndex(row, 0);
+      await firstCell.click();
+      await browser.keys(Key.Return);
+
+      const toggle = await DSToggleCO.getToggleFocuseableByIndex(0);
+      await expect(toggle).toBeFocused();
+    });
+  });
+}

package/ds-data-table-async/vissibility/DSDataTable.vissibility.visual.spec.js

@@ -74,6 +74,8 @@ if (!browser.capabilities['ice:options'].isPhone && !browser.capabilities['ice:o
       await browser.keys(Key.Return);
       await browser.keys(Key.ArrowDown);
       await browser.keys(Key.Return);
+      await browser.keys(Key.ArrowDown);
+      await browser.keys(Key.Return);
       await FiltersCO.openFilterPopperByColumnName('name', 0);
       await browser.keys(Key.ArrowDown);
       await browser.keys(Key.Return);

package/ds-dataviz/DSDataViz.axis.visual.spec.js

@@ -65,8 +65,7 @@ if (!browser.capabilities['ice:options'].isPhone) {
 
   // fails on firefox due to fake-positive of infinte loop
   if (browser.capabilities.browserName !== 'Firefox') {
-    // Skipped until PUI-16334 gets fixed
-    describe.skip('PUI-9401 - DSDataViz, TimeLinear axis -Visual', () => {
+    describe('PUI-9401 - DSDataViz, TimeLinear axis -Visual', () => {
       before('loading page', async () => {
         const errorOnGo = await DSDataVizCO.timeLinearAxis.go();
         if (errorOnGo) throw errorOnGo;

package/ds-dataviz/DSDataViz.ticks.visual.spec.js

@@ -62,8 +62,7 @@ if (!browser.capabilities['ice:options'].isPhone) {
     });
   });
 
-  // Skipped until PUI-16334 gets fixed
-  describe.skip('PUI-10321 - DSDataViz, Force ticks -Visual', () => {
+  describe('PUI-10321 - DSDataViz, Force ticks -Visual', () => {
     before('loading page', async () => {
       const errorOnGo = await DSDataVizCO.forceTicks.go();
       if (errorOnGo) throw errorOnGo;

package/ds-dataviz/DSDataVizCO.js

@@ -25,6 +25,8 @@ export default class DSDatePickerCO extends PageObject {
 
   static timeLinearAxis = new Urlbuilder(PATH_E2E_DATAVIZ_AXIS, 'time-linear-axis-test');
 
+  static timeLinearAxisAxe = new Urlbuilder(PATH_E2E_DATAVIZ_AXIS, 'time-linear-axis-axe-test');
+
   // area
 
   static basicArea = new Urlbuilder(PATH_E2E_DATAVIZ_AREA, 'basic-area-test');

package/ds-dataviz/axecore/DSDataViz.axis.axe-core.func.spec.js

@@ -29,7 +29,7 @@ if (
 
   describe('PUI-11371 - DSDataViz, TimeLinear axis -AxeCore', () => {
     before('loading page', async () => {
-      const errorOnGo = await DSDataVizCO.timeLinearAxis.go();
+      const errorOnGo = await DSDataVizCO.timeLinearAxisAxe.go();
       if (errorOnGo) throw errorOnGo;
     });
     it('01: should display a chart with time-linear axis and pass axe-core scan', async () => {

package/ds-floating-context/DSFloatingContextCO.js

@@ -10,6 +10,8 @@ export default class DSFloatingContextCO extends PageObject {
 
   static slotsURL = new Urlbuilder(PATH_E2E_FLOATING_CONTEXT, 'slots-test');
 
+  static positionsTestURL = new Urlbuilder(PATH_E2E_FLOATING_CONTEXT, 'positions-test');
+
   static async getFloatingContextWrapper() {
     return $('[data-testid="ds-floating-wrapper-root"]');
   }
@@ -18,6 +20,14 @@ export default class DSFloatingContextCO extends PageObject {
     return $('[data-testid="ds-floatingwrapper-content"]');
   }
 
+  static async getFloatingContextContents() {
+    return $$('[data-testid="ds-floatingwrapper-content"]');
+  }
+
+  static async getHelpButtons() {
+    return $$('[aria-label="Help"]');
+  }
+
   static async getFloatingContextArrowSlot() {
     return $('[data-dimsum-slot="dsFloatingwrapperArrow"]');
   }