coalesced_events_attributes.https.html

Enable keyboard shortcuts

This test has a WPT meta file that expects 1 subtest issues.
This WPT test may be referenced by the following Test IDs:
- /pointerevents/coalesced_events_attributes.https.html?mouse - WPT Dashboard Interop Dashboard
- /pointerevents/coalesced_events_attributes.https.html?pen - WPT Dashboard Interop Dashboard
- /pointerevents/coalesced_events_attributes.https.html?touch - WPT Dashboard Interop Dashboard

<!doctype html>

<title>Coalesced events count and properties</title>

<meta name="variant" content="?mouse">

<meta name="variant" content="?pen">

<meta name="variant" content="?touch">

<meta name="viewport" content="width=device-width">

<script src="/resources/testharness.js"></script>

<script src="/resources/testharnessreport.js"></script>

<script src="/resources/testdriver.js"></script>

<script src="/resources/testdriver-actions.js"></script>

<script src="/resources/testdriver-vendor.js"></script>

<script src="pointerevent_support.js"></script>

<link rel="stylesheet" type="text/css" href="pointerevent_styles.css">

<style>

  div {

    width: 100px;

    height: 100px;

</style>

<div id="target"></div>

<div id="done"></div>

<script>

  "use strict";

  const pointer_type = location.search.substring(1);

  const target = document.getElementById("target");

  // https://w3c.github.io/pointerevents/#coalesced-events

  function checkListAttributes(event) {

    assert_equals(typeof event.getCoalescedEvents, "function",

        event.type + ".getCoalescedEvents is a function");

    assert_equals(typeof event.getCoalescedEvents(), "object",

        event.type + ".getCoalescedEvents() returns an object");

    let coalesced_events = event.getCoalescedEvents();

    if (event.type == "pointermove") {

      assert_greater_than_equal(coalesced_events.length, 1,

          event.type + ".getCoalescedEvents() has at least 1 entry");

      for (let i = 0; i < coalesced_events.length; i++) {

        let coalesced_event = coalesced_events[i];

        assert_equals(coalesced_event.isTrusted, true,

          "coalesced_event.isTrusted is true");

        assert_equals(coalesced_event.bubbles, false,

          "coalesced_event.bubbles is false");

        assert_equals(coalesced_event.cancelable, false,

          "coalesced_event.cancelable is false");

        assert_equals(coalesced_event.pointerId, event.pointerId,

          "coalesced_event.pointerId matches the same in the container event");

        assert_equals(coalesced_event.pointerType, event.pointerType,

          "coalesced_event.pointerType matches the same in the container event");

        assert_equals(coalesced_event.isPrimary, event.isPrimary,

          "coalesced_event.isPrimary matches the same in the container event");

        assert_equals(coalesced_event.target, event.target,

          "coalesced_event.target matches the same in the container event");

        assert_equals(coalesced_event.getCoalescedEvents().length, 0,

                      "Coalesced events shouldn't have coalesced events themselves.");

        if (i > 0) {

          assert_greater_than_equal(coalesced_event.timeStamp,

            coalesced_events[i - 1].timeStamp,

            "coalesced_event.timeStamp must be ascending");

    } else {

      assert_equals(coalesced_events.length, 0,

          event.type + ".getCoalescedEvents() has 0 entry");

  promise_test(async () => {

    const done = document.getElementById("done");

    let pointerover_promise  = getEvent("pointerover",  target);

    let pointerenter_promise = getEvent("pointerenter", target);

    let pointerout_promise   = getEvent("pointerout",   target);

    let pointerleave_promise = getEvent("pointerleave", target);

    await clickInTarget(pointer_type, target);

    await clickInTarget(pointer_type, done);

    checkListAttributes(await pointerover_promise);

    checkListAttributes(await pointerenter_promise);

    checkListAttributes(await pointerout_promise);

    checkListAttributes(await pointerleave_promise);

  }, "Coalesced list in boundary events");

  promise_test(async () => {

    // We need "touch-action:none" to guarantee pointermove events.

    target.classList.add("touchActionNone");

    target.addEventListener("pointerdown",

        e => target.setPointerCapture(e.pointerId),

        {once: true});

    target.addEventListener("pointermove",

        e => target.releasePointerCapture(e.pointerId),

        {once: true});

    let gotpointercapture_promise  = getEvent("gotpointercapture",  target);

    let lostpointercapture_promise = getEvent("lostpointercapture", target);

    await new test_driver.Actions()

        .addPointer("TestPointer", pointer_type)

        .pointerMove(0, 0, {origin: target})

        .pointerDown()

        .pointerMove(20, 20, {origin: target})

        .pointerUp()

        .send();

    checkListAttributes(await gotpointercapture_promise);

    checkListAttributes(await lostpointercapture_promise);

    target.classList.remove("touchActionNone");

  }, "Coalesced list in pointer-capture events");

  promise_test(async () => {

    // We need "touch-action:none" to guarantee pointermove events.

    target.classList.add("touchActionNone");

    let pointerdown_promise = getEvent("pointerdown", target);

    let pointermove_promise = getEvent("pointermove", target);

    let pointerup_promise   = getEvent("pointerup",   target);

    await new test_driver.Actions()

        .addPointer("TestPointer", pointer_type)

        .pointerMove(0, 0, {origin: target})

        .pointerDown()

        .pointerMove(20, 20, {origin: target})

        .pointerUp()

        .send();

    checkListAttributes(await pointerdown_promise);

    checkListAttributes(await pointermove_promise);

    checkListAttributes(await pointerup_promise);

    target.classList.remove("touchActionNone");

  }, "Coalesced list in pointerdown/move/up events");

  promise_test(async () => {

    if (pointer_type !== "touch") {

      assert_true(true, "Skipped for " + pointer_type);

      return;

    let pointercancel_promise  = getEvent("pointercancel", target);

    await new test_driver.Actions()

        .addPointer("TestPointer", pointer_type)

        .pointerMove(0, 0, {origin: target})

        .pointerDown()

        .pointerMove(20, 20, {origin: target})

        .pointerUp()

        .send();

    checkListAttributes(await pointercancel_promise);

  }, "Coalesced list in pointercancel event");

</script>