@gjsify/adwaita-web 0.64.1 → 0.64.2-next.254

package/src/gtk-stack.spec.ts

@@ -7,6 +7,8 @@
 import { describe, expect, it } from '@gjsify/unit';
 
 import type { GtkStack } from './elements/gtk-stack.js';
+import { pageChildOf } from './elements/gtk-stack-page.js';
+import { mountSharedTree } from './shared-tree-builder.js';
 
 interface Page {
     name: string;
@@ -144,6 +146,66 @@ export const GtkStackTest = async () => {
             host.remove();
         });
 
+        await it('a descendant toggling hidden keeps the selection', async () => {
+            // gtkstack.c:1617-1633 listens to the PAGE's own visibility, never to what is
+            // nested inside it (an `adw-view-stack` showing and hiding its own pages).
+            const { el, host } = mount([
+                { name: 'single', title: 'Single' },
+                { name: 'three', title: 'Three' },
+            ]);
+            const nested = document.createElement('span');
+            el.children[0]!.appendChild(nested);
+            el.setVisibleChildName('three');
+            nested.setAttribute('hidden', '');
+            await settle();
+            nested.removeAttribute('hidden');
+            await settle();
+            expect(el.visibleChildName).toBe('three');
+            expect(marks(el)).toStrictEqual(['single', 'three:visible']);
+            host.remove();
+        });
+
+        await it('hiding a page that is not visible keeps the selection', async () => {
+            const { el, host } = mount([
+                { name: 'a', title: 'Alpha' },
+                { name: 'b', title: 'Beta' },
+                { name: 'c', title: 'Gamma' },
+            ]);
+            el.setVisibleChildName('c');
+            (el.children[1] as HTMLElement).setAttribute('hidden', '');
+            await settle();
+            expect(el.visibleChildName).toBe('c');
+            host.remove();
+        });
+
+        await it('hiding the visible page after a selection falls back to the first visible', async () => {
+            const { el, host } = mount([
+                { name: 'a', title: 'Alpha' },
+                { name: 'b', title: 'Beta' },
+                { name: 'c', title: 'Gamma' },
+            ]);
+            el.setVisibleChildName('c');
+            (el.children[0] as HTMLElement).setAttribute('hidden', '');
+            (el.children[2] as HTMLElement).setAttribute('hidden', '');
+            await settle();
+            expect(el.visibleChildName).toBe('b');
+            host.remove();
+        });
+
+        await it('a descendant name change dispatches no page-updated', async () => {
+            const { el, host } = mount([{ name: 'a', title: 'Alpha' }]);
+            const nested = document.createElement('span');
+            el.children[0]!.appendChild(nested);
+            await settle();
+            const events: string[] = [];
+            el.addEventListener('page-updated', () => events.push('updated'));
+            nested.setAttribute('name', 'inner');
+            await settle();
+            expect(events).toStrictEqual([]);
+            expect(el.visibleChildName).toBe('a');
+            host.remove();
+        });
+
         await it('re-selecting the visible page is not a change', () => {
             // gtkstack.c:1452-1453 — no notify, no transition.
             const { el, host } = mount([
@@ -429,4 +491,112 @@ export const GtkStackTest = async () => {
             host.remove();
         });
     });
+
+    await describe('<gtk-stack> adopts a <gtk-stack-page> record', async () => {
+        const record = (attrs: Record<string, string>, body = 'page'): HTMLElement => {
+            const page = document.createElement('gtk-stack-page');
+            for (const [name, value] of Object.entries(attrs)) page.setAttribute(name, value);
+            const child = document.createElement('div');
+            child.setAttribute('slot', 'child');
+            child.textContent = body;
+            page.appendChild(child);
+            return page;
+        };
+
+        await it('puts the child where the record was, with its properties as attributes', () => {
+            const host = document.createElement('div');
+            document.body.appendChild(host);
+            const el = document.createElement('gtk-stack') as GtkStack;
+            el.appendChild(
+                record({
+                    name: 'a',
+                    title: 'Alpha',
+                    'icon-name': 'go-home',
+                    'needs-attention': '',
+                    'use-underline': '',
+                }),
+            );
+            el.appendChild(record({ name: 'b' }, 'beta'));
+            host.appendChild(el);
+            expect(el.querySelector('gtk-stack-page')).toBe(null);
+            expect(marks(el)).toStrictEqual(['a:visible', 'b']);
+            const [page] = el.pages;
+            expect(page!.title).toBe('Alpha');
+            expect(page!.iconName).toBe('go-home');
+            expect(page!.needsAttention).toBe(true);
+            expect(page!.useUnderline).toBe(true);
+            expect(page!.child.hasAttribute('slot')).toBe(false);
+            expect(el.getChildByName('b')!.textContent).toBe('beta');
+            host.remove();
+        });
+
+        await it('reads a hidden record as GtkStackPage:visible = FALSE', () => {
+            const host = document.createElement('div');
+            document.body.appendChild(host);
+            const el = document.createElement('gtk-stack') as GtkStack;
+            const hidden = record({ name: 'a' });
+            (hidden as unknown as { visible: boolean }).visible = false;
+            el.appendChild(hidden);
+            el.appendChild(record({ name: 'b' }));
+            host.appendChild(el);
+            expect(el.pages.map((page) => page.visible)).toStrictEqual([false, true]);
+            expect(el.visibleChildName).toBe('b');
+            host.remove();
+        });
+
+        await it('adopts a record appended after connect, counted once', async () => {
+            const { el, host } = mount([{ name: 'a' }]);
+            const events: unknown[] = [];
+            el.addEventListener('items-changed', (e) => events.push((e as CustomEvent).detail));
+            el.appendChild(record({ name: 'b' }));
+            await settle();
+            await settle();
+            expect(marks(el)).toStrictEqual(['a:visible', 'b']);
+            expect(events).toStrictEqual([{ position: 1, removed: 0, added: 1 }]);
+            host.remove();
+        });
+
+        await it('takes a bare child as the page, and refuses a record with two', () => {
+            const bare = document.createElement('gtk-stack-page');
+            const child = document.createElement('div');
+            bare.appendChild(child);
+            expect(pageChildOf(bare)).toBe(child);
+            bare.appendChild(document.createElement('div'));
+            expect(() => pageChildOf(bare)).toThrow('has one `child`');
+            expect(pageChildOf(document.createElement('gtk-stack-page'))).toBe(null);
+        });
+
+        await it('builds `Stack { StackPage { name; child: … } }` from a shared tree', () => {
+            const { root, unmount } = mountSharedTree({
+                tag: 'GtkStack',
+                id: 'layoutHost',
+                children: [
+                    {
+                        tag: 'GtkStackPage',
+                        id: 'singlePage',
+                        props: { name: 'single' },
+                        children: [{ tag: 'AdwBin', slot: 'child', id: 'singleBin' }],
+                    },
+                    {
+                        tag: 'GtkStackPage',
+                        id: 'threePage',
+                        props: { name: 'three', title: 'Three' },
+                        children: [{ tag: 'AdwBin', slot: 'child', id: 'threeBin' }],
+                    },
+                ],
+            });
+            try {
+                const stack = root as GtkStack;
+                expect(stack.pages.map((page) => page.child.id)).toStrictEqual(['singleBin', 'threeBin']);
+                // The first page added is the visible one (gtkstack.c:1773-1775); a breakpoint
+                // setter selects another by the name its record carried.
+                expect(stack.visibleChild!.id).toBe('singleBin');
+                expect(stack.setVisibleChildName('three')).toBe(true);
+                expect(stack.visibleChild!.id).toBe('threeBin');
+                expect(stack.getPage(stack.visibleChild!)!.title).toBe('Three');
+            } finally {
+                unmount();
+            }
+        });
+    });
 };

