stigmergy 1.0.94 → 1.0.95

package/test/e2e/other-cli-test.js

@@ -0,0 +1,130 @@
+// Other CLI Tools Integration Tests
+const { executeCommand, recordTestResult } = require('./test-utils');
+
+async function testOtherCLIIntegration() {
+  console.log('Starting other CLI tools integration testing...\n');
+  
+  // Test 1: Qwen CLI - Java code generation
+  console.log('--- Test 1: Qwen CLI - Java code generation ---');
+  try {
+    const result = await executeCommand('node src/main_english.js call "qwen generate a simple Java method to calculate area of rectangle"', 45000);
+    
+    const passed = result.success && 
+                   result.stdout.length > 100 && 
+                   (result.stdout.includes('public') || result.stdout.includes('private')) && 
+                   (result.stdout.includes('double') || result.stdout.includes('int') || result.stdout.includes('float')) &&
+                   result.stdout.includes('area') &&
+                   !result.stdout.includes('Error') &&
+                   !result.stdout.includes('error');
+                   
+    recordTestResult('Qwen CLI - Java Code Generation', passed, {
+      command: result.command,
+      executionTime: result.executionTime,
+      outputLength: result.stdout.length,
+      hasError: !result.success || result.stderr.length > 0
+    });
+    
+    console.log(`  Result: ${passed ? 'PASS' : 'FAIL'}`);
+    console.log(`  Execution time: ${result.executionTime}ms`);
+    console.log(`  Output length: ${result.stdout.length} characters`);
+    
+  } catch (error) {
+    recordTestResult('Qwen CLI - Java Code Generation', false, {
+      error: error.message
+    });
+    console.log(`  Result: FAIL - ${error.message}`);
+  }
+  
+  // Test 2: Gemini CLI - JavaScript function
+  console.log('\n--- Test 2: Gemini CLI - JavaScript function ---');
+  try {
+    const result = await executeCommand('node src/main_english.js call "gemini create a basic JavaScript function for string reversal"', 45000);
+    
+    const passed = result.success && 
+                   result.stdout.length > 50 && 
+                   (result.stdout.includes('function') || result.stdout.includes('=>')) && 
+                   result.stdout.includes('reverse') &&
+                   !result.stdout.includes('Error') &&
+                   !result.stdout.includes('error');
+                   
+    recordTestResult('Gemini CLI - JavaScript Function', passed, {
+      command: result.command,
+      executionTime: result.executionTime,
+      outputLength: result.stdout.length,
+      hasError: !result.success || result.stderr.length > 0
+    });
+    
+    console.log(`  Result: ${passed ? 'PASS' : 'FAIL'}`);
+    console.log(`  Execution time: ${result.executionTime}ms`);
+    console.log(`  Output length: ${result.stdout.length} characters`);
+    
+  } catch (error) {
+    recordTestResult('Gemini CLI - JavaScript Function', false, {
+      error: error.message
+    });
+    console.log(`  Result: FAIL - ${error.message}`);
+  }
+  
+  // Test 3: iFlow CLI - Algorithm implementation
+  console.log('\n--- Test 3: iFlow CLI - Algorithm implementation ---');
+  try {
+    const result = await executeCommand('node src/main_english.js call "iflow write a basic function to check if a number is even"', 45000);
+    
+    const passed = result.success && 
+                   result.stdout.length > 50 && 
+                   (result.stdout.includes('function') || result.stdout.includes('=>')) && 
+                   (result.stdout.includes('%') || result.stdout.includes('mod')) &&
+                   !result.stdout.includes('Error') &&
+                   !result.stdout.includes('error');
+                   
+    recordTestResult('iFlow CLI - Algorithm Implementation', passed, {
+      command: result.command,
+      executionTime: result.executionTime,
+      outputLength: result.stdout.length,
+      hasError: !result.success || result.stderr.length > 0
+    });
+    
+    console.log(`  Result: ${passed ? 'PASS' : 'FAIL'}`);
+    console.log(`  Execution time: ${result.executionTime}ms`);
+    console.log(`  Output length: ${result.stdout.length} characters`);
+    
+  } catch (error) {
+    recordTestResult('iFlow CLI - Algorithm Implementation', false, {
+      error: error.message
+    });
+    console.log(`  Result: FAIL - ${error.message}`);
+  }
+  
+  // Test 4: CodeBuddy CLI - Code analysis
+  console.log('\n--- Test 4: CodeBuddy CLI - Code analysis ---');
+  try {
+    const result = await executeCommand('node src/main_english.js call "codebuddy analyze this code for potential memory leaks: let arr = []; for(let i=0; i<1000000; i++) { arr.push(new Object()); }"', 45000);
+    
+    const passed = result.success && 
+                   result.stdout.length > 50 && 
+                   (result.stdout.includes('memory') || result.stdout.includes('leak')) &&
+                   !result.stdout.includes('Error') &&
+                   !result.stdout.includes('error');
+                   
+    recordTestResult('CodeBuddy CLI - Code Analysis', passed, {
+      command: result.command,
+      executionTime: result.executionTime,
+      outputLength: result.stdout.length,
+      hasError: !result.success || result.stderr.length > 0
+    });
+    
+    console.log(`  Result: ${passed ? 'PASS' : 'FAIL'}`);
+    console.log(`  Execution time: ${result.executionTime}ms`);
+    console.log(`  Output length: ${result.stdout.length} characters`);
+    
+  } catch (error) {
+    recordTestResult('CodeBuddy CLI - Code Analysis', false, {
+      error: error.message
+    });
+    console.log(`  Result: FAIL - ${error.message}`);
+  }
+  
+  console.log('\n--- Other CLI tools integration testing completed ---\n');
+}
+
+module.exports = testOtherCLIIntegration;

