kempo-testing-framework 1.1.0

package/tests/collapsible.browser-test.js

@@ -0,0 +1,49 @@
+// Browser tests for Collapsible component
+
+const nextTick = () => new Promise(r => setTimeout(r));
+
+export const beforeEach = async () => {
+  document.body.innerHTML = '';
+  try { localStorage.removeItem('ktf_settings'); } catch {}
+};
+
+export default {
+  'Collapsible toggles content visibility': async ({ pass, fail, log }) => {
+    try {
+      await import('/gui/components/Collapsible.js');
+      const el = document.createElement('ktf-collapsible');
+      el.appendChild(document.createElement('div')).textContent = 'Content';
+      document.body.appendChild(el);
+      await nextTick();
+      const btn = el.shadowRoot.querySelector('button.title');
+      const openedBefore = el.hasAttribute('opened') || el.opened;
+      const hasSlotBefore = !!el.shadowRoot.querySelector('div.bt');
+    log(`Before toggle — opened:${openedBefore} slot:${hasSlotBefore}`);
+      btn.click();
+      await nextTick();
+      const openedAfter = el.opened === true;
+      const hasSlotAfter = !!el.shadowRoot.querySelector('div.bt');
+    log(`After toggle — opened:${openedAfter} slot:${hasSlotAfter}`);
+    if (!openedBefore && !hasSlotBefore && openedAfter && hasSlotAfter) pass('Collapsible opened and revealed slotted content');
+    else fail('Collapsible did not toggle as expected');
+    } catch (e) { fail(e.stack || String(e)); }
+  },
+
+  'Collapsible respects opened attribute and can close': async ({ pass, fail, log }) => {
+    try {
+      await import('/gui/components/Collapsible.js');
+      const el = document.createElement('ktf-collapsible');
+      el.setAttribute('opened', '');
+      el.appendChild(document.createElement('div')).textContent = 'Content';
+      document.body.appendChild(el);
+      await nextTick();
+      const btn = el.shadowRoot.querySelector('button.title');
+      const initiallyOpen = el.opened === true;
+    log(`Initially open:${initiallyOpen}`);
+      btn.click();
+      await nextTick();
+      const afterClose = el.opened === false;
+    if (initiallyOpen && afterClose) pass('Opened attribute respected and component can close'); else fail('opened attribute not respected or cannot close');
+    } catch (e) { fail(e.stack || String(e)); }
+  }
+};

package/tests/counter.browser-test.js

