zexus 1.6.2

package/src/tests/test_core_integration.py

@@ -0,0 +1,185 @@
+# Test verify_integration with fixes
+
+# Core test cases that should always pass
+CORE_TESTS = [
+    {
+        'code': '''
+action simple() {
+    print("inside action")
+}
+simple()
+''',
+        'desc': "Basic action execution"
+    },
+    {
+        'code': '''
+action sayHello(name) {
+    print("Hello " + name)
+}
+sayHello("World")
+''',
+        'desc': "Action with parameters"
+    },
+    {
+        'code': '''
+action async getData() {
+    return await async_identity(42)
+}
+let result = getData()
+print(core.string(result))
+''',
+        'desc': "Async action execution"
+    },
+    {
+        'code': '''
+let obj = {x: 1}
+obj.y = 2
+print(core.string(obj))
+''',
+        'desc': "Object property access/assign"
+    },
+    {
+        'code': '''
+let arr = [1,2,3]
+let doubled = arr.map(x => x * 2)
+print(core.string(doubled))
+''',
+        'desc': "Array methods with arrow functions"
+    },
+    {
+        'code': '''
+try {
+    throw "oops"
+} catch(err) {
+    print("Caught: " + core.string(err))
+}
+''',
+        'desc': "Try-catch error handling"
+    },
+    {
+        'code': '''
+let nums = [1,2,3,4,5]
+let sum = nums.reduce((a,b) => a + b)
+print(core.string(sum))
+''',
+        'desc': "Chained method calls"
+    },
+    {
+        'code': '''
+let obj = {
+    data: {
+        users: [
+            { name: "Alice", scores: [10, 20, 30] },
+            { name: "Bob", scores: [15, 25, 35] }
+        ],
+        settings: {
+            active: true,
+            config: {
+                theme: "dark",
+                notifications: {
+                    email: true,
+                    push: false
+                }
+            }
+        }
+    }
+}
+print(core.string(obj.data.users[0].scores[1]))
+print(core.string(obj.data.settings.config.notifications.email))
+''',
+        'desc': "Deep nested structure access"
+    }
+]
+
+import os
+import sys
+import time
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+from zexus.lexer import Lexer
+from zexus.parser import Parser, UltimateParser
+from zexus.evaluator import evaluate
+from zexus.object import Environment
+from zexus.config import config
+
+def run_test(test_case):
+    # Add import of core library
+    code = '''
+use "zexus-core" as core
+
+''' + test_case['code']
+    desc = test_case['desc']
+    
+    print(f"\n=== Testing: {desc} ===")
+    print(f"Code:\n{code}")
+    
+    try:
+        # Start timing
+        start_time = time.time()
+        parse_start = time.time()
+        # Parse with both parsers
+        lexer = Lexer(code)
+        basic_parser = Parser(lexer)
+        basic_prog = basic_parser.parse_program()
+        
+        lexer2 = Lexer(code)
+        ultimate_parser = UltimateParser(lexer2)
+        ultimate_prog = ultimate_parser.parse_program()
+        
+        # Check parser outputs match
+        if str(basic_prog) != str(ultimate_prog):
+            print("⚠️  Parser output mismatch!")
+            print("Basic parser:")
+            print(basic_prog)
+            print("\nUltimate parser:")
+            print(ultimate_prog)
+            return False
+            
+        parse_time = time.time() - parse_start
+        print(f"⏱️  Parsing time: {parse_time:.4f}s")
+            
+        # Evaluate program
+        eval_start = time.time()
+        env = Environment()
+        config.enable_debug('minimal')  # Show important logs only
+        result = evaluate(ultimate_prog, env)
+        config.disable_debug()
+        
+        eval_time = time.time() - eval_start
+        total_time = time.time() - start_time
+        
+        print(f"⏱️  Evaluation time: {eval_time:.4f}s")
+        print(f"⏱️  Total time: {total_time:.4f}s")
+        
+        print("✅ Test passed!")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test failed: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def main():
+    print("🔬 Running core integration tests...")
+    failed = []
+    
+    for test in CORE_TESTS:
+        if not run_test(test):
+            failed.append(test['desc'])
+            
+    print("\n=== Summary ===")
+    print(f"Total tests: {len(CORE_TESTS)}")
+    print(f"Passed: {len(CORE_TESTS) - len(failed)}")
+    print(f"Failed: {len(failed)}")
+    
+    if failed:
+        print("\nFailed tests:")
+        for f in failed:
+            print(f"  - {f}")
+        sys.exit(1)
+    else:
+        print("\n✨ All tests passed!")
+
+if __name__ == "__main__":
+    main()