package/test/e2e/qoder-cli-test.js

@@ -0,0 +1,128 @@
+// Qoder CLI Integration Tests
+const { executeCommand, recordTestResult } = require('./test-utils');
+
+async function testQoderCLIIntegration() {
+  console.log('Starting Qoder CLI integration testing...\n');
+  
+  // Test 1: Function implementation
+  console.log('--- Test 1: Function implementation ---');
+  try {
+    const result = await executeCommand('node src/main_english.js call "qodercli write a simple function to find maximum of two numbers"', 45000);
+    
+    const passed = result.success && 
+                   result.stdout.length > 100 && 
+                   (result.stdout.includes('function') || result.stdout.includes('max')) && 
+                   (result.stdout.includes('return') || result.stdout.includes('=>')) &&
+                   !result.stdout.includes('Error') &&
+                   !result.stdout.includes('error');
+                   
+    recordTestResult('Qoder CLI - Function Implementation', passed, {
+      command: result.command,
+      executionTime: result.executionTime,
+      outputLength: result.stdout.length,
+      hasError: !result.success || result.stderr.length > 0
+    });
+    
+    console.log(`  Result: ${passed ? 'PASS' : 'FAIL'}`);
+    console.log(`  Execution time: ${result.executionTime}ms`);
+    console.log(`  Output length: ${result.stdout.length} characters`);
+    
+  } catch (error) {
+    recordTestResult('Qoder CLI - Function Implementation', false, {
+      error: error.message
+    });
+    console.log(`  Result: FAIL - ${error.message}`);
+  }
+  
+  // Test 2: Code refactoring
+  console.log('\n--- Test 2: Code refactoring ---');
+  try {
+    const result = await executeCommand('node src/main_english.js call "qodercli refactor this JavaScript function to be more readable: function calc(a,b,c){if(c==\"add\")return a+b;if(c==\"sub\")return a-b;if(c==\"mul\")return a*b;}', 60000);
+    
+    const passed = result.success && 
+                   result.stdout.length > 100 && 
+                   (result.stdout.includes('function') || result.stdout.includes('calc')) &&
+                   (result.stdout.includes('if') || result.stdout.includes('switch')) &&
+                   !result.stdout.includes('Error') &&
+                   !result.stdout.includes('error');
+                   
+    recordTestResult('Qoder CLI - Code Refactoring', passed, {
+      command: result.command,
+      executionTime: result.executionTime,
+      outputLength: result.stdout.length,
+      hasError: !result.success || result.stderr.length > 0
+    });
+    
+    console.log(`  Result: ${passed ? 'PASS' : 'FAIL'}`);
+    console.log(`  Execution time: ${result.executionTime}ms`);
+    console.log(`  Output length: ${result.stdout.length} characters`);
+    
+  } catch (error) {
+    recordTestResult('Qoder CLI - Code Refactoring', false, {
+      error: error.message
+    });
+    console.log(`  Result: FAIL - ${error.message}`);
+  }
+  
+  // Test 3: Test generation
+  console.log('\n--- Test 3: Test generation ---');
+  try {
+    const result = await executeCommand('node src/main_english.js call "qodercli generate unit tests for this function: function multiply(a, b) { return a * b; }"', 45000);
+    
+    const passed = result.success && 
+                   result.stdout.length > 100 && 
+                   (result.stdout.includes('test') || result.stdout.includes('assert') || result.stdout.includes('expect')) &&
+                   !result.stdout.includes('Error') &&
+                   !result.stdout.includes('error');
+                   
+    recordTestResult('Qoder CLI - Test Generation', passed, {
+      command: result.command,
+      executionTime: result.executionTime,
+      outputLength: result.stdout.length,
+      hasError: !result.success || result.stderr.length > 0
+    });
+    
+    console.log(`  Result: ${passed ? 'PASS' : 'FAIL'}`);
+    console.log(`  Execution time: ${result.executionTime}ms`);
+    console.log(`  Output length: ${result.stdout.length} characters`);
+    
+  } catch (error) {
+    recordTestResult('Qoder CLI - Test Generation', false, {
+      error: error.message
+    });
+    console.log(`  Result: FAIL - ${error.message}`);
+  }
+  
+  // Test 4: Project structure analysis
+  console.log('\n--- Test 4: Project structure analysis ---');
+  try {
+    const result = await executeCommand('node src/main_english.js call "qodercli analyze the project structure in this directory and suggest improvements"', 45000);
+    
+    const passed = result.success && 
+                   result.stdout.length > 100 && 
+                   (result.stdout.includes('structure') || result.stdout.includes('project') || result.stdout.includes('directory')) &&
+                   !result.stdout.includes('Error') &&
+                   !result.stdout.includes('error');
+                   
+    recordTestResult('Qoder CLI - Project Structure Analysis', passed, {
+      command: result.command,
+      executionTime: result.executionTime,
+      outputLength: result.stdout.length,
+      hasError: !result.success || result.stderr.length > 0
+    });
+    
+    console.log(`  Result: ${passed ? 'PASS' : 'FAIL'}`);
+    console.log(`  Execution time: ${result.executionTime}ms`);
+    console.log(`  Output length: ${result.stdout.length} characters`);
+    
+  } catch (error) {
+    recordTestResult('Qoder CLI - Project Structure Analysis', false, {
+      error: error.message
+    });
+    console.log(`  Result: FAIL - ${error.message}`);
+  }
+  
+  console.log('\n--- Qoder CLI integration testing completed ---\n');
+}
+
+module.exports = testQoderCLIIntegration;

