evolve / openevolve-fixed /tests /test_evaluator_timeout.py

Upload folder using huggingface_hub

ea8c728 verified 7 months ago

16.9 kB

"""
Tests for evaluation timeout functionality in openevolve.evaluator
"""

import asyncio
import os
import tempfile
import time
import unittest
from unittest.mock import patch, MagicMock

from openevolve.config import EvaluatorConfig
from openevolve.evaluator import Evaluator


class TestEvaluatorTimeout(unittest.TestCase):
    """Tests for evaluator timeout functionality"""

    def setUp(self):
        """Set up test evaluation file"""
        # Create a test evaluation file
        self.test_eval_file = tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False)

        # Write test evaluation functions with shorter sleep times for faster tests
        self.test_eval_file.write(
            """
import time
def evaluate(program_path):
    # Read the program to determine behavior
    with open(program_path, 'r') as f:
        code = f.read()
    
    if 'SLEEP_LONG' in code:
        # Sleep for a long time to trigger timeout (reduced for faster tests)
        time.sleep(8)
        return {"score": 1.0}
    elif 'SLEEP_SHORT' in code:
        # Sleep for a short time that should not timeout
        time.sleep(0.5)
        return {"score": 0.8}
    elif 'RAISE_ERROR' in code:
        # Raise an error to trigger retries
        raise RuntimeError("Evaluation failed")
    else:
        # Fast evaluation
        return {"score": 0.5}
def evaluate_stage1(program_path):
    with open(program_path, 'r') as f:
        code = f.read()
    
    if 'STAGE1_TIMEOUT' in code:
        time.sleep(8)
        return {"stage1_score": 1.0}
    else:
        return {"stage1_score": 0.7}
def evaluate_stage2(program_path):
    with open(program_path, 'r') as f:
        code = f.read()
    
    if 'STAGE2_TIMEOUT' in code:
        time.sleep(8)
        return {"stage2_score": 1.0}
    else:
        return {"stage2_score": 0.8}
def evaluate_stage3(program_path):
    with open(program_path, 'r') as f:
        code = f.read()
    
    if 'STAGE3_TIMEOUT' in code:
        time.sleep(8)
        return {"stage3_score": 1.0}
    else:
        return {"stage3_score": 0.9}
"""
        )
        self.test_eval_file.close()

    def tearDown(self):
        """Clean up test files"""
        if os.path.exists(self.test_eval_file.name):
            os.unlink(self.test_eval_file.name)

    def _create_evaluator(self, timeout=3, cascade_evaluation=False):
        """Helper to create evaluator with given settings (shorter timeout for faster tests)"""
        config = EvaluatorConfig()
        config.timeout = timeout
        config.max_retries = 1  # Minimal retries for faster testing
        config.cascade_evaluation = cascade_evaluation
        config.cascade_thresholds = [0.5, 0.7, 0.9]

        return Evaluator(
            config=config,
            evaluation_file=self.test_eval_file.name,
            llm_ensemble=None,
            prompt_sampler=None,
        )

    def test_fast_evaluation_completes(self):
        """Test that fast evaluations complete successfully"""

        async def run_test():
            evaluator = self._create_evaluator(timeout=3)
            program_code = "def test(): return 'fast'"
            start_time = time.time()

            result = await evaluator.evaluate_program(program_code, "test_fast")

            elapsed_time = time.time() - start_time

            # Should complete quickly
            self.assertLess(elapsed_time, 2.0)
            # Should return successful result
            self.assertIn("score", result)
            self.assertEqual(result["score"], 0.5)
            # Should not have timeout or error flags
            self.assertNotIn("timeout", result)
            self.assertNotIn("error", result)

        asyncio.run(run_test())

    def test_short_evaluation_completes(self):
        """Test that evaluations shorter than timeout complete successfully"""

        async def run_test():
            evaluator = self._create_evaluator(timeout=3)
            program_code = "# SLEEP_SHORT\ndef test(): return 'short'"
            start_time = time.time()

            result = await evaluator.evaluate_program(program_code, "test_short")

            elapsed_time = time.time() - start_time

            # Should complete within timeout
            self.assertLess(elapsed_time, 3)
            # Should return successful result
            self.assertIn("score", result)
            self.assertEqual(result["score"], 0.8)
            # Should not have timeout or error flags
            self.assertNotIn("timeout", result)
            self.assertNotIn("error", result)

        asyncio.run(run_test())

    def test_long_evaluation_times_out(self):
        """Test that long evaluations time out properly"""

        async def run_test():
            evaluator = self._create_evaluator(timeout=3)
            program_code = "# SLEEP_LONG\ndef test(): return 'long'"
            start_time = time.time()

            result = await evaluator.evaluate_program(program_code, "test_long")

            elapsed_time = time.time() - start_time

            # Should complete around the timeout period (allowing some margin)
            self.assertGreater(elapsed_time, 2.5)
            self.assertLess(elapsed_time, 5)

            # Should return timeout result
            self.assertIn("error", result)
            self.assertEqual(result["error"], 0.0)
            self.assertIn("timeout", result)
            self.assertTrue(result["timeout"])

        asyncio.run(run_test())

    def test_cascade_evaluation_timeout_stage1(self):
        """Test timeout in cascade evaluation stage 1"""

        async def run_test():
            evaluator = self._create_evaluator(timeout=3, cascade_evaluation=True)
            program_code = "# STAGE1_TIMEOUT\ndef test(): return 'stage1_timeout'"
            start_time = time.time()

            result = await evaluator.evaluate_program(program_code, "test_cascade_stage1")

            elapsed_time = time.time() - start_time

            # Should timeout around the configured timeout
            self.assertGreater(elapsed_time, 2.5)
            self.assertLess(elapsed_time, 5)

            # Should return stage1 timeout result
            self.assertIn("stage1_passed", result)
            self.assertEqual(result["stage1_passed"], 0.0)
            self.assertIn("timeout", result)
            self.assertTrue(result["timeout"])

        asyncio.run(run_test())

    def test_cascade_evaluation_timeout_stage2(self):
        """Test timeout in cascade evaluation stage 2"""

        async def run_test():
            evaluator = self._create_evaluator(timeout=3, cascade_evaluation=True)
            program_code = "# STAGE2_TIMEOUT\ndef test(): return 'stage2_timeout'"
            start_time = time.time()

            result = await evaluator.evaluate_program(program_code, "test_cascade_stage2")

            elapsed_time = time.time() - start_time

            # Should timeout on stage 2, but stage 1 should complete first
            self.assertGreater(elapsed_time, 2.5)
            self.assertLess(elapsed_time, 5)

            # Should have stage1 result but stage2 timeout
            self.assertIn("stage1_score", result)
            self.assertEqual(result["stage1_score"], 0.7)
            self.assertIn("stage2_passed", result)
            self.assertEqual(result["stage2_passed"], 0.0)
            self.assertIn("timeout", result)
            self.assertTrue(result["timeout"])

        asyncio.run(run_test())

    def test_cascade_evaluation_timeout_stage3(self):
        """Test timeout in cascade evaluation stage 3"""

        async def run_test():
            evaluator = self._create_evaluator(timeout=3, cascade_evaluation=True)
            program_code = "# STAGE3_TIMEOUT\ndef test(): return 'stage3_timeout'"
            start_time = time.time()

            result = await evaluator.evaluate_program(program_code, "test_cascade_stage3")

            elapsed_time = time.time() - start_time

            # Should timeout on stage 3, but stages 1 and 2 should complete first
            self.assertGreater(elapsed_time, 2.5)
            self.assertLess(elapsed_time, 5)

            # Should have stage1 and stage2 results but stage3 timeout
            self.assertIn("stage1_score", result)
            self.assertEqual(result["stage1_score"], 0.7)
            self.assertIn("stage2_score", result)
            self.assertEqual(result["stage2_score"], 0.8)
            self.assertIn("stage3_passed", result)
            self.assertEqual(result["stage3_passed"], 0.0)
            self.assertIn("timeout", result)
            self.assertTrue(result["timeout"])

        asyncio.run(run_test())

    def test_timeout_config_respected(self):
        """Test that the timeout configuration value is actually used"""

        async def run_test():
            # Create evaluator with different timeout
            evaluator = self._create_evaluator(timeout=5)

            program_code = "# SLEEP_LONG\ndef test(): return 'long'"
            start_time = time.time()

            result = await evaluator.evaluate_program(program_code, "test_config")

            elapsed_time = time.time() - start_time

            # Should timeout around 5 seconds, not 3
            self.assertGreater(elapsed_time, 4.5)
            self.assertLess(elapsed_time, 7)

            # Should return timeout result
            self.assertIn("timeout", result)
            self.assertTrue(result["timeout"])

        asyncio.run(run_test())

    def test_multiple_retries_with_errors(self):
        """Test that retries work correctly with actual errors (not timeouts)"""

        async def run_test():
            # Create evaluator with more retries
            config = EvaluatorConfig()
            config.timeout = 8  # Long timeout to avoid timeout during this test
            config.max_retries = 2  # 3 total attempts
            config.cascade_evaluation = False

            evaluator = Evaluator(
                config=config,
                evaluation_file=self.test_eval_file.name,
                llm_ensemble=None,
                prompt_sampler=None,
            )

            # Use RAISE_ERROR to trigger actual exceptions that will be retried
            program_code = "# RAISE_ERROR\ndef test(): return 'error'"
            start_time = time.time()

            result = await evaluator.evaluate_program(program_code, "test_retries")

            elapsed_time = time.time() - start_time

            # Should have retried 3 times (max_retries=2 means 3 total attempts)
            # Each attempt should fail quickly, plus 1 second sleep between retries
            # So total time should be around 2-3 seconds (quick failures + 2 sleep periods)
            self.assertGreater(elapsed_time, 1.8)  # At least 2 sleep periods
            self.assertLess(elapsed_time, 4)  # But not too long

            # Should return error result after all retries fail
            self.assertIn("error", result)
            self.assertEqual(result["error"], 0.0)

        asyncio.run(run_test())

    def test_timeout_does_not_trigger_retries(self):
        """Test that timeouts do not trigger retries (correct behavior)"""

        async def run_test():
            # Create evaluator with retries enabled
            config = EvaluatorConfig()
            config.timeout = 2  # Short timeout
            config.max_retries = 2  # Would allow 3 attempts if retries were triggered
            config.cascade_evaluation = False

            evaluator = Evaluator(
                config=config,
                evaluation_file=self.test_eval_file.name,
                llm_ensemble=None,
                prompt_sampler=None,
            )

            # Use SLEEP_LONG to trigger timeout
            program_code = "# SLEEP_LONG\ndef test(): return 'long'"
            start_time = time.time()

            result = await evaluator.evaluate_program(program_code, "test_timeout_no_retry")

            elapsed_time = time.time() - start_time

            # Should timeout only once (~2 seconds), not retry multiple times
            # If retries were happening, this would take ~6 seconds
            self.assertGreater(elapsed_time, 1.8)  # At least the timeout period
            self.assertLess(elapsed_time, 3.5)  # But not multiple timeout periods

            # Should return timeout result
            self.assertIn("timeout", result)
            self.assertTrue(result["timeout"])

        asyncio.run(run_test())

    def test_artifacts_on_timeout(self):
        """Test that timeout artifacts are properly captured"""

        async def run_test():
            # Enable artifacts
            with patch.dict(os.environ, {"ENABLE_ARTIFACTS": "true"}):
                evaluator = self._create_evaluator(timeout=3)
                program_code = "# SLEEP_LONG\ndef test(): return 'long'"

                # Execute evaluation
                result = await evaluator.evaluate_program(program_code, "test_artifacts")

                # Verify timeout occurred
                self.assertIn("timeout", result, "Result should contain timeout flag")
                self.assertTrue(result["timeout"], "Timeout flag should be True")

                # Verify artifacts were captured
                artifacts = evaluator.get_pending_artifacts("test_artifacts")
                self.assertIsNotNone(artifacts, "Artifacts should not be None")

                # Verify required artifact fields
                self.assertIn("failure_stage", artifacts, "Artifacts should contain failure_stage")
                self.assertEqual(
                    artifacts["failure_stage"], "evaluation", "failure_stage should be 'evaluation'"
                )

                self.assertIn("timeout", artifacts, "Artifacts should contain timeout flag")
                self.assertTrue(artifacts["timeout"], "Artifact timeout flag should be True")

                self.assertIn("error_type", artifacts, "Artifacts should contain error_type")
                self.assertEqual(
                    artifacts["error_type"], "timeout", "error_type should be 'timeout'"
                )

                self.assertIn(
                    "timeout_duration", artifacts, "Artifacts should contain timeout_duration"
                )
                self.assertEqual(
                    artifacts["timeout_duration"], 3, "timeout_duration should match config"
                )

                print(f"✅ Artifacts captured correctly: {list(artifacts.keys())}")

        asyncio.run(run_test())


