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

Utforska grunderna och praktiska tillämpningar av bioinspirerade algoritmer i Python. Kursen behandlar evolutionär beräkning, svärmintelligens och andra naturinspirerade optimeringstekniker med enbart standard-Python och tillåtna vetenskapliga bibliotek.

Förstå motivationen, historien och de grundläggande principerna bakom bioinspirerad beräkning, inklusive evolution, anpassning och svärmintelligens.

Utforska strukturen, operatorerna och parameterinställningen för genetiska algoritmer.

Undersök algoritmer inspirerade av kollektivt beteende i naturen, inklusive myror, partiklar och andra svärmar.

Utforska principer och algoritmer inspirerade av det biologiska immunsystemet, inklusive negativ selektion och klonal selektion.

Utmaning: Implementera Negativt Urvalsalgoritm

Lösning