
import unittest
import user_code
import ast
import re   
import importlib
import csv
import unittest
import importlib

class TestTask(unittest.TestCase):

    def test_instance_increments_total_users(self):
        import user_code
        importlib.reload(user_code)
        cls = getattr(user_code, 'User', None)
        # Reset class variable for test
        cls.total_users = 0
        u1 = cls("alice")
        u2 = cls("bob")
        u3 = cls("carol")
        _dynamic_test(self, cls.total_users == 3, "total_users increments with each instance", f"Expected total_users to be 3, got {cls.total_users}")

    def test_username_stored(self):
        import user_code
        importlib.reload(user_code)
        cls = getattr(user_code, 'User', None)
        # Reset class variable for test
        cls.total_users = 0
        u = cls("dave")
        username = getattr(u, 'username', None)
        _dynamic_test(self, username == "dave", "username instance variable is set correctly", f"Expected username 'dave', got {username}")

    def test_get_info_returns_tuple(self):
        import user_code
        importlib.reload(user_code)
        cls = getattr(user_code, 'User', None)
        # Reset class variable for test
        cls.total_users = 0
        u1 = cls("eve")
        u2 = cls("frank")
        res1 = u1.get_info() if u1 is not None else None
        res2 = u2.get_info() if u2 is not None else None
        _dynamic_test(self, isinstance(res1, tuple) and res1[0] == "eve" and res1[1] == 2, "get_info returns correct tuple for u1", f"Expected ('eve', 2), got {res1}")
        _dynamic_test(self, isinstance(res2, tuple) and res2[0] == "frank" and res2[1] == 2, "get_info returns correct tuple for u2", f"Expected ('frank', 2), got {res2}")

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

def normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    changed = False
    # Collect all assignment nodes to modify
    assign_nodes = [
        (i, node)
        for i, node in enumerate(tree.body)
        if isinstance(node, ast.Assign)
        and any(isinstance(target, ast.Name) and target.id == var_name for target in node.targets)
    ]

    # If nothing to change, return unmodified code
    if not assign_nodes:
        return code

    # Perform replacements for all matching assignments (from last to first to not break line offsets)
    for i, node in reversed(assign_nodes):
        start_line = node.lineno - 1
        line = lines[start_line]
        indent = ' ' * (len(line) - len(line.lstrip()))
        lines[start_line] = f"{indent}{var_name} = {value}"
        next_line = len(lines)
        for next_node in tree.body[i+1:]:
            if hasattr(next_node, 'lineno'):
                next_line = next_node.lineno - 1
                break
        if next_line > start_line + 1:
            lines[start_line+1:next_line] = []
        changed = True

    return '\\n'.join(lines) if changed else code

if __name__ == "__main__":
    unittest.main()


test_main.py

Lär dig att bygga rena, säkra och skalbara applikationer med objektorienterad programmering i Python. Täck grunderna i klasser och objekt, och gå sedan vidare till avancerade koncept såsom arv, komposition, polymorfism och inkapsling. Med tydliga förklaringar och praktiska exempel utvecklar du förmågan att designa Python-program som är kraftfulla, underhållbara och redo för verklig användning.

Lär dig de grundläggande byggstenarna i objektorienterad programmering i Python. Detta avsnitt behandlar klasser, objekt, metoder och variabler, vilket ger en stabil grund för att förstå hur OOP organiserar och strukturerar kod.

Utforska hur klasser kan dela och utöka funktionalitet. Du kommer att lära dig olika arvsmönster, från enkla hierarkier till multipelt arv och abstrakta klasser, och se hur dessa möjliggör återanvändning av kod och skalbarhet.

Upptäck hur du bygger flexibla system genom att kombinera objekt. Istället för att enbart förlita dig på arv, visar vi hur komposition gör det möjligt att sammanfoga beteenden på ett modulärt och anpassningsbart sätt.

Förstå hur olika objekt kan dela ett gemensamt gränssnitt men ändå uppträda på sitt eget sätt. Detta avsnitt visar hur metodöverskuggning, gränssnitt och protokoll gör din kod mer dynamisk och återanvändbar.

Lär dig hur du skyddar intern data och kontrollerar åtkomst till klassattribut. Du kommer att utforska privata attribut, getters och setters samt tekniker för att dölja data som håller dina klasser säkra och underhållbara.

Challenge: Working with Instance and Class Variables

Lösning

Challenge: Working with Instance and Class Variables

Lösning