<!DOCTYPE html>
<meta charset="utf-8" />
<title>CSS Test (Selectors): Script focus after blur after mouse click on a NOT focusable element after editing an input does match :focus-visible</title>
<link rel="author" title="Manuel Rego Casasnovas" href="mailto:rego@igalia.com">
<link rel="help" href="https://drafts.csswg.org/selectors-4/#the-focus-visible-pseudo" />
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/resources/testdriver.js"></script>
<script src="/resources/testdriver-vendor.js"></script>
<script src="/css/support/parsing-testcommon.js"></script>
<style>
  #warning {
    display: none;
    background: red;
  }

  @supports not selector(:focus-visible) {
    #instructions {
      display: none;
    }

    #warning {
      display: block;
    }
  }

  :focus-visible {
    outline: solid thick green;
  }

  :focus:not(:focus-visible) {
    background-color: red;
  }
</style>

<p>This test checks that a script focus after blur after a mouse click on a NOT focusable element after editing an input does match <code>:focus-visible</code>.</p>
<ol id="instructions">
  <li>Click on the input below and type some letter.</li>
  <li>Then click on the element that says "Click me".</li>
  <li>If the element that says "Focused" has a red background then the test result is FAILURE, if it has a green outline then the test result is SUCCESS.</li>
</ol>
<p id="warning">Your user-agent does not support <code>:focus-visible</code> pseudo-class, please SKIP this test.</p>

<input id="initial">
<div id="trigger">Click me</div>
<div id="target" tabindex="0">Focused</div>

<script>
  setup({ explicit_done: true });

  // Check that :focus-visible is supported.
  test_valid_selector(':focus-visible');

  trigger.addEventListener("click", () => {
    document.activeElement.blur();
    target.focus();
  });

  async_test(function(t) {
    initial.addEventListener("keypress", () => {
      test_driver.click(trigger).then(() => done());
    });

    target.addEventListener("focus", t.step_func_done(function() {
      assert_equals(getComputedStyle(target).outlineColor, "rgb(0, 128, 0)", `outlineColor for ${target.tagName}#${target.id} should be green`);
      assert_not_equals(getComputedStyle(target).backgroundColor, "rgb(255, 0, 0)", `backgroundColor for ${target.tagName}#${target.id} should NOT be red`);
    }));

    initial.focus();
    test_driver.send_keys(initial, "a");
  }, "Script focus after blur after mouse click on a NOT focusable element after editing an input does match :focus-visible");
</script>