package/src/tests/test_phase10_ecosystem.zx

@@ -0,0 +1,177 @@
+// Zexus Phase 10: Ecosystem Test Suite
+// Tests package management, marketplace, and profiling
+
+// Test 1: Package registry
+function registerPackage(name, version, metadata) {
+    print("Registering package: " + name + "@" + version);
+    return {
+        "name": name,
+        "version": version,
+        "installed": true,
+        "metadata": metadata
+    };
+}
+
+// Test 2: Package installation
+function installPackage(packageName, version) {
+    print("Installing package: " + packageName + "@" + version);
+    return {
+        "name": packageName,
+        "version": version,
+        "status": "installed"
+    };
+}
+
+// Test 3: Package dependencies
+function resolveDependencies(packageName) {
+    print("Resolving dependencies for: " + packageName);
+    let deps = [];
+    if (packageName == "web-framework") {
+        deps = ["express", "router", "middleware"];
+    }
+    if (packageName == "database") {
+        deps = ["connection", "query", "transaction"];
+    }
+    return deps;
+}
+
+// Test 4: Plugin marketplace
+function searchMarketplace(query) {
+    print("Searching marketplace for: " + query);
+    let results = ["plugin1", "plugin2", "plugin3"];
+    return results;
+}
+
+function getMarketplaceStats() {
+    print("Getting marketplace statistics");
+    return {
+        "total_plugins": 1000,
+        "total_packages": 5000,
+        "downloads_today": 50000
+    };
+}
+
+// Test 5: Performance profiler
+function profileFunction(name, func) {
+    print("Profiling function: " + name);
+    // Simulate timing
+    let startTime = 0;
+    let result = func();
+    let endTime = 1000;
+    return {
+        "name": name,
+        "time_ms": endTime - startTime,
+        "result": result
+    };
+}
+
+// Test 6: Performance metrics
+function recordMetric(metricName, value) {
+    print("Recording metric: " + metricName + " = " + value);
+    return {
+        "name": metricName,
+        "value": value,
+        "timestamp": 12345
+    };
+}
+
+// Test 7: Version management
+function checkVersionCompatibility(required, installed) {
+    print("Checking compatibility: required=" + required + ", installed=" + installed);
+    return required == installed;
+}
+
+function upgradePackage(name, fromVersion, toVersion) {
+    print("Upgrading " + name + " from " + fromVersion + " to " + toVersion);
+    return {
+        "name": name,
+        "from": fromVersion,
+        "to": toVersion,
+        "status": "upgraded"
+    };
+}
+
+// Test 8: Package uninstall
+function uninstallPackage(name) {
+    print("Uninstalling package: " + name);
+    return {
+        "name": name,
+        "status": "uninstalled"
+    };
+}
+
+// Test suite execution
+print("Phase 10: Ecosystem Test Suite");
+print("===============================");
+
+// Test package registration
+print("\nTesting package registration:");
+let pkg1 = registerPackage("json-utils", "1.0.0", {"author": "user", "license": "MIT"});
+print("Package registered: " + pkg1["name"]);
+
+let pkg2 = registerPackage("crypto-lib", "2.1.0", {"author": "dev", "license": "Apache"});
+print("Package registered: " + pkg2["name"]);
+
+// Test package installation
+print("\nTesting package installation:");
+let inst1 = installPackage("lodash", "4.17.21");
+print("Installation status: " + inst1["status"]);
+
+let inst2 = installPackage("moment", "2.29.4");
+print("Installation status: " + inst2["status"]);
+
+// Test dependency resolution
+print("\nTesting dependency resolution:");
+let deps1 = resolveDependencies("web-framework");
+print("Dependencies: " + deps1);
+
+let deps2 = resolveDependencies("database");
+print("Dependencies: " + deps2);
+
+// Test marketplace search
+print("\nTesting marketplace search:");
+let results = searchMarketplace("parser");
+print("Search results: " + results);
+
+let results2 = searchMarketplace("compiler");
+print("Search results: " + results2);
+
+// Test marketplace stats
+print("\nTesting marketplace statistics:");
+let stats = getMarketplaceStats();
+print("Total plugins: " + stats["total_plugins"]);
+print("Total packages: " + stats["total_packages"]);
+print("Downloads today: " + stats["downloads_today"]);
+
+// Test performance profiling
+print("\nTesting performance profiling:");
+let prof1 = profileFunction("quicksort", function() {
+    return "sorted";
+});
+print("Function profiled: " + prof1["name"] + " took " + prof1["time_ms"] + "ms");
+
+let prof2 = profileFunction("fibonacci", function() {
+    return 100;
+});
+print("Function profiled: " + prof2["name"] + " returned " + prof2["result"]);
+
+// Test performance metrics
+print("\nTesting performance metrics:");
+recordMetric("cpu_usage", 45.5);
+recordMetric("memory_usage", 512);
+recordMetric("disk_io", 1024);
+
+// Test version management
+print("\nTesting version management:");
+checkVersionCompatibility("1.0.0", "1.0.0");
+checkVersionCompatibility("2.0.0", "1.5.0");
+
+let upgrade = upgradePackage("framework", "1.0.0", "2.0.0");
+print("Upgrade result: " + upgrade["status"]);
+
+// Test package uninstall
+print("\nTesting package uninstall:");
+let uninstall = uninstallPackage("old-plugin");
+print("Uninstall status: " + uninstall["status"]);
+
+print("\n✓ All ecosystem tests completed");