@@ -0,0 +1,141 @@
+import './Counter.js';
+
+const wait = ms => new Promise(r=>setTimeout(r,ms));
+
+export const beforeAll = (log) => {
+  log('Setting up browser test environment for Counter component');
+}
+
+export const beforeEach = (log) => {
+  log('Setting up test fixture - creating counter element');
+  const $counter = document.createElement('my-counter');
+  $counter.id = 'test-counter';
+  document.body.appendChild($counter);
+}
+
+export const afterEach = (log) => {
+  log('Cleaning up - removing counter element');
+  const $counter = document.getElementById('test-counter');
+  if ($counter) {
+    $counter.remove();
+  }
+}
+
+export const afterAll = (log) => {
+  log('Cleaning up browser test environment');
+}
+
+export default {
+  'Counter component should be defined': ({pass, fail, log}) => {
+    log('Checking if my-counter element is defined');
+    if (window.customElements.get('my-counter')) {
+      pass('Counter component is properly registered');
+    } else {
+      fail('Counter component is not registered as a custom element');
+    }
+  },
+  
+  'Counter should render with initial count of 0': ({pass, fail, log}) => {
+    const $counter = document.getElementById('test-counter');
+    log('Checking initial counter value');
+    
+    if (!$counter) {
+      fail('Counter element not found');
+      return;
+    }
+    
+    // Check shadow DOM content
+    const countDisplay = $counter.shadowRoot.querySelector('div');
+    if (countDisplay && countDisplay.textContent.includes('Count: 0')) {
+      pass('Counter initializes with count of 0');
+    } else {
+      fail(`Counter does not show the expected initial value. Found: ${countDisplay?.textContent}`);
+    }
+  },
+  
+  'Counter should increment when clicked': async ({pass, fail, log}) => {
+    const counter = document.getElementById('test-counter');
+    log('Testing click increment functionality');
+    
+    if (!counter) {
+      fail('Counter element not found');
+      return;
+    }
+    
+    const button = counter.shadowRoot.querySelector('button');
+    
+    // Initial state check
+    let countDisplay = counter.shadowRoot.querySelector('div');
+    const initialText = countDisplay.textContent;
+    log(`Initial state: ${initialText}`);
+    
+    // Trigger click event
+    button.click();
+    
+    // Check updated state
+    countDisplay = counter.shadowRoot.querySelector('div');
+    const updatedText = countDisplay.textContent;
+    log(`After click: ${updatedText}`);
+    
+    if (updatedText.includes('Count: 1')) {
+      pass('Counter successfully incremented to 1 after click');
+    } else {
+      fail(`Counter did not increment properly. Expected 'Count: 1' but found '${updatedText}'`);
+    }
+  },
+  
+  'Counter should increment multiple times': async ({pass, fail, log}) => {
+    const counter = document.getElementById('test-counter');
+    log('Testing multiple increments');
+    
+    if (!counter) {
+      fail('Counter element not found');
+      return;
+    }
+    
+    const button = counter.shadowRoot.querySelector('button');
+    
+    // Simply click the button multiple times
+    for (let i = 0; i < 3; i++) {
+      button.click();
+      await wait(100);
+      log(`After click ${i+1}, counter shows: ${counter.shadowRoot.querySelector('div').textContent}`);
+    }
+    
+    const countDisplay = counter.shadowRoot.querySelector('div');
+    const countText = countDisplay.textContent;
+    
+    if (countText.includes('Count: 3')) {
+      pass('Counter successfully incremented multiple times to 3');
+    } else {
+      fail(`Counter did not increment correctly after multiple clicks. Expected 'Count: 3' but found '${countText}'`);
+    }
+  },
+  
+  'Counter should maintain internal state': ({pass, fail, log}) => {
+    const counter = document.getElementById('test-counter');
+    log('Testing internal state management');
+    
+    if (!counter) {
+      fail('Counter element not found');
+      return;
+    }
+    
+    // Check initial internal state
+    if (counter.count === 0) {
+      // Manually update the internal state
+      counter.count = 42;
+      counter.render();
+      
+      // Verify the rendered output matches the internal state
+      const countDisplay = counter.shadowRoot.querySelector('div');
+      if (countDisplay.textContent.includes('Count: 42')) {
+        pass('Counter maintains and displays internal state correctly');
+      } else {
+        fail(`Counter does not display the expected state. Expected 'Count: 42' but found '${countDisplay.textContent}'`);
+      }
+    } else {
+      fail(`Initial counter state is not 0, found: ${counter.count}`);
+    }
+  }
+};

package/tests/example.node-test.js

@@ -0,0 +1,103 @@
+// Example Node test file for Kempo Testing Framework
+// This demonstrates the basic structure and features
+
+/* Export the optional lifecycle callbacks */
+export const beforeAll = async (log) => {
+  log('Setting up Node test environment...');
+  // Setup that runs once before all tests
+}
+
+export const beforeEach = async (log) => {
+  log('Setting up for each test');
+  // Setup that runs before each individual test
+}
+
+export const afterEach = async (log) => {
+  log('Cleaning up after each test');
+  // Cleanup that runs after each individual test
+}
+
+export const afterAll = async (log) => {
+  log('Cleaning up Node test environment...');
+  // Cleanup that runs once after all tests
+}
+
+/* Export the Tests */
+export default {
+  'should handle basic string operations': async ({pass, fail, log}) => {
+    const input = 'hello world';
+    const expected = 'HELLO WORLD';
+    const result = input.toUpperCase();
+    
+    log(`Testing string conversion: "${input}" -> "${result}"`);
+    
+    if (result === expected) {
+      log('✓ String conversion works correctly');
+      pass('String uppercase conversion test passed');
+    } else {
+      fail(`Expected "${expected}", got "${result}"`);
+    }
+  },
+
+  'should validate array operations': async ({pass, fail, log}) => {
+    const numbers = [1, 2, 3, 4, 5];
+    const doubled = numbers.map(n => n * 2);
+    const expected = [2, 4, 6, 8, 10];
+    
+    log(`Testing array mapping: [${numbers}] -> [${doubled}]`);
+    
+    if (JSON.stringify(doubled) === JSON.stringify(expected)) {
+      log('✓ Array mapping works correctly');
+      pass('Array mapping test passed');
+    } else {
+      fail(`Expected [${expected}], got [${doubled}]`);
+    }
+  },
+
+  'should handle async operations': async ({pass, fail, log}) => {
+    log('Testing async operation...');
+    
+    const delay = (ms) => new Promise(resolve => setTimeout(resolve, ms));
+    const start = Date.now();
+    
+    await delay(100);
+    
+    const elapsed = Date.now() - start;
+    log(`Async delay completed in ${elapsed}ms`);
+    
+    if (elapsed >= 100 && elapsed < 200) {
+      log('✓ Async operation timing is correct');
+      pass('Async operation test passed');
+    } else {
+      fail(`Expected delay of ~100ms, got ${elapsed}ms`);
+    }
+  },
+
+  'should handle error conditions': async ({pass, fail, log}) => {
+    log('Testing error handling...');
+    
+    try {
+      JSON.parse('invalid json');
+      fail('Should have thrown an error for invalid JSON');
+    } catch (error) {
+      log(`✓ Caught expected error: ${error.message}`);
+      pass('Error handling test passed');
+    }
+  },
+
+  'should work with Node.js specific features': async ({pass, fail, log}) => {
+    // Test Node.js specific functionality
+    const process_exists = typeof process !== 'undefined';
+    const has_global = typeof global !== 'undefined';
+    
+    log(`Process object exists: ${process_exists}`);
+    log(`Global object available: ${has_global}`);
+    
+    if (process_exists && has_global) {
+      log('✓ Node.js environment detected correctly');
+      pass('Node.js environment test passed');
+    } else {
+      fail('Node.js environment features not available');
+    }
+  }
+};