package/test/e2e/run-e2e-tests.js

@@ -0,0 +1,73 @@
+// Main end-to-end test runner
+const { getTestSummary, saveTestReport, logFilePath } = require('./test-utils');
+const testIndividualTools = require('./individual-tool-test');
+const testCollaboration = require('./collaboration-test');
+const testErrorHandling = require('./error-handling-test');
+const runComprehensiveTest = require('./comprehensive-test');
+const testClaudeCLIIntegration = require('./claude-cli-test');
+const testQoderCLIIntegration = require('./qoder-cli-test');
+const testOtherCLIIntegration = require('./other-cli-test');
+
+async function runEndToEndTests() {
+  console.log('Stigmergy CLI End-to-End Testing');
+  console.log('================================\n');
+  
+  // Check if we should run comprehensive tests
+  const runComprehensive = process.argv.includes('--comprehensive');
+  const runClaudeTests = process.argv.includes('--claude');
+  const runQoderTests = process.argv.includes('--qoder');
+  const runOtherCLITests = process.argv.includes('--other');
+  
+  try {
+    if (runComprehensive) {
+      // Run comprehensive test suite
+      await runComprehensiveTest();
+    } else if (runClaudeTests) {
+      // Run Claude CLI integration tests
+      await testClaudeCLIIntegration();
+    } else if (runQoderTests) {
+      // Run Qoder CLI integration tests
+      await testQoderCLIIntegration();
+    } else if (runOtherCLITests) {
+      // Run other CLI tools integration tests
+      await testOtherCLIIntegration();
+    } else {
+      // Run individual tool tests
+      await testIndividualTools();
+      
+      // Run collaboration tests
+      await testCollaboration();
+      
+      // Run error handling tests
+      await testErrorHandling();
+    }
+    
+    // Generate final report
+    const summary = getTestSummary();
+    const { reportPath, summaryPath } = saveTestReport();
+    
+    console.log('\n' + '='.repeat(50));
+    console.log('FINAL TEST RESULTS');
+    console.log('='.repeat(50));
+    console.log(`Total Tests: ${summary.total}`);
+    console.log(`Passed: ${summary.passed}`);
+    console.log(`Failed: ${summary.failed}`);
+    console.log(`Pass Rate: ${summary.passRate}%`);
+    console.log(`Detailed Report: ${reportPath}`);
+    console.log(`Summary Report: ${summaryPath}`);
+    console.log(`Full Log: ${logFilePath}`);
+    console.log('='.repeat(50));
+    
+    // Exit with appropriate code
+    process.exit(summary.failed > 0 ? 1 : 0);
+    
+  } catch (error) {
+    console.error('Test execution failed:', error);
+    process.exit(1);
+  }
+}
+
+// Run the tests
+if (require.main === module) {
+  runEndToEndTests();
+}