class TestTimeoutIntegration(unittest.TestCase):
    """Integration tests for timeout functionality"""

    def test_real_world_scenario(self):
        """Test a scenario similar to the reported bug"""

        async def run_test():
            # Create a test evaluation file that simulates a long-running evaluation
            test_eval_file = tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False)

            test_eval_file.write(
                """
import time
def evaluate(program_path):
    # Simulate a very long evaluation (like the 11-hour case) 
    time.sleep(6)  # 6 seconds to test timeout (reduced for faster tests)
    return {"accReturn": 0.1, "CalmarRatio": 0.9, "combined_score": 0.82}
"""
            )
            test_eval_file.close()

            try:
                # Configure like user's config but with shorter timeout for testing
                config = EvaluatorConfig()
                config.timeout = 3  # 3 seconds instead of 600
                config.max_retries = 1
                config.cascade_evaluation = False
                config.parallel_evaluations = 1

                evaluator = Evaluator(
                    config=config,
                    evaluation_file=test_eval_file.name,
                    llm_ensemble=None,
                    prompt_sampler=None,
                )

                program_code = """
# Financial optimization algorithm
def search_algorithm():
    # This would normally run for hours
    return {"report_type_factor_map": {}}
"""

                start_time = time.time()
                result = await evaluator.evaluate_program(program_code, "financial_test")
                elapsed_time = time.time() - start_time

                # Should timeout in ~3 seconds, not 6+ seconds
                self.assertLess(elapsed_time, 5)
                self.assertGreater(elapsed_time, 2.5)

                # Should return timeout error
                self.assertIn("error", result)
                self.assertIn("timeout", result)
                self.assertTrue(result["timeout"])

            finally:
                if os.path.exists(test_eval_file.name):
                    os.unlink(test_eval_file.name)

        asyncio.run(run_test())