package/tests/icon.browser-test.js

@@ -0,0 +1,54 @@
+// Browser tests for Icon component
+
+const nextTick = () => new Promise(r => setTimeout(r));
+
+export const beforeEach = async () => {
+  document.body.innerHTML = '';
+  try { localStorage.removeItem('ktf_settings'); } catch {}
+};
+
+export default {
+  'Icon loads via fetch and caches results': async ({ pass, fail, log }) => {
+    try {
+      await import('/gui/components/Icon.js');
+      const originalFetch = window.fetch;
+      let calls = 0;
+      window.fetch = async (url) => {
+        calls++;
+        if (String(url).endsWith('/icons/test.svg')) {
+          return { ok: true, text: async () => '<svg><g id="ok"/></svg>' };
+        }
+        return { ok: false, text: async () => '' };
+      };
+      const a = document.createElement('ktf-icon');
+      a.name = 'test';
+      document.body.appendChild(a);
+      await nextTick(); await nextTick();
+      const firstLoaded = a.shadowRoot.innerHTML.includes('id="ok"');
+    log(`Network calls after first icon: ${calls}`);
+      window.fetch = async () => { throw new Error('blocked'); };
+      const b = document.createElement('ktf-icon');
+      b.name = 'test';
+      document.body.appendChild(b);
+      await nextTick(); await nextTick();
+      const secondLoaded = b.shadowRoot.innerHTML.includes('id="ok"');
+      window.fetch = originalFetch;
+    if (firstLoaded && secondLoaded) pass('Icon fetched once and loaded cached SVG subsequently'); else fail('Icon did not cache/fetch as expected');
+    } catch (e) { fail(e.stack || String(e)); }
+  },
+
+  'Icon falls back when fetch fails': async ({ pass, fail }) => {
+    try {
+      await import('/gui/components/Icon.js');
+      const originalFetch = window.fetch;
+      window.fetch = async () => ({ ok: false, text: async () => '' });
+      const a = document.createElement('ktf-icon');
+      a.name = 'does-not-exist';
+      document.body.appendChild(a);
+      await nextTick(); await nextTick();
+      const hasSvg = a.shadowRoot.innerHTML.includes('<svg');
+      window.fetch = originalFetch;
+    if (hasSvg) pass('Fallback SVG rendered when fetch failed'); else fail('Fallback SVG missing when fetch failed');
+    } catch (e) { fail(e.stack || String(e)); }
+  }
+};

package/tests/logs.browser-test.js