package/src/tests/test_phase1_modifiers.zx

@@ -0,0 +1,87 @@
+// Zexus Phase 1: Modifiers Test Suite
+// Tests semantic tagging of code elements
+
+// Test 1: Basic modifier attachment
+inline function add(a, b) {
+    return a + b;
+}
+
+// Test 2: Multiple modifiers
+pure function fibonacci(n) {
+    if (n <= 1) {
+        return n;
+    }
+    return fibonacci(n - 1) + fibonacci(n - 2);
+}
+
+// Test 3: Async modifier (simulated)
+// In real execution, would run in background
+async function slowComputation() {
+    let result = 0;
+    let i = 0;
+    while (i < 100000) {
+        result = result + i;
+        i = i + 1;
+    }
+    return result;
+}
+
+// Test 4: Secure modifier for sensitive operations
+secure function encryptData(data) {
+    // Simulated encryption
+    return data + "_encrypted";
+}
+
+// Test 5: Native modifier (system-level operation)
+native function systemCall() {
+    // This would call native code
+    return "system_result";
+}
+
+// Test 6: Sealed modifier (cannot be overridden)
+sealed function baseImplementation() {
+    return 42;
+}
+
+// Test 7: Public modifier (default visibility)
+public function publicAPI() {
+    return "public";
+}
+
+// Test 8: Private modifier (not exported)
+private function privateHelper() {
+    return "private";
+}
+
+// Test suite execution
+print("Phase 1: Modifiers Test Suite");
+print("==============================");
+
+// Test inline function
+let result1 = add(5, 3);
+print("Inline add(5, 3) = " + result1);
+
+// Test pure function
+let result2 = fibonacci(5);
+print("Pure fibonacci(5) = " + result2);
+
+// Test async function
+let result3 = slowComputation();
+print("Async computation result = " + result3);
+
+// Test secure function
+let result4 = encryptData("secret");
+print("Secure encrypt = " + result4);
+
+// Test sealed function
+let result5 = baseImplementation();
+print("Sealed base = " + result5);
+
+// Test public/private functions
+let result6 = publicAPI();
+print("Public API = " + result6);
+
+let result7 = privateHelper();
+print("Private helper = " + result7);
+
+print("✓ All modifier tests completed");

package/src/tests/test_phase2_plugins.zx

