12 Debugging und Fehlerbehandlung in Shell-Skripten

# Beispiel: Überprüfung eines Exit-Codes
if ! cp datei.txt backup/; then
    echo "Fehler beim Kopieren der Datei!" >&2
    exit 1
fi

mkdir /tmp/testordner
if [ $? -ne 0 ]; then
    echo "Fehler beim Erstellen des Ordners" >&2
    exit 1
fi

#!/bin/bash
set -e          # Beendet das Skript sofort, wenn ein Befehl fehlschlägt
set -u          # Behandelt nicht definierte Variablen als Fehler
set -o pipefail # Gibt den Exit-Code des ersten fehlgeschlagenen Befehls in einer Pipe zurück

#!/bin/bash
set -euo pipefail

#!/bin/bash
set -euo pipefail

# Temporäre Datei erstellen
TEMP_FILE=$(mktemp)

# Aufräumfunktion definieren
cleanup() {
    echo "Aufräumen temporärer Ressourcen..." >&2
    rm -f "$TEMP_FILE"
}

# trap registrieren für mehrere Signale
trap cleanup EXIT SIGINT SIGTERM

# Hauptlogik des Skripts
echo "Arbeite mit temporärer Datei: $TEMP_FILE"
# ... weitere Befehle ...

#!/bin/bash
set -euo pipefail

# Fehlerbehandlungsfunktion
error_exit() {
    local message="$1"
    local exit_code="${2:-1}"  # Default: 1
    
    echo "[FEHLER] $message" >&2
    # Optional: Logging in eine Datei
    echo "$(date '+%Y-%m-%d %H:%M:%S') - FEHLER: $message" >> /var/log/mein_skript.log
    
    exit "$exit_code"
}

# Verwendung
if ! ping -c 1 example.com > /dev/null 2>&1; then
    error_exit "Netzwerkverbindung nicht verfügbar" 10
fi

# Weiterer Code...

#!/bin/bash
set -euo pipefail

# Prüfen der Anzahl der Argumente
if [ "$#" -lt 2 ]; then
    echo "Verwendung: $0 QUELLE ZIEL" >&2
    exit 1
fi

QUELLE="$1"
ZIEL="$2"

# Validierung der Eingabedatei
if [ ! -f "$QUELLE" ]; then
    echo "Fehler: Die Quelldatei '$QUELLE' existiert nicht oder ist keine reguläre Datei." >&2
    exit 2
fi

# Validierung des Zielverzeichnisses
if [ ! -d "$(dirname "$ZIEL")" ]; then
    echo "Fehler: Das Zielverzeichnis '$(dirname "$ZIEL")' existiert nicht." >&2
    exit 3
fi

# Nach der Validierung kann die eigentliche Operation durchgeführt werden
cp "$QUELLE" "$ZIEL"

#!/bin/bash
set -euo pipefail

LOG_FILE="/var/log/mein_skript.log"

log() {
    local level="$1"
    local message="$2"
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $level: $message" >> "$LOG_FILE"
    
    # Bei Fehlern auch auf stderr ausgeben
    if [ "$level" = "ERROR" ]; then
        echo "$message" >&2
    fi
}

# Verwendung
log "INFO" "Skript gestartet"

if ! some_command; then
    log "ERROR" "Befehl fehlgeschlagen: some_command"
    exit 1
fi

log "INFO" "Skript erfolgreich beendet"

#!/bin/bash
set -euo pipefail

# Funktion, die einen Fehler zurückgibt
function db_backup() {
    local db_name="$1"
    local backup_file="$2"
    
    if ! mysqldump "$db_name" > "$backup_file" 2>/dev/null; then
        echo "Datenbankbackup fehlgeschlagen" >&2
        return 1  # Fehlerstatus zurückgeben
    fi
    
    return 0  # Erfolg
}

# Aufruf mit Fehlerbehandlung
if ! db_backup "meine_db" "/backup/meine_db.sql"; then
    echo "Backup-Prozess fehlgeschlagen, breche ab" >&2
    exit 1
fi

#!/bin/bash
set -euo pipefail

# Befehl mit Timeout ausführen
if ! timeout 10s ping -c 4 example.com; then
    echo "Ping zu example.com fehlgeschlagen oder Timeout überschritten" >&2
    exit 1
fi

#!/bin/bash
set -euo pipefail

# Grundlegende Verwendung von logger
logger "Skript gestartet: $(basename "$0")"

# Mit Priorität (facility.level)
logger -p local0.info "Normale Informationsmeldung"
logger -p local0.warning "Warnung: Festplatte zu 85% gefüllt"
logger -p local0.error "Fehler: Verbindung zum Server fehlgeschlagen"

# Mit Tag für bessere Identifikation
logger -t "backup_script" "Backup-Vorgang gestartet"

# Logger mit Prozess-ID
logger -i -t "user_mgmt" "Benutzer hinzugefügt: $username"

# Strukturiertes Logging mit Metadaten
logger -t "database" --id="$transaction_id" "Datenbankabfrage abgeschlossen: $query_time ms"

# Log-Meldungen in den Systemlogs finden
grep "backup_script" /var/log/syslog
journalctl -t "backup_script"  # Auf systemd-basierten Systemen

systemctl restart rsyslog

#!/bin/bash
set -euo pipefail

# Zentrale Logging-Funktion
log() {
    local level=$1
    local message=$2
    local tag="${3:-$(basename "$0")}"

    # Syslog-Priorität basierend auf Level
    local priority="user.info"
    case $level in
        ERROR)   priority="user.err" ;;
        WARNING) priority="user.warning" ;;
        INFO)    priority="user.info" ;;
        DEBUG)   priority="user.debug" ;;
    esac

    # Logging an syslog mit aussagekräftigem Format
    logger -p "$priority" -t "$tag" "[$level] $message"
}

# Verwendung
log "INFO" "Skript gestartet mit Parameter: $*"
log "DEBUG" "Aktueller Speicherverbrauch: $(free -m | awk '/^Mem:/ {print $3}') MB"
log "WARNING" "Festplatte zu 90% voll" "disk_monitor"
log "ERROR" "Datei konnte nicht geöffnet werden: $filename" "file_handler"

#!/bin/bash
set -euo pipefail

# Strukturiertes Logging mit journald
journald_log() {
    local level=$1
    local message=$2
    local tag="${3:-$(basename "$0")}"
    local code="${4:-}"  # Optionaler Fehlercode
    
    # Grundlegende Felder
    local cmd=(logger -t "$tag" --journald)
    
    # Statusfelder hinzufügen
    cmd+=(PRIORITY="$level" 
          CODE_FILE="$(caller | cut -d ' ' -f 3)" 
          CODE_LINE="$(caller | cut -d ' ' -f 1)")
    
    # Optionalen Fehlercode hinzufügen
    if [[ -n "$code" ]]; then
        cmd+=(CODE="$code")
    fi
    
    # Log senden
    "${cmd[@]}" "$message"
}

