@esri/calcite-components 1.0.0-next.597 → 1.0.0-next.598

package/dist/collection/components/input-text/input-text.e2e.js

@@ -1,276 +0,0 @@
-import { newE2EPage } from "@stencil/core/testing";
-import { defaults, disabled, focusable, formAssociated, labelable, reflects, renders, hidden } from "../../tests/commonTests";
-import { html } from "../../../support/formatting";
-import { TEXT } from "./resources";
-describe("calcite-input-text", () => {
-    it("is labelable", async () => labelable("calcite-input-text"));
-    it("renders", () => renders("calcite-input-text", { display: "block" }));
-    it("honors hidden attribute", async () => hidden("calcite-input-text"));
-    it("reflects", async () => reflects("calcite-input-text", [
-        {
-            propertyName: "status",
-            value: "valid"
-        },
-        {
-            propertyName: "alignment",
-            value: "center"
-        },
-        {
-            propertyName: "scale",
-            value: "s"
-        }
-    ]));
-    it("has defaults", async () => defaults("calcite-input-text", [
-        {
-            propertyName: "status",
-            defaultValue: "idle"
-        },
-        {
-            propertyName: "alignment",
-            defaultValue: "start"
-        },
-        {
-            propertyName: "scale",
-            defaultValue: "m"
-        },
-        {
-            propertyName: "value",
-            defaultValue: ""
-        }
-    ]));
-    it("can be disabled", () => disabled("calcite-input-text"));
-    it("inherits requested props when from wrapping calcite-label when props are provided", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `
-      <calcite-label status="invalid" scale="s">
-        Label text
-        <calcite-input-text></calcite-input-text>
-      </calcite-label>
-    `);
-        const deprecatedLabelStatusElement = await page.find("calcite-input-text");
-        expect(await deprecatedLabelStatusElement.getProperty("status")).toEqual("invalid");
-        expect(await deprecatedLabelStatusElement.getProperty("scale")).toEqual("s");
-    });
-    it("renders an icon when explicit Calcite UI is requested, and is a type without a default icon", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text icon="key"></calcite-input-text>`);
-        const icon = await page.find("calcite-input-text >>> .icon");
-        expect(icon).not.toBeNull();
-    });
-    it("does not render an icon when requested without an explicit Calcite UI, and is a type without a default icon", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text icon></calcite-input-text>`);
-        const icon = await page.find("calcite-input-text >>> .icon");
-        expect(icon).toBeNull();
-    });
-    it("is focusable", async () => focusable(`calcite-input-text`, {
-        shadowFocusTargetSelector: "input"
-    }));
-    it("does not fire any input or change events when a focused input is blurred after its value is set directly", async () => {
-        const page = await newE2EPage({ html: "<calcite-input-text></calcite-input-text>" });
-        const input = await page.find("calcite-input-text");
-        const inputEventSpy = await input.spyOnEvent("calciteInputTextInput");
-        const changeEventSpy = await input.spyOnEvent("calciteInputTextChange");
-        expect(inputEventSpy).not.toHaveReceivedEvent();
-        expect(changeEventSpy).not.toHaveReceivedEvent();
-        await input.callMethod("setFocus");
-        await input.setProperty("value", "not a random value");
-        await page.keyboard.press("Tab");
-        await page.waitForChanges();
-        expect(inputEventSpy).not.toHaveReceivedEvent();
-        expect(changeEventSpy).not.toHaveReceivedEvent();
-    });
-    it.skip("emits events when value is modified", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text></calcite-input-text>`);
-        const element = await page.find("calcite-input-text");
-        const calciteInputTextInput = await element.spyOnEvent("calciteInputTextInput");
-        const calciteInputTextChange = await element.spyOnEvent("calciteInputTextChange");
-        const inputFirstPart = "12345";
-        await element.callMethod("setFocus");
-        await page.keyboard.type(inputFirstPart);
-        expect(await element.getProperty("value")).toBe(inputFirstPart);
-        expect(calciteInputTextInput).toHaveReceivedEventTimes(5);
-        expect(calciteInputTextChange).toHaveReceivedEventTimes(0);
-        await element.callMethod("setFocus");
-        await page.keyboard.press("Enter");
-        expect(calciteInputTextInput).toHaveReceivedEventTimes(5);
-        expect(calciteInputTextChange).toHaveReceivedEventTimes(1);
-        await element.callMethod("setFocus");
-        await page.keyboard.press("Enter");
-        expect(calciteInputTextInput).toHaveReceivedEventTimes(5);
-        expect(calciteInputTextChange).toHaveReceivedEventTimes(1);
-        const textSecondPart = "67890";
-        await element.callMethod("setFocus");
-        await page.keyboard.type(textSecondPart);
-        expect(calciteInputTextInput).toHaveReceivedEventTimes(10);
-        expect(calciteInputTextChange).toHaveReceivedEventTimes(1);
-        await element.callMethod("setFocus");
-        await page.keyboard.press("Tab");
-        expect(calciteInputTextInput).toHaveReceivedEventTimes(10);
-        expect(calciteInputTextChange).toHaveReceivedEventTimes(2);
-        expect(await element.getProperty("value")).toBe(`${inputFirstPart}${textSecondPart}`);
-        await element.callMethod("setFocus");
-        await page.keyboard.press("Tab");
-        expect(calciteInputTextInput).toHaveReceivedEventTimes(10);
-        expect(calciteInputTextChange).toHaveReceivedEventTimes(2);
-        expect(await element.getProperty("value")).toBe(`${inputFirstPart}${textSecondPart}`);
-        const programmaticSetValue = "1337";
-        element.setProperty("value", programmaticSetValue);
-        await page.waitForChanges();
-        expect(await element.getProperty("value")).toBe(programmaticSetValue);
-        expect(calciteInputTextInput).toHaveReceivedEventTimes(10);
-        expect(calciteInputTextChange).toHaveReceivedEventTimes(2);
-    });
-    it("renders clear button when clearable is requested and value is populated at load", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text clearable value="John Doe"></calcite-input-text>`);
-        const clearButton = await page.find("calcite-input-text >>> .clear-button");
-        expect(clearButton).not.toBe(null);
-        expect(clearButton.getAttribute("aria-label")).toBe(TEXT.clear);
-    });
-    it("does not render clear button when clearable is requested and value is not populated", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text clearable></calcite-input-text>`);
-        const clearButton = await page.find("calcite-input-text >>> .clear-button");
-        expect(clearButton).toBe(null);
-    });
-    it("does not render clear button when clearable is not requested", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text></calcite-input-text>`);
-        const clearButton = await page.find("calcite-input-text >>> .clear-button");
-        expect(clearButton).toBe(null);
-    });
-    it("when clearable is requested, value is cleared on escape key press", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text clearable value="John Doe"></calcite-input-text>`);
-        const element = await page.find("calcite-input-text");
-        await element.callMethod("setFocus");
-        await page.keyboard.press("Escape");
-        await page.waitForChanges();
-        expect(await element.getProperty("value")).toBe("");
-    });
-    it("when clearable is requested, value is cleared on clear button click", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text clearable value="John Doe"></calcite-input-text>`);
-        const element = await page.find("calcite-input-text");
-        const clearButton = await page.find("calcite-input-text >>> .clear-button");
-        await clearButton.click();
-        await page.waitForChanges();
-        expect(await element.getProperty("value")).toBe("");
-    });
-    it("when clearable is requested and clear button is clicked, event is received", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text clearable value="John Doe"></calcite-input-text>`);
-        const calciteInputTextInput = await page.spyOnEvent("calciteInputTextInput");
-        const element = await page.find("calcite-input-text");
-        const clearButton = await page.find("calcite-input-text >>> .clear-button");
-        await clearButton.click();
-        await page.waitForChanges();
-        expect(await element.getProperty("value")).toBe("");
-        expect(calciteInputTextInput).toHaveReceivedEventTimes(1);
-    });
-    it("when clearable is requested and input is cleared via escape key, event is received", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text clearable value="John Doe"></calcite-input-text>`);
-        const calciteInputTextInput = await page.spyOnEvent("calciteInputTextInput");
-        const element = await page.find("calcite-input-text");
-        await element.callMethod("setFocus");
-        expect(calciteInputTextInput).toHaveReceivedEventTimes(0);
-        await page.keyboard.press("Escape");
-        await page.waitForChanges();
-        expect(await element.getProperty("value")).toBe("");
-        expect(calciteInputTextInput).toHaveReceivedEventTimes(1);
-    });
-    it("when clearable is not requested and input is cleared via escape key, event is not received", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text value="John Doe"></calcite-input-text>`);
-        const calciteInputTextInput = await page.spyOnEvent("calciteInputTextInput");
-        const element = await page.find("calcite-input-text");
-        await element.callMethod("setFocus");
-        expect(calciteInputTextInput).not.toHaveReceivedEvent();
-        await page.keyboard.press("Escape");
-        await page.waitForChanges();
-        expect(await element.getProperty("value")).toBe("John Doe");
-        expect(calciteInputTextInput).not.toHaveReceivedEvent();
-    });
-    it("allows restricting input length", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text min-length="2" max-length="3" value=""></calcite-input-text>`);
-        const getInputValidity = async () => page.$eval("calcite-input-text", (element) => {
-            const input = element.shadowRoot.querySelector("input");
-            return input.validity.valid;
-        });
-        const input = await page.find("calcite-input-text");
-        await input.callMethod("setFocus");
-        await page.keyboard.type("1");
-        expect(await getInputValidity()).toBe(false);
-        await page.keyboard.type("2");
-        expect(await getInputValidity()).toBe(true);
-        await page.keyboard.type("3");
-        expect(await getInputValidity()).toBe(true);
-        await page.keyboard.type("4");
-        expect(await getInputValidity()).toBe(true);
-        expect(await input.getProperty("value")).toBe("123");
-    });
-    it(`allows clearing value`, async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text value="hello"></calcite-input-text>`);
-        const input = await page.find("calcite-input-text");
-        input.setProperty("value", null);
-        await page.waitForChanges();
-        expect(await input.getProperty("value")).toBe("");
-        input.setProperty("value", undefined);
-        await page.waitForChanges();
-        expect(await input.getProperty("value")).toBe("");
-    });
-    it("cannot be modified when readOnly is true", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text read-only value="John Doe" clearable></calcite-input-text>`);
-        const calciteInputTextInput = await page.spyOnEvent("calciteInputTextInput");
-        const element = await page.find("calcite-input-text");
-        expect(await element.getProperty("value")).toBe("John Doe");
-        await element.callMethod("setFocus");
-        await page.keyboard.press("a");
-        await page.waitForChanges();
-        expect(await element.getProperty("value")).toBe("John Doe");
-        await page.keyboard.press("Escape");
-        await page.waitForChanges();
-        expect(await element.getProperty("value")).toBe("John Doe");
-        expect(calciteInputTextInput).toHaveReceivedEventTimes(0);
-    });
-    it("sets internals to readOnly or disabled when readOnly is true", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-text read-only></calcite-input-text>`);
-        const inputs = await page.findAll("calcite-input-text >>> input");
-        for (const input of inputs) {
-            expect(await input.getProperty("readOnly")).toBe(true);
-        }
-        const buttons = await page.findAll("calcite-input-text button");
-        for (const button of buttons) {
-            expect(await button.getProperty("disabled")).toBe(true);
-        }
-    });
-    it("ArrowUp/ArrowDown function of moving caret to the beginning/end of text", async () => {
-        const determineCaretIndex = (position) => {
-            return page.evaluate((position) => {
-                const element = document.querySelector("calcite-input-text");
-                const el = element.shadowRoot.querySelector("input");
-                return el.selectionStart === (position !== undefined ? position : el.value.length);
-            }, position);
-        };
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-input-text></calcite-input-text>`);
-        const element = await page.find("calcite-input-text");
-        await element.callMethod("setFocus");
-        await page.keyboard.type("test");
-        await page.waitForChanges();
-        await page.keyboard.press("ArrowUp");
-        await page.waitForChanges();
-        expect(await determineCaretIndex(0)).toBeTruthy();
-        await page.keyboard.press("ArrowDown");
-        await page.waitForChanges();
-        expect(await determineCaretIndex()).toBeTruthy();
-    });
-    it("is form-associated", () => formAssociated("calcite-input-text", { testValue: "test", submitsOnEnter: true }));
-});