package/src/gtk-value-doors.spec.ts

@@ -20,8 +20,15 @@
 import { describe, it, expect } from '@gjsify/unit';
 
 import { GtkAdjustment, GtkStringList } from '@gjsify/adwaita-core';
+import {
+    ROW_ACCESSOR_VECTORS,
+    driveRowAccessorVectors,
+    type ComboRowLike,
+    type SwitchRowLike,
+} from '@gjsify/adwaita-core/conformance';
 
 import type { AdwComboRow } from './elements/adw-combo-row.js';
+import type { AdwSwitchRow } from './elements/adw-switch-row.js';
 import type { AdwSpinRow } from './elements/adw-spin-row.js';
 import type { GtkDropDown } from './elements/gtk-drop-down.js';
 
@@ -101,4 +108,16 @@ export const GtkValueDoorsTest = async () => {
             expect(row.value).toBe(16);
         });
     });
+
+    await driveRowAccessorVectors(
+        {
+            name: 'adwaita-web',
+            isOracle: false,
+            makeComboRow: () => mount<AdwComboRow>('adw-combo-row') as unknown as ComboRowLike,
+            makeSwitchRow: () => mount<AdwSwitchRow>('adw-switch-row') as unknown as SwitchRowLike,
+            StringList: GtkStringList,
+        },
+        { describe, it, expect },
+        ROW_ACCESSOR_VECTORS,
+    );
 };

