kempo-testing-framework 1.2.1 → 1.2.3

package/gui/components/SettingCheckbox.js

@@ -35,7 +35,7 @@ window.customElements.define('ktf-setting-checkbox', class extends LitElement {
     return html`
       <div class="d-f mb" style="align-items: center">
         <input id="${id}" type="checkbox" style="font-size: 1.35rem" .checked=${!!this.checked} @change=${(e) => this.onChange(e)} />
-        <label for="${id}" style="line-height: 1.35rem">${this.label || ''}</label>
+        <label for="${id}" style="line-height: 1.35rem" class="pb0">${this.label || ''}</label>
       </div>
     `;
   }

package/gui/components/TestFramework.js

@@ -151,6 +151,8 @@ class TestFrameworkEl extends LitElement {
   };
 
   runSuite = async ({ file, testNames, el }) => {
+    const isUniversal = el.hasAttribute('universal');
+    
     try {
       el.status = 'running';
   const tests = Array.from(el.querySelectorAll('ktf-test'));
@@ -162,7 +164,147 @@ class TestFrameworkEl extends LitElement {
       const fileLogsEl = el.renderRoot?.getElementById('fileLogs');
       if(fileLogsEl) fileLogsEl.clear();
     } catch {}
+    
     const { showBrowser, delayMs } = getSettings();
+    
+    // For universal tests, run both environments
+    if (isUniversal && file.endsWith('.test.js')) {
+      try {
+        // Run both Node and Browser tests
+        const [nodeResp, browserResp] = await Promise.all([
+          fetch(`/runTest?testFile=${encodeURIComponent(file)}&environment=node&showBrowser=false&delayMs=${Number(delayMs||0)}`),
+          fetch(`/runTest?testFile=${encodeURIComponent(file)}&environment=browser&showBrowser=${!!showBrowser}&delayMs=${Number(delayMs||0)}`)
+        ]);
+        
+        let nodeData = null, browserData = null;
+        try { nodeData = await nodeResp.json(); } catch {}
+        try { browserData = await browserResp.json(); } catch {}
+        
+        const fileLogsEl = el.renderRoot?.getElementById('fileLogs');
+        const heading = msg => ({ message: msg, type: 'progress', level: 3 });
+        
+        // Combine results from both environments
+        let combinedResults = { tests: {}, beforeAllLogs: [], afterAllLogs: [] };
+        let hasErrors = false;
+        
+        if (!nodeResp.ok || (nodeData && nodeData.error)) {
+          hasErrors = true;
+          const msg = nodeData?.details || nodeData?.error || `Node: ${nodeResp.status} ${nodeResp.statusText}`;
+          if (fileLogsEl) fileLogsEl.addLog({ message: `Error running Node tests: ${msg}`, type: 'error', level: 3 });
+        } else {
+          const nodeResults = nodeData?.results || {};
+          if (fileLogsEl && nodeResults.beforeAllLogs?.length) {
+            fileLogsEl.addLog(heading('== Node Before All Logs =='), ...nodeResults.beforeAllLogs);
+          }
+          // Merge node test results with 'Node: ' prefix
+          Object.entries(nodeResults.tests || {}).forEach(([testName, testInfo]) => {
+            combinedResults.tests[testName] = {
+              ...testInfo,
+              logs: [
+                heading('== Node Environment =='),
+                ...(testInfo.logs || [])
+              ]
+            };
+          });
+        }
+        
+        if (!browserResp.ok || (browserData && browserData.error)) {
+          hasErrors = true;
+          const msg = browserData?.details || browserData?.error || `Browser: ${browserResp.status} ${browserResp.statusText}`;
+          if (fileLogsEl) fileLogsEl.addLog({ message: `Error running Browser tests: ${msg}`, type: 'error', level: 3 });
+        } else {
+          const browserResults = browserData?.results || {};
+          if (fileLogsEl && browserResults.beforeAllLogs?.length) {
+            fileLogsEl.addLog(heading('== Browser Before All Logs =='), ...browserResults.beforeAllLogs);
+          }
+          // Merge browser test results
+          Object.entries(browserResults.tests || {}).forEach(([testName, testInfo]) => {
+            if (combinedResults.tests[testName]) {
+              // Combine with existing node results
+              combinedResults.tests[testName].logs.push(
+                heading('== Browser Environment =='),
+                ...(testInfo.logs || [])
+              );
+              // Test passes only if both environments pass
+              combinedResults.tests[testName].passed = combinedResults.tests[testName].passed && testInfo.passed;
+            } else {
+              // Browser-only result (shouldn't happen for universal tests, but handle it)
+              combinedResults.tests[testName] = {
+                ...testInfo,
+                logs: [
+                  heading('== Browser Environment =='),
+                  ...(testInfo.logs || [])
+                ]
+              };
+            }
+          });
+        }
+        
+        if (hasErrors) {
+          try {
+            const tests = Array.from(el.querySelectorAll('ktf-test'));
+            for(const t of tests){ t.status = 'fail'; }
+            el.status = 'fail';
+          } catch {}
+          return;
+        }
+        
+        // Update test elements with combined results
+        const testsMap = combinedResults.tests;
+        try {
+          const tests = Array.from(el.querySelectorAll('ktf-test'));
+          for(const t of tests){
+            const name = t.name;
+            const info = testsMap[name];
+            const logsEl = t.renderRoot?.getElementById('logs');
+            if(logsEl && info){
+              logsEl.addLog(...(info.logs || []));
+            }
+            t.status = info?.passed ? 'pass' : 'fail';
+          }
+          
+          if(fileLogsEl){
+            const names = Object.keys(testsMap);
+            const total = names.length;
+            const passed = names.reduce((acc, n) => acc + (testsMap[n]?.passed ? 1 : 0), 0);
+            const failed = total - passed;
+            if(total>0){
+              fileLogsEl.addLog(
+                { message: '=== Universal Test Summary (Node + Browser) ====', type: 'summary', level: 1 },
+                { message: `Total Tests: ${total}`, type: 'summary', level: 1 },
+                { message: `Passed in Both Environments: ${passed}`, type: passed>0 ? 'pass' : 'log', level: 1 },
+                { message: `Failed in At Least One Environment: ${failed}`, type: failed>0 ? 'fail' : 'log', level: 1 },
+                failed===0
+                  ? { message: 'All tests passed in both environments!', type: 'pass', level: 1 }
+                  : { message: 'Some tests failed. See details above.', type: 'fail', level: 1 }
+              );
+            }
+          }
+          
+          // Recalculate suite status
+          const testEls = el.querySelectorAll('ktf-test');
+          const statuses = Array.from(testEls).map(x=>x.status);
+          let suiteStatus = 'notran';
+          if(statuses.includes('running')) suiteStatus = 'running';
+          else if(statuses.includes('fail')) suiteStatus = 'fail';
+          else if(statuses.length && statuses.every(s => s==='pass')) suiteStatus = 'pass';
+          el.status = suiteStatus;
+        } catch {}
+        
+      } catch (error) {
+        console.error('Error running universal test:', error);
+        try {
+          const fileLogsEl = el.renderRoot?.getElementById('fileLogs');
+          if(fileLogsEl) fileLogsEl.addLog({ message: `Error running universal test: ${error.message}`, type: 'error', level: 3 });
+          const tests = Array.from(el.querySelectorAll('ktf-test'));
+          for(const t of tests){ t.status = 'fail'; }
+          el.status = 'fail';
+        } catch {}
+      }
+      return;
+    }
+    
+    // Original single-environment logic for non-universal tests
     const resp = await fetch(`/runTest?testFile=${encodeURIComponent(file)}&showBrowser=${!!showBrowser}&delayMs=${Number(delayMs||0)}`);
     let data = null;
     try { data = await resp.json(); } catch {}

package/gui/index.html

@@ -5,6 +5,29 @@
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <title>Kempo Testing Library GUI</title>
   <link rel="stylesheet" href="/essential.css" />
+  <style>
+    .loading-state {
+      padding: 1rem;
+      text-align: center;
+      color: #666;
+      font-style: italic;
+    }
+    
+    .empty-state {
+      padding: 1rem;
+      color: #888;
+      background-color: #f5f5f5;
+      border-radius: 4px;
+      margin: 0.5rem 0;
+    }
+    
+    .empty-state code {
+      background-color: #e8e8e8;
+      padding: 0.2rem 0.4rem;
+      border-radius: 3px;
+      font-family: monospace;
+    }
+  </style>
 </head>
 <body>
 <main>
@@ -26,12 +49,23 @@
 
   <ktf-test-framework id="framework">
   <ktf-test-summary id="globalSummary"></ktf-test-summary>
+  <div id="universalTestsContainer">
+    <h2>Universal Tests</h2>
+    <p>Tests that run in both Node and Browser environments</p>
+    <div id="universalTestsLoading" class="loading-state">Loading universal tests...</div>
+    <div id="universalTestsEmpty" class="empty-state" style="display: none;">No universal tests found. Create test files with <code>.test.js</code> extension to run tests in both environments.</div>
+    <div id="universalTests"></div>
+  </div>
   <div id="nodeTestsContainer">
     <h2>Node Tests</h2>
+    <div id="nodeTestsLoading" class="loading-state">Loading Node tests...</div>
+    <div id="nodeTestsEmpty" class="empty-state" style="display: none;">No Node-only tests found. Create test files with <code>.node-test.js</code> extension to run tests only in Node.</div>
     <div id="nodeTests"></div>
   </div>
   <div id="browserTestsContainer">
     <h2>Browser Tests</h2>
+    <div id="browserTestsLoading" class="loading-state">Loading browser tests...</div>
+    <div id="browserTestsEmpty" class="empty-state" style="display: none;">No browser-only tests found. Create test files with <code>.browser-test.js</code> extension to run tests only in the browser.</div>
     <div id="browserTests"></div>
   </div>
   </ktf-test-framework>
@@ -70,38 +104,95 @@
   applyToControls(getSettings());
   subscribe(applyToControls);
 
-  const testFiles = await(await fetch('/testFiles')).json();
-  for (const browserTest of testFiles.browserTests) {
-    try {
-      const moduleUrl = `/test/${browserTest.file}`;
-      const testModule = await import(moduleUrl);
-      browserTest.testNames = testModule.default ? Object.keys(testModule.default) : [];
-    } catch (error) {
-      console.error(`Error importing test file ${browserTest.file}:`, error);
-      browserTest.testNames = [];
+  try {
+    const testFiles = await(await fetch('/testFiles')).json();
+    
+    // Get the properly categorized test files from the API
+    const nodeOnlyTests = testFiles.nodeTests || [];
+    const browserOnlyTests = testFiles.browserTests || [];  
+    const universalTests = testFiles.universalTests || [];
+    
+    // Load test names for browser-accessible tests (browser-only and universal)
+    const browserAccessibleTests = [...browserOnlyTests, ...universalTests];
+    for (const test of browserAccessibleTests) {
+      try {
+        const moduleUrl = `/test/${test.file}`;
+        const testModule = await import(moduleUrl);
+        test.testNames = testModule.default ? Object.keys(testModule.default) : [];
+      } catch (error) {
+        console.error(`Error importing test file ${test.file}:`, error);
+        test.testNames = [];
+      }
     }
-  }
-  if(!testFiles?.browserTests?.length){
-    document.getElementById('browserTestsContainer').style.display = 'none';
-  } else {
-    const browserTestsContainer = document.getElementById('browserTests');
-    testFiles.browserTests.forEach(browserTest => {
-      const testFileElement = document.createElement('ktf-test-suite');
-      testFileElement.file = browserTest.file;
-      testFileElement.testNames = browserTest.testNames;
-      browserTestsContainer.appendChild(testFileElement);
-    });
-  }
-  if(!testFiles?.nodeTests?.length){
-    document.getElementById('nodeTestsContainer').style.display = 'none';
-  } else {
+    
+    // Universal tests section (.test.js files)
+    const universalTestsLoading = document.getElementById('universalTestsLoading');
+    const universalTestsEmpty = document.getElementById('universalTestsEmpty');
+    const universalTestsContainer = document.getElementById('universalTests');
+    
+    universalTestsLoading.style.display = 'none';
+    if(!universalTests?.length){
+      universalTestsEmpty.style.display = 'block';
+    } else {
+      universalTests.forEach(universalTest => {
+        const testFileElement = document.createElement('ktf-test-suite');
+        testFileElement.file = universalTest.file;
+        testFileElement.testNames = universalTest.testNames;
+        testFileElement.setAttribute('universal', 'true'); // Mark as universal for special handling
+        universalTestsContainer.appendChild(testFileElement);
+      });
+    }
+    
+    // Node-only tests section
+    const nodeTestsLoading = document.getElementById('nodeTestsLoading');
+    const nodeTestsEmpty = document.getElementById('nodeTestsEmpty');
     const nodeTestsContainer = document.getElementById('nodeTests');
-    testFiles.nodeTests.forEach(nodeTest => {
-      const testFileElement = document.createElement('ktf-test-suite');
-      testFileElement.file = nodeTest.file;
-      testFileElement.testNames = nodeTest.testNames || [];
-      nodeTestsContainer.appendChild(testFileElement);
-    });
+    
+    nodeTestsLoading.style.display = 'none';
+    if(!nodeOnlyTests?.length){
+      nodeTestsEmpty.style.display = 'block';
+    } else {
+      nodeOnlyTests.forEach(nodeTest => {
+        const testFileElement = document.createElement('ktf-test-suite');
+        testFileElement.file = nodeTest.file;
+        testFileElement.testNames = nodeTest.testNames || [];
+        nodeTestsContainer.appendChild(testFileElement);
+      });
+    }
+    
+    // Browser-only tests section
+    const browserTestsLoading = document.getElementById('browserTestsLoading');
+    const browserTestsEmpty = document.getElementById('browserTestsEmpty');
+    const browserTestsContainer = document.getElementById('browserTests');
+    
+    browserTestsLoading.style.display = 'none';
+    if(!browserOnlyTests?.length){
+      browserTestsEmpty.style.display = 'block';
+    } else {
+      browserOnlyTests.forEach(browserTest => {
+        const testFileElement = document.createElement('ktf-test-suite');
+        testFileElement.file = browserTest.file;
+        testFileElement.testNames = browserTest.testNames;
+        browserTestsContainer.appendChild(testFileElement);
+      });
+    }
+    
+  } catch (error) {
+    console.error('Error loading test files:', error);
+    
+    // Hide loading states and show error messages
+    document.getElementById('universalTestsLoading').style.display = 'none';
+    document.getElementById('nodeTestsLoading').style.display = 'none';
+    document.getElementById('browserTestsLoading').style.display = 'none';
+    
+    // Show error messages
+    const errorMsg = 'Error loading test files. Please check the console for details.';
+    document.getElementById('universalTestsEmpty').textContent = errorMsg;
+    document.getElementById('universalTestsEmpty').style.display = 'block';
+    document.getElementById('nodeTestsEmpty').textContent = errorMsg;
+    document.getElementById('nodeTestsEmpty').style.display = 'block';
+    document.getElementById('browserTestsEmpty').textContent = errorMsg;
+    document.getElementById('browserTestsEmpty').style.display = 'block';
   }
 </script>
 </body>

package/index.js

@@ -23,7 +23,7 @@ const remainingArgs = [];
 
 // Define which flags take values vs booleans
 const valueFlags = new Set(['log-level', 'delay', 'port']);
-const booleanFlags = new Set(['browser', 'node', 'gui', 'show-browser', 'help']);
+const booleanFlags = new Set(['browser', 'node', 'gui', 'show-browser', 'help', 'debug-flags']);
 
 for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -144,6 +144,13 @@ EXAMPLES:
     process.exit(0);
 }
 
+/*
+ * Debug Flags (for testing only)
+ */
+if (flags['debug-flags']) {
+    console.log('kempo-test flags:', flags);
+}
+
 /*
  * Mode Selection and Execution
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kempo-testing-framework",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "description": "The Kempo Testing Framework is a simple testing framework built on the principle that code intended to be ran in the browser should be tested in the browser, code intended to be ran in Node should be tested in Node, and code intended to be ran in both should be tested in both. No mocking, no complexity—just testing.",
   "main": "index.js",
   "bin": {

package/src/gui.js

@@ -33,9 +33,28 @@ export default async (flags, args) => {
       try {
         const testFiles = await findTests('', '', true, true);
         
-        // Extract test names from Node test files (safe to import in Node.js)
+        // Categorize test files properly
+        const nodeOnlyTests = [];
+        const browserOnlyTests = [];
+        const universalTests = [];
+        
+        // Process all found test files and categorize them
+        const allTestFiles = new Set([...testFiles.nodeTests, ...testFiles.browserTests]);
+        
+        for (const file of allTestFiles) {
+          if (file.endsWith('.test.js')) {
+            universalTests.push(file);
+          } else if (file.endsWith('.node-test.js')) {
+            nodeOnlyTests.push(file);
+          } else if (file.endsWith('.browser-test.js')) {
+            browserOnlyTests.push(file);
+          }
+        }
+        
+        // Extract test names from Node-accessible test files (node-only and universal)
+        const nodeAccessibleTests = [...nodeOnlyTests, ...universalTests];
         const nodeTestsWithNames = await Promise.all(
-          testFiles.nodeTests.map(async file => {
+          nodeAccessibleTests.map(async file => {
             try {
               // Convert forward slashes back to OS-specific path separators for import
               const normalizedFile = file.replace(/\//g, path.sep);
@@ -48,13 +67,18 @@ export default async (flags, args) => {
             }
           })
         );
+        
+        // Separate the results back into node-only and universal
+        const nodeOnlyWithNames = nodeTestsWithNames.filter(test => test.file.endsWith('.node-test.js'));
+        const universalWithNames = nodeTestsWithNames.filter(test => test.file.endsWith('.test.js'));
 
-        // Browser tests just return file names (test names will be extracted client-side)
-        const browserTestsWithNames = testFiles.browserTests.map(file => ({ file, testNames: null }));
+        // Browser-only tests just return file names (test names will be extracted client-side)
+        const browserOnlyWithNames = browserOnlyTests.map(file => ({ file, testNames: null }));
 
         const result = {
-          nodeTests: nodeTestsWithNames,
-          browserTests: browserTestsWithNames
+          nodeTests: nodeOnlyWithNames,
+          browserTests: browserOnlyWithNames,
+          universalTests: universalWithNames
         };
 
         res.writeHead(200, { 'Content-Type': 'application/json' });
@@ -105,12 +129,25 @@ export default async (flags, args) => {
       const testNames = testNamesParam ? testNamesParam.split(',') : [];
       const showBrowserParam = url.searchParams.get('showBrowser');
       const showBrowser = showBrowserParam === 'true';
-     const delayMs = Math.max(0, parseInt(url.searchParams.get('delayMs')||'0', 10) || 0);
+      const delayMs = Math.max(0, parseInt(url.searchParams.get('delayMs')||'0', 10) || 0);
+      const environment = url.searchParams.get('environment'); // 'node', 'browser', or null for auto-detect
 
       try {
-        // Determine if this is a browser or node test based on file extension
-        const isBrowserTest = testFile.endsWith('.browser-test.js') || testFile.endsWith('.test.js');
-        const isNodeTest = testFile.endsWith('.node-test.js') || testFile.endsWith('.test.js');
+        let isBrowserTest, isNodeTest;
+        
+        if (environment === 'node') {
+          // Force Node-only execution
+          isBrowserTest = false;
+          isNodeTest = true;
+        } else if (environment === 'browser') {
+          // Force Browser-only execution  
+          isBrowserTest = true;
+          isNodeTest = false;
+        } else {
+          // Auto-detect based on file extension (original behavior)
+          isBrowserTest = testFile.endsWith('.browser-test.js') || testFile.endsWith('.test.js');
+          isNodeTest = testFile.endsWith('.node-test.js') || testFile.endsWith('.test.js');
+        }
         
         if (!isBrowserTest && !isNodeTest) {
           res.writeHead(400, { 'Content-Type': 'application/json' });
@@ -138,6 +175,7 @@ export default async (flags, args) => {
         res.end(JSON.stringify({
           testFile,
           testNames,
+          environment: environment || (isBrowserTest && isNodeTest ? 'both' : (isBrowserTest ? 'browser' : 'node')),
           results: fileResults
         }));
       } catch (error) {

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

@@ -1,7 +1,7 @@
 import { spawn } from 'child_process';
 
 const runWithArgs = (args, timeoutMs = 3000) => new Promise((resolve) => {
-  const child = spawn(process.execPath, ['index.js', ...args], {
+  const child = spawn(process.execPath, ['index.js', ...args, '--debug-flags'], {
     cwd: process.cwd(),
     stdio: ['ignore', 'pipe', 'pipe']
   });

package/tests/fibonacci.js

@@ -0,0 +1,92 @@
+/**
+ * Fibonacci sequence utility functions
+ * Works in both Node.js and browser environments
+ */
+
+/**
+ * Generate the nth Fibonacci number (0-indexed)
+ * @param {number} n - The position in the sequence (0-indexed)
+ * @returns {number} The Fibonacci number at position n
+ * @throws {Error} If n is negative or not a number
+ */
+const fibonacci = (n) => {
+  if(typeof n !== 'number' || !Number.isInteger(n)) {
+    throw new Error('Input must be a non-negative integer');
+  }
+  
+  if(n < 0) {
+    throw new Error('Input must be a non-negative integer');
+  }
+  
+  if(n === 0) return 0;
+  if(n === 1) return 1;
+  
+  let a = 0;
+  let b = 1;
+  
+  for(let i = 2; i <= n; i++) {
+    const temp = a + b;
+    a = b;
+    b = temp;
+  }
+  
+  return b;
+};
+
+/**
+ * Generate a Fibonacci sequence up to n terms
+ * @param {number} count - Number of terms to generate
+ * @returns {number[]} Array containing the Fibonacci sequence
+ * @throws {Error} If count is negative or not a number
+ */
+const fibonacciSequence = (count) => {
+  if(typeof count !== 'number' || !Number.isInteger(count)) {
+    throw new Error('Count must be a non-negative integer');
+  }
+  
+  if(count < 0) {
+    throw new Error('Count must be a non-negative integer');
+  }
+  
+  if(count === 0) return [];
+  if(count === 1) return [0];
+  if(count === 2) return [0, 1];
+  
+  const sequence = [0, 1];
+  
+  for(let i = 2; i < count; i++) {
+    sequence.push(sequence[i - 1] + sequence[i - 2]);
+  }
+  
+  return sequence;
+};
+
+/**
+ * Check if a number is a Fibonacci number
+ * @param {number} num - The number to check
+ * @returns {boolean} True if the number is in the Fibonacci sequence
+ */
+const isFibonacci = (num) => {
+  if(typeof num !== 'number' || !Number.isInteger(num) || num < 0) {
+    return false;
+  }
+  
+  if(num === 0 || num === 1) return true;
+  
+  let a = 0;
+  let b = 1;
+  
+  while (b < num) {
+    const temp = a + b;
+    a = b;
+    b = temp;
+  }
+  
+  return b === num;
+};
+
+export default {
+  fibonacci,
+  fibonacciSequence,
+  isFibonacci
+};

package/tests/fibonacci.test.js

@@ -0,0 +1,285 @@
+// Import the fibonacci utility functions
+import fibonacciUtils from './fibonacci.js';
+
+const { fibonacci, fibonacciSequence, isFibonacci } = fibonacciUtils;
+
+/*
+  Lifecycle Callbacks
+*/
+export const beforeAll = async (log) => {
+  log('Setting up Fibonacci utility tests...');
+};
+
+export const beforeEach = async (log) => {
+  log('Running Fibonacci test');
+};
+
+export const afterEach = async (log) => {
+  log('Fibonacci test completed');
+};
+
+export const afterAll = async (log) => {
+  log('Fibonacci utility tests finished');
+};
+
+/*
+  Test Cases
+*/
+export default {
+  'fibonacci - should return correct values for base cases': async ({pass, fail, log}) => {
+    try {
+      const testCases = [
+        { input: 0, expected: 0 },
+        { input: 1, expected: 1 },
+        { input: 2, expected: 1 }
+      ];
+      
+      for(const { input, expected } of testCases) {
+        const result = fibonacci(input);
+        if(result !== expected) {
+          fail(`fibonacci(${input}) expected ${expected}, got ${result}`);
+          return;
+        }
+        log(`✓ fibonacci(${input}) = ${result}`);
+      }
+      
+      pass('Base cases work correctly');
+    } catch (error) {
+      fail(`Unexpected error: ${error.message}`);
+    }
+  },
+
+  'fibonacci - should calculate correct sequence values': async ({pass, fail, log}) => {
+    try {
+      const testCases = [
+        { input: 3, expected: 2 },
+        { input: 4, expected: 3 },
+        { input: 5, expected: 5 },
+        { input: 6, expected: 8 },
+        { input: 7, expected: 13 },
+        { input: 8, expected: 21 },
+        { input: 10, expected: 55 }
+      ];
+      
+      for(const { input, expected } of testCases) {
+        const result = fibonacci(input);
+        if(result !== expected) {
+          fail(`fibonacci(${input}) expected ${expected}, got ${result}`);
+          return;
+        }
+        log(`✓ fibonacci(${input}) = ${result}`);
+      }
+      
+      pass('Sequence calculations are correct');
+    } catch (error) {
+      fail(`Unexpected error: ${error.message}`);
+    }
+  },
+
+  'fibonacci - should handle large numbers efficiently': async ({pass, fail, log}) => {
+    try {
+      const result = fibonacci(20);
+      const expected = 6765;
+      
+      if(result !== expected) {
+        fail(`fibonacci(20) expected ${expected}, got ${result}`);
+        return;
+      }
+      
+      log(`✓ fibonacci(20) = ${result}`);
+      pass('Large number calculation works efficiently');
+    } catch (error) {
+      fail(`Unexpected error: ${error.message}`);
+    }
+  },
+
+  'fibonacci - should throw error for negative numbers': async ({pass, fail, log}) => {
+    try {
+      fibonacci(-1);
+      fail('Should have thrown an error for negative input');
+    } catch (error) {
+      if(error.message === 'Input must be a non-negative integer') {
+        log('✓ Properly rejects negative numbers');
+        pass('Input validation for negative numbers works');
+      } else {
+        fail(`Expected specific error message, got: ${error.message}`);
+      }
+    }
+  },
+
+  'fibonacci - should throw error for non-integer inputs': async ({pass, fail, log}) => {
+    try {
+      const testInputs = [3.14, 'string', null, undefined, {}];
+      
+      for(const input of testInputs) {
+        try {
+          fibonacci(input);
+          fail(`Should have thrown an error for input: ${input}`);
+          return;
+        } catch (error) {
+          if(error.message === 'Input must be a non-negative integer') {
+            log(`✓ Properly rejects invalid input: ${input}`);
+          } else {
+            fail(`Expected specific error message for ${input}, got: ${error.message}`);
+            return;
+          }
+        }
+      }
+      
+      pass('Input validation for non-integers works');
+    } catch (error) {
+      fail(`Unexpected error: ${error.message}`);
+    }
+  },
+
+  'fibonacciSequence - should return empty array for count 0': async ({pass, fail, log}) => {
+    try {
+      const result = fibonacciSequence(0);
+      
+      if(!Array.isArray(result) || result.length !== 0) {
+        fail(`Expected empty array, got: ${JSON.stringify(result)}`);
+        return;
+      }
+      
+      log('✓ Returns empty array for count 0');
+      pass('Empty sequence handling works');
+    } catch (error) {
+      fail(`Unexpected error: ${error.message}`);
+    }
+  },
+
+  'fibonacciSequence - should return correct sequences': async ({pass, fail, log}) => {
+    try {
+      const testCases = [
+        { count: 1, expected: [0] },
+        { count: 2, expected: [0, 1] },
+        { count: 5, expected: [0, 1, 1, 2, 3] },
+        { count: 8, expected: [0, 1, 1, 2, 3, 5, 8, 13] }
+      ];
+      
+      for(const { count, expected } of testCases) {
+        const result = fibonacciSequence(count);
+        
+        if(JSON.stringify(result) !== JSON.stringify(expected)) {
+          fail(`fibonacciSequence(${count}) expected ${JSON.stringify(expected)}, got ${JSON.stringify(result)}`);
+          return;
+        }
+        
+        log(`✓ fibonacciSequence(${count}) = [${result.join(', ')}]`);
+      }
+      
+      pass('Sequence generation works correctly');
+    } catch (error) {
+      fail(`Unexpected error: ${error.message}`);
+    }
+  },
+
+  'fibonacciSequence - should validate input parameters': async ({pass, fail, log}) => {
+    try {
+      const invalidInputs = [-1, 3.14, 'string', null];
+      
+      for(const input of invalidInputs) {
+        try {
+          fibonacciSequence(input);
+          fail(`Should have thrown an error for input: ${input}`);
+          return;
+        } catch (error) {
+          if(error.message === 'Count must be a non-negative integer') {
+            log(`✓ Properly rejects invalid input: ${input}`);
+          } else {
+            fail(`Expected specific error message for ${input}, got: ${error.message}`);
+            return;
+          }
+        }
+      }
+      
+      pass('Sequence input validation works');
+    } catch (error) {
+      fail(`Unexpected error: ${error.message}`);
+    }
+  },
+
+  'isFibonacci - should correctly identify Fibonacci numbers': async ({pass, fail, log}) => {
+    try {
+      const fibonacciNumbers = [0, 1, 2, 3, 5, 8, 13, 21, 34, 55];
+      const nonFibonacciNumbers = [4, 6, 7, 9, 10, 11, 12, 14, 15, 16];
+      
+      for(const num of fibonacciNumbers) {
+        const result = isFibonacci(num);
+        if(!result) {
+          fail(`isFibonacci(${num}) should return true, got false`);
+          return;
+        }
+        log(`✓ ${num} is correctly identified as Fibonacci`);
+      }
+      
+      for(const num of nonFibonacciNumbers) {
+        const result = isFibonacci(num);
+        if(result) {
+          fail(`isFibonacci(${num}) should return false, got true`);
+          return;
+        }
+        log(`✓ ${num} is correctly identified as non-Fibonacci`);
+      }
+      
+      pass('Fibonacci number identification works correctly');
+    } catch (error) {
+      fail(`Unexpected error: ${error.message}`);
+    }
+  },
+
+  'isFibonacci - should handle edge cases and invalid inputs': async ({pass, fail, log}) => {
+    try {
+      const invalidInputs = [
+        { input: -1, expected: false, desc: 'negative number' },
+        { input: 3.14, expected: false, desc: 'decimal number' },
+        { input: 'string', expected: false, desc: 'string input' },
+        { input: null, expected: false, desc: 'null input' },
+        { input: undefined, expected: false, desc: 'undefined input' }
+      ];
+      
+      for(const { input, expected, desc } of invalidInputs) {
+        const result = isFibonacci(input);
+        if(result !== expected) {
+          fail(`isFibonacci(${input}) for ${desc} expected ${expected}, got ${result}`);
+          return;
+        }
+        log(`✓ ${desc} handled correctly`);
+      }
+      
+      pass('Edge case handling works correctly');
+    } catch (error) {
+      fail(`Unexpected error: ${error.message}`);
+    }
+  },
+
+  'integration - should work together across all functions': async ({pass, fail, log}) => {
+    try {
+      // Generate a sequence and verify each number
+      const sequence = fibonacciSequence(10);
+      log(`Generated sequence: [${sequence.join(', ')}]`);
+      
+      // Verify each number in the sequence using fibonacci function
+      for(let i = 0; i < sequence.length; i++) {
+        const expected = fibonacci(i);
+        if(sequence[i] !== expected) {
+          fail(`Sequence position ${i}: expected ${expected}, got ${sequence[i]}`);
+          return;
+        }
+      }
+      
+      // Verify each number is identified as Fibonacci
+      for(const num of sequence) {
+        if(!isFibonacci(num)) {
+          fail(`Number ${num} from sequence not identified as Fibonacci`);
+          return;
+        }
+      }
+      
+      log('✓ All functions work together correctly');
+      pass('Integration test passed successfully');
+    } catch (error) {
+      fail(`Integration test failed: ${error.message}`);
+    }
+  }
+};