Add tests for recent features

Add comprehensive tests for recently merged PRs:

- test_llm_config_optional_params.py: Tests for optional temperature/top_p
  parameters (PR #385 - Anthropic model compatibility)

- test_snapshot_artifacts_limit.py: Tests for configurable max_snapshot_artifacts
  (PR #386)

- test_visualization_sanitization.py: Tests for -inf/+inf/NaN sanitization
  in visualization (PR #384)

- test_early_stopping_config.py: Tests for event-based early stopping
  configuration (PR #375)

- test_changes_description.py: Tests for large codebase support via
  changes description (PR #376)

Total tests increased from 264 to 326.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: codelion

tests/test_changes_description.py

@@ -0,0 +1,153 @@
+"""
+Tests for large codebase support via changes description.
+Programs can be represented as compact change descriptions instead of full code.
+"""
+
+import unittest
+
+from openevolve.config import Config, PromptConfig
+
+
+class TestChangesDescriptionConfigDefaults(unittest.TestCase):
+    """Tests for changes description configuration defaults"""
+
+    def test_programs_as_changes_description_default_false(self):
+        """Test that programs_as_changes_description defaults to False"""
+        config = Config()
+        self.assertFalse(config.prompt.programs_as_changes_description)
+
+    def test_system_message_changes_description_default_none(self):
+        """Test that system_message_changes_description defaults to None"""
+        config = Config()
+        self.assertIsNone(config.prompt.system_message_changes_description)
+
+    def test_initial_changes_description_default_empty(self):
+        """Test that initial_changes_description defaults to empty string"""
+        config = Config()
+        self.assertEqual(config.prompt.initial_changes_description, "")
+
+
+class TestChangesDescriptionValidation(unittest.TestCase):
+    """Tests for changes description validation rules"""
+
+    def test_requires_diff_based_evolution(self):
+        """Test that programs_as_changes_description requires diff_based_evolution"""
+        config_dict = {
+            "llm": {"primary_model": "gpt-4"},
+            "diff_based_evolution": False,
+            "prompt": {
+                "programs_as_changes_description": True,
+            }
+        }
+        with self.assertRaises(ValueError) as context:
+            Config.from_dict(config_dict)
+        self.assertIn("diff_based_evolution", str(context.exception))
+
+    def test_works_with_diff_based_evolution_enabled(self):
+        """Test that changes description works when diff_based_evolution=True"""
+        config_dict = {
+            "llm": {"primary_model": "gpt-4"},
+            "diff_based_evolution": True,
+            "prompt": {
+                "programs_as_changes_description": True,
+            }
+        }
+        config = Config.from_dict(config_dict)
+        self.assertTrue(config.prompt.programs_as_changes_description)
+        self.assertTrue(config.diff_based_evolution)
+
+    def test_disabled_without_diff_based_evolution_is_ok(self):
+        """Test that disabled changes description works without diff_based_evolution"""
+        config_dict = {
+            "llm": {"primary_model": "gpt-4"},
+            "diff_based_evolution": False,
+            "prompt": {
+                "programs_as_changes_description": False,
+            }
+        }
+        config = Config.from_dict(config_dict)
+        self.assertFalse(config.prompt.programs_as_changes_description)
+
+
+class TestChangesDescriptionFromDict(unittest.TestCase):
+    """Tests for loading changes description config from dict"""
+
+    def test_custom_system_message(self):
+        """Test setting custom system_message_changes_description"""
+        config_dict = {
+            "llm": {"primary_model": "gpt-4"},
+            "diff_based_evolution": True,
+            "prompt": {
+                "programs_as_changes_description": True,
+                "system_message_changes_description": "You are optimizing a large codebase.",
+            }
+        }
+        config = Config.from_dict(config_dict)
+        self.assertEqual(
+            config.prompt.system_message_changes_description,
+            "You are optimizing a large codebase."
+        )
+
+    def test_custom_initial_description(self):
+        """Test setting custom initial_changes_description"""
+        config_dict = {
+            "llm": {"primary_model": "gpt-4"},
+            "diff_based_evolution": True,
+            "prompt": {
+                "programs_as_changes_description": True,
+                "initial_changes_description": "Initial implementation with basic algorithm.",
+            }
+        }
+        config = Config.from_dict(config_dict)
+        self.assertEqual(
+            config.prompt.initial_changes_description,
+            "Initial implementation with basic algorithm."
+        )
+
+    def test_all_changes_description_options(self):
+        """Test setting all changes description options together"""
+        config_dict = {
+            "llm": {"primary_model": "gpt-4"},
+            "diff_based_evolution": True,
+            "prompt": {
+                "programs_as_changes_description": True,
+                "system_message_changes_description": "Custom system message",
+                "initial_changes_description": "Initial state description",
+            }
+        }
+        config = Config.from_dict(config_dict)
+        self.assertTrue(config.prompt.programs_as_changes_description)
+        self.assertEqual(
+            config.prompt.system_message_changes_description,
+            "Custom system message"
+        )
+        self.assertEqual(
+            config.prompt.initial_changes_description,
+            "Initial state description"
+        )
+
+
+class TestPromptConfigChangesDescription(unittest.TestCase):
+    """Tests for PromptConfig changes description fields"""
+
+    def test_prompt_config_defaults(self):
+        """Test PromptConfig defaults for changes description"""
+        prompt_config = PromptConfig()
+        self.assertFalse(prompt_config.programs_as_changes_description)
+        self.assertIsNone(prompt_config.system_message_changes_description)
+        self.assertEqual(prompt_config.initial_changes_description, "")
+
+    def test_prompt_config_custom_values(self):
+        """Test PromptConfig with custom changes description values"""
+        prompt_config = PromptConfig(
+            programs_as_changes_description=True,
+            system_message_changes_description="Custom message",
+            initial_changes_description="Initial state",
+        )
+        self.assertTrue(prompt_config.programs_as_changes_description)
+        self.assertEqual(prompt_config.system_message_changes_description, "Custom message")
+        self.assertEqual(prompt_config.initial_changes_description, "Initial state")
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_early_stopping_config.py

@@ -0,0 +1,106 @@
+"""
+Tests for early stopping configuration and behavior.
+"""
+
+import unittest
+
+from openevolve.config import Config
+
+
+class TestEarlyStoppingConfigDefaults(unittest.TestCase):
+    """Tests for early stopping configuration defaults"""
+
+    def test_patience_default_is_none(self):
+        """Test that early_stopping_patience defaults to None (disabled)"""
+        config = Config()
+        self.assertIsNone(config.early_stopping_patience)
+
+    def test_convergence_threshold_default(self):
+        """Test that convergence_threshold defaults to 0.001"""
+        config = Config()
+        self.assertEqual(config.convergence_threshold, 0.001)
+
+    def test_metric_default(self):
+        """Test that early_stopping_metric defaults to combined_score"""
+        config = Config()
+        self.assertEqual(config.early_stopping_metric, "combined_score")
+
+
+class TestEarlyStoppingConfigFromDict(unittest.TestCase):
+    """Tests for loading early stopping config from dict"""
+
+    def test_custom_patience(self):
+        """Test setting custom early_stopping_patience"""
+        config_dict = {
+            "llm": {"primary_model": "gpt-4"},
+            "early_stopping_patience": 50,
+        }
+        config = Config.from_dict(config_dict)
+        self.assertEqual(config.early_stopping_patience, 50)
+
+    def test_custom_convergence_threshold(self):
+        """Test setting custom convergence_threshold"""
+        config_dict = {
+            "llm": {"primary_model": "gpt-4"},
+            "convergence_threshold": 0.01,
+        }
+        config = Config.from_dict(config_dict)
+        self.assertEqual(config.convergence_threshold, 0.01)
+
+    def test_custom_metric(self):
+        """Test setting custom early_stopping_metric"""
+        config_dict = {
+            "llm": {"primary_model": "gpt-4"},
+            "early_stopping_metric": "score",
+        }
+        config = Config.from_dict(config_dict)
+        self.assertEqual(config.early_stopping_metric, "score")
+
+    def test_all_early_stopping_options(self):
+        """Test setting all early stopping options together"""
+        config_dict = {
+            "llm": {"primary_model": "gpt-4"},
+            "early_stopping_patience": 100,
+            "convergence_threshold": 0.005,
+            "early_stopping_metric": "validity",
+        }
+        config = Config.from_dict(config_dict)
+        self.assertEqual(config.early_stopping_patience, 100)
+        self.assertEqual(config.convergence_threshold, 0.005)
+        self.assertEqual(config.early_stopping_metric, "validity")
+
+    def test_zero_patience_disables_early_stopping(self):
+        """Test that patience=0 effectively disables early stopping"""
+        config_dict = {
+            "llm": {"primary_model": "gpt-4"},
+            "early_stopping_patience": 0,
+        }
+        config = Config.from_dict(config_dict)
+        self.assertEqual(config.early_stopping_patience, 0)
+
+    def test_negative_patience_allowed(self):
+        """Test that negative patience is allowed (but probably shouldn't be used)"""
+        config_dict = {
+            "llm": {"primary_model": "gpt-4"},
+            "early_stopping_patience": -1,
+        }
+        # Should not raise an error during loading
+        config = Config.from_dict(config_dict)
+        self.assertEqual(config.early_stopping_patience, -1)
+
+
+class TestEarlyStoppingWithYaml(unittest.TestCase):
+    """Tests for early stopping config from YAML"""
+
+    def test_config_to_dict_includes_early_stopping(self):
+        """Test that to_dict includes early stopping settings"""
+        config = Config()
+        config_dict = config.to_dict()
+
+        self.assertIn("early_stopping_patience", config_dict)
+        self.assertIn("convergence_threshold", config_dict)
+        self.assertIn("early_stopping_metric", config_dict)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_llm_config_optional_params.py

@@ -0,0 +1,127 @@
+"""
+Tests for optional LLM parameters (temperature, top_p).
+Ensures Anthropic model compatibility where both params cannot be specified together.
+"""
+
+import unittest
+
+from openevolve.config import Config, LLMConfig, LLMModelConfig
+
+
+class TestOptionalTemperatureTopP(unittest.TestCase):
+    """Tests for optional temperature and top_p parameters"""
+
+    def test_llm_config_temperature_default(self):
+        """Test that temperature defaults to 0.7 in LLMConfig"""
+        config = LLMConfig()
+        self.assertEqual(config.temperature, 0.7)
+
+    def test_llm_config_top_p_default_is_none(self):
+        """Test that top_p defaults to None in LLMConfig (for Anthropic compatibility)"""
+        config = LLMConfig()
+        self.assertIsNone(config.top_p)
+
+    def test_model_config_temperature_none_by_default(self):
+        """Test that LLMModelConfig temperature is None by default"""
+        config = LLMModelConfig()
+        self.assertIsNone(config.temperature)
+
+    def test_model_config_top_p_none_by_default(self):
+        """Test that LLMModelConfig top_p is None by default"""
+        config = LLMModelConfig()
+        self.assertIsNone(config.top_p)
+
+    def test_type_annotation_allows_none(self):
+        """Test that temperature and top_p can be set to None"""
+        config = LLMModelConfig(temperature=None, top_p=None)
+        self.assertIsNone(config.temperature)
+        self.assertIsNone(config.top_p)
+
+    def test_type_annotation_allows_float(self):
+        """Test that temperature and top_p can be set to float values"""
+        config = LLMModelConfig(temperature=0.5, top_p=0.9)
+        self.assertEqual(config.temperature, 0.5)
+        self.assertEqual(config.top_p, 0.9)
+
+
+class TestConfigFromDictWithOptionalParams(unittest.TestCase):
+    """Tests for loading config with optional temperature/top_p from dict"""
+
+    def test_config_with_null_temperature_uses_default(self):
+        """Test loading config with null temperature uses default"""
+        config_dict = {
+            "llm": {
+                "primary_model": "claude-sonnet",
+                "api_base": "https://api.anthropic.com/v1",
+                "temperature": None,
+            }
+        }
+        config = Config.from_dict(config_dict)
+        # None is stripped, so default 0.7 is used
+        self.assertEqual(config.llm.temperature, 0.7)
+
+    def test_config_with_null_top_p(self):
+        """Test loading config with null top_p"""
+        config_dict = {
+            "llm": {
+                "primary_model": "gpt-4",
+                "top_p": None,
+            }
+        }
+        config = Config.from_dict(config_dict)
+        self.assertIsNone(config.llm.top_p)
+
+    def test_config_with_only_temperature(self):
+        """Test config with only temperature set (typical for Anthropic)"""
+        config_dict = {
+            "llm": {
+                "primary_model": "claude-sonnet",
+                "temperature": 0.9,
+            }
+        }
+        config = Config.from_dict(config_dict)
+        self.assertEqual(config.llm.temperature, 0.9)
+        self.assertIsNone(config.llm.top_p)
+
+    def test_config_with_only_top_p(self):
+        """Test config with only top_p set"""
+        config_dict = {
+            "llm": {
+                "primary_model": "gpt-4",
+                "temperature": None,
+                "top_p": 0.95,
+            }
+        }
+        config = Config.from_dict(config_dict)
+        self.assertEqual(config.llm.top_p, 0.95)
+
+    def test_config_with_both_params(self):
+        """Test config with both temperature and top_p set (OpenAI compatible)"""
+        config_dict = {
+            "llm": {
+                "primary_model": "gpt-4",
+                "temperature": 0.8,
+                "top_p": 0.9,
+            }
+        }
+        config = Config.from_dict(config_dict)
+        self.assertEqual(config.llm.temperature, 0.8)
+        self.assertEqual(config.llm.top_p, 0.9)
+
+    def test_models_inherit_optional_params(self):
+        """Test that models inherit temperature/top_p from parent config"""
+        config_dict = {
+            "llm": {
+                "primary_model": "gpt-4",
+                "temperature": 0.5,
+                "top_p": None,
+            }
+        }
+        config = Config.from_dict(config_dict)
+        # Check that models inherited the temperature
+        for model in config.llm.models:
+            self.assertEqual(model.temperature, 0.5)
+
+
+if __name__ == "__main__":
+    unittest.main()