package/src/gtk-window.spec.ts

@@ -310,11 +310,11 @@ export const GtkWindowTest = async () => {
             const { el, host } = mount();
             let message = '';
             try {
-                el.connect('map', () => {});
+                el.connect('toggled', () => {});
             } catch (error) {
                 message = (error as Error).message;
             }
-            expect(message.includes("'map'")).toBe(true);
+            expect(message.includes("'toggled'")).toBe(true);
             host.remove();
         });
 

package/src/gtksource/gtk-source-view.ts

@@ -20,6 +20,7 @@ import type { Buffer, Gutter } from '@gjsify/gtksource-core';
 import { EditorSession, GutterSet, STOP_EMISSION, toBoolean, toNumber } from '@gjsify/gtksource-core';
 
 import { WebEditorDriver } from './web-editor-driver.js';
+import { WidgetElement } from '../widget-element.js';
 
 const STYLE_ID = 'gjsify-gtk-source-view-style';
 
@@ -130,7 +131,7 @@ const OBSERVED_ATTRIBUTES = [
     'bottom-margin',
 ];
 
-export class GtkSourceView extends HTMLElement {
+export class GtkSourceView extends WidgetElement {
     static get observedAttributes(): string[] {
         return OBSERVED_ATTRIBUTES;
     }

package/src/{icon-registry.spec.ts → icon-masks.spec.ts}

@@ -14,17 +14,12 @@
 // that was never given draws nothing at all.
 import { describe, expect, it } from '@gjsify/unit';
 
-import { isIconAvailable, registerIcon } from './icon-registry.js';
+import { isIconAvailable } from './icon-theme.js';
 import type { GtkImage } from './elements/gtk-image.js';
 
 /** A name no compiled entry can collide with, for the "not shipped" arm. */
 const ABSENT = 'gjsify-registry-probe';
 
-/** An Adwaita symbolic SVG, small and distinctive — a filled 8px square in the 16px grid. */
-const PROBE_SVG = `<svg height="16px" viewBox="0 0 16 16" width="16px" xmlns="http://www.w3.org/2000/svg">
-    <path d="m 4 4 h 8 v 8 h -8 z m 0 0" fill="currentColor"/>
-</svg>`;
-
 function mount(iconName: string | null): { el: GtkImage; host: HTMLElement } {
     const host = document.createElement('div');
     document.body.appendChild(host);
@@ -55,7 +50,7 @@ export function fallbackMask(): string {
     return getComputedStyle(document.documentElement).getPropertyValue('--icon-image-missing').trim();
 }
 
-export const AdwIconRegistryTest = async () => {
+export const AdwIconMasksTest = async () => {
     await describe('<gtk-image> resolves a name to a real mask', async () => {
         await it('a compiled name draws its OWN glyph, not the fallback', () => {
             const { el, host } = mount('go-next');
@@ -136,8 +131,8 @@ export const AdwIconRegistryTest = async () => {
         });
     });
 
-    await describe('registerIcon — the documented way out of the compiled set', async () => {
-        await it('reports an unshipped name as unavailable before registration', () => {
+    await describe('isIconAvailable', async () => {
+        await it('answers for the compiled set and nothing else', () => {
             expect(isIconAvailable(ABSENT)).toBe(false);
             // …and a compiled one as available, so the check is not answering `false` to
             // everything. `image-missing` is the case a fallback-comparison would get wrong.
@@ -145,96 +140,5 @@ export const AdwIconRegistryTest = async () => {
             expect(isIconAvailable('image-missing')).toBe(true);
             expect(isIconAvailable('')).toBe(false);
         });
-
-        await it('makes the name resolve, on an element that is ALREADY mounted', () => {
-            const { el, host } = mount(ABSENT);
-            const before = maskOf(el);
-            expect(before).toBe(fallbackMask());
-
-            registerIcon(ABSENT, PROBE_SVG);
-
-            const after = maskOf(el);
-            expect(after).not.toBe(before);
-            expect(after).not.toBe(fallbackMask());
-            // The glyph really is the SVG that was handed over: `toDataUri` percent-encodes
-            // it, so the path data survives as `m%204%204`.
-            expect(after.includes('m%204%204')).toBe(true);
-            expect(isIconAvailable(ABSENT)).toBe(true);
-            host.remove();
-        });
-
-        await it('serves an element mounted AFTER the registration too', () => {
-            const { el, host } = mount(`${ABSENT}-symbolic`);
-            // The `-symbolic` suffix is stripped on both sides, so a consumer may spell the
-            // name either way at either end.
-            expect(el.resolvedIconName).toBe(ABSENT);
-            expect(maskOf(el).includes('m%204%204')).toBe(true);
-            host.remove();
-        });
-
-        await it('re-registering REPLACES the glyph without a second rule', () => {
-            const sheet = (document.getElementById('adwaita-web-icon-registry') as HTMLStyleElement).sheet;
-            const rulesBefore = (sheet as CSSStyleSheet).cssRules.length;
-
-            registerIcon(ABSENT, PROBE_SVG.replace('m 4 4 h 8 v 8 h -8 z', 'm 2 2 h 12 v 12 h -12 z'));
-
-            const { el, host } = mount(ABSENT);
-            expect(maskOf(el).includes('m%202%202')).toBe(true);
-            expect((sheet as CSSStyleSheet).cssRules.length).toBe(rulesBefore);
-            host.remove();
-        });
-
-        await it('throws on a name that could never be one CSS class', () => {
-            // Silently registering nothing is the exact failure this area exists to end, and
-            // unlike a render this is an explicit call with a wrong argument.
-            expect(() => registerIcon('org.gnome.Builder', PROBE_SVG)).toThrow();
-            expect(() => registerIcon('a b', PROBE_SVG)).toThrow();
-            expect(() => registerIcon('', PROBE_SVG)).toThrow();
-        });
-
-        await it('throws on a payload that is not SVG source, and registers nothing', () => {
-            // The NAME was checked from the start; the payload was not, and a wrong payload
-            // is worse than no registration at all: `toDataUri` percent-encodes anything, so
-            // the mask comes out well-formed and masks NOTHING, the registered class beats
-            // `:where(.adw-icon)` and switches this PR's fallback off, and `isIconAvailable`
-            // answers `true`. Measured in Firefox before the guard: `'not an svg at all'`
-            // gave `url("data:image/svg+xml,not%20an%20svg%20at%20all")` on a box painted 0 %,
-            // where the unregistered control painted the 30 % image-missing glyph.
-            const REJECTED = 'gjsify-registry-payload-probe';
-            expect(() => registerIcon(REJECTED, 'not an svg at all')).toThrow();
-            expect(() => registerIcon(REJECTED, '')).toThrow();
-            // The likeliest wrong argument of all: what the custom property HOLDS, handed
-            // over instead of what it was made from.
-            expect(() => registerIcon(REJECTED, 'url("data:image/svg+xml,%3Csvg%3E%3C/svg%3E")')).toThrow();
-            expect(isIconAvailable(REJECTED)).toBe(false);
-
-            const { el, host } = mount(REJECTED);
-            expect(maskOf(el)).toBe(fallbackMask());
-            host.remove();
-        });
-
-        await it('rebuilds its rules after the <style> element is taken away', () => {
-            // What an SPA head swap or an Astro view transition does. The record of inserted
-            // rules is module-level and outlives the element it describes, so the early
-            // return above used to skip the insert forever: the custom property was re-set
-            // and the rule that consumes it never came back.
-            const LOST = 'gjsify-registry-sheet-probe';
-            registerIcon(LOST, PROBE_SVG);
-            document.getElementById('adwaita-web-icon-registry')?.remove();
-
-            registerIcon(LOST, PROBE_SVG);
-
-            expect(document.getElementById('adwaita-web-icon-registry')).not.toBe(null);
-            const { el, host } = mount(LOST);
-            expect(maskOf(el).includes('m%204%204')).toBe(true);
-            host.remove();
-
-            // …and the names registered BEFORE the swap are on the rebuilt sheet too. Their
-            // custom properties survived on the document element, so re-issuing only the
-            // one name being registered would leave every earlier icon on the fallback.
-            const { el: earlier, host: earlierHost } = mount(ABSENT);
-            expect(maskOf(earlier)).not.toBe(fallbackMask());
-            earlierHost.remove();
-        });
     });
 };

package/src/icon-theme.spec.ts

@@ -1,30 +1,38 @@
 // The colour half of the icon theme, measured through `getComputedStyle` like
-// `icon-registry.spec.ts` measures the symbolic half: a class on the node proves nothing
+// `icon-masks.spec.ts` measures the symbolic half: a class on the node proves nothing
 // about what it paints.
 //
 // The order under test is GLib's (`g_themed_icon_update_names`, which `GtkImage`'s lookup
 // goes through): `X` tries [X, X-symbolic], `X-symbolic` tries [X-symbolic, X], and a name
 // neither answers draws `image-missing`. Over the names the order is gtkicontheme.c's: the
-// current theme (the stylesheet's glyphs) before hicolor, where a colour registration sits.
-// The registry is module-level and outlives a test,
-// so every case registers names of its own.
+// current theme (the stylesheet's glyphs) before hicolor, where an app's resource files sit.
+// Colour icons come from the shared GResource fixture, on the theme's resource path as
+// `GtkApplication` adds `<resource-base-path>/icons/` (ADR 0116 § 4).
+import { ICON_FIXTURE_PATH, gioResourceFixtures } from '@gjsify/adwaita-core/conformance';
 import { describe, expect, it } from '@gjsify/unit';
 
 import { COLOR_ICON_CLASS, type GtkImage } from './elements/gtk-image.js';
-import { fallbackMask, maskOf } from './icon-registry.spec.js';
-import { isIconAvailable, registerIcon } from './icon-registry.js';
-import { registerColorIcon } from './icon-theme.js';
-
-/** A full-colour app icon: a red square on a blue disc, nothing `currentColor` about it. */
-const COLOR_SVG = `<svg height="128" viewBox="0 0 128 128" width="128" xmlns="http://www.w3.org/2000/svg">
-    <circle cx="64" cy="64" r="60" fill="#3584e4"/>
-    <rect x="40" y="40" width="48" height="48" fill="#e01b24"/>
-</svg>`;
-
-/** A symbolic glyph, distinct from the colour one by its path data. */
-const SYMBOLIC_SVG = `<svg height="16px" viewBox="0 0 16 16" width="16px" xmlns="http://www.w3.org/2000/svg">
-    <path d="m 3 3 h 10 v 10 h -10 z m 0 0" fill="currentColor"/>
-</svg>`;
+import { fallbackMask, maskOf } from './icon-masks.spec.js';
+import { isIconAvailable } from './icon-theme.js';
+import { Gio, Gtk } from './index.js';
+
+const theme = Gtk.IconTheme.get_for_display(null);
+
+/** Runs `body` with the fixture's icons on the theme's resource path. */
+async function withIcons(body: () => void): Promise<void> {
+    const resource = Gio.Resource.new_from_data(gioResourceFixtures().icons);
+    Gio.resources_register(resource);
+    const before = theme.get_resource_path();
+    theme.add_resource_path(ICON_FIXTURE_PATH);
+    // `changed` is deferred: let it drop the previous scan's URLs first.
+    await new Promise((resolve) => setTimeout(resolve, 0));
+    try {
+        body();
+    } finally {
+        theme.set_resource_path(before);
+        Gio.resources_unregister(resource);
+    }
+}
 
 function mount(iconName: string): { el: GtkImage; host: HTMLElement } {
     const host = document.createElement('div');
@@ -40,7 +48,7 @@ function maskClasses(el: HTMLElement): string[] {
     return [...el.classList].filter((c) => c.startsWith('adw-icon--'));
 }
 
-/** True when `el` paints the registered colour image and nothing masked. */
+/** True when `el` paints a resource image as-is and nothing masked. */
 function drawsInColor(el: HTMLElement): boolean {
     const style = getComputedStyle(el);
     return (
@@ -48,66 +56,41 @@ function drawsInColor(el: HTMLElement): boolean {
         maskClasses(el).length === 0 &&
         style.maskImage === 'none' &&
         style.backgroundColor === 'rgba(0, 0, 0, 0)' &&
-        // `#e01b24` survives `toDataUri` as `%23e01b24`.
-        style.backgroundImage.includes('%23e01b24')
+        style.backgroundImage.startsWith('url("blob:')
     );
 }
 
 export const AdwIconThemeTest = async () => {
-    await describe('registerColorIcon — a full-colour icon draws as-is', async () => {
-        await it('a reverse-DNS application id draws its image, unmasked and unfilled', () => {
-            const APP_ID = 'org.gjsify.ColorProbe';
-            registerColorIcon(APP_ID, COLOR_SVG);
-
-            const { el, host } = mount(APP_ID);
-            expect(drawsInColor(el)).toBe(true);
-            expect(isIconAvailable(APP_ID)).toBe(true);
-            host.remove();
-        });
-
-        await it('an already-mounted element redraws when the registration lands', () => {
-            const APP_ID = 'org.gjsify.LateColorProbe';
-            const { el, host } = mount(APP_ID);
-            // Before: what GTK draws for a name its theme does not have.
-            expect(maskOf(el)).toBe(fallbackMask());
-
-            registerColorIcon(APP_ID, COLOR_SVG);
-            expect(drawsInColor(el)).toBe(true);
-            host.remove();
-        });
-
-        await it("AdwAboutDialog's application-icon draws in colour", () => {
-            const APP_ID = 'org.gjsify.AboutColorProbe';
-            registerColorIcon(APP_ID, COLOR_SVG);
-
-            const host = document.createElement('div');
-            document.body.appendChild(host);
-            const dialog = document.createElement('adw-about-dialog');
-            dialog.setAttribute('application-icon', APP_ID);
-            host.appendChild(dialog);
-
-            const icon = dialog.querySelector('.adw-about-dialog-icon') as HTMLElement;
-            expect(drawsInColor(icon)).toBe(true);
-            // The 96px box, and NOT a solid square under the image: the about dialog used to
-            // force `background-color: currentColor` on it.
-            expect(getComputedStyle(icon).width).toBe('96px');
-            host.remove();
+    await describe('a full-colour resource icon draws as-is', async () => {
+        await it('draws its image, unmasked and unfilled', async () => {
+            await withIcons(() => {
+                const { el, host } = mount('flat');
+                expect(drawsInColor(el)).toBe(true);
+                expect(isIconAvailable('flat')).toBe(true);
+                host.remove();
+            });
         });
 
-        await it('a URL source resolves against the document', () => {
-            const APP_ID = 'org.gjsify.UrlColorProbe';
-            registerColorIcon(APP_ID, 'icons/org.gjsify.UrlColorProbe.svg');
-
-            const { el, host } = mount(APP_ID);
-            const expected = new URL('icons/org.gjsify.UrlColorProbe.svg', document.baseURI).href;
-            expect(el.classList.contains(COLOR_ICON_CLASS)).toBe(true);
-            expect(getComputedStyle(el).backgroundImage).toBe(`url("${expected}")`);
-            host.remove();
+        await it("AdwAboutDialog's application-icon draws in colour", async () => {
+            await withIcons(() => {
+                const host = document.createElement('div');
+                document.body.appendChild(host);
+                const dialog = document.createElement('adw-about-dialog');
+                dialog.setAttribute('application-icon', 'flat');
+                host.appendChild(dialog);
+
+                const icon = dialog.querySelector('.adw-about-dialog-icon') as HTMLElement;
+                expect(drawsInColor(icon)).toBe(true);
+                // The 96px box, and NOT a solid square under the image: the about dialog used to
+                // force `background-color: currentColor` on it.
+                expect(getComputedStyle(icon).width).toBe('96px');
+                host.remove();
+            });
         });
     });
 
     await describe('the lookup order is GThemedIcon’s', async () => {
-        await it('a symbolic icon still masks — a compiled one with no colour entry', () => {
+        await it('a symbolic icon still masks — a compiled one with no resource', () => {
             const { el, host } = mount('go-next-symbolic');
             expect(el.classList.contains(COLOR_ICON_CLASS)).toBe(false);
             expect(maskClasses(el)).toStrictEqual(['adw-icon--go-next']);
@@ -116,41 +99,28 @@ export const AdwIconThemeTest = async () => {
             host.remove();
         });
 
-        await it("the theme's X-symbolic answers X and X-symbolic before the colour X, as on GTK", () => {
-            const NAME = 'gjsify-theme-both-probe';
-            registerColorIcon(NAME, COLOR_SVG);
-            registerIcon(`${NAME}-symbolic`, SYMBOLIC_SVG);
-
-            // gtkicontheme.c `real_choose_icon`: theme outer, name inner, and the colour icon is
-            // hicolor's, so the current theme's `X-symbolic` comes first (ADR 0115 Amendment 2).
-            const plain = mount(NAME);
-            expect(plain.el.classList.contains(COLOR_ICON_CLASS)).toBe(false);
-            expect(maskOf(plain.el).includes('m%203%203')).toBe(true);
-            plain.host.remove();
-
-            const symbolic = mount(`${NAME}-symbolic`);
-            expect(symbolic.el.classList.contains(COLOR_ICON_CLASS)).toBe(false);
-            expect(maskOf(symbolic.el).includes('m%203%203')).toBe(true);
-            expect(getComputedStyle(symbolic.el).backgroundImage).toBe('none');
-            symbolic.host.remove();
+        await it("the theme's X-symbolic answers X before a resource's colour X, as on GTK", async () => {
+            // The fixture ships a colour `16x16/actions/go-next.png`; gtkicontheme.c
+            // `real_choose_icon` goes theme outer, name inner, and the file is hicolor's.
+            await withIcons(() => {
+                const { el, host } = mount('go-next');
+                expect(el.classList.contains(COLOR_ICON_CLASS)).toBe(false);
+                expect(maskClasses(el)).toStrictEqual(['adw-icon--go-next']);
+                host.remove();
+            });
         });
 
-        await it('X-symbolic falls back to the colour X, and back again once X-symbolic lands', () => {
-            const NAME = 'gjsify-theme-fallback-probe';
-            registerColorIcon(NAME, COLOR_SVG);
-
-            const { el, host } = mount(`${NAME}-symbolic`);
-            expect(drawsInColor(el)).toBe(true);
-            expect(isIconAvailable(`${NAME}-symbolic`)).toBe(true);
-
-            registerIcon(NAME, SYMBOLIC_SVG);
-            expect(el.classList.contains(COLOR_ICON_CLASS)).toBe(false);
-            expect(maskOf(el).includes('m%203%203')).toBe(true);
-            host.remove();
+        await it('X-symbolic falls back to the colour X', async () => {
+            await withIcons(() => {
+                const { el, host } = mount('flat-symbolic');
+                expect(drawsInColor(el)).toBe(true);
+                expect(isIconAvailable('flat-symbolic')).toBe(true);
+                host.remove();
+            });
         });
 
         await it('an unknown name draws image-missing', () => {
-            for (const unknown of ['org.gjsify.NeverRegistered', 'gjsify-theme-never-registered']) {
+            for (const unknown of ['org.gjsify.NeverShipped', 'gjsify-theme-never-shipped', 'flat']) {
                 const { el, host } = mount(unknown);
                 expect(el.classList.contains(COLOR_ICON_CLASS)).toBe(false);
                 expect(maskOf(el)).toBe(fallbackMask());
@@ -159,29 +129,4 @@ export const AdwIconThemeTest = async () => {
             }
         });
     });
-
-    await describe('registerColorIcon rejects what it cannot draw faithfully', async () => {
-        await it('throws on a name that is empty, spaced, or symbolic', () => {
-            expect(() => registerColorIcon('', COLOR_SVG)).toThrow();
-            expect(() => registerColorIcon('a b', COLOR_SVG)).toThrow();
-            // The symbolic half has its own door; GTK's theme treats all three suffixes as
-            // symbolic files.
-            expect(() => registerColorIcon('gjsify-probe-symbolic', COLOR_SVG)).toThrow();
-            expect(() => registerColorIcon('gjsify-probe-symbolic-ltr', COLOR_SVG)).toThrow();
-            expect(() => registerColorIcon('gjsify-probe-symbolic-rtl', COLOR_SVG)).toThrow();
-        });
-
-        await it('throws on a source that is not SVG or an image URL, and registers nothing', () => {
-            const REJECTED = 'org.gjsify.RejectedColorProbe';
-            expect(() => registerColorIcon(REJECTED, '')).toThrow();
-            expect(() => registerColorIcon(REJECTED, '<p>not svg</p>')).toThrow();
-            expect(() => registerColorIcon(REJECTED, 'javascript:alert(1)')).toThrow();
-            expect(() => registerColorIcon(REJECTED, 'data:text/html,<svg></svg>')).toThrow();
-            expect(isIconAvailable(REJECTED)).toBe(false);
-
-            const { el, host } = mount(REJECTED);
-            expect(maskOf(el)).toBe(fallbackMask());
-            host.remove();
-        });
-    });
 };