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

Explore the foundations and practical applications of bio-inspired algorithms in Python. This course covers evolutionary computation, swarm intelligence, and other nature-inspired optimization techniques, using only standard Python and permitted scientific libraries.

Understand the motivation, history, and core principles behind bio-inspired computation, including evolution, adaptation, and swarm intelligence.

Dive into the structure, operators, and parameter tuning of genetic algorithms.

Investigate algorithms inspired by collective behavior in nature, including ants, particles, and other swarms.

Explore the principles and algorithms inspired by the biological immune system, including negative selection and clonal selection.

Challenge: Implement Negative Selection Algorithm

Solution

Awesome!

Challenge: Implement Negative Selection Algorithm

Solution