@@ -0,0 +1,80 @@
+// Zexus Phase 2: Plugin System Test Suite
+// Tests plugin hooks and extensibility
+
+// Test 1: Hook-like function definitions
+function hookListener(eventName) {
+    print("Hook: " + eventName + " triggered");
+}
+
+// Test 2: Event emitter simulation
+function emitEvent(eventName, data) {
+    print("Emitting event: " + eventName + " with data: " + data);
+    hookListener(eventName);
+    return true;
+}
+
+// Test 3: Plugin system with callbacks
+function registerPlugin(pluginName, callback) {
+    print("Plugin registered: " + pluginName);
+    return callback();
+}
+
+// Test 4: Before/After hooks
+function beforeHook(functionName) {
+    print("Before hook: executing " + functionName);
+}
+
+function afterHook(functionName, result) {
+    print("After hook: " + functionName + " returned " + result);
+}
+
+function executeWithHooks(name, operation) {
+    beforeHook(name);
+    let result = operation();
+    afterHook(name, result);
+    return result;
+}
+
+// Test 5: Plugin capability checks
+function checkCapability(capability) {
+    print("Checking capability: " + capability);
+    return true;
+}
+
+// Test suite execution
+print("Phase 2: Plugin System Test Suite");
+print("=================================");
+
+// Test event emission
+print("\nTesting event emission:");
+emitEvent("init", 42);
+emitEvent("process", "data");
+
+// Test plugin registration
+print("\nTesting plugin registration:");
+registerPlugin("logging", function() {
+    print("Logging plugin initialized");
+    return 1;
+});
+
+registerPlugin("caching", function() {
+    print("Caching plugin initialized");
+    return 2;
+});
+
+// Test hooks
+print("\nTesting before/after hooks:");
+let hookResult = executeWithHooks("testFunc", function() {
+    print("Executing main function");
+    return 99;
+});
+
+print("Hook execution result: " + hookResult);
+
+// Test capability checks
+print("\nTesting capability checks:");
+checkCapability("io.read");
+checkCapability("io.write");
+checkCapability("network.access");
+
+print("\n✓ All plugin system tests completed");

package/src/tests/test_phase3_security.zx

@@ -0,0 +1,97 @@
+// Zexus Phase 3: Capability Security Test Suite
+// Tests fine-grained access control
+
+// Test 1: Permission checking function
+function checkPermission(capability) {
+    print("Checking permission: " + capability);
+    return true;
+}
+
+// Test 2: Access control wrapper
+function requireCapability(cap, operation) {
+    if (checkPermission(cap)) {
+        print("Capability granted: " + cap);
+        return operation();
+    } else {
+        print("Capability denied: " + cap);
+        return false;
+    }
+}
+
+// Test 3: File I/O with capability checks
+function readFile(filename) {
+    print("Read capability check for: " + filename);
+    return "file_contents";
+}
+
+function writeFile(filename, content) {
+    print("Write capability check for: " + filename);
+    return true;
+}
+
+// Test 4: Network operations with capabilities
+function httpRequest(url) {
+    print("Network capability check for: " + url);
+    return "response";
+}
+
+// Test 5: Dangerous operations
+function executeCommand(cmd) {
+    print("Executing with capability check: " + cmd);
+    return "command_output";
+}
+
+// Test 6: Selective permission granting
+function createRestrictedContext() {
+    print("Creating restricted execution context");
+    let permissions = {
+        "io.read": true,
+        "io.write": false,
+        "network": false,
+        "execute": false
+    };
+    return permissions;
+}
+
+// Test suite execution
+print("Phase 3: Capability Security Test Suite");
+print("========================================");
+
+// Test basic permission checks
+print("\nTesting basic permissions:");
+checkPermission("core.language");
+checkPermission("io.read");
+checkPermission("io.write");
+
+// Test with operations
+print("\nTesting capability-gated operations:");
+requireCapability("io.read", function() {
+    print("Reading file with permission");
+    return readFile("test.txt");
+});
+
+requireCapability("io.write", function() {
+    print("Writing file with permission");
+    return writeFile("output.txt", "data");
+});
+
+// Test network operations
+print("\nTesting network operations:");
+requireCapability("network.access", function() {
+    return httpRequest("https://example.com");
+});
+
+// Test dangerous operations
+print("\nTesting dangerous operations:");
+requireCapability("system.execute", function() {
+    return executeCommand("ls -la");
+});
+
+// Test restricted context
+print("\nTesting restricted context:");
+let context = createRestrictedContext();
+print("Context has io.read: " + context["io.read"]);
+print("Context has io.write: " + context["io.write"]);
+print("Context has network: " + context["network"]);
+
+print("\n✓ All capability security tests completed");