eval, pickle und shell=True

def parse_settings(text: str) -> dict[str, object]:
    """Turn text such as "{'width': 80, 'tags': ['a']}" into a dict."""
    # eval runs any expression in text. Use ast.literal_eval, and raise
    # ValueError unless the result is a dict with only str keys.
    return eval(text)

from main import parse_settings


def rejects(text):
    try:
        parse_settings(text)
    except ValueError:
        return True
    return False


def test_literal_dict():
    """Ein dict aus Literalen wird geparst"""
    got = parse_settings("{'width': 80, 'tags': ['a', 'b'], 'theme': None}")
    assert got == {"width": 80, "tags": ["a", "b"], "theme": None}, f"parse_settings lieferte {got!r}"


def test_rejects_call():
    """Ein Funktionsaufruf im Text wird abgelehnt, nicht ausgeführt"""
    assert rejects("{'n': len('abc')}"), "{'n': len('abc')} wurde angenommen: eval hat len() ausgeführt; nutzen Sie ast.literal_eval"


def test_rejects_name():
    """Ein Variablenname im Text wird abgelehnt"""
    assert rejects("{'n': width}"), "ein Name im Text wurde angenommen oder löste den falschen Fehler aus"


def test_rejects_non_dict():
    """Eine Liste ist keine Einstellung"""
    assert rejects("[1, 2]"), "[1, 2] wurde angenommen; lösen Sie ValueError aus, wenn das Ergebnis kein dict ist"


def test_rejects_non_str_key():
    """Schlüssel müssen Strings sein"""
    assert rejects("{1: 'a'}"), "{1: 'a'} wurde angenommen; jeder Schlüssel muss ein str sein"

import pickle


def dump_scores(scores: dict[str, int]) -> str:
    """Save scores as text that another program can read back."""
    return pickle.dumps(scores).hex()


def load_scores(text: str) -> dict[str, int]:
    """Read scores saved by dump_scores; raise ValueError for anything else."""
    return pickle.loads(bytes.fromhex(text))

import json
import pickle

from main import dump_scores, load_scores


class Alarm:
    def __reduce__(self):
        return (print, ("alarm",))


def rejects(text):
    try:
        load_scores(text)
    except ValueError:
        return True
    return False


def test_round_trip():
    """Punkte überstehen Speichern und Laden"""
    scores = {"ada": 3, "bob": 5}
    got = load_scores(dump_scores(scores))
    assert got == scores, f"load_scores(dump_scores(...)) lieferte {got!r}"


def test_readable_json():
    """dump_scores schreibt JSON, das jedes Programm lesen kann"""
    text = dump_scores({"ada": 3})
    try:
        got = json.loads(text)
    except ValueError:
        got = None
    assert got == {"ada": 3}, f"dump_scores schrieb {text[:40]!r}, und das ist kein JSON"


def test_refuses_pickle():
    """Ein Pickle wird mit ValueError abgelehnt, und nichts darin läuft"""
    blob = pickle.dumps(Alarm()).hex()
    assert rejects(blob), "load_scores hat ein Pickle angenommen: Es könnte beim Laden Code ausführen"


def test_checks_types():
    """Eine Punktzahl, die keine Ganzzahl ist, wird abgelehnt"""
    assert rejects('{"ada": "three"}'), 'load_scores hat {"ada": "three"} angenommen'

import json
import subprocess
import sys

CHILD = "import json, sys; print(json.dumps(sys.argv[1:]))"


def child_args(words: list[str]) -> list[str]:
    """Run CHILD in a new Python process with words as its arguments; return what it received."""
    # A shell splits, expands and interprets the words. Pass a list instead.
    command = f'"{sys.executable}" -c "{CHILD}" ' + " ".join(words)
    result = subprocess.run(command, shell=True, capture_output=True, text=True)
    return json.loads(result.stdout)

from main import child_args


def test_simple():
    """Zwei einfache Wörter kommen als zwei Argumente an"""
    got = child_args(["a", "b"])
    assert got == ["a", "b"], f"der Kindprozess bekam {got!r}"


def test_spaces():
    """Ein Wort mit Leerzeichen bleibt ein Argument"""
    got = child_args(["two words"])
    assert got == ["two words"], f"der Kindprozess bekam {got!r}: keine Shell, übergeben Sie eine Liste"


def test_special_characters():
    """$HOME und ein Apostroph kommen unverändert an"""
    got = child_args(["$HOME", "it's"])
    assert got == ["$HOME", "it's"], f"der Kindprozess bekam {got!r}: eine Shell hat sie ersetzt oder zerbrochen"