# Verwendung
journald_log 6 "Debug-Nachricht" "my_app"  # 6 = INFO
journald_log 3 "Kritischer Fehler" "my_app" "E1001"  # 3 = ERROR

# Nach Tag filtern
journalctl -t "my_app"

# Nach Priorität filtern
journalctl PRIORITY=3 -t "my_app"

# Nach Fehlercode filtern 
journalctl CODE="E1001"

# Nach Datei/Zeile filtern
journalctl CODE_FILE="mein_skript.sh"

#!/bin/bash
set -euo pipefail

# Log an entfernten syslog-Server senden
remote_log() {
    local level=$1
    local message=$2
    local server=$3
    local port="${4:-514}"  # Standard-syslog-Port
    local tag="${5:-$(basename "$0")}"
    
    # Priorität basierend auf Level
    local priority="user.info"
    case $level in
        ERROR)   priority="user.err" ;;
        WARNING) priority="user.warning" ;;
        INFO)    priority="user.info" ;;
        DEBUG)   priority="user.debug" ;;
    esac
    
    # Log an entfernten Server senden
    logger -p "$priority" -t "$tag" -n "$server" -P "$port" "[$level] $message"
}

# Verwendung
remote_log "ERROR" "Kritischer Fehler im Backup-Prozess" "logs.example.com" "514" "backup"

#!/bin/bash
set -euo pipefail

# JSON-Logging über syslog
json_log() {
    local level=$1
    local message=$2
    local tag="${3:-$(basename "$0")}"
    local additional_fields="${4:-}"
    
    # Basis-JSON erstellen
    local json="{\"timestamp\":\"$(date -u +"%Y-%m-%dT%H:%M:%SZ")\",\"level\":\"$level\",\"message\":\"$message\""
    
    # Weitere Felder hinzufügen
    if [[ -n "$additional_fields" ]]; then
        # Annahme: additional_fields ist bereits im JSON-Format ohne { }
        json="$json,$additional_fields"
    fi
    
    # JSON schließen
    json="$json}"
    
    # An syslog senden
    logger -p "user.info" -t "$tag" "$json"
}

# Verwendung
json_log "INFO" "Backup gestartet" "backup_script" "\"size\":1024,\"files\":15,\"target\":\"/mnt/backup\""

#!/bin/bash
set -euo pipefail

# Batch-Logging für hohe Performance
declare -a LOG_QUEUE
LOG_QUEUE_MAX_SIZE=100

# Log zur Queue hinzufügen
queue_log() {
    LOG_QUEUE+=("$*")
    
    # Queue leeren, wenn maximale Größe erreicht
    if [[ ${#LOG_QUEUE[@]} -ge $LOG_QUEUE_MAX_SIZE ]]; then
        flush_log_queue
    fi
}

# Log-Queue an syslog senden
flush_log_queue() {
    if [[ ${#LOG_QUEUE[@]} -eq 0 ]]; then
        return
    fi
    
    # Alle Logs in einer Datei sammeln
    local temp_file
    temp_file=$(mktemp)
    
    printf "%s\n" "${LOG_QUEUE[@]}" > "$temp_file"
    
    # Datei an logger senden und Queue leeren
    logger -f "$temp_file"
    rm -f "$temp_file"
    LOG_QUEUE=()
}

# Beim Beenden sicherstellen, dass alle Logs gesendet werden
trap flush_log_queue EXIT

# Verwendung
for i in {1..1000}; do
    # Operationen ausführen
    result=$((i * 2))
    
    # Log zur Queue hinzufügen
    queue_log "Verarbeite Element $i: Ergebnis=$result"
done

# Am Ende der Verarbeitung Queue leeren
flush_log_queue

#!/bin/bash

# Trace-Ausgabe in syslog umleiten
exec 19> >(logger -p local0.debug -t "${0##*/}[$$] TRACE")
BASH_XTRACEFD=19
PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'
set -x

# Ab hier wird jeder ausgeführte Befehl in syslog protokolliert
echo "Beispielbefehl"
for i in {1..3}; do
    echo "Schleifendurchlauf $i"
done

# Tracing wieder ausschalten für bestimmte Abschnitte
set +x
echo "Dieser Befehl wird nicht getracet"
set -x

#!/bin/bash
set -euo pipefail

# Log-Level-Konfiguration
# 0=DEBUG, 1=INFO, 2=WARNING, 3=ERROR
LOG_LEVEL=${LOG_LEVEL:-1}  # Default: INFO

# Log-Funktion mit Level-Steuerung
log() {
    local level_name=$1
    local message=$2
    local tag="${3:-$(basename "$0")}"
    
    # Level in numerischen Wert konvertieren
    local level_num
    case $level_name in
        DEBUG)   level_num=0 ;;
        INFO)    level_num=1 ;;
        WARNING) level_num=2 ;;
        ERROR)   level_num=3 ;;
        *)       level_num=1 ;;  # Default: INFO
    esac
    
    # Nur loggen, wenn Level höher/gleich konfiguriertem Level
    if [[ $level_num -ge $LOG_LEVEL ]]; then
        # syslog-Priorität bestimmen
        local priority
        case $level_name in
            DEBUG)   priority="local0.debug" ;;
            INFO)    priority="local0.info" ;;
            WARNING) priority="local0.warning" ;;
            ERROR)   priority="local0.err" ;;
            *)       priority="local0.info" ;;
        esac
        
        logger -p "$priority" -t "$tag" "[$level_name] $message"
    fi
}

# Verwendung
log "DEBUG" "Detaillierte Debug-Information"  # Wird nur bei LOG_LEVEL=0 ausgegeben
log "INFO" "Normale Informationsmeldung"      # Wird bei LOG_LEVEL<=1 ausgegeben
log "WARNING" "Warnung: Ressourcen knapp"     # Wird bei LOG_LEVEL<=2 ausgegeben
log "ERROR" "Kritischer Fehler aufgetreten"   # Wird immer ausgegeben bei LOG_LEVEL<=3

#!/bin/bash
set -x  # Aktiviert den Trace-Modus für das gesamte Skript
echo "Starte Operation"
for i in {1..3}; do
    echo "Durchlauf $i"
done
set +x  # Deaktiviert den Trace-Modus

function problematische_funktion() {
    set -x  # Tracing nur für diese Funktion aktivieren
    # Code der Funktion
    set +x  # Tracing wieder deaktivieren
}

