
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 hvordan du bygger rene, sikre og skalerbare applikasjoner med objektorientert programmering i Python. Dekker grunnleggende konsepter som klasser og objekter, og går deretter videre til avanserte emner som arv, komposisjon, polymorfisme og innkapsling. Med tydelige forklaringer og praktiske eksempler utvikler du evnen til å designe Python-programmer som er kraftige, vedlikeholdbare og klare for bruk i virkelige situasjoner.

Lær de grunnleggende byggesteinene i objektorientert programmering i Python. Denne delen dekker klasser, objekter, metoder og variabler, og gir deg et solid grunnlag for å forstå hvordan OOP organiserer og strukturerer kode.

Utforsk hvordan klasser kan dele og utvide funksjonalitet. Du vil lære om ulike arvmønstre, fra enkle hierarkier til multippel arv og abstrakte klasser, og se hvordan de muliggjør gjenbruk av kode og skalerbarhet.

Lær hvordan du bygger fleksible systemer ved å kombinere objekter. I stedet for å kun stole på arv, vil du se hvordan komposisjon lar deg sette sammen funksjonalitet på en modulær og tilpasningsdyktig måte.

Forstå hvordan ulike objekter kan dele et felles grensesnitt samtidig som de oppfører seg på sin egen måte. Denne delen viser hvordan metodeoverstyring, grensesnitt og protokoller gjør koden din mer dynamisk og gjenbrukbar.

Lær hvordan du beskytter interne data og kontrollerer tilgang til klasseattributter. Du vil utforske private attributter, getters og setters, samt teknikker for å skjule data som gjør klassene dine sikre og vedlikeholdbare.

Challenge: Working with Instance and Class Variables

Løsning

Challenge: Working with Instance and Class Variables

Løsning