import unittest
import importlib
import random

def _dynamic_test(test_case, condition, success_message, failure_message):
    """Helper function to dynamically pass/fail tests."""
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestNegativeSelection(unittest.TestCase):
    
    @classmethod
    def setUpClass(cls):
        """Importing the user's code and running the functions."""
        global user_code
        try:
            user_code = importlib.import_module("user_code")
            
            # Running the user's functions with a fixed seed
            # Even if the seed produces different detectors on different systems,
            # the classification logic should be the same.
            random.seed(42)
            cls.self_patterns = ["0101", "1100", "1001"]
            cls.test_patterns = ["0000", "0101", "1111", "1001", "1010"]
            cls.num_detectors = 6
            
            cls.detectors = user_code.generate_detectors(cls.self_patterns, cls.num_detectors)
            cls.results = user_code.classify_patterns(cls.self_patterns, cls.detectors, cls.test_patterns)
            
            # This is the expected classification logic, regardless of
            # which specific detectors were generated (as long as they are not 'self').
            cls.expected_results = {
                "0000": "non-self", # Not in self_set
                "0101": "self",     # In self_set
                "1111": "non-self", # Not in self_set
                "1001": "self",     # In self_set
                "1010": "non-self"  # Not in self_set
            }

        except ImportError:
            cls.fail("Could not import user_code.py. Make sure the file exists.")
        except Exception as e:
            cls.fail(f"Error running the user's code: {e}")

    def test_detector_generation_logic(self):
        """Checking that no generated detectors are in the self_patterns list."""
        self_set = set(self.self_patterns)
        detector_set = set(self.detectors)
        
        # Checking for any overlap
        overlap = self_set.intersection(detector_set)
        condition = len(overlap) == 0
        
        _dynamic_test(
            self,
            condition,
            "No detectors are present in the `self_patterns` list.",
            f"Found detectors that are in `self_patterns`: {overlap}. This violates negative selection."
        )

    def test_classification_results(self):
        """Checking if `classify_patterns` produces the correct classification dictionary."""
        # This test checks the *logic* (self is 'self', non-self is 'non-self')
        condition = self.results == self.expected_results
        _dynamic_test(
            self,
            condition,
            "The `classify_patterns` function produced the correct logical results.",
            f"Results dictionary {self.results} did not match expected {self.expected_results}."
        )
        
    def test_classification_of_self(self):
        """Checking that known self patterns are classified as 'self'."""
        condition = self.results.get("0101") == 'self' and self.results.get("1001") == 'self'
        _dynamic_test(
            self,
            condition,
            "Known self patterns ('0101', '1001') were correctly classified as 'self'.",
            "One or more known self patterns were not classified as 'self'."
        )
        
    def test_classification_of_non_self(self):
        """Checking that known non-self patterns are classified as 'non-self'."""
        # These patterns are not in the self_patterns list
        condition = self.results.get("0000") == 'non-self' and self.results.get("1111") == 'non-self'
        _dynamic_test(
            self,
            condition,
            "Known non-self patterns ('0000', '1111') were correctly classified as 'non-self'.",
            "One or more known non-self patterns were not classified as 'non-self'."
        )

if __name__ == "__main__":
    unittest.main(argv=['first-arg-is-ignored'], exit=False)


test_main.py

Explora los fundamentos y las aplicaciones prácticas de los algoritmos bioinspirados en Python. Este curso abarca computación evolutiva, inteligencia de enjambre y otras técnicas de optimización inspiradas en la naturaleza, utilizando únicamente Python estándar y bibliotecas científicas permitidas.

Comprender la motivación, la historia y los principios fundamentales detrás de la computación bioinspirada, incluyendo evolución, adaptación e inteligencia de enjambre.

Explora la estructura, los operadores y el ajuste de parámetros de los algoritmos genéticos.

Investigar algoritmos inspirados en el comportamiento colectivo en la naturaleza, incluyendo hormigas, partículas y otros enjambres.

Explora los principios y algoritmos inspirados en el sistema inmunológico biológico, incluyendo la selección negativa y la selección clonal.

Desafío: Implementar el Algoritmo de Selección Negativa

Solución