package/test/e2e/test-data.js

@@ -0,0 +1,88 @@
+// Test data for end-to-end testing
+const testData = {
+  // Simple code generation prompts for each tool
+  simpleCodeGeneration: {
+    claude: "claude write a simple Python function to add two numbers",
+    gemini: "gemini create a basic JavaScript function for string reversal",
+    qwen: "qwen generate a simple Java method to calculate area of rectangle",
+    iflow: "iflow write a basic function to check if a number is even",
+    qodercli: "qodercli write a simple function to find maximum of two numbers",
+    codebuddy: "codebuddy create a basic function to calculate circle circumference",
+    copilot: "copilot generate a simple function to convert Celsius to Fahrenheit",
+    codex: "codex write a basic function to calculate factorial of a number"
+  },
+  
+  // Complex code generation prompts
+  complexCodeGeneration: {
+    claude: "claude implement a binary search algorithm in Python with proper error handling",
+    gemini: "gemini create a JavaScript class for a simple banking system with deposit and withdraw methods",
+    qwen: "qwen generate a Java implementation of a linked list with insert and delete operations",
+    iflow: "iflow write a function to sort an array using quicksort algorithm",
+    qodercli: "qodercli implement a hash table data structure with collision handling",
+    codebuddy: "codebuddy create a function to parse JSON data and validate its structure",
+    copilot: "copilot generate a function to implement a simple REST API client",
+    codex: "codex write a function to process CSV data and generate statistics"
+  },
+  
+  // Analysis prompts
+  analysis: {
+    claude: "claude analyze this Python code for potential security vulnerabilities",
+    gemini: "gemini review this JavaScript code for performance optimization opportunities", 
+    qwen: "qwen check this Java code for adherence to best practices",
+    iflow: "iflow evaluate this code for potential bugs and logical errors",
+    qodercli: "qodercli assess this function for code quality and maintainability",
+    codebuddy: "codebuddy analyze this code for potential memory leaks",
+    copilot: "copilot review this code for proper error handling",
+    codex: "codex examine this code for potential scalability issues"
+  },
+  
+  // Documentation prompts
+  documentation: {
+    claude: "claude generate documentation for a Python function that sorts arrays",
+    gemini: "gemini create JSDoc for a JavaScript function that validates email addresses",
+    qwen: "qwen write JavaDoc for a Java method that connects to database",
+    iflow: "iflow generate comments for a C++ function that processes image data",
+    qodercli: "qodercli create documentation for a function that handles HTTP requests",
+    codebuddy: "codebuddy write documentation for a function that encrypts data",
+    copilot: "copilot generate README section for a machine learning model API",
+    codex: "codex create API documentation for a weather data processing function"
+  },
+  
+  // Collaboration scenarios
+  collaborationScenarios: [
+    {
+      name: "Code Review Workflow",
+      steps: [
+        "qodercli write a Python function to handle user authentication",
+        "claude analyze the security of the authentication function",
+        "gemini suggest performance improvements for the function"
+      ]
+    },
+    {
+      name: "Multi-language Implementation", 
+      steps: [
+        "qwen generate a Java implementation of a calculator class",
+        "copilot create a C# version of the same calculator",
+        "codex write a JavaScript equivalent of the calculator"
+      ]
+    },
+    {
+      name: "Documentation and Testing",
+      steps: [
+        "iflow write a complex algorithm in Python",
+        "codebuddy generate unit tests for the algorithm",
+        "qodercli create comprehensive documentation for the algorithm"
+      ]
+    }
+  ],
+  
+  // Error handling test cases
+  errorHandling: {
+    invalidTool: "xyz generate a function to add two numbers",
+    malformedInput: "claude ",
+    extremelyLongInput: "claude " + "very long prompt ".repeat(1000),
+    specialCharacters: "gemini analyze code with special chars: \n\t\r\\\"'"
+  }
+};
+
+module.exports = testData;