#!/bin/bash
# Angepasstes Trace-Format mit Dateiname, Zeilennummer und Funktionsname
export PS4='+(${BASH_SOURCE}:${LINENO}): ${FUNCNAME[0]:+${FUNCNAME[0]}(): }'
set -x

function test_func() {
    echo "In der Testfunktion"
}

test_func

#!/bin/bash
set -v  # Aktiviert den Verbose-Modus
NAME="Welt"
echo "Hallo $NAME"
set +v  # Deaktiviert den Verbose-Modus

#!/bin/bash
set -vx  # Aktiviert Verbose- und Trace-Modus

# Installation (auf Debian/Ubuntu-Systemen)
apt-get install bashdb

# Verwendung
bashdb mein_skript.sh parameter1 parameter2

# Installation (auf Debian/Ubuntu-Systemen)
apt-get install shellcheck

# Verwendung
shellcheck mein_skript.sh

#!/bin/bash
set -euo pipefail

DEBUG_FILE="/tmp/debug_$(basename "$0").log"
debug() {
    echo "$(date '+%H:%M:%S.%N') [DEBUG] $*" >> "$DEBUG_FILE"
}

# Debug-Datei initialisieren
echo "=== Debug-Log gestartet $(date) ===" > "$DEBUG_FILE"

# Verwendung
debug "Skript gestartet mit Parametern: $*"
debug "Aktueller Wert von \$PATH: $PATH"

# In einer Schleife
for file in *.txt; do
    debug "Verarbeite Datei: $file"
    # Operationen an der Datei
    debug "Datei $file verarbeitet, Ergebnis: $?"
done

#!/bin/bash
set -euo pipefail

# Debug-Modus aktivieren, wenn DEBUG=1 gesetzt ist
if [ "${DEBUG:-0}" = "1" ]; then
    # Debug-Ausgabe an einen speziellen Socket senden
    exec 2> >(nc -U /tmp/debug_socket)
fi

# Rest des Skripts...

socat UNIX-LISTEN:/tmp/debug_socket,fork STDOUT

# Ausführlichere Fehlermeldungen für Befehlsexpansionen
export BASH_XTRACEFD=1

# Erweiterte Debugging-Informationen für die Variablensubstitution
export BASH_XTRACE=1

#!/bin/bash
set -euo pipefail

start_time=$(date +%s.%N)

time_checkpoint() {
    local checkpoint_name=$1
    local current_time=$(date +%s.%N)
    local elapsed=$(echo "$current_time - $start_time" | bc)
    echo "TIMING: $checkpoint_name - $elapsed Sekunden" >&2
}

# Verwendung
time_checkpoint "Start"
sleep 1
time_checkpoint "Nach Sleep 1"
for i in {1..100}; do
    : # Noop
done
time_checkpoint "Nach Schleife"

# Bash-Skript mit Profiling ausführen
bash -x mein_skript.sh 2> xtrace.log

# Profiling-Informationen auswerten
bash-xtraceprofile < xtrace.log

#!/bin/bash
set -euo pipefail

# Funktion zum Anzeigen aller Variablen mit einem bestimmten Präfix
dump_vars() {
    local prefix=$1
    eval "$(declare -p | grep "^declare .* $prefix" | sed 's/^declare/echo/')"
}

# Funktion zum Anzeigen eines Arrays
dump_array() {
    local arr_name=$1
    local arr_ref="$arr_name[@]"
    local i=0
    
    echo "Array $arr_name:"
    for element in "${!arr_ref}"; do
        echo "  [$i] = '$element'"
        ((i++))
    done
}

# Beispiel-Verwendung
CONFIG_HOST="example.com"
CONFIG_PORT=8080
CONFIG_TIMEOUT=30

dump_vars "CONFIG_"

# Arrays debuggen
FILES=("file1.txt" "file2.txt" "file with spaces.txt")
dump_array "FILES"

#!/bin/bash
set -euo pipefail

# PID des aktuellen Skripts speichern
echo "PID des Hauptskripts: $$" >&2

# Subshell mit eigener PID starten
(
    echo "PID der Subshell: $$" >&2
    sleep 10 &
    SLEEP_PID=$!
    echo "PID des Sleep-Prozesses: $SLEEP_PID" >&2
    
    # Prozesshierarchie anzeigen
    ps f -o pid,ppid,cmd --forest -p $$ $SLEEP_PID
) &

SUBSHELL_PID=$!
echo "PID der gestarteten Subshell: $SUBSHELL_PID" >&2

# Warten, damit die Ausgabe sichtbar ist
sleep 2

#!/bin/bash
set -euo pipefail

# Debugging-Optionen aktivieren
set -o errtrace  # ERR-Trap auch in Funktionen auslösen
set -o functrace # DEBUG und RETURN-Traps auch in Funktionen auslösen

# DEBUG-Trap für schrittweises Debugging
trap 'echo "DEBUG: $BASH_COMMAND (Zeile $LINENO)"' DEBUG

# Funktion definieren
function test_func() {
    echo "In test_func"
    return 0
}

# Hauptcode
echo "Hauptcode beginnt"
test_func
echo "Hauptcode endet"

# DEBUG-Trap wieder deaktivieren
trap - DEBUG

# Problematisch: Fehlende Anführungszeichen
FILE_PATH=/path/with spaces/file.txt
cd $FILE_PATH   # Wird als mehrere Argumente interpretiert

# Korrekt: Variablen in doppelte Anführungszeichen setzen
cd "$FILE_PATH"

# Problematisch: Dateien mit Leerzeichen werden falsch behandelt
for file in *.txt; do
    cp $file /backup/
done

# Korrekt: Variablen in Anführungszeichen setzen
for file in *.txt; do
    cp "$file" /backup/
done

# Problematisch: Unkontrollierte Expansion
OPTS="-l -a"
ls $OPTS /tmp   # Wird als separate Argumente behandelt

# Korrekt: Erhalt der Argumentstruktur
ls "$OPTS" /tmp  # Falsch: übergibt "-l -a" als einzelnes Argument
ls $OPTS /tmp    # Korrekt in diesem speziellen Fall

# Bei Arrays korrekt:
OPTS=(-l -a)
ls "${OPTS[@]}" /tmp  # Übergibt die Array-Elemente als separate Argumente

# Problematisch: Ungeschützte Variable
rm -rf $DIRECTORY/temp

# Korrekt: Schützen gegen leere Variablen
rm -rf "${DIRECTORY:?}/temp"  # Bricht ab, wenn DIRECTORY leer ist

# Problematisch: Ungeprüfte Standardwerte
echo ${LOGFILE:-/var/log/app.log}

