use a proper rust project for testing

Author: ifsheldon

examples/rust_adaptive_sort/evaluator.py

@@ -9,6 +9,10 @@
 from pathlib import Path
 from openevolve.evaluation_result import EvaluationResult
 import logging
+import os
+
+THIS_FILE_DIR = Path(os.path.dirname(os.path.realpath(__file__)))
+
 logger = logging.getLogger("examples.rust_adaptive_sort.evaluator")
 
 
@@ -63,127 +67,28 @@ async def _evaluate(program_path: str) -> EvaluationResult:
                 dst.write(lib_content)
 
             # Create main.rs with benchmark code
-            main_content = """
-use sort_test::{adaptive_sort, run_benchmark};
-use std::time::Instant;
-
-fn main() {
-    // Generate test datasets with different characteristics
-    let test_data = vec![
-        // Random data
-        generate_random_data(1000),
-        generate_random_data(10000),
-        
-        // Nearly sorted data
-        generate_nearly_sorted_data(1000, 0.05),
-        generate_nearly_sorted_data(10000, 0.05),
-        
-        // Reverse sorted data
-        generate_reverse_sorted_data(1000),
-        generate_reverse_sorted_data(10000),
-        
-        // Data with many duplicates
-        generate_data_with_duplicates(1000, 10),
-        generate_data_with_duplicates(10000, 100),
-        
-        // Partially sorted data
-        generate_partially_sorted_data(1000, 0.3),
-        generate_partially_sorted_data(10000, 0.3),
-    ];
-    
-    let results = run_benchmark(test_data);
-    
-    // Calculate metrics
-    let all_correct = results.correctness.iter().all(|&c| c);
-    let correctness_score = if all_correct { 1.0 } else { 0.0 };
-    
-    let avg_time: f64 = results.times.iter().sum::<f64>() / results.times.len() as f64;
-    
-    // Performance score (normalized, assuming baseline of 0.1 seconds for largest dataset)
-    let performance_score = 1.0 / (1.0 + avg_time * 10.0);
-    
-    // Output results as JSON
-    println!("{{");
-    println!("  \\"correctness\\": {},", correctness_score);
-    println!("  \\"avg_time\\": {},", avg_time);
-    println!("  \\"performance_score\\": {},", performance_score);
-    println!("  \\"adaptability_score\\": {},", results.adaptability_score);
-    println!("  \\"times\\": {:?},", results.times);
-    println!("  \\"all_correct\\": {}", all_correct);
-    println!("}}");
-}
-
-fn generate_random_data(size: usize) -> Vec<i32> {
-    (0..size).map(|_| rand::random::<i32>() % 10000).collect()
-}
-
-fn generate_nearly_sorted_data(size: usize, disorder_rate: f64) -> Vec<i32> {
-    let mut data: Vec<i32> = (0..size as i32).collect();
-    let swaps = (size as f64 * disorder_rate) as usize;
-    
-    for _ in 0..swaps {
-        let i = rand::random::<usize>() % size;
-        let j = rand::random::<usize>() % size;
-        data.swap(i, j);
-    }
-    
-    data
-}
-
-fn generate_reverse_sorted_data(size: usize) -> Vec<i32> {
-    (0..size as i32).rev().collect()
-}
-
-fn generate_data_with_duplicates(size: usize, unique_values: usize) -> Vec<i32> {
-    (0..size).map(|_| rand::random::<i32>() % unique_values as i32).collect()
-}
-
-fn generate_partially_sorted_data(size: usize, sorted_fraction: f64) -> Vec<i32> {
-    let sorted_size = (size as f64 * sorted_fraction) as usize;
-    let mut data = Vec::with_capacity(size);
-    
-    // Add sorted portion
-    data.extend((0..sorted_size as i32));
-    
-    // Add random portion
-    data.extend((0..(size - sorted_size)).map(|_| rand::random::<i32>() % 10000));
-    
-    data
-}
-
-// Simple random implementation
-mod rand {
-    use std::cell::Cell;
-    use std::time::{SystemTime, UNIX_EPOCH};
-    
-    thread_local! {
-        static SEED: Cell<u64> = Cell::new(
-            SystemTime::now()
-                .duration_since(UNIX_EPOCH)
-                .unwrap()
-                .as_secs()
-        );
-    }
-    
-    pub fn random<T>() -> T
-    where
-        T: From<u64>,
-    {
-        SEED.with(|seed| {
-            let mut x = seed.get();
-            x ^= x << 13;
-            x ^= x >> 7;
-            x ^= x << 17;
-            seed.set(x);
-            T::from(x)
-        })
-    }
-}
-"""
+            project_source_dir = THIS_FILE_DIR / "sort_test"
+            main_file_source = project_source_dir / "src" / "main.rs"
+            with open(main_file_source, "r") as f:
+                main_content = f.read()
             main_path = project_dir / "src" / "main.rs"
             with open(main_path, "w") as f:
                 f.write(main_content)
 
+            cargo_toml_source = project_source_dir / "Cargo.toml"
+            with open(cargo_toml_source, "r") as f:
+                cargo_toml_content = f.read()
+            cargo_toml_path = project_dir / "Cargo.toml"
+            with open(cargo_toml_path, "w") as f:
+                f.write(cargo_toml_content)
+
+            cargo_lock_source = project_source_dir / "Cargo.lock"
+            with open(cargo_lock_source, "r") as f:
+                cargo_lock_content = f.read()
+            cargo_lock_path = project_dir / "Cargo.lock"
+            with open(cargo_lock_path, "w") as f:
+                f.write(cargo_lock_content)
+
             # Build the project
             build_result = subprocess.run(
                 ["cargo", "build", "--release"],

examples/rust_adaptive_sort/sort_test/.gitignore

@@ -0,0 +1 @@
+target/

examples/rust_adaptive_sort/sort_test/Cargo.lock

@@ -0,0 +1,7 @@
+[package]
+name = "sort_test"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+rand = "0.9.2"