@@ -0,0 +1,47 @@
+// Browser tests for Logs component
+
+const nextTick = () => new Promise(r => setTimeout(r));
+
+export const beforeEach = async () => {
+  document.body.innerHTML = '';
+  try { localStorage.removeItem('ktf_settings'); } catch {}
+};
+
+export default {
+  'Logs filters by level and reacts to settings changes': async ({ pass, fail, log }) => {
+    try {
+      const { set: setSettings } = (await import('/gui/components/settingsStore.js')).default?.KTF_SETTINGS || window.KTF_SETTINGS || { set: () => {} };
+      await import('/gui/components/Logs.js');
+      const logs = document.createElement('ktf-logs');
+      document.body.appendChild(logs);
+      await nextTick();
+      logs.addLog({ message: 'L0', level: 0 }, { message: 'L2', level: 2 }, { message: 'L4', level: 4 });
+      await nextTick();
+      const text1 = logs.shadowRoot.textContent;
+      const cond1 = text1.includes('L0') && text1.includes('L2') && !text1.includes('L4');
+    log(`Initial filter text: ${text1.replace(/\s+/g,' ').trim()}`);
+      window.KTF_SETTINGS.set({ logLevel: 4 });
+      await nextTick();
+      const text2 = logs.shadowRoot.textContent;
+      const cond2 = text2.includes('L4');
+    if (cond1 && cond2) pass('Logs filtered by level and reacted to settings change'); else fail('Filtering by level or settings reaction failed');
+    } catch (e) { fail(e.stack || String(e)); }
+  },
+
+  'Logs clear removes previous entries': async ({ pass, fail, log }) => {
+    try {
+      await import('/gui/components/Logs.js');
+      const logs = document.createElement('ktf-logs');
+      document.body.appendChild(logs);
+      await nextTick();
+      logs.addLog({ message: 'A', level: 2 }, { message: 'B', level: 2 });
+      await nextTick();
+      const before = logs.shadowRoot.textContent.includes('A') && logs.shadowRoot.textContent.includes('B');
+      logs.clear();
+      await nextTick();
+      const after = logs.shadowRoot.textContent.trim().length === 0 || !logs.shadowRoot.textContent.includes('A');
+    log(`Before clear contained A/B: ${before}, after clear emptyish: ${after}`);
+    if (before && after) pass('Logs.clear() removed previous entries'); else fail('clear did not remove entries');
+    } catch (e) { fail(e.stack || String(e)); }
+  }
+};

package/tests/setting-checkbox.browser-test.js

@@ -0,0 +1,48 @@
+// Browser tests for SettingCheckbox component
+
+const nextTick = () => new Promise(r => setTimeout(r));
+
+export const beforeEach = async () => {
+  document.body.innerHTML = '';
+  try { localStorage.removeItem('ktf_settings'); } catch {}
+};
+
+export default {
+  'SettingCheckbox reflects and updates settings': async ({ pass, fail, log }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/SettingCheckbox.js');
+      window.KTF_SETTINGS.set({ showBrowser: false });
+      const el = document.createElement('ktf-setting-checkbox');
+      el.name = 'showBrowser';
+      el.label = 'Show Browser';
+      document.body.appendChild(el);
+      await nextTick();
+      const input = el.querySelector('input[type="checkbox"]');
+    const before = input.checked === false;
+      input.checked = true; input.dispatchEvent(new Event('change'));
+      await nextTick();
+      const after = window.KTF_SETTINGS.get().showBrowser === true;
+    log(`Checkbox before:${before} after:${after}`);
+    if (before && after) pass('SettingCheckbox updated setting from false to true'); else fail('SettingCheckbox did not update setting');
+    } catch (e) { fail(e.stack || String(e)); }
+  },
+
+  'SettingCheckbox unchecks updates back to false': async ({ pass, fail, log }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/SettingCheckbox.js');
+      window.KTF_SETTINGS.set({ showBrowser: true });
+      const el = document.createElement('ktf-setting-checkbox');
+      el.name = 'showBrowser';
+      document.body.appendChild(el);
+      await nextTick();
+      const input = el.querySelector('input[type="checkbox"]');
+      input.checked = false; input.dispatchEvent(new Event('change'));
+      await nextTick();
+      const after = window.KTF_SETTINGS.get().showBrowser === false;
+    log(`Setting after uncheck:${after}`);
+    if (after) pass('SettingCheckbox updated setting back to false'); else fail('Uncheck did not update setting');
+    } catch (e) { fail(e.stack || String(e)); }
+  }
+};

package/tests/setting-number.browser-test.js

