import { test, expect } from '@playwright/test';

test.describe('Functional - homepage', () => {
  test('homepage: title matches GT', async ({ page }) => {
    await page.goto('/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('glyphel');
  });
  test('homepage: h1 "Heads up"', async ({ page }) => {
    await page.goto('/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('homepage: h1 "Confirm"', async ({ page }) => {
    await page.goto('/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('homepage: h1 "Browse 4784+ free glyphs acros"', async ({ page }) => {
    await page.goto('/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Browse 4784+ free glyphs across 316 categories' || t.startsWith('Browse 4784+ free glyphs across 316 categories'))).toBeTruthy();
  });
  test('homepage: h2 "Latest glyphs See details"', async ({ page }) => {
    await page.goto('/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Latest glyphs See details' || t.startsWith('Latest glyphs See details'))).toBeTruthy();
  });
  test('homepage: nav link "80"', async ({ page }) => {
    await page.goto('/');
    const links = page.locator('nav a');
    const texts = (await links.allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === '80' || t.startsWith('80')), 'link text in nav').toBeTruthy();
    const hrefs = await links.evaluateAll(els => els.map(e => (e.getAttribute('href') || '').toLowerCase()));
    expect(hrefs.some(h => h.includes('80')), 'href fragment present').toBeTruthy();
  });
});

test.describe('Functional - 3d_lined_svg', () => {
  test('3d_lined_svg: h1 "Heads Up"', async ({ page }) => {
    await page.goto('/3d-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads Up' || t.startsWith('Heads Up'))).toBeTruthy();
  });
  test('3d_lined_svg: h1 "Hold On"', async ({ page }) => {
    await page.goto('/3d-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('3d_lined_svg: h2 "Copied!"', async ({ page }) => {
    await page.goto('/3d-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied!' || t.startsWith('Copied!'))).toBeTruthy();
  });
});