if __name__ == "__main__":
    # Run with verbose output to see test progress
    unittest.main(verbosity=2)

	"""
	Tests for evaluation timeout functionality in openevolve.evaluator
	"""

	import asyncio
	import os
	import tempfile
	import time
	import unittest
	from unittest.mock import patch, MagicMock

	from openevolve.config import EvaluatorConfig
	from openevolve.evaluator import Evaluator


	class TestEvaluatorTimeout(unittest.TestCase):
	"""Tests for evaluator timeout functionality"""

	def setUp(self):
	"""Set up test evaluation file"""
	# Create a test evaluation file
	self.test_eval_file = tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False)

	# Write test evaluation functions with shorter sleep times for faster tests
	self.test_eval_file.write(
	"""
	import time

	def evaluate(program_path):
	# Read the program to determine behavior
	with open(program_path, 'r') as f:
	code = f.read()

	if 'SLEEP_LONG' in code:
	# Sleep for a long time to trigger timeout (reduced for faster tests)
	time.sleep(8)
	return {"score": 1.0}
	elif 'SLEEP_SHORT' in code:
	# Sleep for a short time that should not timeout
	time.sleep(0.5)
	return {"score": 0.8}
	elif 'RAISE_ERROR' in code:
	# Raise an error to trigger retries
	raise RuntimeError("Evaluation failed")
	else:
	# Fast evaluation
	return {"score": 0.5}

	def evaluate_stage1(program_path):
	with open(program_path, 'r') as f:
	code = f.read()

	if 'STAGE1_TIMEOUT' in code:
	time.sleep(8)
	return {"stage1_score": 1.0}
	else:
	return {"stage1_score": 0.7}

	def evaluate_stage2(program_path):
	with open(program_path, 'r') as f:
	code = f.read()

	if 'STAGE2_TIMEOUT' in code:
	time.sleep(8)
	return {"stage2_score": 1.0}
	else:
	return {"stage2_score": 0.8}

	def evaluate_stage3(program_path):
	with open(program_path, 'r') as f:
	code = f.read()

	if 'STAGE3_TIMEOUT' in code:
	time.sleep(8)
	return {"stage3_score": 1.0}
	else:
	return {"stage3_score": 0.9}
	"""
	)
	self.test_eval_file.close()

	def tearDown(self):
	"""Clean up test files"""
	if os.path.exists(self.test_eval_file.name):
	os.unlink(self.test_eval_file.name)

	def _create_evaluator(self, timeout=3, cascade_evaluation=False):
	"""Helper to create evaluator with given settings (shorter timeout for faster tests)"""
	config = EvaluatorConfig()
	config.timeout = timeout
	config.max_retries = 1 # Minimal retries for faster testing
	config.cascade_evaluation = cascade_evaluation
	config.cascade_thresholds = [0.5, 0.7, 0.9]

	return Evaluator(
	config=config,
	evaluation_file=self.test_eval_file.name,
	llm_ensemble=None,
	prompt_sampler=None,
	)

	def test_fast_evaluation_completes(self):
	"""Test that fast evaluations complete successfully"""

	async def run_test():
	evaluator = self._create_evaluator(timeout=3)
	program_code = "def test(): return 'fast'"
	start_time = time.time()

	result = await evaluator.evaluate_program(program_code, "test_fast")

	elapsed_time = time.time() - start_time

	# Should complete quickly
	self.assertLess(elapsed_time, 2.0)
	# Should return successful result
	self.assertIn("score", result)
	self.assertEqual(result["score"], 0.5)
	# Should not have timeout or error flags
	self.assertNotIn("timeout", result)
	self.assertNotIn("error", result)

	asyncio.run(run_test())

	def test_short_evaluation_completes(self):
	"""Test that evaluations shorter than timeout complete successfully"""

	async def run_test():
	evaluator = self._create_evaluator(timeout=3)
	program_code = "# SLEEP_SHORT\ndef test(): return 'short'"
	start_time = time.time()

	result = await evaluator.evaluate_program(program_code, "test_short")

	elapsed_time = time.time() - start_time

	# Should complete within timeout
	self.assertLess(elapsed_time, 3)
	# Should return successful result
	self.assertIn("score", result)
	self.assertEqual(result["score"], 0.8)
	# Should not have timeout or error flags
	self.assertNotIn("timeout", result)
	self.assertNotIn("error", result)

	asyncio.run(run_test())

	def test_long_evaluation_times_out(self):
	"""Test that long evaluations time out properly"""

	async def run_test():
	evaluator = self._create_evaluator(timeout=3)
	program_code = "# SLEEP_LONG\ndef test(): return 'long'"
	start_time = time.time()

	result = await evaluator.evaluate_program(program_code, "test_long")

	elapsed_time = time.time() - start_time

	# Should complete around the timeout period (allowing some margin)
	self.assertGreater(elapsed_time, 2.5)
	self.assertLess(elapsed_time, 5)

	# Should return timeout result
	self.assertIn("error", result)
	self.assertEqual(result["error"], 0.0)
	self.assertIn("timeout", result)
	self.assertTrue(result["timeout"])

	asyncio.run(run_test())

	def test_cascade_evaluation_timeout_stage1(self):
	"""Test timeout in cascade evaluation stage 1"""

	async def run_test():
	evaluator = self._create_evaluator(timeout=3, cascade_evaluation=True)
	program_code = "# STAGE1_TIMEOUT\ndef test(): return 'stage1_timeout'"
	start_time = time.time()

	result = await evaluator.evaluate_program(program_code, "test_cascade_stage1")

	elapsed_time = time.time() - start_time

	# Should timeout around the configured timeout
	self.assertGreater(elapsed_time, 2.5)
	self.assertLess(elapsed_time, 5)

	# Should return stage1 timeout result
	self.assertIn("stage1_passed", result)
	self.assertEqual(result["stage1_passed"], 0.0)
	self.assertIn("timeout", result)
	self.assertTrue(result["timeout"])

	asyncio.run(run_test())

	def test_cascade_evaluation_timeout_stage2(self):
	"""Test timeout in cascade evaluation stage 2"""

	async def run_test():
	evaluator = self._create_evaluator(timeout=3, cascade_evaluation=True)
	program_code = "# STAGE2_TIMEOUT\ndef test(): return 'stage2_timeout'"
	start_time = time.time()

	result = await evaluator.evaluate_program(program_code, "test_cascade_stage2")

	elapsed_time = time.time() - start_time

	# Should timeout on stage 2, but stage 1 should complete first
	self.assertGreater(elapsed_time, 2.5)
	self.assertLess(elapsed_time, 5)

	# Should have stage1 result but stage2 timeout
	self.assertIn("stage1_score", result)
	self.assertEqual(result["stage1_score"], 0.7)
	self.assertIn("stage2_passed", result)
	self.assertEqual(result["stage2_passed"], 0.0)
	self.assertIn("timeout", result)
	self.assertTrue(result["timeout"])

	asyncio.run(run_test())

	def test_cascade_evaluation_timeout_stage3(self):
	"""Test timeout in cascade evaluation stage 3"""

	async def run_test():
	evaluator = self._create_evaluator(timeout=3, cascade_evaluation=True)
	program_code = "# STAGE3_TIMEOUT\ndef test(): return 'stage3_timeout'"
	start_time = time.time()

	result = await evaluator.evaluate_program(program_code, "test_cascade_stage3")

	elapsed_time = time.time() - start_time

	# Should timeout on stage 3, but stages 1 and 2 should complete first
	self.assertGreater(elapsed_time, 2.5)
	self.assertLess(elapsed_time, 5)

	# Should have stage1 and stage2 results but stage3 timeout
	self.assertIn("stage1_score", result)
	self.assertEqual(result["stage1_score"], 0.7)
	self.assertIn("stage2_score", result)
	self.assertEqual(result["stage2_score"], 0.8)
	self.assertIn("stage3_passed", result)
	self.assertEqual(result["stage3_passed"], 0.0)
	self.assertIn("timeout", result)
	self.assertTrue(result["timeout"])

	asyncio.run(run_test())

	def test_timeout_config_respected(self):
	"""Test that the timeout configuration value is actually used"""

	async def run_test():
	# Create evaluator with different timeout
	evaluator = self._create_evaluator(timeout=5)

	program_code = "# SLEEP_LONG\ndef test(): return 'long'"
	start_time = time.time()

	result = await evaluator.evaluate_program(program_code, "test_config")

	elapsed_time = time.time() - start_time

	# Should timeout around 5 seconds, not 3
	self.assertGreater(elapsed_time, 4.5)
	self.assertLess(elapsed_time, 7)

	# Should return timeout result
	self.assertIn("timeout", result)
	self.assertTrue(result["timeout"])

	asyncio.run(run_test())

	def test_multiple_retries_with_errors(self):
	"""Test that retries work correctly with actual errors (not timeouts)"""

	async def run_test():
	# Create evaluator with more retries
	config = EvaluatorConfig()
	config.timeout = 8 # Long timeout to avoid timeout during this test
	config.max_retries = 2 # 3 total attempts
	config.cascade_evaluation = False

	evaluator = Evaluator(
	config=config,
	evaluation_file=self.test_eval_file.name,
	llm_ensemble=None,
	prompt_sampler=None,
	)

	# Use RAISE_ERROR to trigger actual exceptions that will be retried
	program_code = "# RAISE_ERROR\ndef test(): return 'error'"
	start_time = time.time()

	result = await evaluator.evaluate_program(program_code, "test_retries")

	elapsed_time = time.time() - start_time

	# Should have retried 3 times (max_retries=2 means 3 total attempts)
	# Each attempt should fail quickly, plus 1 second sleep between retries
	# So total time should be around 2-3 seconds (quick failures + 2 sleep periods)
	self.assertGreater(elapsed_time, 1.8) # At least 2 sleep periods
	self.assertLess(elapsed_time, 4) # But not too long

	# Should return error result after all retries fail
	self.assertIn("error", result)
	self.assertEqual(result["error"], 0.0)

	asyncio.run(run_test())

	def test_timeout_does_not_trigger_retries(self):
	"""Test that timeouts do not trigger retries (correct behavior)"""

	async def run_test():
	# Create evaluator with retries enabled
	config = EvaluatorConfig()
	config.timeout = 2 # Short timeout
	config.max_retries = 2 # Would allow 3 attempts if retries were triggered
	config.cascade_evaluation = False

	evaluator = Evaluator(
	config=config,
	evaluation_file=self.test_eval_file.name,
	llm_ensemble=None,
	prompt_sampler=None,
	)

	# Use SLEEP_LONG to trigger timeout
	program_code = "# SLEEP_LONG\ndef test(): return 'long'"
	start_time = time.time()

	result = await evaluator.evaluate_program(program_code, "test_timeout_no_retry")

	elapsed_time = time.time() - start_time

	# Should timeout only once (~2 seconds), not retry multiple times
	# If retries were happening, this would take ~6 seconds
	self.assertGreater(elapsed_time, 1.8) # At least the timeout period
	self.assertLess(elapsed_time, 3.5) # But not multiple timeout periods

	# Should return timeout result
	self.assertIn("timeout", result)
	self.assertTrue(result["timeout"])

	asyncio.run(run_test())

	def test_artifacts_on_timeout(self):
	"""Test that timeout artifacts are properly captured"""

	async def run_test():
	# Enable artifacts
	with patch.dict(os.environ, {"ENABLE_ARTIFACTS": "true"}):
	evaluator = self._create_evaluator(timeout=3)
	program_code = "# SLEEP_LONG\ndef test(): return 'long'"

	# Execute evaluation
	result = await evaluator.evaluate_program(program_code, "test_artifacts")

	# Verify timeout occurred
	self.assertIn("timeout", result, "Result should contain timeout flag")
	self.assertTrue(result["timeout"], "Timeout flag should be True")

	# Verify artifacts were captured
	artifacts = evaluator.get_pending_artifacts("test_artifacts")
	self.assertIsNotNone(artifacts, "Artifacts should not be None")

	# Verify required artifact fields
	self.assertIn("failure_stage", artifacts, "Artifacts should contain failure_stage")
	self.assertEqual(
	artifacts["failure_stage"], "evaluation", "failure_stage should be 'evaluation'"
	)

	self.assertIn("timeout", artifacts, "Artifacts should contain timeout flag")
	self.assertTrue(artifacts["timeout"], "Artifact timeout flag should be True")

	self.assertIn("error_type", artifacts, "Artifacts should contain error_type")
	self.assertEqual(
	artifacts["error_type"], "timeout", "error_type should be 'timeout'"
	)

	self.assertIn(
	"timeout_duration", artifacts, "Artifacts should contain timeout_duration"
	)
	self.assertEqual(
	artifacts["timeout_duration"], 3, "timeout_duration should match config"
	)

	print(f"✅ Artifacts captured correctly: {list(artifacts.keys())}")

	asyncio.run(run_test())


	class TestTimeoutIntegration(unittest.TestCase):
	"""Integration tests for timeout functionality"""

	def test_real_world_scenario(self):
	"""Test a scenario similar to the reported bug"""

	async def run_test():
	# Create a test evaluation file that simulates a long-running evaluation
	test_eval_file = tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False)

	test_eval_file.write(
	"""
	import time

	def evaluate(program_path):
	# Simulate a very long evaluation (like the 11-hour case)
	time.sleep(6) # 6 seconds to test timeout (reduced for faster tests)
	return {"accReturn": 0.1, "CalmarRatio": 0.9, "combined_score": 0.82}
	"""
	)
	test_eval_file.close()

	try:
	# Configure like user's config but with shorter timeout for testing
	config = EvaluatorConfig()
	config.timeout = 3 # 3 seconds instead of 600
	config.max_retries = 1
	config.cascade_evaluation = False
	config.parallel_evaluations = 1

	evaluator = Evaluator(
	config=config,
	evaluation_file=test_eval_file.name,
	llm_ensemble=None,
	prompt_sampler=None,
	)

	program_code = """
	# Financial optimization algorithm
	def search_algorithm():
	# This would normally run for hours
	return {"report_type_factor_map": {}}
	"""

	start_time = time.time()
	result = await evaluator.evaluate_program(program_code, "financial_test")
	elapsed_time = time.time() - start_time

	# Should timeout in ~3 seconds, not 6+ seconds
	self.assertLess(elapsed_time, 5)
	self.assertGreater(elapsed_time, 2.5)

	# Should return timeout error
	self.assertIn("error", result)
	self.assertIn("timeout", result)
	self.assertTrue(result["timeout"])

	finally:
	if os.path.exists(test_eval_file.name):
	os.unlink(test_eval_file.name)

	asyncio.run(run_test())


	if __name__ == "__main__":
	# Run with verbose output to see test progress
	unittest.main(verbosity=2)