@@ -0,0 +1,54 @@
+// Browser tests for SettingNumber component
+
+const nextTick = () => new Promise(r => setTimeout(r));
+
+export const beforeEach = async () => {
+  document.body.innerHTML = '';
+  try { localStorage.removeItem('ktf_settings'); } catch {}
+};
+
+export default {
+  'SettingNumber reflects and updates settings with clamping': async ({ pass, fail, log }) => {
+    try {
+      const store = await import('/gui/components/settingsStore.js');
+      await import('/gui/components/SettingNumber.js');
+      store.setSettings({ delayMs: 500 });
+      const el = document.createElement('ktf-setting-number');
+      el.name = 'delayMs';
+      el.label = 'Delay';
+      el.min = 0; el.max = 1000; el.step = 100; el.suffix = 'ms';
+      document.body.appendChild(el);
+      await nextTick();
+      const input = el.querySelector('input[type="number"]');
+      const before = String(input.value) === '500';
+      input.value = '1200'; input.dispatchEvent(new Event('change'));
+      await nextTick();
+      const clamped = store.getSettings().delayMs === 1000;
+      input.value = 'abc'; input.dispatchEvent(new Event('change'));
+      await nextTick();
+      const nanToZero = store.getSettings().delayMs === 0;
+      log(`before:${before} clamped:${clamped} nanToZero:${nanToZero}`);
+      if (before && clamped && nanToZero) pass('SettingNumber reflected, clamped, and sanitized values');
+      else fail('SettingNumber did not reflect/clamp/sanitize as expected');
+    } catch (e) { fail(e.stack || String(e)); }
+  },
+
+  'SettingNumber input syncs when settings change externally': async ({ pass, fail }) => {
+    try {
+      const store = await import('/gui/components/settingsStore.js');
+      await import('/gui/components/SettingNumber.js');
+      store.setSettings({ delayMs: 0 });
+      const el = document.createElement('ktf-setting-number');
+      el.name = 'delayMs';
+      document.body.appendChild(el);
+      await nextTick();
+      const input = el.querySelector('input[type="number"]');
+      const initial = String(input.value) === '0';
+      store.setSettings({ delayMs: 250 });
+      await nextTick();
+      const updated = String(input.value) === '250';
+      if (initial && updated) pass('SettingNumber stayed in sync with external setting change');
+      else fail('SettingNumber did not sync input after settings change');
+    } catch (e) { fail(e.stack || String(e)); }
+  }
+};

package/tests/setting-select.browser-test.js

@@ -0,0 +1,47 @@
+// Browser tests for SettingSelect component
+
+const nextTick = () => new Promise(r => setTimeout(r));
+
+export const beforeEach = async () => {
+  document.body.innerHTML = '';
+  try { localStorage.removeItem('ktf_settings'); } catch {}
+};
+
+export default {
+  'SettingSelect reflects and updates settings': async ({ pass, fail, log }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/SettingSelect.js');
+      window.KTF_SETTINGS.set({ logLevel: 2 });
+      const el = document.createElement('ktf-setting-select');
+      el.name = 'logLevel';
+      el.label = 'Log Level';
+      document.body.appendChild(el);
+      await nextTick();
+      const select = el.querySelector('select');
+      const before = String(select.value) === '2';
+      select.value = '1'; select.dispatchEvent(new Event('change'));
+      await nextTick();
+      const after = window.KTF_SETTINGS.get().logLevel === 1;
+    log(`Select value before:${before} after:${after}`);
+    if (before && after) pass('SettingSelect updated setting from 2 to 1'); else fail('SettingSelect did not update setting');
+    } catch (e) { fail(e.stack || String(e)); }
+  },
+
+  'SettingSelect stays in sync when settings change externally': async ({ pass, fail }) => {
+    try {
+      await import('/gui/components/settingsStore.js');
+      await import('/gui/components/SettingSelect.js');
+      window.KTF_SETTINGS.set({ logLevel: 1 });
+      const el = document.createElement('ktf-setting-select');
+      el.name = 'logLevel';
+      document.body.appendChild(el);
+      await nextTick();
+      const select = el.querySelector('select');
+      window.KTF_SETTINGS.set({ logLevel: 4 });
+      await nextTick();
+      const synced = String(select.value) === '4';
+    if (synced) pass('SettingSelect synced after external settings change'); else fail('Select did not sync after external change');
+    } catch (e) { fail(e.stack || String(e)); }
+  }
+};

package/tests/settings-store.browser-test.js

@@ -0,0 +1,26 @@
+// Browser tests for settingsStore helpers
+
+const nextTick = () => new Promise(r => setTimeout(r));
+
+export const beforeEach = async () => {
+  document.body.innerHTML = '';
+  try { localStorage.removeItem('ktf_settings'); } catch {}
+};
+
+export default {
+  'settingsStore get/set persists to localStorage and dispatches event': async ({ pass, fail }) => {
+    try {
+      const store = await import('/gui/components/settingsStore.js');
+      const before = store.getSettings();
+      const p = new Promise(resolve => {
+        const unsub = store.subscribe((s) => { unsub(); resolve(s); });
+      });
+      store.setSettings({ theme: 'dark', logLevel: 4 });
+      const evtState = await p;
+      const raw = localStorage.getItem('ktf_settings');
+      const parsed = JSON.parse(raw || '{}');
+      const ok = evtState.theme === 'dark' && evtState.logLevel === 4 && parsed.theme === 'dark' && parsed.logLevel === 4;
+      ok ? pass('settingsStore persisted and dispatched change event') : fail(`state:${JSON.stringify(evtState)} raw:${raw}`);
+    } catch (e) { fail(e.stack || String(e)); }
+  }
+};