test.describe('Functional - 500px', () => {
  test('500px: title matches GT', async ({ page }) => {
    await page.goto('/500px/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('framea');
  });
  test('500px: h1 "Hold on"', async ({ page }) => {
    await page.goto('/500px/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('500px: h1 "Confirm"', async ({ page }) => {
    await page.goto('/500px/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('500px: h1 "Framea"', async ({ page }) => {
    await page.goto('/500px/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Framea' || t.startsWith('Framea'))).toBeTruthy();
  });
});

test.describe('Functional - about', () => {
  test('about: title matches GT', async ({ page }) => {
    await page.goto('/about/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('about glyphel glyphel');
  });
  test('about: h1 "Notice"', async ({ page }) => {
    await page.goto('/about/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('about: h1 "Confirm"', async ({ page }) => {
    await page.goto('/about/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('about: h1 "Features"', async ({ page }) => {
    await page.goto('/about/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Features' || t.startsWith('Features'))).toBeTruthy();
  });
});

test.describe('Functional - accessibility', () => {
  test('accessibility: title matches GT', async ({ page }) => {
    await page.goto('/accessibility/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('accessibility');
  });
  test('accessibility: h1 "Notice"', async ({ page }) => {
    await page.goto('/accessibility/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('accessibility: h1 "Confirm"', async ({ page }) => {
    await page.goto('/accessibility/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
});

test.describe('Functional - adhesive_bandage', () => {
  test('adhesive_bandage: title matches GT', async ({ page }) => {
    await page.goto('/adhesive-bandage/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('adhesive bandage');
  });
  test('adhesive_bandage: h1 "Heads up"', async ({ page }) => {
    await page.goto('/adhesive-bandage/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('adhesive_bandage: h1 "Confirm"', async ({ page }) => {
    await page.goto('/adhesive-bandage/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('adhesive_bandage: h1 "Adhesive Bandage"', async ({ page }) => {
    await page.goto('/adhesive-bandage/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Adhesive Bandage' || t.startsWith('Adhesive Bandage'))).toBeTruthy();
  });
});

test.describe('Functional - airport', () => {
  test('airport: title matches GT', async ({ page }) => {
    await page.goto('/airport/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('airport');
  });
  test('airport: h1 "Alert"', async ({ page }) => {
    await page.goto('/airport/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('airport: h1 "Verify"', async ({ page }) => {
    await page.goto('/airport/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('airport: h1 "Airport"', async ({ page }) => {
    await page.goto('/airport/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Airport' || t.startsWith('Airport'))).toBeTruthy();
  });
});

test.describe('Functional - amazon', () => {
  test('amazon: title matches GT', async ({ page }) => {
    await page.goto('/amazon/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('compass');
  });
  test('amazon: h1 "Heads up"', async ({ page }) => {
    await page.goto('/amazon/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('amazon: h1 "Confirm"', async ({ page }) => {
    await page.goto('/amazon/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('amazon: h1 "Compass"', async ({ page }) => {
    await page.goto('/amazon/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Compass' || t.startsWith('Compass'))).toBeTruthy();
  });
});

test.describe('Functional - american_football', () => {
  test('american_football: title matches GT', async ({ page }) => {
    await page.goto('/american-football/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('american football');
  });
  test('american_football: h1 "Notice"', async ({ page }) => {
    await page.goto('/american-football/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('american_football: h1 "Confirm"', async ({ page }) => {
    await page.goto('/american-football/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('american_football: h1 "American Football"', async ({ page }) => {
    await page.goto('/american-football/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'American Football' || t.startsWith('American Football'))).toBeTruthy();
  });
});

test.describe('Functional - anchor', () => {
  test('anchor: title matches GT', async ({ page }) => {
    await page.goto('/anchor/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('anchor icon');
  });
  test('anchor: h1 "Prompt"', async ({ page }) => {
    await page.goto('/anchor/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Prompt' || t.startsWith('Prompt'))).toBeTruthy();
  });
  test('anchor: h1 "Warning"', async ({ page }) => {
    await page.goto('/anchor/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Warning' || t.startsWith('Warning'))).toBeTruthy();
  });
  test('anchor: h1 "Anchor"', async ({ page }) => {
    await page.goto('/anchor/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Anchor' || t.startsWith('Anchor'))).toBeTruthy();
  });
});

test.describe('Functional - android_os', () => {
  test('android_os: title matches GT', async ({ page }) => {
    await page.goto('/android-os/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('orbit core');
  });
  test('android_os: h1 "Alert"', async ({ page }) => {
    await page.goto('/android-os/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('android_os: h1 "Hold on"', async ({ page }) => {
    await page.goto('/android-os/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('android_os: h1 "Orbit Core"', async ({ page }) => {
    await page.goto('/android-os/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Orbit Core' || t.startsWith('Orbit Core'))).toBeTruthy();
  });
});

test.describe('Functional - antenna', () => {
  test('antenna: title matches GT', async ({ page }) => {
    await page.goto('/antenna/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('antenna');
  });
  test('antenna: h1 "Notice"', async ({ page }) => {
    await page.goto('/antenna/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('antenna: h1 "Confirm"', async ({ page }) => {
    await page.goto('/antenna/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('antenna: h1 "Antenna"', async ({ page }) => {
    await page.goto('/antenna/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Antenna' || t.startsWith('Antenna'))).toBeTruthy();
  });
});

test.describe('Functional - apple_os', () => {
  test('apple_os: title matches GT', async ({ page }) => {
    await page.goto('/apple-os/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('nimbus os');
  });
  test('apple_os: h1 "Hold on"', async ({ page }) => {
    await page.goto('/apple-os/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('apple_os: h1 "One sec"', async ({ page }) => {
    await page.goto('/apple-os/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'One sec' || t.startsWith('One sec'))).toBeTruthy();
  });
  test('apple_os: h1 "Nimbus OS"', async ({ page }) => {
    await page.goto('/apple-os/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Nimbus OS' || t.startsWith('Nimbus OS'))).toBeTruthy();
  });
});

test.describe('Functional - archive', () => {
  test('archive: title matches GT', async ({ page }) => {
    await page.goto('/archive/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('archive');
  });
  test('archive: h1 "Notice"', async ({ page }) => {
    await page.goto('/archive/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('archive: h1 "Confirm"', async ({ page }) => {
    await page.goto('/archive/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('archive: h1 "Archive"', async ({ page }) => {
    await page.goto('/archive/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Archive' || t.startsWith('Archive'))).toBeTruthy();
  });
});

test.describe('Functional - arrow', () => {
  test('arrow: title matches GT', async ({ page }) => {
    await page.goto('/arrow/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('arrows');
  });
  test('arrow: h1 "Alert"', async ({ page }) => {
    await page.goto('/arrow/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('arrow: h1 "Verify"', async ({ page }) => {
    await page.goto('/arrow/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('arrow: h1 "Arrows"', async ({ page }) => {
    await page.goto('/arrow/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Arrows' || t.startsWith('Arrows'))).toBeTruthy();
  });
});

test.describe('Functional - audio', () => {
  test('audio: title matches GT', async ({ page }) => {
    await page.goto('/audio/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('audio');
  });
  test('audio: h1 "Notice"', async ({ page }) => {
    await page.goto('/audio/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('audio: h1 "Confirm"', async ({ page }) => {
    await page.goto('/audio/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('audio: h1 "Audio"', async ({ page }) => {
    await page.goto('/audio/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Audio' || t.startsWith('Audio'))).toBeTruthy();
  });
});

test.describe('Functional - award', () => {
  test('award: title matches GT', async ({ page }) => {
    await page.goto('/award/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('awards');
  });
  test('award: h1 "Heads up"', async ({ page }) => {
    await page.goto('/award/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('award: h1 "Confirm"', async ({ page }) => {
    await page.goto('/award/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('award: h1 "Award"', async ({ page }) => {
    await page.goto('/award/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Award' || t.startsWith('Award'))).toBeTruthy();
  });
});

test.describe('Functional - badge', () => {
  test('badge: title matches GT', async ({ page }) => {
    await page.goto('/badge/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('badge');
  });
  test('badge: h1 "Heads up"', async ({ page }) => {
    await page.goto('/badge/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('badge: h1 "Confirm"', async ({ page }) => {
    await page.goto('/badge/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('badge: h1 "Badge"', async ({ page }) => {
    await page.goto('/badge/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Badge' || t.startsWith('Badge'))).toBeTruthy();
  });
});

test.describe('Functional - badminton', () => {
  test('badminton: title matches GT', async ({ page }) => {
    await page.goto('/badminton/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('badminton');
  });
  test('badminton: h1 "Notice"', async ({ page }) => {
    await page.goto('/badminton/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('badminton: h1 "Confirm"', async ({ page }) => {
    await page.goto('/badminton/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('badminton: h1 "Badminton"', async ({ page }) => {
    await page.goto('/badminton/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Badminton' || t.startsWith('Badminton'))).toBeTruthy();
  });
});

test.describe('Functional - banknote', () => {
  test('banknote: title matches GT', async ({ page }) => {
    await page.goto('/banknote/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('banknote icon');
  });
  test('banknote: h1 "Notice"', async ({ page }) => {
    await page.goto('/banknote/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('banknote: h1 "Confirm"', async ({ page }) => {
    await page.goto('/banknote/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('banknote: h1 "Banknote"', async ({ page }) => {
    await page.goto('/banknote/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Banknote' || t.startsWith('Banknote'))).toBeTruthy();
  });
});

test.describe('Functional - barcode', () => {
  test('barcode: title matches GT', async ({ page }) => {
    await page.goto('/barcode/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('barcode');
  });
  test('barcode: h1 "Notice"', async ({ page }) => {
    await page.goto('/barcode/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('barcode: h1 "Confirm"', async ({ page }) => {
    await page.goto('/barcode/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('barcode: h1 "Barcode"', async ({ page }) => {
    await page.goto('/barcode/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Barcode' || t.startsWith('Barcode'))).toBeTruthy();
  });
});

test.describe('Functional - baseball', () => {
  test('baseball: title matches GT', async ({ page }) => {
    await page.goto('/baseball/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('baseball');
  });
  test('baseball: h1 "Heads Up"', async ({ page }) => {
    await page.goto('/baseball/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads Up' || t.startsWith('Heads Up'))).toBeTruthy();
  });
  test('baseball: h1 "Hold On"', async ({ page }) => {
    await page.goto('/baseball/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('baseball: h1 "Baseball"', async ({ page }) => {
    await page.goto('/baseball/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Baseball' || t.startsWith('Baseball'))).toBeTruthy();
  });
});

test.describe('Functional - basket', () => {
  test('basket: title matches GT', async ({ page }) => {
    await page.goto('/basket/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('basket');
  });
  test('basket: h1 "Alert"', async ({ page }) => {
    await page.goto('/basket/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('basket: h1 "Verify"', async ({ page }) => {
    await page.goto('/basket/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('basket: h1 "Basket"', async ({ page }) => {
    await page.goto('/basket/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Basket' || t.startsWith('Basket'))).toBeTruthy();
  });
});

test.describe('Functional - basketball', () => {
  test('basketball: title matches GT', async ({ page }) => {
    await page.goto('/basketball/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('basketball');
  });
  test('basketball: h1 "Heads Up"', async ({ page }) => {
    await page.goto('/basketball/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads Up' || t.startsWith('Heads Up'))).toBeTruthy();
  });
  test('basketball: h1 "Hold On"', async ({ page }) => {
    await page.goto('/basketball/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('basketball: h1 "Basketball"', async ({ page }) => {
    await page.goto('/basketball/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Basketball' || t.startsWith('Basketball'))).toBeTruthy();
  });
});

test.describe('Functional - battery', () => {
  test('battery: title matches GT', async ({ page }) => {
    await page.goto('/battery/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('battery');
  });
  test('battery: h1 "Alert"', async ({ page }) => {
    await page.goto('/battery/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('battery: h1 "Verify"', async ({ page }) => {
    await page.goto('/battery/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('battery: h1 "Battery"', async ({ page }) => {
    await page.goto('/battery/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Battery' || t.startsWith('Battery'))).toBeTruthy();
  });
});

test.describe('Functional - bed', () => {
  test('bed: title matches GT', async ({ page }) => {
    await page.goto('/bed/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('bed icon');
  });
  test('bed: h1 "Heads Up"', async ({ page }) => {
    await page.goto('/bed/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads Up' || t.startsWith('Heads Up'))).toBeTruthy();
  });
  test('bed: h1 "Hold On"', async ({ page }) => {
    await page.goto('/bed/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('bed: h1 "Bed"', async ({ page }) => {
    await page.goto('/bed/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Bed' || t.startsWith('Bed'))).toBeTruthy();
  });
});

test.describe('Functional - beer', () => {
  test('beer: title matches GT', async ({ page }) => {
    await page.goto('/beer/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('beer set');
  });
  test('beer: h1 "Notice"', async ({ page }) => {
    await page.goto('/beer/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('beer: h1 "Confirm"', async ({ page }) => {
    await page.goto('/beer/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('beer: h1 "Beer"', async ({ page }) => {
    await page.goto('/beer/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Beer' || t.startsWith('Beer'))).toBeTruthy();
  });
});

test.describe('Functional - behance', () => {
  test('behance: title matches GT', async ({ page }) => {
    await page.goto('/behance/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('portflow');
  });
  test('behance: h1 "Notice"', async ({ page }) => {
    await page.goto('/behance/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('behance: h1 "Confirm"', async ({ page }) => {
    await page.goto('/behance/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('behance: h1 "Portflow"', async ({ page }) => {
    await page.goto('/behance/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Portflow' || t.startsWith('Portflow'))).toBeTruthy();
  });
});

test.describe('Functional - bell', () => {
  test('bell: title matches GT', async ({ page }) => {
    await page.goto('/bell/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('bell');
  });
  test('bell: h1 "Notice"', async ({ page }) => {
    await page.goto('/bell/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('bell: h1 "Confirm"', async ({ page }) => {
    await page.goto('/bell/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('bell: h1 "Bell"', async ({ page }) => {
    await page.goto('/bell/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Bell' || t.startsWith('Bell'))).toBeTruthy();
  });
});

test.describe('Functional - bicycle', () => {
  test('bicycle: title matches GT', async ({ page }) => {
    await page.goto('/bicycle/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('bicycle');
  });
  test('bicycle: h1 "Heads up"', async ({ page }) => {
    await page.goto('/bicycle/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('bicycle: h1 "Hold on"', async ({ page }) => {
    await page.goto('/bicycle/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('bicycle: h1 "Bicycle"', async ({ page }) => {
    await page.goto('/bicycle/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Bicycle' || t.startsWith('Bicycle'))).toBeTruthy();
  });
});

test.describe('Functional - binoculars', () => {
  test('binoculars: title matches GT', async ({ page }) => {
    await page.goto('/binoculars/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('binoculars');
  });
  test('binoculars: h1 "Heads up"', async ({ page }) => {
    await page.goto('/binoculars/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('binoculars: h1 "Confirm"', async ({ page }) => {
    await page.goto('/binoculars/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('binoculars: h1 "Binoculars"', async ({ page }) => {
    await page.goto('/binoculars/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Binoculars' || t.startsWith('Binoculars'))).toBeTruthy();
  });
});

test.describe('Functional - bitcoin', () => {
  test('bitcoin: title matches GT', async ({ page }) => {
    await page.goto('/bitcoin/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('currency');
  });
  test('bitcoin: h1 "Notice"', async ({ page }) => {
    await page.goto('/bitcoin/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('bitcoin: h1 "Confirm"', async ({ page }) => {
    await page.goto('/bitcoin/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('bitcoin: h1 "Currency"', async ({ page }) => {
    await page.goto('/bitcoin/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Currency' || t.startsWith('Currency'))).toBeTruthy();
  });
});

test.describe('Functional - blogger', () => {
  test('blogger: title matches GT', async ({ page }) => {
    await page.goto('/blogger/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('blogger');
  });
  test('blogger: h1 "Notice"', async ({ page }) => {
    await page.goto('/blogger/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('blogger: h1 "Confirm"', async ({ page }) => {
    await page.goto('/blogger/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('blogger: h1 "Blogger"', async ({ page }) => {
    await page.goto('/blogger/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Blogger' || t.startsWith('Blogger'))).toBeTruthy();
  });
});

test.describe('Functional - book', () => {
  test('book: title matches GT', async ({ page }) => {
    await page.goto('/book/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('book glyphel');
  });
  test('book: h1 "Alert"', async ({ page }) => {
    await page.goto('/book/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('book: h1 "Verify"', async ({ page }) => {
    await page.goto('/book/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('book: h1 "Book"', async ({ page }) => {
    await page.goto('/book/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Book' || t.startsWith('Book'))).toBeTruthy();
  });
});

test.describe('Functional - bookmark', () => {
  test('bookmark: title matches GT', async ({ page }) => {
    await page.goto('/bookmark/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('bookmark');
  });
  test('bookmark: h1 "Reminder"', async ({ page }) => {
    await page.goto('/bookmark/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Reminder' || t.startsWith('Reminder'))).toBeTruthy();
  });
  test('bookmark: h1 "Confirm?"', async ({ page }) => {
    await page.goto('/bookmark/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm?' || t.startsWith('Confirm?'))).toBeTruthy();
  });
  test('bookmark: h1 "Bookmark"', async ({ page }) => {
    await page.goto('/bookmark/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Bookmark' || t.startsWith('Bookmark'))).toBeTruthy();
  });
});

test.describe('Functional - bowling', () => {
  test('bowling: title matches GT', async ({ page }) => {
    await page.goto('/bowling/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('bowling');
  });
  test('bowling: h1 "Notice"', async ({ page }) => {
    await page.goto('/bowling/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('bowling: h1 "Confirm"', async ({ page }) => {
    await page.goto('/bowling/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('bowling: h1 "Bowling"', async ({ page }) => {
    await page.goto('/bowling/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Bowling' || t.startsWith('Bowling'))).toBeTruthy();
  });
});

test.describe('Functional - boxing', () => {
  test('boxing: title matches GT', async ({ page }) => {
    await page.goto('/boxing/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('boxing set');
  });
  test('boxing: h1 "Alert"', async ({ page }) => {
    await page.goto('/boxing/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('boxing: h1 "Verify"', async ({ page }) => {
    await page.goto('/boxing/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('boxing: h1 "Boxing"', async ({ page }) => {
    await page.goto('/boxing/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Boxing' || t.startsWith('Boxing'))).toBeTruthy();
  });
});

test.describe('Functional - brick', () => {
  test('brick: title matches GT', async ({ page }) => {
    await page.goto('/brick/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('brick icon');
  });
  test('brick: h1 "Alert"', async ({ page }) => {
    await page.goto('/brick/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('brick: h1 "Confirm"', async ({ page }) => {
    await page.goto('/brick/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('brick: h1 "Brick"', async ({ page }) => {
    await page.goto('/brick/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Brick' || t.startsWith('Brick'))).toBeTruthy();
  });
});

test.describe('Functional - briefcase', () => {
  test('briefcase: title matches GT', async ({ page }) => {
    await page.goto('/briefcase/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('briefcase');
  });
  test('briefcase: h1 "Alert"', async ({ page }) => {
    await page.goto('/briefcase/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('briefcase: h1 "Confirm"', async ({ page }) => {
    await page.goto('/briefcase/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('briefcase: h1 "Briefcase"', async ({ page }) => {
    await page.goto('/briefcase/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Briefcase' || t.startsWith('Briefcase'))).toBeTruthy();
  });
});

test.describe('Functional - brightness', () => {
  test('brightness: title matches GT', async ({ page }) => {
    await page.goto('/brightness/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('brightness');
  });
  test('brightness: h1 "Alert!"', async ({ page }) => {
    await page.goto('/brightness/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert!' || t.startsWith('Alert!'))).toBeTruthy();
  });
  test('brightness: h1 "Verify"', async ({ page }) => {
    await page.goto('/brightness/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('brightness: h1 "Brightness"', async ({ page }) => {
    await page.goto('/brightness/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Brightness' || t.startsWith('Brightness'))).toBeTruthy();
  });
});

test.describe('Functional - bug', () => {
  test('bug: title matches GT', async ({ page }) => {
    await page.goto('/bug/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('bug icon');
  });
  test('bug: h1 "Alert"', async ({ page }) => {
    await page.goto('/bug/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('bug: h1 "Hold on"', async ({ page }) => {
    await page.goto('/bug/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('bug: h1 "Bug"', async ({ page }) => {
    await page.goto('/bug/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Bug' || t.startsWith('Bug'))).toBeTruthy();
  });
});

test.describe('Functional - building', () => {
  test('building: title matches GT', async ({ page }) => {
    await page.goto('/building/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('building glyphel');
  });
  test('building: h1 "Alert!"', async ({ page }) => {
    await page.goto('/building/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert!' || t.startsWith('Alert!'))).toBeTruthy();
  });
  test('building: h1 "Confirm?"', async ({ page }) => {
    await page.goto('/building/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm?' || t.startsWith('Confirm?'))).toBeTruthy();
  });
  test('building: h1 "Buildings"', async ({ page }) => {
    await page.goto('/building/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Buildings' || t.startsWith('Buildings'))).toBeTruthy();
  });
});

test.describe('Functional - bus', () => {
  test('bus: title matches GT', async ({ page }) => {
    await page.goto('/bus/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('bus');
  });
  test('bus: h1 "Heads up"', async ({ page }) => {
    await page.goto('/bus/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('bus: h1 "Please confirm"', async ({ page }) => {
    await page.goto('/bus/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Please confirm' || t.startsWith('Please confirm'))).toBeTruthy();
  });
  test('bus: h1 "Bus"', async ({ page }) => {
    await page.goto('/bus/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Bus' || t.startsWith('Bus'))).toBeTruthy();
  });
});

test.describe('Functional - calculator', () => {
  test('calculator: title matches GT', async ({ page }) => {
    await page.goto('/calculator/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('calculator');
  });
  test('calculator: h1 "Alert"', async ({ page }) => {
    await page.goto('/calculator/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('calculator: h1 "Hold on"', async ({ page }) => {
    await page.goto('/calculator/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('calculator: h1 "Calculator"', async ({ page }) => {
    await page.goto('/calculator/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Calculator' || t.startsWith('Calculator'))).toBeTruthy();
  });
});

test.describe('Functional - calendar', () => {
  test('calendar: title matches GT', async ({ page }) => {
    await page.goto('/calendar/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('calendar');
  });
  test('calendar: h1 "Heads up"', async ({ page }) => {
    await page.goto('/calendar/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('calendar: h1 "Please confirm"', async ({ page }) => {
    await page.goto('/calendar/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Please confirm' || t.startsWith('Please confirm'))).toBeTruthy();
  });
  test('calendar: h1 "Calendar"', async ({ page }) => {
    await page.goto('/calendar/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Calendar' || t.startsWith('Calendar'))).toBeTruthy();
  });
});

test.describe('Functional - candy', () => {
  test('candy: title matches GT', async ({ page }) => {
    await page.goto('/candy/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('candy set');
  });
  test('candy: h1 "Alert"', async ({ page }) => {
    await page.goto('/candy/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('candy: h1 "Hold up"', async ({ page }) => {
    await page.goto('/candy/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold up' || t.startsWith('Hold up'))).toBeTruthy();
  });
  test('candy: h1 "Candy"', async ({ page }) => {
    await page.goto('/candy/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Candy' || t.startsWith('Candy'))).toBeTruthy();
  });
});

test.describe('Functional - car', () => {
  test('car: title matches GT', async ({ page }) => {
    await page.goto('/car/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('car set');
  });
  test('car: h1 "Alert!"', async ({ page }) => {
    await page.goto('/car/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert!' || t.startsWith('Alert!'))).toBeTruthy();
  });
  test('car: h1 "Verify"', async ({ page }) => {
    await page.goto('/car/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('car: h1 "Car"', async ({ page }) => {
    await page.goto('/car/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Car' || t.startsWith('Car'))).toBeTruthy();
  });
});

test.describe('Functional - cargo', () => {
  test('cargo: title matches GT', async ({ page }) => {
    await page.goto('/cargo/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('cargo');
  });
  test('cargo: h1 "Heads up"', async ({ page }) => {
    await page.goto('/cargo/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('cargo: h1 "Confirm"', async ({ page }) => {
    await page.goto('/cargo/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('cargo: h1 "Cargo"', async ({ page }) => {
    await page.goto('/cargo/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Cargo' || t.startsWith('Cargo'))).toBeTruthy();
  });
});

test.describe('Functional - carousel_filled_svg', () => {
  test('carousel_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/carousel-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('carousel');
  });
  test('carousel_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/carousel-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('carousel_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/carousel-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('carousel_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/carousel-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - carousel_lined_svg', () => {
  test('carousel_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/carousel-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('carousel');
  });
  test('carousel_lined_svg: h1 "Heads Up"', async ({ page }) => {
    await page.goto('/carousel-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads Up' || t.startsWith('Heads Up'))).toBeTruthy();
  });
  test('carousel_lined_svg: h1 "Hold On"', async ({ page }) => {
    await page.goto('/carousel-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('carousel_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/carousel-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - cat', () => {
  test('cat: title matches GT', async ({ page }) => {
    await page.goto('/cat/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('cat');
  });
  test('cat: h1 "Notice"', async ({ page }) => {
    await page.goto('/cat/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('cat: h1 "Confirm"', async ({ page }) => {
    await page.goto('/cat/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('cat: h1 "Cat"', async ({ page }) => {
    await page.goto('/cat/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Cat' || t.startsWith('Cat'))).toBeTruthy();
  });
});

test.describe('Functional - certificate', () => {
  test('certificate: title matches GT', async ({ page }) => {
    await page.goto('/certificate/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('certificate');
  });
  test('certificate: h1 "Notice"', async ({ page }) => {
    await page.goto('/certificate/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('certificate: h1 "Confirm"', async ({ page }) => {
    await page.goto('/certificate/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('certificate: h1 "Certificate"', async ({ page }) => {
    await page.goto('/certificate/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Certificate' || t.startsWith('Certificate'))).toBeTruthy();
  });
});

test.describe('Functional - chart', () => {
  test('chart: title matches GT', async ({ page }) => {
    await page.goto('/chart/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('charts');
  });
  test('chart: h1 "Heads up"', async ({ page }) => {
    await page.goto('/chart/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('chart: h1 "Please confirm"', async ({ page }) => {
    await page.goto('/chart/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Please confirm' || t.startsWith('Please confirm'))).toBeTruthy();
  });
  test('chart: h1 "Chart"', async ({ page }) => {
    await page.goto('/chart/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Chart' || t.startsWith('Chart'))).toBeTruthy();
  });
});

test.describe('Functional - check_mark', () => {
  test('check_mark: title matches GT', async ({ page }) => {
    await page.goto('/check-mark/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('check mark');
  });
  test('check_mark: h1 "Notice"', async ({ page }) => {
    await page.goto('/check-mark/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('check_mark: h1 "Confirm"', async ({ page }) => {
    await page.goto('/check-mark/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('check_mark: h1 "Check Mark"', async ({ page }) => {
    await page.goto('/check-mark/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Check Mark' || t.startsWith('Check Mark'))).toBeTruthy();
  });
});

test.describe('Functional - checkbox', () => {
  test('checkbox: title matches GT', async ({ page }) => {
    await page.goto('/checkbox/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('checkbox');
  });
  test('checkbox: h1 "Heads Up"', async ({ page }) => {
    await page.goto('/checkbox/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads Up' || t.startsWith('Heads Up'))).toBeTruthy();
  });
  test('checkbox: h1 "Hold On"', async ({ page }) => {
    await page.goto('/checkbox/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('checkbox: h1 "Checkbox"', async ({ page }) => {
    await page.goto('/checkbox/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Checkbox' || t.startsWith('Checkbox'))).toBeTruthy();
  });
});

test.describe('Functional - checkout', () => {
  test('checkout: title matches GT', async ({ page }) => {
    await page.goto('/checkout/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('checkout');
  });
  test('checkout: h1 "Notice"', async ({ page }) => {
    await page.goto('/checkout/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('checkout: h1 "Confirm"', async ({ page }) => {
    await page.goto('/checkout/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('checkout: h1 "Checkout"', async ({ page }) => {
    await page.goto('/checkout/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Checkout' || t.startsWith('Checkout'))).toBeTruthy();
  });
});

test.describe('Functional - christmas', () => {
  test('christmas: title matches GT', async ({ page }) => {
    await page.goto('/christmas/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('christmas glyphel');
  });
  test('christmas: h1 "Alert"', async ({ page }) => {
    await page.goto('/christmas/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('christmas: h1 "Hold On"', async ({ page }) => {
    await page.goto('/christmas/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('christmas: h1 "Christmas"', async ({ page }) => {
    await page.goto('/christmas/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Christmas' || t.startsWith('Christmas'))).toBeTruthy();
  });
});

test.describe('Functional - chrome', () => {
  test('chrome: title matches GT', async ({ page }) => {
    await page.goto('/chrome/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('prism glyphel');
  });
  test('chrome: h1 "Hold on"', async ({ page }) => {
    await page.goto('/chrome/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('chrome: h1 "Verify"', async ({ page }) => {
    await page.goto('/chrome/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('chrome: h1 "Prism"', async ({ page }) => {
    await page.goto('/chrome/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Prism' || t.startsWith('Prism'))).toBeTruthy();
  });
});

test.describe('Functional - circle', () => {
  test('circle: title matches GT', async ({ page }) => {
    await page.goto('/circle/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('circle glyphel');
  });
  test('circle: h1 "Alert"', async ({ page }) => {
    await page.goto('/circle/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('circle: h1 "Confirm?"', async ({ page }) => {
    await page.goto('/circle/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm?' || t.startsWith('Confirm?'))).toBeTruthy();
  });
  test('circle: h1 "Circle"', async ({ page }) => {
    await page.goto('/circle/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Circle' || t.startsWith('Circle'))).toBeTruthy();
  });
});

test.describe('Functional - clipboard', () => {
  test('clipboard: title matches GT', async ({ page }) => {
    await page.goto('/clipboard/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('clipboard');
  });
  test('clipboard: h1 "Notice"', async ({ page }) => {
    await page.goto('/clipboard/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('clipboard: h1 "Confirm"', async ({ page }) => {
    await page.goto('/clipboard/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('clipboard: h1 "Clipboard"', async ({ page }) => {
    await page.goto('/clipboard/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Clipboard' || t.startsWith('Clipboard'))).toBeTruthy();
  });
});

test.describe('Functional - clothing', () => {
  test('clothing: title matches GT', async ({ page }) => {
    await page.goto('/clothing/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('clothing');
  });
  test('clothing: h1 "Heads up"', async ({ page }) => {
    await page.goto('/clothing/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('clothing: h1 "Confirm"', async ({ page }) => {
    await page.goto('/clothing/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('clothing: h1 "Clothing"', async ({ page }) => {
    await page.goto('/clothing/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Clothing' || t.startsWith('Clothing'))).toBeTruthy();
  });
});

test.describe('Functional - cloud', () => {
  test('cloud: title matches GT', async ({ page }) => {
    await page.goto('/cloud/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('cloud');
  });
  test('cloud: h1 "Reminder"', async ({ page }) => {
    await page.goto('/cloud/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Reminder' || t.startsWith('Reminder'))).toBeTruthy();
  });
  test('cloud: h1 "Confirm"', async ({ page }) => {
    await page.goto('/cloud/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('cloud: h1 "Cloud"', async ({ page }) => {
    await page.goto('/cloud/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Cloud' || t.startsWith('Cloud'))).toBeTruthy();
  });
});

test.describe('Functional - code', () => {
  test('code: title matches GT', async ({ page }) => {
    await page.goto('/code/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('code');
  });
  test('code: h1 "Notice"', async ({ page }) => {
    await page.goto('/code/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('code: h1 "Confirm"', async ({ page }) => {
    await page.goto('/code/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('code: h1 "Code"', async ({ page }) => {
    await page.goto('/code/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Code' || t.startsWith('Code'))).toBeTruthy();
  });
});

test.describe('Functional - code_fork', () => {
  test('code_fork: title matches GT', async ({ page }) => {
    await page.goto('/code-fork/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('code fork icon');
  });
  test('code_fork: h1 "Alert"', async ({ page }) => {
    await page.goto('/code-fork/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('code_fork: h1 "Verify"', async ({ page }) => {
    await page.goto('/code-fork/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('code_fork: h1 "Code Fork"', async ({ page }) => {
    await page.goto('/code-fork/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Code Fork' || t.startsWith('Code Fork'))).toBeTruthy();
  });
});

test.describe('Functional - coffee', () => {
  test('coffee: title matches GT', async ({ page }) => {
    await page.goto('/coffee/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('coffee');
  });
  test('coffee: h1 "Notice"', async ({ page }) => {
    await page.goto('/coffee/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('coffee: h1 "Confirm"', async ({ page }) => {
    await page.goto('/coffee/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('coffee: h1 "Coffee"', async ({ page }) => {
    await page.goto('/coffee/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Coffee' || t.startsWith('Coffee'))).toBeTruthy();
  });
});

test.describe('Functional - collections', () => {
  test('collections: title matches GT', async ({ page }) => {
    await page.goto('/collections/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('collections');
  });
  test('collections: h1 "Heads up"', async ({ page }) => {
    await page.goto('/collections/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('collections: h1 "Confirm?"', async ({ page }) => {
    await page.goto('/collections/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm?' || t.startsWith('Confirm?'))).toBeTruthy();
  });
  test('collections: h1 "Collections"', async ({ page }) => {
    await page.goto('/collections/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Collections' || t.startsWith('Collections'))).toBeTruthy();
  });
  test('collections: h2 "Discover 316+ beautiful icon s"', async ({ page }) => {
    await page.goto('/collections/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Discover 316+ beautiful icon sets' || t.startsWith('Discover 316+ beautiful icon sets'))).toBeTruthy();
  });
});

test.describe('Functional - contrast_filled_svg', () => {
  test('contrast_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/contrast-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('contrast');
  });
  test('contrast_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/contrast-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('contrast_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/contrast-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('contrast_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/contrast-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - contrast_lined_svg', () => {
  test('contrast_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/contrast-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('halftone');
  });
  test('contrast_lined_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/contrast-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('contrast_lined_svg: h1 "Hold on"', async ({ page }) => {
    await page.goto('/contrast-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('contrast_lined_svg: h1 "Halftone - Lined"', async ({ page }) => {
    await page.goto('/contrast-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Halftone - Lined' || t.startsWith('Halftone - Lined'))).toBeTruthy();
  });
  test('contrast_lined_svg: h2 "Copied!"', async ({ page }) => {
    await page.goto('/contrast-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied!' || t.startsWith('Copied!'))).toBeTruthy();
  });
});

test.describe('Functional - copy_clipboard_lined_svg', () => {
  test('copy_clipboard_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/copy-clipboard-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('copy clipboard');
  });
  test('copy_clipboard_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/copy-clipboard-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('copy_clipboard_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/copy-clipboard-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('copy_clipboard_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/copy-clipboard-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - copy_filled_svg', () => {
  test('copy_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/copy-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('copy icon');
  });
  test('copy_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/copy-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('copy_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/copy-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('copy_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/copy-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - copy_lined_svg', () => {
  test('copy_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/copy-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('clone');
  });
  test('copy_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/copy-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('copy_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/copy-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('copy_lined_svg: h1 "Clone - Lined"', async ({ page }) => {
    await page.goto('/copy-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Clone - Lined' || t.startsWith('Clone - Lined'))).toBeTruthy();
  });
  test('copy_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/copy-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - cut_filled_svg', () => {
  test('cut_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/cut-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('cut');
  });
  test('cut_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/cut-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('cut_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/cut-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('cut_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/cut-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - cut_lined_svg', () => {
  test('cut_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/cut-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('cut');
  });
  test('cut_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/cut-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('cut_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/cut-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('cut_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/cut-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - dashboard_alt_filled_svg', () => {
  test('dashboard_alt_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/dashboard-alt-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('dashboard alt');
  });
  test('dashboard_alt_filled_svg: h1 "Heads Up"', async ({ page }) => {
    await page.goto('/dashboard-alt-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads Up' || t.startsWith('Heads Up'))).toBeTruthy();
  });
  test('dashboard_alt_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/dashboard-alt-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('dashboard_alt_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/dashboard-alt-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - dashboard_alt_lined_svg', () => {
  test('dashboard_alt_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/dashboard-alt-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('dashboard alt');
  });
  test('dashboard_alt_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/dashboard-alt-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('dashboard_alt_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/dashboard-alt-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('dashboard_alt_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/dashboard-alt-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - dashboard_filled_svg', () => {
  test('dashboard_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/dashboard-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('grid panel');
  });
  test('dashboard_filled_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/dashboard-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('dashboard_filled_svg: h1 "Warning"', async ({ page }) => {
    await page.goto('/dashboard-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Warning' || t.startsWith('Warning'))).toBeTruthy();
  });
  test('dashboard_filled_svg: h1 "Grid Panel - Filled"', async ({ page }) => {
    await page.goto('/dashboard-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Grid Panel - Filled' || t.startsWith('Grid Panel - Filled'))).toBeTruthy();
  });
  test('dashboard_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/dashboard-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - dashboard_lined_svg', () => {
  test('dashboard_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/dashboard-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('dashboard');
  });
  test('dashboard_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/dashboard-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('dashboard_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/dashboard-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('dashboard_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/dashboard-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - duplicate_filled_svg', () => {
  test('duplicate_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/duplicate-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('duplicate');
  });
  test('duplicate_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/duplicate-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('duplicate_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/duplicate-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('duplicate_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/duplicate-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - duplicate_lined_svg', () => {
  test('duplicate_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/duplicate-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('clone pair');
  });
  test('duplicate_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/duplicate-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('duplicate_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/duplicate-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('duplicate_lined_svg: h1 "Clone Pair - Lined"', async ({ page }) => {
    await page.goto('/duplicate-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Clone Pair - Lined' || t.startsWith('Clone Pair - Lined'))).toBeTruthy();
  });
  test('duplicate_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/duplicate-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - filter_down_lined_svg', () => {
  test('filter_down_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/filter-down-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('filter down');
  });
  test('filter_down_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/filter-down-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('filter_down_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/filter-down-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('filter_down_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/filter-down-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - filter_up_lined_svg', () => {
  test('filter_up_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/filter-up-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('filter up');
  });
  test('filter_up_lined_svg: h1 "Alert!"', async ({ page }) => {
    await page.goto('/filter-up-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert!' || t.startsWith('Alert!'))).toBeTruthy();
  });
  test('filter_up_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/filter-up-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('filter_up_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/filter-up-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - full_screen_filled_svg', () => {
  test('full_screen_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/full-screen-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('expand frame');
  });
  test('full_screen_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/full-screen-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('full_screen_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/full-screen-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('full_screen_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/full-screen-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - full_screen_lined_svg', () => {
  test('full_screen_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/full-screen-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('expand screen');
  });
  test('full_screen_lined_svg: h1 "Hold On"', async ({ page }) => {
    await page.goto('/full-screen-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('full_screen_lined_svg: h1 "Proceed?"', async ({ page }) => {
    await page.goto('/full-screen-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Proceed?' || t.startsWith('Proceed?'))).toBeTruthy();
  });
  test('full_screen_lined_svg: h2 "Copied!"', async ({ page }) => {
    await page.goto('/full-screen-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied!' || t.startsWith('Copied!'))).toBeTruthy();
  });
});

test.describe('Functional - future_lined_svg', () => {
  test('future_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/future-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('future');
  });
  test('future_lined_svg: h1 "Heads up"', async ({ page }) => {
    await page.goto('/future-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('future_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/future-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('future_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/future-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - gallery_horizontal_filled_svg', () => {
  test('gallery_horizontal_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/gallery-horizontal-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('gallery horizontal');
  });
  test('gallery_horizontal_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/gallery-horizontal-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('gallery_horizontal_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/gallery-horizontal-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('gallery_horizontal_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/gallery-horizontal-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - gallery_horizontal_lined_svg', () => {
  test('gallery_horizontal_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/gallery-horizontal-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('horizontal scroller');
  });
  test('gallery_horizontal_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/gallery-horizontal-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('gallery_horizontal_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/gallery-horizontal-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('gallery_horizontal_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/gallery-horizontal-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - gallery_list_filled_svg', () => {
  test('gallery_list_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/gallery-list-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('symbol list');
  });
  test('gallery_list_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/gallery-list-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('gallery_list_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/gallery-list-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('gallery_list_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/gallery-list-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - gallery_list_lined_svg', () => {
  test('gallery_list_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/gallery-list-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('symbol list');
  });
  test('gallery_list_lined_svg: h1 "Heads Up"', async ({ page }) => {
    await page.goto('/gallery-list-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads Up' || t.startsWith('Heads Up'))).toBeTruthy();
  });
  test('gallery_list_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/gallery-list-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('gallery_list_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/gallery-list-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - gallery_vertical_filled_svg', () => {
  test('gallery_vertical_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/gallery-vertical-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('stacked card layout');
  });
  test('gallery_vertical_filled_svg: h1 "Warning"', async ({ page }) => {
    await page.goto('/gallery-vertical-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Warning' || t.startsWith('Warning'))).toBeTruthy();
  });
  test('gallery_vertical_filled_svg: h1 "Hold On"', async ({ page }) => {
    await page.goto('/gallery-vertical-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('gallery_vertical_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/gallery-vertical-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - gallery_vertical_lined_svg', () => {
  test('gallery_vertical_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/gallery-vertical-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('gallery vertical');
  });
  test('gallery_vertical_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/gallery-vertical-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('gallery_vertical_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/gallery-vertical-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('gallery_vertical_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/gallery-vertical-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - heart_filled_svg', () => {
  test('heart_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/heart-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('heart icon');
  });
  test('heart_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/heart-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('heart_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/heart-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('heart_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/heart-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - heart_lined_svg', () => {
  test('heart_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/heart-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('heart icon');
  });
  test('heart_lined_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/heart-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('heart_lined_svg: h1 "Verify"', async ({ page }) => {
    await page.goto('/heart-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('heart_lined_svg: h2 "Copied!"', async ({ page }) => {
    await page.goto('/heart-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied!' || t.startsWith('Copied!'))).toBeTruthy();
  });
});

test.describe('Functional - heart_plus_filled_svg', () => {
  test('heart_plus_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/heart-plus-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('heart plus');
  });
  test('heart_plus_filled_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/heart-plus-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('heart_plus_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/heart-plus-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('heart_plus_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/heart-plus-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - heart_plus_lined_svg', () => {
  test('heart_plus_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/heart-plus-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('heart plus');
  });
  test('heart_plus_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/heart-plus-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('heart_plus_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/heart-plus-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('heart_plus_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/heart-plus-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - heart_x_filled_svg', () => {
  test('heart_x_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/heart-x-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('heart x');
  });
  test('heart_x_filled_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/heart-x-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('heart_x_filled_svg: h1 "Hold on"', async ({ page }) => {
    await page.goto('/heart-x-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('heart_x_filled_svg: h2 "Copied!"', async ({ page }) => {
    await page.goto('/heart-x-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied!' || t.startsWith('Copied!'))).toBeTruthy();
  });
});

test.describe('Functional - heart_x_lined_svg', () => {
  test('heart_x_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/heart-x-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('heart x');
  });
  test('heart_x_lined_svg: h1 "Heads Up"', async ({ page }) => {
    await page.goto('/heart-x-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads Up' || t.startsWith('Heads Up'))).toBeTruthy();
  });
  test('heart_x_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/heart-x-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('heart_x_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/heart-x-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - history_lined_svg', () => {
  test('history_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/history-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('history');
  });
  test('history_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/history-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('history_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/history-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('history_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/history-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - large_thumbnail_filled_svg', () => {
  test('large_thumbnail_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/large-thumbnail-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('large preview icon');
  });
  test('large_thumbnail_filled_svg: h1 "Alert!"', async ({ page }) => {
    await page.goto('/large-thumbnail-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert!' || t.startsWith('Alert!'))).toBeTruthy();
  });
  test('large_thumbnail_filled_svg: h1 "Verify"', async ({ page }) => {
    await page.goto('/large-thumbnail-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('large_thumbnail_filled_svg: h2 "Snagged"', async ({ page }) => {
    await page.goto('/large-thumbnail-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Snagged' || t.startsWith('Snagged'))).toBeTruthy();
  });
});

test.describe('Functional - large_thumbnail_lined_svg', () => {
  test('large_thumbnail_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/large-thumbnail-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('large thumbnail');
  });
  test('large_thumbnail_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/large-thumbnail-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('large_thumbnail_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/large-thumbnail-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('large_thumbnail_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/large-thumbnail-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - layer_multiple_alt_filled_svg', () => {
  test('layer_multiple_alt_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/layer-multiple-alt-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('stacked panels alt');
  });
  test('layer_multiple_alt_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/layer-multiple-alt-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('layer_multiple_alt_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/layer-multiple-alt-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('layer_multiple_alt_filled_svg: h1 "Stacked Panels Alt - Filled"', async ({ page }) => {
    await page.goto('/layer-multiple-alt-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Stacked Panels Alt - Filled' || t.startsWith('Stacked Panels Alt - Filled'))).toBeTruthy();
  });
  test('layer_multiple_alt_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/layer-multiple-alt-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - layer_multiple_alt_lined_svg', () => {
  test('layer_multiple_alt_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/layer-multiple-alt-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('layered frames alt');
  });
  test('layer_multiple_alt_lined_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/layer-multiple-alt-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('layer_multiple_alt_lined_svg: h1 "Hold On"', async ({ page }) => {
    await page.goto('/layer-multiple-alt-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('layer_multiple_alt_lined_svg: h1 "Layered Frames Alt - Lined"', async ({ page }) => {
    await page.goto('/layer-multiple-alt-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Layered Frames Alt - Lined' || t.startsWith('Layered Frames Alt - Lined'))).toBeTruthy();
  });
  test('layer_multiple_alt_lined_svg: h2 "Grabbed"', async ({ page }) => {
    await page.goto('/layer-multiple-alt-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Grabbed' || t.startsWith('Grabbed'))).toBeTruthy();
  });
});

test.describe('Functional - layer_multiple_filled_svg', () => {
  test('layer_multiple_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/layer-multiple-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('stacked layers');
  });
  test('layer_multiple_filled_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/layer-multiple-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('layer_multiple_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/layer-multiple-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('layer_multiple_filled_svg: h1 "Stacked Layers - Filled"', async ({ page }) => {
    await page.goto('/layer-multiple-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Stacked Layers - Filled' || t.startsWith('Stacked Layers - Filled'))).toBeTruthy();
  });
  test('layer_multiple_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/layer-multiple-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - layer_multiple_lined_svg', () => {
  test('layer_multiple_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/layer-multiple-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('stacked layers');
  });
  test('layer_multiple_lined_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/layer-multiple-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('layer_multiple_lined_svg: h1 "Hold On"', async ({ page }) => {
    await page.goto('/layer-multiple-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('layer_multiple_lined_svg: h1 "Stacked Layers - Lined"', async ({ page }) => {
    await page.goto('/layer-multiple-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Stacked Layers - Lined' || t.startsWith('Stacked Layers - Lined'))).toBeTruthy();
  });
  test('layer_multiple_lined_svg: h2 "Copied!"', async ({ page }) => {
    await page.goto('/layer-multiple-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied!' || t.startsWith('Copied!'))).toBeTruthy();
  });
});

test.describe('Functional - layout_filled_svg', () => {
  test('layout_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/layout-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('layout');
  });
  test('layout_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/layout-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('layout_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/layout-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('layout_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/layout-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - legal', () => {
  test('legal: title matches GT', async ({ page }) => {
    await page.goto('/legal/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('legal notice');
  });
  test('legal: h1 "Notice"', async ({ page }) => {
    await page.goto('/legal/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('legal: h1 "Confirm"', async ({ page }) => {
    await page.goto('/legal/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('legal: h2 "Publisher"', async ({ page }) => {
    await page.goto('/legal/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Publisher' || t.startsWith('Publisher'))).toBeTruthy();
  });
});

test.describe('Functional - license', () => {
  test('license: title matches GT', async ({ page }) => {
    await page.goto('/license/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('license terms');
  });
  test('license: h1 "Heads up"', async ({ page }) => {
    await page.goto('/license/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('license: h1 "Confirm"', async ({ page }) => {
    await page.goto('/license/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('license: h1 "License Terms"', async ({ page }) => {
    await page.goto('/license/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'License Terms' || t.startsWith('License Terms'))).toBeTruthy();
  });
  test('license: h2 "1. Grant of Rights"', async ({ page }) => {
    await page.goto('/license/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === '1. Grant of Rights' || t.startsWith('1. Grant of Rights'))).toBeTruthy();
  });
});

test.describe('Functional - magnifier_dots_lined_svg', () => {
  test('magnifier_dots_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/magnifier-dots-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('magnifier dots');
  });
  test('magnifier_dots_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/magnifier-dots-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('magnifier_dots_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/magnifier-dots-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('magnifier_dots_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/magnifier-dots-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - magnifier_lined_svg', () => {
  test('magnifier_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/magnifier-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('magnifier');
  });
  test('magnifier_lined_svg: h1 "Heads Up"', async ({ page }) => {
    await page.goto('/magnifier-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads Up' || t.startsWith('Heads Up'))).toBeTruthy();
  });
  test('magnifier_lined_svg: h1 "Are You Sure?"', async ({ page }) => {
    await page.goto('/magnifier-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Are You Sure?' || t.startsWith('Are You Sure?'))).toBeTruthy();
  });
  test('magnifier_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/magnifier-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - magnifier_minus_lined_svg', () => {
  test('magnifier_minus_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/magnifier-minus-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('magnifier minus');
  });
  test('magnifier_minus_lined_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/magnifier-minus-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('magnifier_minus_lined_svg: h1 "Verify"', async ({ page }) => {
    await page.goto('/magnifier-minus-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('magnifier_minus_lined_svg: h2 "Copied!"', async ({ page }) => {
    await page.goto('/magnifier-minus-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied!' || t.startsWith('Copied!'))).toBeTruthy();
  });
});

test.describe('Functional - magnifier_plus_lined_svg', () => {
  test('magnifier_plus_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/magnifier-plus-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('search plus outline');
  });
  test('magnifier_plus_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/magnifier-plus-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('magnifier_plus_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/magnifier-plus-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('magnifier_plus_lined_svg: h1 "Search Plus - Outline"', async ({ page }) => {
    await page.goto('/magnifier-plus-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Search Plus - Outline' || t.startsWith('Search Plus - Outline'))).toBeTruthy();
  });
  test('magnifier_plus_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/magnifier-plus-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - magnifier_text_lined_svg', () => {
  test('magnifier_text_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/magnifier-text-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('magnifier text');
  });
  test('magnifier_text_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/magnifier-text-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('magnifier_text_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/magnifier-text-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('magnifier_text_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/magnifier-text-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - page_2', () => {
  test('page_2: title matches GT', async ({ page }) => {
    await page.goto('/page/2/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('glyphel');
  });
  test('page_2: h1 "Heads up"', async ({ page }) => {
    await page.goto('/page/2/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('page_2: h1 "Please confirm"', async ({ page }) => {
    await page.goto('/page/2/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Please confirm' || t.startsWith('Please confirm'))).toBeTruthy();
  });
  test('page_2: h1 "Fresh Symbols"', async ({ page }) => {
    await page.goto('/page/2/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Fresh Symbols' || t.startsWith('Fresh Symbols'))).toBeTruthy();
  });
  test('page_2: h2 "Page 2"', async ({ page }) => {
    await page.goto('/page/2/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Page 2' || t.startsWith('Page 2'))).toBeTruthy();
  });
  test('page_2: nav link "80"', async ({ page }) => {
    await page.goto('/page/2/');
    const links = page.locator('nav a');
    const texts = (await links.allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === '80' || t.startsWith('80')), 'link text in nav').toBeTruthy();
    const hrefs = await links.evaluateAll(els => els.map(e => (e.getAttribute('href') || '').toLowerCase()));
    expect(hrefs.some(h => h.includes('80')), 'href fragment present').toBeTruthy();
  });
});

test.describe('Functional - page_3', () => {
  test('page_3: title matches GT', async ({ page }) => {
    await page.goto('/page/3/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('glyphel');
  });
  test('page_3: h1 "Notice"', async ({ page }) => {
    await page.goto('/page/3/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('page_3: h1 "Confirm"', async ({ page }) => {
    await page.goto('/page/3/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('page_3: h1 "Latest Glyphel"', async ({ page }) => {
    await page.goto('/page/3/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Latest Glyphel' || t.startsWith('Latest Glyphel'))).toBeTruthy();
  });
  test('page_3: h2 "Page 3"', async ({ page }) => {
    await page.goto('/page/3/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Page 3' || t.startsWith('Page 3'))).toBeTruthy();
  });
  test('page_3: nav link "80"', async ({ page }) => {
    await page.goto('/page/3/');
    const links = page.locator('nav a');
    const texts = (await links.allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === '80' || t.startsWith('80')), 'link text in nav').toBeTruthy();
    const hrefs = await links.evaluateAll(els => els.map(e => (e.getAttribute('href') || '').toLowerCase()));
    expect(hrefs.some(h => h.includes('80')), 'href fragment present').toBeTruthy();
  });
});

test.describe('Functional - page_4', () => {
  test('page_4: title matches GT', async ({ page }) => {
    await page.goto('/page/4/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('glyphel');
  });
  test('page_4: h1 "Notice"', async ({ page }) => {
    await page.goto('/page/4/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('page_4: h1 "Confirm"', async ({ page }) => {
    await page.goto('/page/4/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('page_4: h1 "New Glyphs"', async ({ page }) => {
    await page.goto('/page/4/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'New Glyphs' || t.startsWith('New Glyphs'))).toBeTruthy();
  });
  test('page_4: h2 "Page 4"', async ({ page }) => {
    await page.goto('/page/4/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Page 4' || t.startsWith('Page 4'))).toBeTruthy();
  });
  test('page_4: nav link "80"', async ({ page }) => {
    await page.goto('/page/4/');
    const links = page.locator('nav a');
    const texts = (await links.allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === '80' || t.startsWith('80')), 'link text in nav').toBeTruthy();
    const hrefs = await links.evaluateAll(els => els.map(e => (e.getAttribute('href') || '').toLowerCase()));
    expect(hrefs.some(h => h.includes('80')), 'href fragment present').toBeTruthy();
  });
});

test.describe('Functional - page_80', () => {
  test('page_80: title matches GT', async ({ page }) => {
    await page.goto('/page/80/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('glyphel');
  });
  test('page_80: h1 "Heads up"', async ({ page }) => {
    await page.goto('/page/80/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('page_80: h1 "Confirm"', async ({ page }) => {
    await page.goto('/page/80/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('page_80: h1 "Fresh Symbols"', async ({ page }) => {
    await page.goto('/page/80/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Fresh Symbols' || t.startsWith('Fresh Symbols'))).toBeTruthy();
  });
  test('page_80: h2 "Page 80"', async ({ page }) => {
    await page.goto('/page/80/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Page 80' || t.startsWith('Page 80'))).toBeTruthy();
  });
  test('page_80: nav link "77"', async ({ page }) => {
    await page.goto('/page/80/');
    const links = page.locator('nav a');
    const texts = (await links.allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === '77' || t.startsWith('77')), 'link text in nav').toBeTruthy();
    const hrefs = await links.evaluateAll(els => els.map(e => (e.getAttribute('href') || '').toLowerCase()));
    expect(hrefs.some(h => h.includes('77')), 'href fragment present').toBeTruthy();
  });
  test('page_80: nav link "78"', async ({ page }) => {
    await page.goto('/page/80/');
    const links = page.locator('nav a');
    const texts = (await links.allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === '78' || t.startsWith('78')), 'link text in nav').toBeTruthy();
    const hrefs = await links.evaluateAll(els => els.map(e => (e.getAttribute('href') || '').toLowerCase()));
    expect(hrefs.some(h => h.includes('78')), 'href fragment present').toBeTruthy();
  });
  test('page_80: nav link "79"', async ({ page }) => {
    await page.goto('/page/80/');
    const links = page.locator('nav a');
    const texts = (await links.allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === '79' || t.startsWith('79')), 'link text in nav').toBeTruthy();
    const hrefs = await links.evaluateAll(els => els.map(e => (e.getAttribute('href') || '').toLowerCase()));
    expect(hrefs.some(h => h.includes('79')), 'href fragment present').toBeTruthy();
  });
});

test.describe('Functional - paste_clipboard_filled_svg', () => {
  test('paste_clipboard_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/paste-clipboard-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('paste clipboard');
  });
  test('paste_clipboard_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/paste-clipboard-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('paste_clipboard_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/paste-clipboard-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('paste_clipboard_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/paste-clipboard-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - paste_clipboard_lined_svg', () => {
  test('paste_clipboard_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/paste-clipboard-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('paste clipboard');
  });
  test('paste_clipboard_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/paste-clipboard-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('paste_clipboard_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/paste-clipboard-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('paste_clipboard_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/paste-clipboard-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - paste_filled_svg', () => {
  test('paste_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/paste-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('paste icon');
  });
  test('paste_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/paste-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('paste_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/paste-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('paste_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/paste-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - paste_lined_svg', () => {
  test('paste_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/paste-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('paste');
  });
  test('paste_lined_svg: h1 "Heads up"', async ({ page }) => {
    await page.goto('/paste-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('paste_lined_svg: h1 "Hold on"', async ({ page }) => {
    await page.goto('/paste-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('paste_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/paste-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - pencil_filled_svg', () => {
  test('pencil_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/pencil-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('marker');
  });
  test('pencil_filled_svg: h1 "Alert!"', async ({ page }) => {
    await page.goto('/pencil-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert!' || t.startsWith('Alert!'))).toBeTruthy();
  });
  test('pencil_filled_svg: h1 "Hold on"', async ({ page }) => {
    await page.goto('/pencil-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('pencil_filled_svg: h1 "Marker - Filled"', async ({ page }) => {
    await page.goto('/pencil-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Marker - Filled' || t.startsWith('Marker - Filled'))).toBeTruthy();
  });
  test('pencil_filled_svg: h2 "Grabbed"', async ({ page }) => {
    await page.goto('/pencil-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Grabbed' || t.startsWith('Grabbed'))).toBeTruthy();
  });
});

test.describe('Functional - pencil_line_filled_svg', () => {
  test('pencil_line_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/pencil-line-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('quill stroke');
  });
  test('pencil_line_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/pencil-line-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('pencil_line_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/pencil-line-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('pencil_line_filled_svg: h1 "Quill Stroke - Filled"', async ({ page }) => {
    await page.goto('/pencil-line-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Quill Stroke - Filled' || t.startsWith('Quill Stroke - Filled'))).toBeTruthy();
  });
  test('pencil_line_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/pencil-line-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - pencil_line_lined_svg', () => {
  test('pencil_line_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/pencil-line-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('pencil line');
  });
  test('pencil_line_lined_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/pencil-line-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('pencil_line_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/pencil-line-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('pencil_line_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/pencil-line-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - pencil_lined_svg', () => {
  test('pencil_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/pencil-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('pencil');
  });
  test('pencil_lined_svg: h1 "Heads-Up"', async ({ page }) => {
    await page.goto('/pencil-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads-Up' || t.startsWith('Heads-Up'))).toBeTruthy();
  });
  test('pencil_lined_svg: h1 "Hold On"', async ({ page }) => {
    await page.goto('/pencil-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('pencil_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/pencil-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - pencil_square_filled_svg', () => {
  test('pencil_square_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/pencil-square-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('pencil square');
  });
  test('pencil_square_filled_svg: h1 "Heads up"', async ({ page }) => {
    await page.goto('/pencil-square-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('pencil_square_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/pencil-square-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('pencil_square_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/pencil-square-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - pencil_square_lined_svg', () => {
  test('pencil_square_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/pencil-square-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('pencil square');
  });
  test('pencil_square_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/pencil-square-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('pencil_square_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/pencil-square-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('pencil_square_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/pencil-square-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - pencil_text_filled_svg', () => {
  test('pencil_text_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/pencil-text-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('pencil text');
  });
  test('pencil_text_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/pencil-text-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('pencil_text_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/pencil-text-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('pencil_text_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/pencil-text-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - pencil_text_lined_svg', () => {
  test('pencil_text_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/pencil-text-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('marker note');
  });
  test('pencil_text_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/pencil-text-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('pencil_text_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/pencil-text-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('pencil_text_lined_svg: h1 "Marker Note - Outline"', async ({ page }) => {
    await page.goto('/pencil-text-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Marker Note - Outline' || t.startsWith('Marker Note - Outline'))).toBeTruthy();
  });
  test('pencil_text_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/pencil-text-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - privacy', () => {
  test('privacy: title matches GT', async ({ page }) => {
    await page.goto('/privacy/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('privacy policy');
  });
  test('privacy: h1 "Notice"', async ({ page }) => {
    await page.goto('/privacy/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('privacy: h1 "Confirm"', async ({ page }) => {
    await page.goto('/privacy/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('privacy: h2 "1. Defining personal data"', async ({ page }) => {
    await page.goto('/privacy/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === '1. Defining personal data' || t.startsWith('1. Defining personal data'))).toBeTruthy();
  });
});

test.describe('Functional - quote_left_filled_svg', () => {
  test('quote_left_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/quote-left-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('quote left');
  });
  test('quote_left_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/quote-left-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('quote_left_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/quote-left-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('quote_left_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/quote-left-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - quote_left_lined_svg', () => {
  test('quote_left_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/quote-left-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('quote left');
  });
  test('quote_left_lined_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/quote-left-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('quote_left_lined_svg: h1 "Hold on"', async ({ page }) => {
    await page.goto('/quote-left-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('quote_left_lined_svg: h2 "Copied!"', async ({ page }) => {
    await page.goto('/quote-left-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied!' || t.startsWith('Copied!'))).toBeTruthy();
  });
});

test.describe('Functional - quote_right_filled_svg', () => {
  test('quote_right_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/quote-right-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('speech mark');
  });
  test('quote_right_filled_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/quote-right-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('quote_right_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/quote-right-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('quote_right_filled_svg: h1 "Speech Mark - Solid"', async ({ page }) => {
    await page.goto('/quote-right-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Speech Mark - Solid' || t.startsWith('Speech Mark - Solid'))).toBeTruthy();
  });
  test('quote_right_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/quote-right-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - quote_right_lined_svg', () => {
  test('quote_right_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/quote-right-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('quote right');
  });
  test('quote_right_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/quote-right-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('quote_right_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/quote-right-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('quote_right_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/quote-right-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - refresh_lined_svg', () => {
  test('refresh_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/refresh-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('refresh');
  });
  test('refresh_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/refresh-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('refresh_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/refresh-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('refresh_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/refresh-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - reload_alt_filled_svg', () => {
  test('reload_alt_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/reload-alt-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('reload alt');
  });
  test('reload_alt_filled_svg: h1 "Heads Up"', async ({ page }) => {
    await page.goto('/reload-alt-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads Up' || t.startsWith('Heads Up'))).toBeTruthy();
  });
  test('reload_alt_filled_svg: h1 "Hold On"', async ({ page }) => {
    await page.goto('/reload-alt-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('reload_alt_filled_svg: h2 "Copied!"', async ({ page }) => {
    await page.goto('/reload-alt-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied!' || t.startsWith('Copied!'))).toBeTruthy();
  });
});

test.describe('Functional - reload_lined_svg', () => {
  test('reload_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/reload-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('reload');
  });
  test('reload_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/reload-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('reload_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/reload-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('reload_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/reload-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - restore_lined_svg', () => {
  test('restore_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/restore-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('restore');
  });
  test('restore_lined_svg: h1 "Heads up"', async ({ page }) => {
    await page.goto('/restore-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Heads up' || t.startsWith('Heads up'))).toBeTruthy();
  });
  test('restore_lined_svg: h1 "Hold on"', async ({ page }) => {
    await page.goto('/restore-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('restore_lined_svg: h2 "Copied!"', async ({ page }) => {
    await page.goto('/restore-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied!' || t.startsWith('Copied!'))).toBeTruthy();
  });
});

test.describe('Functional - save_as_lined_svg', () => {
  test('save_as_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/save-as-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('save as');
  });
  test('save_as_lined_svg: h1 "Hold On"', async ({ page }) => {
    await page.goto('/save-as-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold On' || t.startsWith('Hold On'))).toBeTruthy();
  });
  test('save_as_lined_svg: h1 "Verify"', async ({ page }) => {
    await page.goto('/save-as-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Verify' || t.startsWith('Verify'))).toBeTruthy();
  });
  test('save_as_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/save-as-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - save_lined_svg', () => {
  test('save_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/save-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('save');
  });
  test('save_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/save-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('save_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/save-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('save_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/save-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - sync_check_lined_svg', () => {
  test('sync_check_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/sync-check-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('loop check');
  });
  test('sync_check_lined_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/sync-check-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('sync_check_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/sync-check-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('sync_check_lined_svg: h1 "Loop Check - Lined"', async ({ page }) => {
    await page.goto('/sync-check-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Loop Check - Lined' || t.startsWith('Loop Check - Lined'))).toBeTruthy();
  });
  test('sync_check_lined_svg: h2 "Copied!"', async ({ page }) => {
    await page.goto('/sync-check-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied!' || t.startsWith('Copied!'))).toBeTruthy();
  });
});

test.describe('Functional - sync_exclamation_lined_svg', () => {
  test('sync_exclamation_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/sync-exclamation-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('refresh alert lined');
  });
  test('sync_exclamation_lined_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/sync-exclamation-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('sync_exclamation_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/sync-exclamation-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('sync_exclamation_lined_svg: h1 "Refresh Alert - Lined"', async ({ page }) => {
    await page.goto('/sync-exclamation-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Refresh Alert - Lined' || t.startsWith('Refresh Alert - Lined'))).toBeTruthy();
  });
  test('sync_exclamation_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/sync-exclamation-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - sync_lined_svg', () => {
  test('sync_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/sync-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('sync');
  });
  test('sync_lined_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/sync-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('sync_lined_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/sync-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('sync_lined_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/sync-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - trash_can_filled_svg', () => {
  test('trash_can_filled_svg: title matches GT', async ({ page }) => {
    await page.goto('/trash-can-filled-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('trash can');
  });
  test('trash_can_filled_svg: h1 "Notice"', async ({ page }) => {
    await page.goto('/trash-can-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('trash_can_filled_svg: h1 "Confirm"', async ({ page }) => {
    await page.goto('/trash-can-filled-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
  test('trash_can_filled_svg: h2 "Copied"', async ({ page }) => {
    await page.goto('/trash-can-filled-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Copied' || t.startsWith('Copied'))).toBeTruthy();
  });
});

test.describe('Functional - trash_can_lined_svg', () => {
  test('trash_can_lined_svg: title matches GT', async ({ page }) => {
    await page.goto('/trash-can-lined-svg/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('waste bin');
  });
  test('trash_can_lined_svg: h1 "Alert"', async ({ page }) => {
    await page.goto('/trash-can-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Alert' || t.startsWith('Alert'))).toBeTruthy();
  });
  test('trash_can_lined_svg: h1 "Hold on"', async ({ page }) => {
    await page.goto('/trash-can-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Hold on' || t.startsWith('Hold on'))).toBeTruthy();
  });
  test('trash_can_lined_svg: h1 "Waste Bin - Lined"', async ({ page }) => {
    await page.goto('/trash-can-lined-svg/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Waste Bin - Lined' || t.startsWith('Waste Bin - Lined'))).toBeTruthy();
  });
  test('trash_can_lined_svg: h2 "All set"', async ({ page }) => {
    await page.goto('/trash-can-lined-svg/');
    const texts = (await page.locator('h2').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'All set' || t.startsWith('All set'))).toBeTruthy();
  });
});

test.describe('Functional - logo', () => {
  test('logo: title matches GT', async ({ page }) => {
    await page.goto('/logo/');
    const t = (await page.title()).toLowerCase();
    expect(t).toContain('logos');
  });
  test('logo: h1 "Notice"', async ({ page }) => {
    await page.goto('/logo/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Notice' || t.startsWith('Notice'))).toBeTruthy();
  });
  test('logo: h1 "Confirm"', async ({ page }) => {
    await page.goto('/logo/');
    const texts = (await page.locator('h1').allTextContents()).map(s => s.replace(/\s+/g, ' ').trim());
    expect(texts.some(t => t === 'Confirm' || t.startsWith('Confirm'))).toBeTruthy();
  });
});

test.describe('Functional - Routing', () => {
  test('navigate to about via "Story"', async ({ page }) => {
    await page.goto('/');
    const link = page.locator('a[href*="about"]').first();
    expect(await link.count(), 'nav link to about exists').toBeGreaterThan(0);
    await link.click();
    await page.waitForTimeout(1200);
    expect(page.url().toLowerCase(), 'URL changed to destination').toContain('about');
    const bodyText = (await page.evaluate(() => document.body.innerText)).replace(/\s+/g, ' ');
    expect(bodyText, 'destination distinctive content shown').toContain('Notice');
  });
  test('navigate to license via "License"', async ({ page }) => {
    await page.goto('/');
    const link = page.locator('a[href*="license"]').first();
    expect(await link.count(), 'nav link to license exists').toBeGreaterThan(0);
    await link.click();
    await page.waitForTimeout(1200);
    expect(page.url().toLowerCase(), 'URL changed to destination').toContain('license');
    const bodyText = (await page.evaluate(() => document.body.innerText)).replace(/\s+/g, ' ');
    expect(bodyText, 'destination distinctive content shown').toContain('Heads up');
  });
  test('navigate to privacy via "Privacy"', async ({ page }) => {
    await page.goto('/');
    const link = page.locator('a[href*="privacy"]').first();
    expect(await link.count(), 'nav link to privacy exists').toBeGreaterThan(0);
    await link.click();
    await page.waitForTimeout(1200);
    expect(page.url().toLowerCase(), 'URL changed to destination').toContain('privacy');
    const bodyText = (await page.evaluate(() => document.body.innerText)).replace(/\s+/g, ' ');
    expect(bodyText, 'destination distinctive content shown').toContain('Notice');
  });
});