# Korrekt: Prüfen, ob der Standardwert gültig ist
LOGFILE=${LOGFILE:-/var/log/app.log}
if [ ! -d "$(dirname "$LOGFILE")" ]; then
    echo "Fehler: Verzeichnis für Log-Datei existiert nicht" >&2
    exit 1
fi

# Problematisch: Ungültiger Zahlenwert führt zu Fehlern
COUNT="nicht-numerisch"
RESULT=$((COUNT + 1))  # Führt zu einem Fehler

# Korrekt: Validierung vor Verwendung
if [[ "$COUNT" =~ ^[0-9]+$ ]]; then
    RESULT=$((COUNT + 1))
else
    echo "Fehler: COUNT muss numerisch sein" >&2
    exit 1
fi

# Problematisch: [ ] vs [[ ]] Unterschiede nicht beachtet
if [ $VAR == "test" ]; then  # Kann zu Syntaxfehlern führen, wenn VAR leer ist
    echo "Übereinstimmung gefunden"
fi

# Korrekt: [[ ]] für erweiterte Tests und bessere Fehlertoleranz verwenden
if [[ $VAR == "test" ]]; then  # Funktioniert auch, wenn VAR leer ist
    echo "Übereinstimmung gefunden"
fi

# Problematisch: Keine Prüfung auf Existenz vor Verwendung
cat $CONFIG_FILE

# Korrekt: Existenz und Typ prüfen
if [ ! -f "$CONFIG_FILE" ]; then
    echo "Fehler: Konfigurationsdatei '$CONFIG_FILE' nicht gefunden" >&2
    exit 1
fi
cat "$CONFIG_FILE"

# Problematisch: Keine Fehlerprüfung nach kritischen Operationen
cp wichtige_datei.txt /backup/
rm wichtige_datei.txt       # Löscht Original ohne zu prüfen, ob Backup erstellt wurde

# Korrekt: Exit-Code prüfen und entsprechend reagieren
if cp wichtige_datei.txt /backup/; then
    rm wichtige_datei.txt
else
    echo "Fehler: Backup fehlgeschlagen, Original bleibt erhalten" >&2
    exit 1
fi

#!/bin/bash
set -euo pipefail  # Strikte Fehlerbehandlung aktivieren

# Dieser Befehl würde das Skript bei Fehler beenden
not_existing_command  # Wird mit Exit-Code 127 abbrechen

# Dieser Code wird nie erreicht
echo "Fertig"

# Problematisch: Annahme über das aktuelle Arbeitsverzeichnis
cd /tmp
./setup.sh        # Fehler, wenn setup.sh nicht in /tmp liegt

# Korrekt: Absoluter Pfad zum Skript bestimmen und verwenden
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
cd /tmp
"$SCRIPT_DIR/setup.sh"

# Problematisch: Unerwartete Auswirkungen auf nachfolgende Befehle
cd /tmp
rm *.log  # Löscht Log-Dateien im falschen Verzeichnis, wenn cd fehlschlägt

# Korrekt: In Subshell arbeiten, um das Arbeitsverzeichnis zu isolieren
(
    cd /tmp || { echo "Fehler: Konnte nicht nach /tmp wechseln" >&2; exit 1; }
    rm *.log
)
# Arbeitsverzeichnis bleibt unverändert, unabhängig vom Erfolg der Befehle in der Subshell