package/tests/src-browserTestServer.node-test.js

@@ -0,0 +1,47 @@
+import http from 'http';
+import { startServer, stopServer } from '../src/browserTestServer.js';
+
+const get = (port, path) => new Promise((resolve, reject) => {
+  const req = http.request({ hostname: 'localhost', port, path, method: 'GET' }, (res) => {
+    let data = '';
+    res.on('data', chunk => { data += chunk.toString(); });
+    res.on('end', () => resolve({ status: res.statusCode, body: data }));
+  });
+  req.on('error', reject);
+  req.end();
+});
+
+export default {
+  'serves index html at /': async ({ pass, fail, log }) => {
+    const port = 3101;
+    try {
+      const url = await startServer(port);
+      const { status, body } = await get(port, '/');
+    log(`GET / -> ${status}`);
+    if (status === 200 && /<title>Test<\/title>/.test(body)) pass('Browser test server served index.html');
+    else fail(`Bad response from /: status=${status} body=${body?.slice(0,80)}`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    } finally {
+      await stopServer();
+    }
+  },
+  'serves test runner script and static files, 404s missing': async ({ pass, fail, log }) => {
+    const port = 3101;
+    try {
+      await startServer(port);
+      const a = await get(port, '/runTests.js');
+      const b = await get(port, '/tests/counter.browser-test.js');
+      const c = await get(port, '/does-not-exist.js');
+    log(`Statuses: /runTests.js=${a.status} /tests/counter.browser-test.js=${b.status} /does-not-exist.js=${c.status}`);
+      const ok = a.status === 200 && /export default|const wait/.test(a.body)
+        && b.status === 200 && /Counter component/.test(b.body)
+        && c.status === 404;
+    ok ? pass('Static and test files served; missing files 404 as expected') : fail(`Unexpected statuses: a=${a.status}, b=${b.status}, c=${c.status}`);
+    } catch (e) {
+      fail(e.stack || String(e));
+    } finally {
+      await stopServer();
+    }
+  }
+};

package/tests/src-cli.node-test.js

@@ -0,0 +1,32 @@
+import { spawn } from 'child_process';
+
+const stripAnsi = (s) => s.replace(/\x1b\[[0-9;]*m/g, '');
+
+const run = (args, timeoutMs = 10000) => new Promise((resolve) => {
+  const child = spawn(process.execPath, ['index.js', ...args], {
+    cwd: process.cwd(),
+    stdio: ['ignore', 'pipe', 'pipe']
+  });
+  let out = '';
+  const finish = () => { try { child.kill('SIGTERM'); } catch {} resolve(out); };
+  child.stdout.on('data', c => { out += c.toString(); });
+  child.stderr.on('data', c => { out += c.toString(); });
+  child.on('exit', finish);
+  setTimeout(finish, timeoutMs);
+});
+
+export default {
+  'passes delay to browser runner and prints delay logs in verbose': async ({ pass, fail }) => {
+    const out = await run(['-b', '-w', '-l', 'verbose', '-d', '200', 'counter']);
+    const txt = stripAnsi(out);
+    const ok = /Applying pre-test browser delay: 200ms/.test(txt) && /Applying post-test browser delay: 200ms/.test(txt);
+  ok ? pass('CLI printed verbose delay logs for browser run') : fail(`Unexpected CLI output:\n${out}`);
+  },
+  'node-only ignores delay and still runs filtered tests': async ({ pass, fail }) => {
+    const out = await run(['-n', '-l', 'minimal', 'example']);
+    const txt = stripAnsi(out);
+    const hasSummary = /=== Test Summary ===/.test(txt) && /Total Tests:\s*\d+/.test(txt);
+    const noBrowser = !/=== Browser Test Results ===/.test(txt) && !/Running Browser test:/.test(txt);
+  hasSummary && noBrowser ? pass('Node-only run produced summary without browser section') : fail(`Unexpected CLI output:\n${out}`);
+  }
+};