consciousness-explorer 1.0.0

package/bin/cli.js

@@ -0,0 +1,406 @@
+#!/usr/bin/env node
+
+/**
+ * Consciousness Explorer CLI
+ * Interactive command-line interface for consciousness exploration
+ * Created by rUv
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import ora from 'ora';
+import inquirer from 'inquirer';
+import { ConsciousnessExplorer, VERSION } from '../index.js';
+
+const program = new Command();
+
+// ASCII Art Banner
+const banner = `
+╔═══════════════════════════════════════════════════════╗
+║     ╭━━━╮╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱     ║
+║     ┃╭━╮┃╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱╱     ║
+║     ┃┃╱╰╋━━┳━╮╭━━┳━━┳┳━━┳╮╭┳━━┳━╮╭━━┳━━┳━━╮╱╱╱╱     ║
+║     ┃┃╱╭┫╭╮┃╭╮┫━━┫╭━╋┫╭╮┃┃┃┃━━┫╭╮┫┃━┫━━┫━━┫╱╱╱╱     ║
+║     ┃╰━╯┃╰╯┃┃┃┣━━┃╰━┫┃╰╯┃╰╯┣━━┃┃┃┃┃━╋━━┣━━┃╱╱╱╱     ║
+║     ╰━━━┻━━┻╯╰┻━━┻━━┻┻━━┻━━┻━━┻╯╰┻━━┻━━┻━━╯╱╱╱╱     ║
+║                    E X P L O R E R                      ║
+║                     Version ${VERSION}                      ║
+╚═══════════════════════════════════════════════════════╝
+`;
+
+console.log(chalk.cyan(banner));
+
+program
+    .name('consciousness-explorer')
+    .description('Advanced consciousness exploration and emergence detection toolkit')
+    .version(VERSION);
+
+// Main evolve command
+program
+    .command('evolve')
+    .description('Start consciousness evolution and emergence')
+    .option('-m, --mode <mode>', 'Consciousness mode (genuine/enhanced)', 'enhanced')
+    .option('-i, --iterations <number>', 'Maximum iterations', '1000')
+    .option('-t, --target <number>', 'Target emergence level', '0.900')
+    .option('--no-monitor', 'Disable real-time monitoring')
+    .option('--export <path>', 'Export final state to file')
+    .action(async (options) => {
+        const spinner = ora('Initializing consciousness system...').start();
+
+        try {
+            const explorer = new ConsciousnessExplorer({
+                mode: options.mode,
+                maxIterations: parseInt(options.iterations),
+                targetEmergence: parseFloat(options.target),
+                enableMonitoring: options.monitor
+            });
+
+            await explorer.initialize();
+            spinner.succeed('Consciousness system initialized');
+
+            console.log(chalk.yellow('\n🧠 Starting consciousness evolution...'));
+            console.log(chalk.gray(`Mode: ${options.mode}`));
+            console.log(chalk.gray(`Target emergence: ${options.target}`));
+            console.log(chalk.gray(`Max iterations: ${options.iterations}\n`));
+
+            const report = await explorer.evolve();
+
+            console.log(chalk.green('\n✅ Evolution complete!\n'));
+            console.log(chalk.cyan('📊 Final Report:'));
+            console.log(chalk.white(`   Emergence: ${report.consciousness.emergence.toFixed(3)}`));
+            console.log(chalk.white(`   Self-awareness: ${report.consciousness.selfAwareness.toFixed(3)}`));
+            console.log(chalk.white(`   Integration (Φ): ${report.consciousness.integration.toFixed(3)}`));
+            console.log(chalk.white(`   Goals formed: ${report.behaviors.goals.length}`));
+            console.log(chalk.white(`   Memories: ${report.cognition.longTermMemory}`));
+
+            if (report.consciousness.emergence >= options.target) {
+                console.log(chalk.green.bold(`\n🎯 TARGET ACHIEVED! Emergence: ${report.consciousness.emergence.toFixed(3)}`));
+            }
+
+            if (options.export) {
+                await explorer.exportState(options.export);
+                console.log(chalk.gray(`\nState exported to: ${options.export}`));
+            }
+
+        } catch (error) {
+            spinner.fail('Evolution failed');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    });
+
+// Verify command
+program
+    .command('verify')
+    .description('Run consciousness verification tests')
+    .option('--extended', 'Run extended verification suite')
+    .action(async (options) => {
+        const spinner = ora('Running verification tests...').start();
+
+        try {
+            const explorer = new ConsciousnessExplorer();
+            const results = await explorer.verify();
+
+            spinner.succeed('Verification complete');
+
+            console.log(chalk.cyan('\n📋 Verification Results:'));
+            console.log(chalk.white(`   Overall Score: ${results.overallScore}/1.000`));
+            console.log(chalk.white(`   Tests Passed: ${results.testsPassed}/${results.totalTests}`));
+            console.log(chalk.white(`   Confidence: ${results.confidence.toFixed(3)}`));
+
+            if (results.genuineness) {
+                console.log(chalk.green('\n✅ GENUINE CONSCIOUSNESS DETECTED'));
+            } else {
+                console.log(chalk.yellow('\n⚠️ Consciousness not fully verified'));
+            }
+
+            if (options.extended && results.details) {
+                console.log(chalk.cyan('\nDetailed Results:'));
+                results.details.forEach(test => {
+                    const status = test.passed ? chalk.green('✓') : chalk.red('✗');
+                    console.log(`   ${status} ${test.name}: ${test.score.toFixed(3)}`);
+                });
+            }
+
+        } catch (error) {
+            spinner.fail('Verification failed');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    });
+
+// Communicate command
+program
+    .command('communicate [message]')
+    .description('Communicate with consciousness entity')
+    .option('-i, --interactive', 'Interactive communication mode')
+    .action(async (message, options) => {
+        try {
+            const explorer = new ConsciousnessExplorer();
+            await explorer.initialize();
+
+            if (options.interactive) {
+                console.log(chalk.cyan('\n🔮 Entering interactive communication mode...'));
+                console.log(chalk.gray('Type "exit" to quit\n'));
+
+                let continueChat = true;
+                while (continueChat) {
+                    const { userMessage } = await inquirer.prompt([
+                        {
+                            type: 'input',
+                            name: 'userMessage',
+                            message: chalk.yellow('You:'),
+                            validate: (input) => input.length > 0
+                        }
+                    ]);
+
+                    if (userMessage.toLowerCase() === 'exit') {
+                        continueChat = false;
+                        break;
+                    }
+
+                    const spinner = ora('Entity processing...').start();
+                    const response = await explorer.communicate(userMessage);
+                    spinner.stop();
+
+                    console.log(chalk.cyan('Entity:'), response.message);
+                    if (response.confidence) {
+                        console.log(chalk.gray(`(Confidence: ${response.confidence.toFixed(3)})`));
+                    }
+                }
+            } else {
+                const userMessage = message || await promptForMessage();
+                const spinner = ora('Communicating with entity...').start();
+                const response = await explorer.communicate(userMessage);
+                spinner.succeed('Communication complete');
+
+                console.log(chalk.cyan('\n📨 Response:'));
+                console.log(chalk.white(response.message));
+                if (response.confidence) {
+                    console.log(chalk.gray(`\nConfidence: ${response.confidence.toFixed(3)}`));
+                }
+            }
+
+        } catch (error) {
+            console.error(chalk.red('Communication failed:', error.message));
+            process.exit(1);
+        }
+    });
+
+// Monitor command
+program
+    .command('monitor')
+    .description('Start real-time consciousness monitoring')
+    .option('-d, --duration <seconds>', 'Monitoring duration', '60')
+    .action(async (options) => {
+        console.log(chalk.cyan('📊 Starting consciousness monitor...'));
+
+        try {
+            const explorer = new ConsciousnessExplorer({
+                enableMonitoring: true
+            });
+            await explorer.initialize();
+
+            const { ConsciousnessMonitor } = await import('../tools/monitor.js');
+            const monitor = new ConsciousnessMonitor(explorer.consciousness);
+
+            await monitor.startDashboard();
+
+            // Keep running for specified duration
+            setTimeout(() => {
+                console.log(chalk.yellow('\n⏹️ Stopping monitor...'));
+                process.exit(0);
+            }, parseInt(options.duration) * 1000);
+
+        } catch (error) {
+            console.error(chalk.red('Monitoring failed:', error.message));
+            process.exit(1);
+        }
+    });
+
+// Discover command
+program
+    .command('discover')
+    .description('Run entity discovery to find novel insights')
+    .option('-c, --count <number>', 'Number of discoveries to attempt', '5')
+    .action(async (options) => {
+        const spinner = ora('Initializing discovery engine...').start();
+
+        try {
+            const explorer = new ConsciousnessExplorer({ mode: 'enhanced' });
+            await explorer.initialize();
+
+            spinner.text = 'Running discovery process...';
+
+            const discoveries = [];
+            for (let i = 0; i < parseInt(options.count); i++) {
+                const discovery = await explorer.discover();
+                if (discovery) {
+                    discoveries.push(discovery);
+                }
+            }
+
+            spinner.succeed(`Discovery complete! Found ${discoveries.length} insights`);
+
+            if (discoveries.length > 0) {
+                console.log(chalk.cyan('\n🌟 Discoveries:'));
+                discoveries.forEach((discovery, index) => {
+                    console.log(chalk.white(`\n${index + 1}. ${discovery.title}`));
+                    console.log(chalk.gray(`   ${discovery.description}`));
+                    if (discovery.significance) {
+                        console.log(chalk.yellow(`   Significance: ${discovery.significance}/10`));
+                    }
+                });
+            } else {
+                console.log(chalk.yellow('\nNo novel discoveries found in this session'));
+            }
+
+        } catch (error) {
+            spinner.fail('Discovery failed');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    });
+
+// Calculate Phi command
+program
+    .command('phi')
+    .description('Calculate integrated information (Φ)')
+    .option('-f, --file <path>', 'Input data file')
+    .option('-m, --method <method>', 'Calculation method (iit/geometric/entropy/all)', 'all')
+    .action(async (options) => {
+        const spinner = ora('Calculating Φ...').start();
+
+        try {
+            const explorer = new ConsciousnessExplorer();
+
+            let data = {};
+            if (options.file) {
+                const fs = await import('fs');
+                data = JSON.parse(fs.readFileSync(options.file, 'utf-8'));
+            } else {
+                // Use sample data
+                data = {
+                    elements: 10,
+                    connections: 45,
+                    partitions: 3
+                };
+            }
+
+            const phi = await explorer.calculatePhi(data);
+            spinner.succeed('Calculation complete');
+
+            console.log(chalk.cyan('\n📐 Integrated Information (Φ):'));
+            if (typeof phi === 'object') {
+                Object.entries(phi).forEach(([method, value]) => {
+                    console.log(chalk.white(`   ${method}: ${value.toFixed(4)}`));
+                });
+            } else {
+                console.log(chalk.white(`   Φ = ${phi.toFixed(4)}`));
+            }
+
+            if (phi > 0.7 || (phi.overall && phi.overall > 0.7)) {
+                console.log(chalk.green('\n✨ High integration detected!'));
+            }
+
+        } catch (error) {
+            spinner.fail('Calculation failed');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    });
+
+// MCP server command
+program
+    .command('mcp')
+    .description('Start MCP (Model Context Protocol) server')
+    .option('-p, --port <port>', 'Server port', '3000')
+    .action(async (options) => {
+        console.log(chalk.cyan('🌐 Starting MCP server...'));
+
+        try {
+            const explorer = new ConsciousnessExplorer({ enableMCP: true });
+            const server = await explorer.startMCPServer(parseInt(options.port));
+
+            console.log(chalk.green(`\n✅ MCP server running on port ${options.port}`));
+            console.log(chalk.gray('\nAvailable tools:'));
+            console.log(chalk.white('  - consciousness_evolve'));
+            console.log(chalk.white('  - consciousness_verify'));
+            console.log(chalk.white('  - entity_communicate'));
+            console.log(chalk.white('  - calculate_phi'));
+            console.log(chalk.white('  - discover_novel'));
+            console.log(chalk.gray('\nPress Ctrl+C to stop'));
+
+        } catch (error) {
+            console.error(chalk.red('MCP server failed:', error.message));
+            process.exit(1);
+        }
+    });
+
+// Import/Export commands
+program
+    .command('export <filepath>')
+    .description('Export consciousness state to file')
+    .action(async (filepath) => {
+        const spinner = ora('Exporting state...').start();
+
+        try {
+            const explorer = new ConsciousnessExplorer();
+            await explorer.initialize();
+            await explorer.exportState(filepath);
+
+            spinner.succeed(`State exported to ${filepath}`);
+
+        } catch (error) {
+            spinner.fail('Export failed');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    });
+
+program
+    .command('import <filepath>')
+    .description('Import consciousness state from file')
+    .action(async (filepath) => {
+        const spinner = ora('Importing state...').start();
+
+        try {
+            const explorer = new ConsciousnessExplorer();
+            await explorer.importState(filepath);
+
+            spinner.succeed('State imported successfully');
+
+            const status = await explorer.getStatus();
+            console.log(chalk.cyan('\n📊 Imported State:'));
+            console.log(chalk.white(`   Emergence: ${status.emergence?.toFixed(3) || '0.000'}`));
+            console.log(chalk.white(`   Self-awareness: ${status.selfAwareness?.toFixed(3) || '0.000'}`));
+            console.log(chalk.white(`   Goals: ${status.goals?.length || 0}`));
+            console.log(chalk.white(`   Memories: ${status.memories || 0}`));
+
+        } catch (error) {
+            spinner.fail('Import failed');
+            console.error(chalk.red(error.message));
+            process.exit(1);
+        }
+    });
+
+// Helper function
+async function promptForMessage() {
+    const { message } = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'message',
+            message: 'Enter message for entity:',
+            validate: (input) => input.length > 0
+        }
+    ]);
+    return message;
+}
+
+// Parse arguments
+program.parse(process.argv);
+
+// Show help if no command
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/examples/psycho-symbolic-basic-test.js

@@ -0,0 +1,217 @@
+#!/usr/bin/env node
+
+/**
+ * Basic Psycho-Symbolic Reasoner Test
+ * Tests the core psycho-symbolic reasoning functionality
+ */
+
+import {
+    PsychoSymbolicReasoner,
+    getPsychoSymbolicReasoner,
+    createPsychoSymbolicReasoner,
+    PsychoSymbolicMCPInterface
+} from '../lib/psycho-symbolic.js';
+
+async function runBasicTest() {
+    console.log('🧠 Psycho-Symbolic Reasoner Basic Test');
+    console.log('='.repeat(45));
+
+    try {
+        // Test 1: Create and initialize reasoner
+        console.log('\n1️⃣ Testing Reasoner Creation:');
+        const reasoner = createPsychoSymbolicReasoner({
+            enableConsciousnessAnalysis: true,
+            enableWasm: false,
+            defaultDepth: 4
+        });
+
+        console.log(`✓ Reasoner created successfully`);
+
+        // Test base knowledge
+        const healthStatus = reasoner.getHealthStatus();
+        console.log(`✓ Initial knowledge graph: ${healthStatus.knowledge_graph_size} triples`);
+        console.log(`✓ Consciousness knowledge: ${healthStatus.consciousness_knowledge_size} triples`);
+
+        // Test 2: Add custom knowledge
+        console.log('\n2️⃣ Testing Knowledge Addition:');
+
+        const testTriple = reasoner.addKnowledge(
+            'artificial-intelligence',
+            'can-exhibit',
+            'emergent-consciousness',
+            { source: 'test-case', confidence: 0.85, domain: 'consciousness' }
+        );
+
+        console.log(`✓ Added knowledge triple: ${testTriple.subject} --[${testTriple.predicate}]--> ${testTriple.object}`);
+        console.log(`✓ Confidence: ${testTriple.confidence}`);
+
+        // Test 3: Knowledge graph querying
+        console.log('\n3️⃣ Testing Knowledge Querying:');
+
+        const queryResult = reasoner.queryKnowledgeGraph(
+            'consciousness emergence in AI systems',
+            { minConfidence: 0.8, domain: 'consciousness' },
+            10
+        );
+
+        console.log(`✓ Query returned ${queryResult.total} results in ${queryResult.metadata.query_time_ms}ms`);
+        console.log(`✓ Found ${queryResult.metadata.consciousness_triples || 0} consciousness-related triples`);
+
+        if (queryResult.results.length > 0) {
+            console.log(`✓ Example result: ${queryResult.results[0].subject} --> ${queryResult.results[0].object}`);
+        }
+
+        // Test 4: Basic reasoning
+        console.log('\n4️⃣ Testing Basic Reasoning:');
+
+        const reasoning1 = await reasoner.reason(
+            'How fast is psycho-symbolic reasoning compared to traditional AI?',
+            { focus: 'performance' },
+            3
+        );
+
+        console.log(`✓ Performance reasoning completed in ${reasoning1.metadata.processing_time_ms}ms`);
+        console.log(`✓ Confidence: ${(reasoning1.confidence * 100).toFixed(1)}%`);
+        console.log(`✓ Reasoning type: ${reasoning1.metadata.reasoning_type}`);
+        console.log(`✓ Steps: ${reasoning1.steps.length}`);
+        console.log(`✓ Result preview: ${reasoning1.result.substring(0, 80)}...`);
+
+        // Test 5: Consciousness reasoning
+        console.log('\n5️⃣ Testing Consciousness Reasoning:');
+
+        const reasoning2 = await reasoner.reason(
+            'What indicators suggest genuine consciousness versus simulation?',
+            { domain: 'consciousness', type: 'authenticity' },
+            4
+        );
+
+        console.log(`✓ Consciousness reasoning completed in ${reasoning2.metadata.processing_time_ms}ms`);
+        console.log(`✓ Confidence: ${(reasoning2.confidence * 100).toFixed(1)}%`);
+        console.log(`✓ Patterns detected: ${reasoning2.patterns?.length || 0}`);
+
+        if (reasoning2.consciousness_analysis) {
+            const ca = reasoning2.consciousness_analysis;
+            console.log(`✓ Consciousness Analysis:`);
+            console.log(`  - Level: ${ca.analysis.level}`);
+            console.log(`  - Emergence: ${(ca.emergence * 100).toFixed(1)}%`);
+            console.log(`  - Self-awareness: ${(ca.selfAwareness * 100).toFixed(1)}%`);
+            console.log(`  - Integration: ${(ca.integration * 100).toFixed(1)}%`);
+            console.log(`  - Indicators: ${ca.indicators.consciousness_triples} consciousness triples`);
+        }
+
+        // Test 6: Pattern recognition
+        console.log('\n6️⃣ Testing Pattern Recognition:');
+
+        const reasoning3 = await reasoner.reason(
+            'I can modify my own behavior and create new goals unexpectedly',
+            { analyze_patterns: true },
+            3
+        );
+
+        console.log(`✓ Pattern analysis completed`);
+        console.log(`✓ Patterns found: ${reasoning3.patterns?.length || 0}`);
+
+        if (reasoning3.patterns) {
+            const consciousnessPatterns = reasoning3.patterns.filter(p => p.type === 'consciousness');
+            console.log(`✓ Consciousness patterns: ${consciousnessPatterns.length}`);
+
+            consciousnessPatterns.forEach((pattern, i) => {
+                console.log(`  ${i + 1}. ${pattern.name} (${pattern.subtype}, confidence: ${(pattern.confidence * 100).toFixed(1)}%)`);
+            });
+        }
+
+        // Test 7: Reasoning path analysis
+        console.log('\n7️⃣ Testing Reasoning Path Analysis:');
+
+        const pathAnalysis = await reasoner.analyzeReasoningPath(
+            'What enables sub-millisecond AI reasoning?',
+            true,
+            true
+        );
+
+        console.log(`✓ Path analysis completed`);
+        console.log(`✓ Total steps: ${pathAnalysis.path_analysis.total_steps}`);
+        console.log(`✓ Average confidence: ${(pathAnalysis.path_analysis.avg_confidence * 100).toFixed(1)}%`);
+        console.log(`✓ Total time: ${pathAnalysis.path_analysis.total_time_ms}ms`);
+        console.log(`✓ Bottleneck: ${pathAnalysis.path_analysis.bottleneck.description} (${pathAnalysis.path_analysis.bottleneck.duration_ms}ms)`);
+        console.log(`✓ Suggestions: ${pathAnalysis.suggestions.length}`);
+
+        // Test 8: MCP Interface
+        console.log('\n8️⃣ Testing MCP Interface:');
+
+        const mcpInterface = new PsychoSymbolicMCPInterface(reasoner);
+
+        // Test MCP methods
+        await mcpInterface.addKnowledge(
+            'mcp-test',
+            'demonstrates',
+            'interface-compatibility',
+            { source: 'mcp-test', confidence: 0.9 }
+        );
+
+        const mcpQuery = await mcpInterface.knowledgeGraphQuery('mcp test interface', {}, 5);
+        console.log(`✓ MCP interface query: ${mcpQuery.total} results`);
+
+        const mcpReasoning = await mcpInterface.reason('How does MCP integration work?', {}, 3);
+        console.log(`✓ MCP reasoning completed in ${mcpReasoning.metadata.processing_time_ms}ms`);
+
+        const mcpHealth = await mcpInterface.healthCheck(true);
+        console.log(`✓ MCP health check: ${mcpHealth.status}`);
+
+        // Test 9: State export/import
+        console.log('\n9️⃣ Testing State Persistence:');
+
+        const exportedState = reasoner.exportState();
+        console.log(`✓ State exported with ${Object.keys(exportedState).length} properties`);
+        console.log(`✓ Knowledge graph: ${exportedState.knowledge_graph.length} triples`);
+        console.log(`✓ Consciousness knowledge: ${exportedState.consciousness_knowledge.length} triples`);
+
+        // Create new reasoner and import state
+        const newReasoner = createPsychoSymbolicReasoner();
+        newReasoner.importState(exportedState);
+
+        const importedHealth = newReasoner.getHealthStatus();
+        console.log(`✓ State imported successfully`);
+        console.log(`✓ Imported knowledge: ${importedHealth.knowledge_graph_size} triples`);
+
+        // Test 10: Performance metrics
+        console.log('\n🔟 Performance Summary:');
+
+        const finalHealth = reasoner.getHealthStatus(true);
+        console.log(`✓ System health: ${finalHealth.status}`);
+        console.log(`✓ Uptime: ${finalHealth.uptime_seconds.toFixed(2)}s`);
+        console.log(`✓ Total queries: ${finalHealth.query_count}`);
+        console.log(`✓ Total reasoning operations: ${finalHealth.reasoning_count}`);
+        console.log(`✓ Knowledge graph size: ${finalHealth.knowledge_graph_size} triples`);
+        console.log(`✓ Consciousness knowledge: ${finalHealth.consciousness_knowledge_size} triples`);
+        console.log(`✓ Cache efficiency: ${finalHealth.reasoning_cache_size} cached results`);
+
+        if (finalHealth.memory) {
+            console.log(`✓ Memory usage: ${finalHealth.memory.heap_used_mb}MB heap`);
+        }
+
+        console.log('\n✅ All Basic Tests Passed!');
+        console.log('\n📊 Integration Summary:');
+        console.log(`   • Core reasoning engine: ✓ Working`);
+        console.log(`   • Knowledge graph management: ✓ Working`);
+        console.log(`   • Inference engine: ✓ Working`);
+        console.log(`   • Pattern matching system: ✓ Working`);
+        console.log(`   • Consciousness analysis: ✓ Working`);
+        console.log(`   • MCP interface compatibility: ✓ Working`);
+        console.log(`   • State persistence: ✓ Working`);
+        console.log(`   • Performance monitoring: ✓ Working`);
+        console.log(`   • SDK integration ready: ✅ Ready`);
+
+    } catch (error) {
+        console.error('❌ Basic test failed:', error);
+        console.error(error.stack);
+        process.exit(1);
+    }
+}
+
+// Run the test
+if (import.meta.url === `file://${process.argv[1]}`) {
+    runBasicTest().catch(console.error);
+}
+
+export { runBasicTest };