package/test/e2e/test-utils.js

@@ -0,0 +1,222 @@
+// Utility functions for end-to-end testing
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+// Test result tracker
+const testResults = {
+  passed: 0,
+  failed: 0,
+  total: 0,
+  details: []
+};
+
+// Log file path
+const logFilePath = path.join(__dirname, 'logs', `e2e-test-${new Date().toISOString().replace(/[:.]/g, '-')}.log`);
+
+// Initialize log file
+fs.writeFileSync(logFilePath, `Stigmergy CLI End-to-End Test Log\n`);
+fs.appendFileSync(logFilePath, `Started at: ${new Date().toISOString()}\n`);
+fs.appendFileSync(logFilePath, `=`.repeat(80) + '\n\n');
+
+/**
+ * Execute a command and return the result
+ * @param {string} command - Command to execute
+ * @param {number} timeout - Timeout in milliseconds (default: 30000)
+ * @returns {Promise<Object>} Result object with status, stdout, stderr
+ */
+function executeCommand(command, timeout = 30000) {
+  return new Promise((resolve) => {
+    const startTime = Date.now();
+    
+    // Log the command
+    const logEntry = `[${new Date().toISOString()}] Executing: ${command}\n`;
+    fs.appendFileSync(logFilePath, logEntry);
+    console.log(`Executing: ${command}`);
+    
+    // Spawn the process
+    const child = spawn(command, { 
+      shell: true,
+      stdio: ['pipe', 'pipe', 'pipe']
+    });
+    
+    let stdout = '';
+    let stderr = '';
+    
+    // Capture stdout
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+    
+    // Capture stderr
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+    
+    // Handle process close
+    child.on('close', (code) => {
+      const executionTime = Date.now() - startTime;
+      const result = {
+        command,
+        code,
+        stdout,
+        stderr,
+        executionTime,
+        success: code === 0
+      };
+      
+      // Log the result
+      const resultLog = `  Status: ${code}, Time: ${executionTime}ms\n`;
+      fs.appendFileSync(logFilePath, resultLog);
+      
+      if (stdout) {
+        fs.appendFileSync(logFilePath, `  STDOUT:\n${stdout}\n`);
+      }
+      if (stderr) {
+        fs.appendFileSync(logFilePath, `  STDERR:\n${stderr}\n`);
+      }
+      
+      fs.appendFileSync(logFilePath, `  ---\n\n`);
+      
+      resolve(result);
+    });
+    
+    // Handle errors
+    child.on('error', (error) => {
+      const executionTime = Date.now() - startTime;
+      const result = {
+        command,
+        code: -1,
+        stdout: '',
+        stderr: error.message,
+        executionTime,
+        success: false
+      };
+      
+      // Log the error
+      const errorLog = `  ERROR: ${error.message}, Time: ${executionTime}ms\n  ---\n\n`;
+      fs.appendFileSync(logFilePath, errorLog);
+      
+      resolve(result);
+    });
+    
+    // Handle timeout
+    setTimeout(() => {
+      if (child.exitCode === null) {
+        child.kill();
+        const executionTime = Date.now() - startTime;
+        const result = {
+          command,
+          code: -2,
+          stdout: '',
+          stderr: 'TIMEOUT',
+          executionTime,
+          success: false
+        };
+        
+        // Log the timeout
+        const timeoutLog = `  TIMEOUT after ${timeout}ms\n  ---\n\n`;
+        fs.appendFileSync(logFilePath, timeoutLog);
+        
+        resolve(result);
+      }
+    }, timeout);
+  });
+}
+
+/**
+ * Record test result
+ * @param {string} testName - Name of the test
+ * @param {boolean} passed - Whether the test passed
+ * @param {Object} details - Additional details about the test
+ */
+function recordTestResult(testName, passed, details = {}) {
+  testResults.total++;
+  if (passed) {
+    testResults.passed++;
+  } else {
+    testResults.failed++;
+  }
+  
+  const result = {
+    name: testName,
+    passed,
+    details
+  };
+  
+  testResults.details.push(result);
+  
+  // Log to file
+  const status = passed ? 'PASS' : 'FAIL';
+  const logEntry = `[${status}] ${testName}\n`;
+  fs.appendFileSync(logFilePath, logEntry);
+  
+  // Log to console
+  console.log(`${status}: ${testName}`);
+}
+
+/**
+ * Get test summary
+ * @returns {Object} Test summary
+ */
+function getTestSummary() {
+  return {
+    ...testResults,
+    passRate: testResults.total > 0 ? (testResults.passed / testResults.total * 100).toFixed(2) : 0
+  };
+}
+
+/**
+ * Save detailed test report
+ */
+function saveTestReport() {
+  const summary = getTestSummary();
+  const reportPath = path.join(__dirname, 'logs', `e2e-report-${new Date().toISOString().replace(/[:.]/g, '-')}.json`);
+  
+  const report = {
+    timestamp: new Date().toISOString(),
+    summary,
+    details: testResults.details
+  };
+  
+  fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
+  
+  // Also save a human-readable summary
+  const summaryPath = path.join(__dirname, 'logs', `e2e-summary-${new Date().toISOString().replace(/[:.]/g, '-')}.txt`);
+  let summaryContent = `Stigmergy CLI End-to-End Test Summary\n`;
+  summaryContent += `=====================================\n\n`;
+  summaryContent += `Timestamp: ${report.timestamp}\n`;
+  summaryContent += `Total Tests: ${summary.total}\n`;
+  summaryContent += `Passed: ${summary.passed}\n`;
+  summaryContent += `Failed: ${summary.failed}\n`;
+  summaryContent += `Pass Rate: ${summary.passRate}%\n\n`;
+  
+  summaryContent += `Detailed Results:\n`;
+  summaryContent += `-----------------\n`;
+  testResults.details.forEach(detail => {
+    const status = detail.passed ? 'PASS' : 'FAIL';
+    summaryContent += `${status}: ${detail.name}\n`;
+  });
+  
+  fs.writeFileSync(summaryPath, summaryContent);
+  
+  return { reportPath, summaryPath };
+}
+
+/**
+ * Wait for a specified time
+ * @param {number} ms - Milliseconds to wait
+ * @returns {Promise<void>}
+ */
+function wait(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+module.exports = {
+  executeCommand,
+  recordTestResult,
+  getTestSummary,
+  saveTestReport,
+  wait,
+  logFilePath
+};

package/test/hash-table-demo.js

@@ -0,0 +1,33 @@
+const { HashTable } = require('../src/utils');
+
+// Test without linting issues
+function runHashTableTests() {
+  console.log('=== Hash Table Implementation Test ===');
+  
+  // Create a new hash table
+  const ht = new HashTable(17);
+
+  // Test setting values
+  ht.set('maroon', '#800000');
+  ht.set('yellow', '#FFFF00');
+  ht.set('olive', '#808000');
+  ht.set('salmon', '#FA8072');
+  ht.set('lightcoral', '#F08080');
+  ht.set('mediumvioletred', '#C71585');
+  ht.set('plum', '#DDA0DD');
+
+  // Test getting values
+  console.log('Get maroon:', ht.get('maroon')); // #800000
+  console.log('Get yellow:', ht.get('yellow')); // #FFFF00
+  console.log('Get invalid:', ht.get('invalid')); // undefined
+
+  // Test keys method
+  console.log('Keys:', ht.keys()); 
+
+  // Test values method
+  console.log('Values:', ht.values());
+
+  console.log('=== Hash Table tests completed successfully! ===');
+}
+
+runHashTableTests();