# Problematisch: Unbeabsichtigte Expansion
rm -rf /pfad/zu/verzeichnis/*    # Könnte bei fehlerhaftem Pfad gefährlich sein

# Korrekt: Prüfen, ob Expansion erfolgt
shopt -s nullglob  # Leere Liste, wenn keine Übereinstimmung
FILES=(/pfad/zu/verzeichnis/*)
if [ ${#FILES[@]} -gt 0 ]; then
    rm -rf "${FILES[@]}"
else
    echo "Warnung: Keine Dateien gefunden" >&2
fi

# Problematisch: Benutzereingabe wird als Globbing-Muster interpretiert
echo "Welche Datei soll gelöscht werden?"
read filename
rm $filename  # Gefährlich, wenn filename Platzhalter enthält

# Korrekt: Benutzereingabe als literalen String behandeln
rm "$filename"

# Problematisch: Variable in Subshell geändert, aber nicht im Hauptskript verfügbar
result=$(cd /tmp && VAR="neuer Wert" && echo "OK")
echo $VAR  # Gibt nichts aus, da VAR nur in der Subshell existiert

# Korrekt: Wert aus der Subshell explizit zurückgeben
VAR=$(cd /tmp && echo "neuer Wert")
echo $VAR  # Gibt "neuer Wert" aus

# Problematisch: Variablenänderungen in einer Pipeline gehen verloren
echo "Zeile 1
Zeile 2" | while read line; do
    count=$((count + 1))
done
echo "Anzahl Zeilen: $count"  # count ist außerhalb der while-Schleife nicht verändert

# Korrekt: Process Substitution verwenden, um dieses Problem zu umgehen
count=0
while read line; do
    count=$((count + 1))
done < <(echo "Zeile 1
Zeile 2")
echo "Anzahl Zeilen: $count"  # Gibt "Anzahl Zeilen: 2" aus

# Problematisch: Mehrere Prozesse schreiben in dieselbe Datei
for i in {1..10}; do
    (echo "Prozess $i schreibt" >> output.log) &
done
wait

# Korrekt: Synchronisation mit Datei-Locks
for i in {1..10}; do
    (
        # flock sorgt für exklusiven Zugriff
        flock -x 200
        echo "Prozess $i schreibt" >> output.log
    ) 200>/tmp/lock_file &
done
wait

# Problematisch: Vorhersehbarer temporärer Dateiname
TEMP_FILE="/tmp/myapp_temp.txt"
echo "Daten" > "$TEMP_FILE"  # Kollision, wenn mehrere Instanzen laufen

# Korrekt: Sicheres Erstellen temporärer Dateien mit mktemp
TEMP_FILE=$(mktemp)
echo "Daten" > "$TEMP_FILE"
# Aufräumen nicht vergessen
trap 'rm -f "$TEMP_FILE"' EXIT

# Problematisch: Fehlinterpretation von Daten mit Sonderzeichen
DATA="Zeile mit
Zeilenumbruch"
echo $DATA  # Gibt "Zeile mit Zeilenumbruch" ohne Zeilenumbruch aus

# Korrekt: Erhalt von Zeilenumbrüchen und Struktur
echo "$DATA"  # Gibt die Daten mit Zeilenumbruch aus

# Problematisch: Naives Parsen von CSV mit Bash
while IFS=, read -r name alter stadt; do
    echo "Name: $name, Alter: $alter"
done < daten.csv  # Versagt bei Kommas innerhalb von Feldern oder Zeilenumbrüchen

# Besser: Spezialisierte Tools verwenden
awk -F, '{print "Name: " $1 ", Alter: " $2}' daten.csv  # Für einfache Fälle
# Für komplexere Fälle: Python, Perl oder andere Sprachen mit CSV-Parsern

# Problematisch: Ungenauigkeit bei der Zeitmessung
start_time=$(date +%s)
sleep 0.1  # Befehl mit kurzer Laufzeit
end_time=$(date +%s)
duration=$((end_time - start_time))  # Könnte 0 sein bei kurzen Operationen

# Besser: Genauere Zeitmessung mit Nanosekunden
start_time=$(date +%s.%N)
sleep 0.1
end_time=$(date +%s.%N)
duration=$(echo "$end_time - $start_time" | bc)  # Erfordert bc für Fließkommaberechnung

# Problematisch: Einfache Datumsberechnungen
today=$(date +%Y-%m-%d)
# Wie addiert man 30 Tage in reiner Bash?

# Besser: date-Befehl mit spezifischen Optionen oder externe Tools nutzen
today=$(date +%Y-%m-%d)
in_30_days=$(date -d "$today + 30 days" +%Y-%m-%d)  # GNU date Syntax
# Oder mit BSD/macOS:
# in_30_days=$(date -v+30d +%Y-%m-%d)

# Problematisch: Unerwartete Sortierreihenfolge
if [ "10" > "2" ]; then
    echo "10 ist größer als 2"
else
    echo "10 ist NICHT größer als 2"
fi
# Gibt "10 ist NICHT größer als 2" aus, da es sich um lexikographischen Vergleich handelt

# Korrekt für numerischen Vergleich:
if [ 10 -gt 2 ]; then
    echo "10 ist größer als 2"
fi

# Problematisch: Falsche Syntax für reguläre Ausdrücke
if [ "$string" =~ ^[0-9]+$ ]; then  # Syntax-Fehler in [ ]
    echo "Numerischer String"
fi

# Korrekt: Doppelte eckige Klammern für reguläre Ausdrücke
if [[ "$string" =~ ^[0-9]+$ ]]; then
    echo "Numerischer String"
fi

# Problematisch: Annahme über die Verfügbarkeit eines Befehls
sort -V versionsliste.txt  # -V Option ist nicht auf allen Systemen verfügbar

# Korrekt: Verfügbarkeit prüfen oder Alternative bereitstellen
if sort --version 2>&1 | grep -q "GNU coreutils"; then
    # GNU sort mit -V Option ist verfügbar
    sort -V versionsliste.txt
else
    # Alternative Implementierung
    cat versionsliste.txt | awk '{ ... }'
fi

# Problematisch: Unterschiedliche Interpretation von Optionen
echo "Text" | grep -q "Text"  # -q ist auf einigen älteren Systemen nicht verfügbar

# Korrekt: Kompatiblere Alternative verwenden
if echo "Text" | grep "Text" > /dev/null 2>&1; then
    echo "Gefunden"
fi

if (( $count > 10 )); then

$ command_that_fails
$ echo $?
1

#!/bin/bash
set -euo pipefail

analyze_exit_code() {
    local exit_code=$1
    local command=$2
    
    case $exit_code in
        0)   echo "Befehl '$command' erfolgreich ausgeführt" ;;
        1)   echo "Befehl '$command' fehlgeschlagen: Allgemeiner Fehler" ;;
        2)   echo "Befehl '$command' fehlgeschlagen: Falsche Verwendung" ;;
        126) echo "Befehl '$command' fehlgeschlagen: Keine Ausführungsberechtigung" ;;
        127) echo "Befehl '$command' fehlgeschlagen: Befehl nicht gefunden" ;;
        *)   
            if [ $exit_code -gt 128 ] && [ $exit_code -lt 165 ]; then
                sig=$((exit_code - 128))
                echo "Befehl '$command' fehlgeschlagen: Signal $sig empfangen"
            else
                echo "Befehl '$command' fehlgeschlagen: Unbekannter Exit-Code $exit_code"
            fi
            ;;
    esac
}

# Verwendung
command_to_test="ls /nicht/existierender/pfad"
$command_to_test || analyze_exit_code $? "$command_to_test"

$ ls /nicht/existierender/pfad
ls: cannot access '/nicht/existierender/pfad': No such file or directory

#!/bin/bash
set -euo pipefail

# Fehlerausgabe in Variable speichern
error_output=$(ls /nicht/existierender/pfad 2>&1)

# Fehlerausgabe analysieren
if echo "$error_output" | grep -q "No such file or directory"; then
    echo "DIAGNOSE: Das angegebene Verzeichnis existiert nicht."
    echo "LÖSUNG: Überprüfen Sie den Pfad oder erstellen Sie das Verzeichnis."
elif echo "$error_output" | grep -q "Permission denied"; then
    echo "DIAGNOSE: Keine ausreichenden Berechtigungen für das Verzeichnis."
    echo "LÖSUNG: Überprüfen Sie die Zugriffsrechte mit 'ls -la'."
else
    echo "UNBEKANNTER FEHLER: $error_output"
fi

#!/bin/bash

# Beispiel zur Analyse von Umgebungsfehlern
analyze_environment_error() {
    local command=$1
    local error_output=$2
    
    # Typische Umgebungsfehler erkennen
    if echo "$error_output" | grep -q "No space left on device"; then
        echo "UMGEBUNGSFEHLER: Kein Speicherplatz mehr verfügbar."
        echo "DIAGNOSE: Überprüfen Sie freien Speicherplatz mit 'df -h'."
    elif echo "$error_output" | grep -q "Too many open files"; then
        echo "UMGEBUNGSFEHLER: Zu viele offene Dateien."
        echo "DIAGNOSE: Überprüfen Sie die Datei-Limits mit 'ulimit -a'."
    elif echo "$error_output" | grep -q "Cannot allocate memory"; then
        echo "UMGEBUNGSFEHLER: Nicht genügend Arbeitsspeicher."
        echo "DIAGNOSE: Überprüfen Sie den Speicherverbrauch mit 'free -m'."
    else
        echo "UNBEKANNTER UMGEBUNGSFEHLER: $error_output"
    fi
}

# Verwendung
command_to_test="tar -czf /backup.tar.gz /home"
error_output=$(eval "$command_to_test" 2>&1) || analyze_environment_error "$command_to_test" "$error_output"

#!/bin/bash
set -euo pipefail

# Prüfen auf nicht-ASCII-Zeichen in einer Datei
check_encoding() {
    local file=$1
    if grep -P "[\x80-\xFF]" "$file" > /dev/null; then
        echo "WARNUNG: Datei enthält nicht-ASCII-Zeichen, die Probleme verursachen könnten."
        echo "         Überprüfen Sie die Zeichencodierung oder konvertieren Sie mit iconv."
    fi
}

# Beispiel
input_file="input.txt"
check_encoding "$input_file"

#!/bin/bash
set -euo pipefail  # pipefail aktivieren, um Fehler in Pipelines zu erkennen

# Beispiel für eine Pipeline mit Fehler
grep "muster" nicht_existierende_datei.txt | sort | uniq > ergebnis.txt

# Ohne pipefail würde das Skript hier weiterlaufen, da sort und uniq erfolgreich waren
# Mit pipefail wird der Fehler von grep erkannt und das Skript beendet

#!/bin/bash
set -euo pipefail

debug_pipeline() {
    echo "Debugging Pipeline: $*"
    
    # Temporäre Dateien für Zwischenergebnisse erstellen
    local temp_dir=$(mktemp -d)
    trap 'rm -rf "$temp_dir"' EXIT
    
    # Pipeline in einzelne Befehle zerlegen und schrittweise ausführen
    local commands=("$@")
    local input="/dev/null"
    local output=""
    
    for ((i=0; i<${#commands[@]}; i++)); do
        output="$temp_dir/step_$i.out"
        echo "Schritt $i: ${commands[$i]}"
        
        # Befehl ausführen und Exit-Code prüfen
        if ! eval "${commands[$i]} < $input > $output 2> $temp_dir/step_$i.err"; then
            echo "FEHLER bei Schritt $i: ${commands[$i]}"
            echo "Exit-Code: $?"
            echo "Fehlerausgabe:"
            cat "$temp_dir/step_$i.err"
            return 1
        fi
        
        echo "Zwischenergebnis (erste 5 Zeilen):"
        head -n 5 "$output"
        echo "---"
        
        input="$output"
    done
    
    echo "Pipeline erfolgreich abgeschlossen."
}

# Beispiel
debug_pipeline "grep 'Muster' datei.txt" "sort" "uniq"

#!/bin/bash
set -euo pipefail

interpret_grep_result() {
    local pattern=$1
    local file=$2
    local exit_code=$3
    
    case $exit_code in
        0)  echo "Muster '$pattern' wurde in '$file' gefunden." ;;
        1)  echo "Muster '$pattern' wurde in '$file' NICHT gefunden." ;;
        2)  echo "FEHLER: Beim Durchsuchen von '$file' nach Muster '$pattern'."
            echo "        Überprüfen Sie, ob die Datei existiert und lesbar ist."
            ;;
        *)  echo "UNBEKANNTER FEHLER: Exit-Code $exit_code bei grep." ;;
    esac
}

# Anwendung
pattern="wichtiger_eintrag"
file="/var/log/system.log"

grep "$pattern" "$file" > /dev/null || interpret_grep_result "$pattern" "$file" $?

#!/bin/bash
# test_runner.sh - Einfacher manueller Test-Runner

set -euo pipefail

# Zu testendes Skript
SCRIPT="./mein_skript.sh"

# Testfälle definieren
echo "=== Testfall 1: Normaler Betrieb ==="
$SCRIPT parameter1 parameter2
echo "Exit-Code: $?"

echo "=== Testfall 2: Fehlender Parameter ==="
$SCRIPT parameter1
echo "Exit-Code: $?"

echo "=== Testfall 3: Ungültiger Parameter ==="
$SCRIPT --ungueltige-option
echo "Exit-Code: $?"

#!/usr/bin/env bats
# test_mein_skript.bats

setup() {
    # Wird vor jedem Test ausgeführt
    export TEMP_DIR=$(mktemp -d)
    export PATH="$BATS_TEST_DIRNAME:$PATH"
}

teardown() {
    # Wird nach jedem Test ausgeführt
    rm -rf "$TEMP_DIR"
}

@test "Skript sollte bei korrekten Parametern 0 zurückgeben" {
    run mein_skript.sh parameter1 parameter2
    
    # Überprüfungen
    [ "$status" -eq 0 ]
    [ "${lines[0]}" = "Erwartete Ausgabe" ]
}

@test "Skript sollte bei fehlenden Parametern 1 zurückgeben" {
    run mein_skript.sh
    
    [ "$status" -eq 1 ]
    [[ "${output}" =~ "Fehler: Parameter fehlen" ]]
}

# Installation (auf Debian/Ubuntu)
apt-get install bats

# Alternative: Installation aus GitHub
git clone https://github.com/bats-core/bats-core.git
cd bats-core
./install.sh /usr/local

# Tests ausführen
bats test_mein_skript.bats

#!/usr/bin/env bats

load "test_helper"  # Lädt gemeinsame Hilfsfunktionen

# Funktionstest
@test "add_numbers sollte Zahlen korrekt addieren" {
    # Source das zu testende Skript, wenn es Funktionen enthält
    source "$BATS_TEST_DIRNAME/../lib/math_functions.sh"
    
    result=$(add_numbers 5 7)
    [ "$result" -eq 12 ]
}

# Integrationstest
@test "process_file sollte CSV-Datei korrekt verarbeiten" {
    # Testdatei erstellen
    echo "Name,Alter,Stadt
Anna,28,Berlin
Boris,42,Hamburg" > "$TEMP_DIR/test.csv"
    
    run "$BATS_TEST_DIRNAME/../bin/process_file.sh" "$TEMP_DIR/test.csv"
    
    [ "$status" -eq 0 ]
    [ -f "$TEMP_DIR/test.csv.processed" ]
    [[ "$(cat "$TEMP_DIR/test.csv.processed")" =~ "2 Datensätze verarbeitet" ]]
}

# Fehlertest
@test "Skript sollte nicht-existierende Datei korrekt behandeln" {
    run "$BATS_TEST_DIRNAME/../bin/process_file.sh" "/nicht/existierend.csv"
    
    [ "$status" -eq 2 ]
    [[ "${output}" =~ "Fehler: Datei nicht gefunden" ]]
}

#!/usr/bin/env bash
# test_helper.bash

# Temporäres Testverzeichnis erstellen
setup_test_environment() {
    export TEST_DIR=$(mktemp -d)
    export TEST_INPUT="$TEST_DIR/input"
    export TEST_OUTPUT="$TEST_DIR/output"
    
    mkdir -p "$TEST_INPUT" "$TEST_OUTPUT"
}

# Testdaten generieren
generate_test_data() {
    local size=$1
    local file="$TEST_INPUT/data.txt"
    
    for ((i=1; i<=size; i++)); do
        echo "Testzeile $i mit zufälligem Inhalt $RANDOM" >> "$file"
    done
}

# Ausgaben validieren
assert_output_contains() {
    local pattern=$1
    local message=${2:-"Ausgabe sollte '$pattern' enthalten"}
    
    [[ "$output" =~ $pattern ]] || {
        echo "Fehler: $message"
        echo "Tatsächliche Ausgabe:"
        echo "$output"
        return 1
    }
}

# Dateien validieren
assert_file_contains() {
    local file=$1
    local pattern=$2
    local message=${3:-"Datei '$file' sollte '$pattern' enthalten"}
    
    [[ -f "$file" ]] || {
        echo "Fehler: Datei '$file' existiert nicht"
        return 1
    }
    
    grep -q "$pattern" "$file" || {
        echo "Fehler: $message"
        echo "Dateiinhalt:"
        cat "$file"
        return 1
    }
}

#!/usr/bin/env bats

load "test_helper"

setup() {
    setup_test_environment
}

teardown() {
    rm -rf "$TEST_DIR"
}

@test "Skript sollte große Dateien verarbeiten können" {
    generate_test_data 1000
    
    run "$BATS_TEST_DIRNAME/../bin/process_large_file.sh" "$TEST_INPUT/data.txt"
    
    [ "$status" -eq 0 ]
    assert_output_contains "1000 Zeilen verarbeitet"
    assert_file_contains "$TEST_OUTPUT/summary.txt" "Verarbeitung abgeschlossen"
}

# Installation
git clone https://github.com/shellspec/shellspec.git
cd shellspec
./install.sh

# Initialisierung eines Testprojekts
shellspec --init

# spec/mein_skript_spec.sh
Describe 'mein_skript.sh'
  Include ./mein_skript.sh
  
  Describe 'parse_arguments()'
    It 'sollte Standardwerte setzen, wenn keine Argumente übergeben werden'
      When call parse_arguments
      The variable CONFIG_FILE should equal '/etc/default.conf'
      The variable VERBOSE should equal 'false'
    End
    
    It 'sollte -c Option korrekt verarbeiten'
      When call parse_arguments -c /custom/config.conf
      The variable CONFIG_FILE should equal '/custom/config.conf'
    End
  End
  
  Describe 'process_file()'
    setup() { touch "$SHELLSPEC_TMPDIR/test.txt"; }
    
    It 'sollte eine Erfolgsausgabe für existierende Dateien erzeugen'
      When call process_file "$SHELLSPEC_TMPDIR/test.txt"
      The output should include 'Verarbeitung erfolgreich'
      The status should be 0
    End
    
    It 'sollte bei nicht existierenden Dateien einen Fehler ausgeben'
      When call process_file "$SHELLSPEC_TMPDIR/nicht_existierend.txt"
      The stderr should include 'Fehler'
      The status should be 1
    End
  End
End

#!/usr/bin/env bats

setup() {
    # Temporäres Verzeichnis für Mock-Befehle
    export MOCK_BIN_DIR=$(mktemp -d)
    export PATH="$MOCK_BIN_DIR:$PATH"
    
    # Mock für den 'curl' Befehl erstellen
    cat > "$MOCK_BIN_DIR/curl" << 'EOF'
#!/bin/bash
echo "HTTP/1.1 200 OK"
echo ""
echo "Mocked API Response"
EOF
    chmod +x "$MOCK_BIN_DIR/curl"
}

teardown() {
    rm -rf "$MOCK_BIN_DIR"
}

@test "api_request sollte Daten erfolgreich abrufen" {
    source "$BATS_TEST_DIRNAME/../lib/api_functions.sh"
    
    result=$(api_request "https://example.com/api")
    
    [[ "$result" =~ "Mocked API Response" ]]
}

#!/bin/bash
# mock_helper.sh

# Mock-Verzeichnis einrichten
setup_mocks() {
    export ORIGINAL_PATH="$PATH"
    export MOCK_DIR=$(mktemp -d)
    export PATH="$MOCK_DIR:$PATH"
}

# Mock-Verzeichnis aufräumen
teardown_mocks() {
    export PATH="$ORIGINAL_PATH"
    rm -rf "$MOCK_DIR"
}

# Mock für einen Befehl erstellen
create_mock() {
    local command=$1
    local exit_code=${2:-0}
    local stdout=${3:-""}
    local stderr=${4:-""}
    
    cat > "$MOCK_DIR/$command" << EOF
#!/bin/bash
echo "$stdout"
echo "$stderr" >&2
exit $exit_code
EOF
    chmod +x "$MOCK_DIR/$command"
}

# Mock für einen Befehl, der Argumente prüft
create_mock_with_args() {
    local command=$1
    local args_pattern=$2
    local success_stdout=${3:-""}
    local success_exit=${4:-0}
    local failure_stderr=${5:-"Ungültige Argumente"}
    local failure_exit=${6:-1}
    
    cat > "$MOCK_DIR/$command" << EOF
#!/bin/bash
if [[ "\$*" =~ $args_pattern ]]; then
    echo "$success_stdout"
    exit $success_exit
else
    echo "$failure_stderr" >&2
    exit $failure_exit
fi
EOF
    chmod +x "$MOCK_DIR/$command"
}

#!/usr/bin/env bats

load "mock_helper"

setup() {
    setup_mocks
}

teardown() {
    teardown_mocks
}

@test "backup-Skript sollte rsync mit korrekten Optionen aufrufen" {
    # Mock für rsync erstellen, der die Argumente überprüft
    create_mock_with_args "rsync" "-av --delete .* /backup" "Erfolgreiches Backup"
    
    run ./backup.sh /quelle /backup
    
    [ "$status" -eq 0 ]
    [[ "${output}" =~ "Backup abgeschlossen" ]]
}

# Installation von kcov (auf Debian/Ubuntu)
apt-get install kcov

# Ausführen von Tests mit Abdeckungsmessung
kcov --include-pattern=.sh coverage_report bats test_mein_skript.bats

# Ergebnis als HTML-Report in coverage_report/

#!/bin/bash
# unit_test_framework.sh

set -euo pipefail

# Globale Testvariablen
TEST_COUNT=0
PASS_COUNT=0
FAIL_COUNT=0

# Farbcodes für die Ausgabe
GREEN='\033[0;32m'
RED='\033[0;31m'
NC='\033[0m' # No Color

# Testfunktion, die einen Ausdruck bewertet
assert() {
    local expression=$1
    local message=${2:-"Assertion fehlgeschlagen"}
    
    ((TEST_COUNT++))
    
    if eval "$expression"; then
        printf "${GREEN}PASS${NC}: $message\n"
        ((PASS_COUNT++))
    else
        printf "${RED}FAIL${NC}: $message\n"
        printf "      Expression: $expression\n"
        ((FAIL_COUNT++))
    fi
}

# Gleichheit prüfen
assert_equals() {
    local actual=$1
    local expected=$2
    local message=${3:-"Erwartete '$expected', erhalten '$actual'"}
    
    assert "[ \"$actual\" = \"$expected\" ]" "$message"
}

# Ausgabe testen
assert_output() {
    local command=$1
    local expected_pattern=$2
    local message=${3:-"Ausgabe sollte '$expected_pattern' enthalten"}
    
    local output
    output=$(eval "$command" 2>&1)
    
    assert "[[ \"$output\" =~ \"$expected_pattern\" ]]" "$message (Ausgabe: $output)"
}

# Testgruppe starten
describe() {
    echo "=== $1 ==="
}

# Zusammenfassung drucken
summarize() {
    echo "------------------------"
    echo "Tests: $TEST_COUNT, Bestanden: $PASS_COUNT, Fehlgeschlagen: $FAIL_COUNT"
    
    if [ "$FAIL_COUNT" -eq 0 ]; then
        printf "${GREEN}Alle Tests bestanden!${NC}\n"
        exit 0
    else
        printf "${RED}Es gibt fehlgeschlagene Tests.${NC}\n"
        exit 1
    fi
}

#!/bin/bash
# test_math_functions.sh

source "./unit_test_framework.sh"
source "./math_functions.sh"  # Die zu testenden Funktionen

describe "Funktion add_numbers"
assert_equals "$(add_numbers 5 7)" "12" "5 + 7 sollte 12 ergeben"
assert_equals "$(add_numbers -3 3)" "0" "-3 + 3 sollte 0 ergeben"
assert_equals "$(add_numbers 0 0)" "0" "0 + 0 sollte 0 ergeben"

describe "Funktion multiply_numbers"
assert_equals "$(multiply_numbers 4 3)" "12" "4 * 3 sollte 12 ergeben"
assert_equals "$(multiply_numbers -2 5)" "-10" "-2 * 5 sollte -10 ergeben"
assert_equals "$(multiply_numbers 0 100)" "0" "0 * 100 sollte 0 ergeben"

describe "Fehlerbehandlung"
assert_output "add_numbers abc 5" "Fehler: Ungültige Zahl"
assert_output "multiply_numbers 5" "Fehler: Zwei Zahlen erforderlich"

summarize

#!/bin/bash
# integration_test.sh

set -euo pipefail

# Testumgebung aufsetzen
setup() {
    echo "Testumgebung wird eingerichtet..."
    export TEST_DIR=$(mktemp -d)
    export TEST_DB="${TEST_DIR}/test.db"
    export CONFIG_FILE="${TEST_DIR}/config.ini"
    
    # Testdatenbank initialisieren
    sqlite3 "$TEST_DB" << EOF
CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, email TEXT);
INSERT INTO users (name, email) VALUES ('Test User', 'test@example.com');
EOF
    
    # Testkonfiguration erstellen
    cat > "$CONFIG_FILE" << EOF
[Database]
path = $TEST_DB

[Settings]
verbose = true
log_level = debug
EOF
}

# Testumgebung aufräumen
teardown() {
    echo "Testumgebung wird aufgeräumt..."
    rm -rf "$TEST_DIR"
}

# Integrationstests ausführen
run_tests() {
    echo "Starte Integrationstests..."
    
    # Test 1: Benutzer auflisten
    echo "Test 1: Benutzer auflisten"
    output=$(./user_manager.sh --config "$CONFIG_FILE" list)
    if [[ "$output" =~ "Test User" ]] && [[ "$output" =~ "test@example.com" ]]; then
        echo "Test 1 bestanden"
    else
        echo "Test 1 fehlgeschlagen. Ausgabe: $output"
        exit 1
    fi
    
    # Test 2: Neuen Benutzer hinzufügen
    echo "Test 2: Benutzer hinzufügen"
    ./user_manager.sh --config "$CONFIG_FILE" add "New User" "new@example.com"
    output=$(./user_manager.sh --config "$CONFIG_FILE" list)
    if [[ "$output" =~ "New User" ]] && [[ "$output" =~ "new@example.com" ]]; then
        echo "Test 2 bestanden"
    else
        echo "Test 2 fehlgeschlagen. Ausgabe: $output"
        exit 1
    fi
    
    # Test 3: Benutzer löschen
    echo "Test 3: Benutzer löschen"
    ./user_manager.sh --config "$CONFIG_FILE" delete "New User"
    output=$(./user_manager.sh --config "$CONFIG_FILE" list)
    if [[ "$output" =~ "New User" ]]; then
        echo "Test 3 fehlgeschlagen. Ausgabe: $output"
        exit 1
    else
        echo "Test 3 bestanden"
    fi
    
    echo "Alle Integrationstests bestanden!"
}

# Hauptfunktion
main() {
    trap teardown EXIT
    
    setup
    run_tests
}

main

#!/bin/bash
# property_test.sh

set -euo pipefail

# Zufällige Zahlen generieren
generate_random_int() {
    local min=${1:-0}
    local max=${2:-100}
    echo $((RANDOM % (max - min + 1) + min))
}

# Zufällige Strings generieren
generate_random_string() {
    local length=${1:-10}
    cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w "$length" | head -n 1
}

# Property: add(a,b) = add(b,a) (Kommutativität)
test_add_commutative() {
    echo "Teste Kommutativität der Addition..."
    
    for ((i=1; i<=100; i++)); do
        a=$(generate_random_int -100 100)
        b=$(generate_random_int -100 100)
        
        result1=$(./math_functions.sh add "$a" "$b")
        result2=$(./math_functions.sh add "$b" "$a")
        
        if [ "$result1" -ne "$result2" ]; then
            echo "FEHLER: add($a,$b) = $result1, aber add($b,$a) = $result2"
            exit 1
        fi
    done
    
    echo "Kommutativitäts-Property bestanden!"
}

# Property: len(a + b) = len(a) + len(b)
test_string_concat() {
    echo "Teste String-Verkettung..."
    
    for ((i=1; i<=100; i++)); do
        a=$(generate_random_string $(generate_random_int 1 20))
        b=$(generate_random_string $(generate_random_int 1 20))
        
        concat=$(./string_functions.sh concat "$a" "$b")
        
        len_a=${#a}
        len_b=${#b}
        len_concat=${#concat}
        
        if [ "$len_concat" -ne $((len_a + len_b)) ]; then
            echo "FEHLER: Länge von '$a'+'$b' ist $len_concat, sollte aber $((len_a + len_b)) sein"
            exit 1
        fi
    done
    
    echo "String-Verkettungs-Property bestanden!"
}

# Alle Property-Tests ausführen
run_property_tests() {
    test_add_commutative
    test_string_concat
    
    echo "Alle Property-Tests bestanden!"
}

run_property_tests