<!DOCTYPE html>
<html>
  <head>
    <title>CSS Shadow Parts - Invalidation Change Part Name IDL Setter</title>
    <meta href="mailto:fergal@chromium.org" rel="author" title="Fergal Daly">
    <link href="http://www.google.com/" rel="author" title="Google">
    <link href="https://drafts.csswg.org/css-shadow-parts/" rel="help">
    <script src="/resources/testharness.js"></script>
    <script src="/resources/testharnessreport.js"></script>
    <script src="support/shadow-helper.js"></script>
  </head>
  <body>
    <style>#c-e::part(partp) { color: red; }</style>
    <style>#c-e::part(new-partp) { color: green; }</style>
    <script>installCustomElement("custom-element", "custom-element-template");</script>
    <template id="custom-element-template">
      <style>span { color: blue; }</style>
      <span id="part" part="partp">This text</span>
    </template>
    The following text should be green:
    <div><custom-element id="c-e"></custom-element></div>
    <script>
      "use strict";
      const colorGreen = "rgb(0, 128, 0)";
      test(function() {
        const el = getElementByShadowIds(document, ["c-e", "part"]);
        el.part = "new-partp"
        assert_equals(window.getComputedStyle(el).color, colorGreen);
      }, "Part in selected host changed color via part IDL attribute setter.");
    </script>
  </body>
</html>