package/dist/collection/components/input-time-picker/input-time-picker.e2e.js

@@ -1,241 +0,0 @@
-import { newE2EPage } from "@stencil/core/testing";
-import { localizeTimeString } from "../../utils/time";
-import { accessible, defaults, disabled, focusable, formAssociated, labelable, reflects, renders, hidden } from "../../tests/commonTests";
-import { html } from "../../../support/formatting";
-describe("calcite-input-time-picker", () => {
-    it("renders", async () => renders("calcite-input-time-picker", { display: "inline-block" }));
-    it("honors hidden attribute", async () => hidden("calcite-input-time-picker"));
-    it("is accessible", async () => accessible(`
-    <calcite-label>
-      Input Time Picker
-      <calcite-input-time-picker name="test"></calcite-input-time-picker>
-    </calcite-label>
-  `));
-    it("has defaults", async () => defaults("calcite-input-time-picker", [
-        { propertyName: "scale", defaultValue: "m" },
-        { propertyName: "step", defaultValue: 60 },
-        { propertyName: "overlayPositioning", defaultValue: "absolute" }
-    ]));
-    it("reflects", async () => reflects(`calcite-input-time-picker`, [
-        { propertyName: "active", value: true },
-        { propertyName: "open", value: true },
-        { propertyName: "disabled", value: true },
-        { propertyName: "scale", value: "m" }
-    ]));
-    it("is labelable", async () => labelable("calcite-input-time-picker"));
-    it("should focus the input when setFocus is called", async () => focusable(`calcite-input-time-picker`, {
-        shadowFocusTargetSelector: "calcite-input"
-    }));
-    it("can be disabled", () => disabled("calcite-input-time-picker"));
-    it("when set to readOnly, element still focusable but won't display the controls or allow for changing the value", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-input-time-picker read-only triggerDisabled={true} id="canReadOnly"></calcite-input-time-picker>`);
-        const component = await page.find("#canReadOnly");
-        const input = await page.find("#canReadOnly >>> calcite-input");
-        const popover = await page.find("#canReadOnly >>> calcite-popover");
-        expect(await input.getProperty("value")).toBe("");
-        await component.callMethod("setFocus");
-        await page.waitForChanges();
-        expect(await page.evaluate(() => document.activeElement.id)).toBe("canReadOnly");
-        expect(await popover.getProperty("open")).toBe(false);
-        await component.click();
-        await page.waitForChanges();
-        expect(await popover.getProperty("open")).toBe(false);
-        await component.type("atención atención");
-        await page.waitForChanges();
-        expect(await input.getProperty("value")).toBe("");
-    });
-    it("opens the time picker on input keyboard focus", async () => {
-        const page = await newE2EPage({
-            html: `<calcite-input-time-picker></calcite-input-time-picker>`
-        });
-        const popover = await page.find("calcite-input-time-picker >>> calcite-popover");
-        await page.keyboard.press("Tab");
-        await page.waitForChanges();
-        expect(await popover.getProperty("open")).toBe(true);
-    });
-    it("opens the time picker on input click", async () => {
-        const page = await newE2EPage({
-            html: `<calcite-input-time-picker></calcite-input-time-picker>`
-        });
-        const input = await page.find("calcite-input-time-picker >>> calcite-input");
-        const popover = await page.find("calcite-input-time-picker >>> calcite-popover");
-        await input.click();
-        await page.waitForChanges();
-        expect(await popover.getProperty("open")).toBe(true);
-    });
-    it("programmatically changing the value reflects in the input for fr lang (24-hour)", async () => {
-        const lang = "fr";
-        const page = await newE2EPage({
-            html: `<calcite-input-time-picker lang="${lang}"" step="1"></calcite-input-time-picker>`
-        });
-        const inputTimePicker = await page.find("calcite-input-time-picker");
-        const input = await page.find("calcite-input-time-picker >>> calcite-input");
-        for (let second = 0; second < 10; second++) {
-            const date = new Date(0);
-            date.setSeconds(second);
-            const expectedValue = date.toISOString().substr(11, 8);
-            const expectedInputValue = localizeTimeString(expectedValue, lang);
-            inputTimePicker.setProperty("value", expectedValue);
-            await page.waitForChanges();
-            const inputValue = await input.getProperty("value");
-            const inputTimePickerValue = await inputTimePicker.getProperty("value");
-            expect(inputValue).toBe(expectedInputValue);
-            expect(inputTimePickerValue).toBe(expectedValue);
-        }
-        for (let minute = 0; minute < 10; minute++) {
-            const date = new Date(0);
-            date.setMinutes(minute);
-            const expectedValue = date.toISOString().substr(11, 8);
-            const expectedInputValue = localizeTimeString(expectedValue, lang);
-            inputTimePicker.setProperty("value", expectedValue);
-            await page.waitForChanges();
-            const inputValue = await input.getProperty("value");
-            const inputTimePickerValue = await inputTimePicker.getProperty("value");
-            expect(inputValue).toBe(expectedInputValue);
-            expect(inputTimePickerValue).toBe(expectedValue);
-        }
-        for (let hour = 0; hour < 10; hour++) {
-            const date = new Date(0);
-            date.setHours(hour);
-            const expectedValue = date.toISOString().substr(11, 8);
-            const expectedInputValue = localizeTimeString(expectedValue, lang);
-            inputTimePicker.setProperty("value", expectedValue);
-            await page.waitForChanges();
-            const inputValue = await input.getProperty("value");
-            const inputTimePickerValue = await inputTimePicker.getProperty("value");
-            expect(inputValue).toBe(expectedInputValue);
-            expect(inputTimePickerValue).toBe(expectedValue);
-        }
-    });
-    it("value displays correctly in the input when it is programmatically changed for a 12-hour language", async () => {
-        const lang = "en";
-        const page = await newE2EPage({
-            html: `<calcite-input-time-picker step="1"></calcite-input-time-picker>`
-        });
-        const inputTimePicker = await page.find("calcite-input-time-picker");
-        const input = await page.find("calcite-input-time-picker >>> calcite-input");
-        const date = new Date(0);
-        date.setHours(13);
-        date.setMinutes(59);
-        date.setSeconds(59);
-        const expectedValue = date.toISOString().substr(11, 8);
-        const expectedDisplayValue = localizeTimeString(expectedValue, lang);
-        inputTimePicker.setProperty("value", expectedValue);
-        await page.waitForChanges();
-        const inputValue = await input.getProperty("value");
-        const inputTimePickerValue = await inputTimePicker.getProperty("value");
-        expect(inputValue).toBe(expectedDisplayValue);
-        expect(inputTimePickerValue).toBe(expectedValue);
-    });
-    it("value displays correctly in the input when it is programmatically changed for a 12-hour language when a default value is present", async () => {
-        const lang = "en";
-        const page = await newE2EPage({
-            html: `<calcite-input-time-picker step="1" value="11:00:00"></calcite-input-time-picker>`
-        });
-        const inputTimePicker = await page.find("calcite-input-time-picker");
-        const input = await page.find("calcite-input-time-picker >>> calcite-input");
-        expect(await input.getProperty("value")).toBe("11:00:00 AM");
-        expect(await inputTimePicker.getProperty("value")).toBe("11:00:00");
-        const date = new Date(0);
-        date.setHours(13);
-        date.setMinutes(59);
-        date.setSeconds(59);
-        const expectedValue = date.toISOString().substr(11, 8);
-        const expectedDisplayValue = localizeTimeString(expectedValue, lang);
-        inputTimePicker.setProperty("value", expectedValue);
-        await page.waitForChanges();
-        const inputValue = await input.getProperty("value");
-        const inputTimePickerValue = await inputTimePicker.getProperty("value");
-        expect(inputValue).toBe(expectedDisplayValue);
-        expect(inputTimePickerValue).toBe(expectedValue);
-    });
-    it("value displays correctly in the input when it is programmatically changed for a 24-hour language when a default value is present", async () => {
-        const lang = "fr";
-        const page = await newE2EPage({
-            html: `<calcite-input-time-picker step="1" value="11:00:00" lang="${lang}"></calcite-input-time-picker>`
-        });
-        const inputTimePicker = await page.find("calcite-input-time-picker");
-        const input = await page.find("calcite-input-time-picker >>> calcite-input");
-        expect(await input.getProperty("value")).toBe("11:00:00");
-        expect(await inputTimePicker.getProperty("value")).toBe("11:00:00");
-        const date = new Date(0);
-        date.setHours(13);
-        date.setMinutes(59);
-        date.setSeconds(59);
-        const expectedValue = "13:59:59";
-        const expectedDisplayValue = localizeTimeString(expectedValue, lang);
-        inputTimePicker.setProperty("value", expectedValue);
-        await page.waitForChanges();
-        const inputValue = await input.getProperty("value");
-        const inputTimePickerValue = await inputTimePicker.getProperty("value");
-        expect(inputValue).toBe(expectedDisplayValue);
-        expect(inputTimePickerValue).toBe(expectedValue);
-    });
-    it("appropriately triggers calciteInputTimePickerChange event when the user types a value", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-input-time-picker step="1"></calcite-input-time-picker>`);
-        const inputTimePicker = await page.find("calcite-input-time-picker");
-        const changeEvent = await inputTimePicker.spyOnEvent("calciteInputTimePickerChange");
-        expect(changeEvent).toHaveReceivedEventTimes(0);
-        await page.keyboard.press("Tab");
-        await page.keyboard.press("1");
-        await page.keyboard.press(":");
-        await page.keyboard.press("2");
-        await page.waitForChanges();
-        expect(changeEvent).toHaveReceivedEventTimes(1);
-        await page.keyboard.press(":");
-        await page.keyboard.press("3");
-        await page.waitForChanges();
-        expect(changeEvent).toHaveReceivedEventTimes(2);
-    });
-    it("formats valid typed time value appropriately on blur", async () => {
-        const page = await newE2EPage();
-        await page.setContent(`<calcite-input-time-picker step="1"></calcite-input-time-picker><input>`);
-        const inputTimePicker = await page.find("calcite-input-time-picker");
-        await page.keyboard.press("Tab");
-        await page.keyboard.type("2:3:4");
-        await page.keyboard.press("Tab");
-        await page.waitForChanges();
-        expect(await inputTimePicker.getProperty("value")).toBe("02:03:04");
-    });
-    it("resets to previous value when default event behavior is prevented", async () => {
-        const page = await newE2EPage({
-            html: `<calcite-input-time-picker value="14:59"></calcite-input-time-picker>`
-        });
-        const inputTimePicker = await page.find("calcite-input-time-picker");
-        await page.evaluate(() => {
-            const inputTimePicker = document.querySelector("calcite-input-time-picker");
-            inputTimePicker.addEventListener("calciteInputTimePickerChange", (event) => {
-                event.preventDefault();
-            });
-        });
-        expect(await inputTimePicker.getProperty("value")).toBe("14:59");
-        await page.keyboard.press("Tab");
-        await page.keyboard.press(":");
-        await page.keyboard.press("5");
-        await page.waitForChanges();
-        expect(await inputTimePicker.getProperty("value")).toBe("14:59");
-    });
-    it("sets initial value to undefined when it is not a valid time value", async () => {
-        const page = await newE2EPage({
-            html: `<calcite-input-time-picker value="invalid"></calcite-input-time-picker>`
-        });
-        const inputTimePicker = await page.find("calcite-input-time-picker");
-        expect(await inputTimePicker.getProperty("value")).toBeUndefined();
-    });
-    it("is form-associated", () => formAssociated("calcite-input-time-picker", { testValue: "03:23", submitsOnEnter: true }));
-    it("should set active prop to same value as open and vice-versa", async () => {
-        const page = await newE2EPage();
-        await page.setContent(html `<calcite-input-time-picker value="14:59"></calcite-input-time-picker>`);
-        const inputTimePicker = await page.find("calcite-input-time-picker");
-        expect(await inputTimePicker.getProperty("active")).toBe(false);
-        expect(await inputTimePicker.getProperty("open")).toBe(false);
-        inputTimePicker.setProperty("open", true);
-        await page.waitForChanges();
-        expect(await inputTimePicker.getProperty("active")).toBe(true);
-        inputTimePicker.setProperty("active", false);
-        await page.waitForChanges();
-        expect(await inputTimePicker.getProperty("open")).toBe(false);
-    });
-});