chore: complete update

tests/Domain/QrCode/End2EndTest.php

@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Application\Service\QrCodeService;
+use App\Domain\QrCode\QrCode;
+use App\Domain\QrCode\Service\QrCodeEncoder;
+use App\Domain\QrCode\Service\QrCodeGenerator;
+use App\Domain\QrCode\Service\QrCodeMasker;
+use App\Domain\QrCode\Service\QrCodeRenderer;
+use App\Domain\QrCode\Service\ReedSolomon;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+use App\Domain\QrCode\ValueObject\QrCodeMatrix;
+use App\Domain\QrCode\ValueObject\QrCodeVersion;
+
+test('End-to-End QR-Code-Generierung funktioniert', function () {
+    // Abhängigkeiten aufbauen
+    $encoder = new QrCodeEncoder();
+    $renderer = new QrCodeRenderer(new QrCodeMasker(), new ReedSolomon());
+    $generator = new QrCodeGenerator($encoder, $renderer);
+
+    // Test-Daten
+    $data = 'https://example.com';
+    $errorLevel = ErrorCorrectionLevel::M;
+    $version = 2; // Fixe Version für Test-Vorhersagbarkeit
+
+    // QR-Code generieren
+    $qrCode = new QrCode($data, $errorLevel, new QrCodeVersion($version));
+    $matrix = $generator->generate($qrCode);
+
+    // Prüfungen
+    expect($matrix)->toBeInstanceOf(QrCodeMatrix::class);
+
+    // Prüfe die Größe (Version 2 = 25x25)
+    $expectedSize = 25; // 21 + (2-1)*4 = 25
+    expect($matrix->getSize())->toBe($expectedSize);
+
+    // Prüfe, ob Finder-Patterns vorhanden sind (3 Ecken haben spezifische Muster)
+    $topLeft = $this->hasFinderPattern($matrix->getMatrix(), 0, 0);
+    $topRight = $this->hasFinderPattern($matrix->getMatrix(), 0, $expectedSize - 7);
+    $bottomLeft = $this->hasFinderPattern($matrix->getMatrix(), $expectedSize - 7, 0);
+
+    expect($topLeft)->toBeTrue('Finder Pattern oben links fehlt');
+    expect($topRight)->toBeTrue('Finder Pattern oben rechts fehlt');
+    expect($bottomLeft)->toBeTrue('Finder Pattern unten links fehlt');
+});
+
+// Hilfsfunktion zur Prüfung von Finder-Patterns
+function hasFinderPattern(array $matrix, int $startRow, int $startCol): bool
+{
+    // Prüfe das 7x7 Finder-Pattern-Muster
+    // Das äußere Quadrat sollte 7x7 sein und vollständig dunkel
+    for ($i = 0; $i < 7; $i++) {
+        for ($j = 0; $j < 7; $j++) {
+            if ($i === 0 || $i === 6 || $j === 0 || $j === 6) {
+                if ($matrix[$startRow + $i][$startCol + $j] !== true) {
+                    return false;
+                }
+            }
+        }
+    }
+
+    // Das mittlere Quadrat sollte 5x5 sein und weiß (false)
+    for ($i = 1; $i < 6; $i++) {
+        for ($j = 1; $j < 6; $j++) {
+            if ($i === 1 || $i === 5 || $j === 1 || $j === 5) {
+                if ($matrix[$startRow + $i][$startCol + $j] !== false) {
+                    return false;
+                }
+            }
+        }
+    }
+
+    // Das innerste Quadrat sollte 3x3 sein und dunkel (true)
+    for ($i = 2; $i < 5; $i++) {
+        for ($j = 2; $j < 5; $j++) {
+            if ($matrix[$startRow + $i][$startCol + $j] !== true) {
+                return false;
+            }
+        }
+    }
+
+    return true;
+}

tests/Domain/QrCode/QrCodeTest.php

@@ -0,0 +1,96 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Domain\QrCode\QrCode;
+use App\Domain\QrCode\Exception\QrCodeException;
+use App\Domain\QrCode\Service\QrCodeEncoder;
+use App\Domain\QrCode\Service\QrCodeGenerator;
+use App\Domain\QrCode\Service\QrCodeMasker;
+use App\Domain\QrCode\Service\QrCodeRenderer;
+use App\Domain\QrCode\Service\ReedSolomon;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+use App\Domain\QrCode\ValueObject\MaskPattern;
+use App\Domain\QrCode\ValueObject\QrCodeVersion;
+
+test('QrCode Objekt kann erstellt werden', function () {
+    $qrCode = new QrCode('Testdaten');
+
+    expect($qrCode->getData())->toBe('Testdaten');
+    expect($qrCode->getErrorCorrectionLevel())->toBe(ErrorCorrectionLevel::M);
+    expect($qrCode->getVersion())->toBeNull();
+});
+
+test('QrCode wirft Exception bei leeren Daten', function () {
+    expect(fn() => new QrCode(''))->toThrow(QrCodeException::class);
+});
+
+test('QrCode withMethods erzeugen neue Instanzen', function () {
+    $original = new QrCode('Test');
+    $withLevel = $original->withErrorCorrectionLevel(ErrorCorrectionLevel::H);
+    $withVersion = $original->withVersion(new QrCodeVersion(5));
+
+    expect($withLevel)->not->toBe($original);
+    expect($withVersion)->not->toBe($original);
+    expect($withLevel->getErrorCorrectionLevel())->toBe(ErrorCorrectionLevel::H);
+    expect($withVersion->getVersion()->getValue())->toBe(5);
+});
+
+test('MaskPattern kann Maskenbedingungen korrekt auswerten', function () {
+    $pattern = MaskPattern::PATTERN_0;
+
+    expect($pattern->shouldMask(0, 0))->toBeTrue(); // (0+0)%2 = 0
+    expect($pattern->shouldMask(1, 0))->toBeFalse(); // (1+0)%2 = 1
+    expect($pattern->shouldMask(1, 1))->toBeTrue(); // (1+1)%2 = 0
+});
+
+test('QrCodeEncoder kann Daten kodieren', function () {
+    $encoder = new QrCodeEncoder();
+    $qrCode = new QrCode('123');
+    $version = new QrCodeVersion(1);
+
+    $encoded = $encoder->encode($qrCode, $version);
+
+    expect($encoded)->toBeString();
+    expect(strlen($encoded))->toBeGreaterThan(0);
+});
+
+test('QrCodeGenerator kann QR-Code-Matrix generieren', function () {
+    $generator = new QrCodeGenerator(
+        new QrCodeEncoder(),
+        new QrCodeRenderer(new QrCodeMasker(), new ReedSolomon())
+    );
+
+    $qrCode = new QrCode('Test123');
+    $matrix = $generator->generate($qrCode);
+
+    expect($matrix->getSize())->toBeGreaterThan(20); // QR-Code ist mindestens Version 1 (21x21)
+});
+
+test('QrCodeMasker berechnet Maskenstrafen korrekt', function () {
+    $masker = new QrCodeMasker();
+    $size = 21; // Version 1
+
+    // Matrix mit alternierenden Modulen (geringe Strafe)
+    $alternatingMatrix = [];
+    for ($i = 0; $i < $size; $i++) {
+        $alternatingMatrix[$i] = [];
+        for ($j = 0; $j < $size; $j++) {
+            $alternatingMatrix[$i][$j] = ($i + $j) % 2 === 0;
+        }
+    }
+
+    // Matrix mit vielen aufeinanderfolgenden gleichen Modulen (hohe Strafe)
+    $repeatingMatrix = [];
+    for ($i = 0; $i < $size; $i++) {
+        $repeatingMatrix[$i] = [];
+        for ($j = 0; $j < $size; $j++) {
+            $repeatingMatrix[$i][$j] = $j < $size / 2;
+        }
+    }
+
+    $alternatingPenalty = $masker->calculateMaskPenalty($alternatingMatrix, $size);
+    $repeatingPenalty = $masker->calculateMaskPenalty($repeatingMatrix, $size);
+
+    expect($alternatingPenalty)->toBeLessThan($repeatingPenalty);
+});

tests/Domain/QrCode/Service/QrCodeEncoderTest.php

@@ -0,0 +1,72 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Domain\QrCode\QrCode;
+use App\Domain\QrCode\Service\QrCodeEncoder;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+use App\Domain\QrCode\ValueObject\QrCodeVersion;
+
+test('QrCodeEncoder kann numerische Daten kodieren', function () {
+    $encoder = new QrCodeEncoder();
+    $qrCode = new QrCode('12345', ErrorCorrectionLevel::M);
+    $version = new QrCodeVersion(1);
+
+    $encoded = $encoder->encode($qrCode, $version);
+
+    // Prüfe, dass das Ergebnis ein binärer String ist
+    expect($encoded)->toBeString();
+    expect(strlen($encoded) % 8)->toBe(0); // Muss ein Vielfaches von 8 sein
+
+    // Prüfe den Mode Indicator für numerische Daten (0001)
+    expect(substr($encoded, 0, 4))->toBe('0001');
+});
+
+test('QrCodeEncoder kann alphanumerische Daten kodieren', function () {
+    $encoder = new QrCodeEncoder();
+    $qrCode = new QrCode('ABC123', ErrorCorrectionLevel::M);
+    $version = new QrCodeVersion(1);
+
+    $encoded = $encoder->encode($qrCode, $version);
+
+    // Prüfe, dass das Ergebnis ein binärer String ist
+    expect($encoded)->toBeString();
+    expect(strlen($encoded) % 8)->toBe(0); // Muss ein Vielfaches von 8 sein
+
+    // Prüfe den Mode Indicator für alphanumerische Daten (0010)
+    expect(substr($encoded, 0, 4))->toBe('0010');
+});
+
+test('QrCodeEncoder kann Byte-Daten kodieren', function () {
+    $encoder = new QrCodeEncoder();
+    $qrCode = new QrCode('Hello World!', ErrorCorrectionLevel::M);
+    $version = new QrCodeVersion(1);
+
+    $encoded = $encoder->encode($qrCode, $version);
+
+    // Prüfe, dass das Ergebnis ein binärer String ist
+    expect($encoded)->toBeString();
+    expect(strlen($encoded) % 8)->toBe(0); // Muss ein Vielfaches von 8 sein
+
+    // Prüfe den Mode Indicator für Byte-Daten (0100)
+    expect(substr($encoded, 0, 4))->toBe('0100');
+});
+
+test('QrCodeEncoder fügt Terminator und Padding korrekt hinzu', function () {
+    $encoder = new QrCodeEncoder();
+    $qrCode = new QrCode('1', ErrorCorrectionLevel::M); // Minimale Daten
+    $version = new QrCodeVersion(1);
+
+    $encoded = $encoder->encode($qrCode, $version);
+
+    // Prüfe, dass das Ergebnis ein binärer String ist
+    expect($encoded)->toBeString();
+
+    // Prüfe die Länge (sollte der vollen Datenkapazität entsprechen)
+    $expectedLength = (new QrCodeVersion(1))->getDataCapacity(ErrorCorrectionLevel::M) * 8;
+    expect(strlen($encoded))->toBe($expectedLength);
+
+    // Prüfe, ob Pad-Bytes vorhanden sind (11101100 oder 00010001)
+    $containsPadBytes = str_contains($encoded, '11101100') || str_contains($encoded, '00010001');
+    expect($containsPadBytes)->toBeTrue();
+});

tests/Domain/QrCode/Service/ReedSolomonTest.php

@@ -0,0 +1,84 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Domain\QrCode\Service\ReedSolomon;
+use App\Domain\QrCode\Service\ReedSolomonEncoder;
+use App\Domain\QrCode\ValueObject\ErrorCorrectionLevel;
+
+test('ReedSolomon kann Fehlerkorrektur hinzufügen', function () {
+    $rs = new ReedSolomon();
+
+    // Erstelle einen einfachen Testfall mit 4 Datenbytes
+    $data = '00110011' . '01010101' . '11001100' . '10101010'; // Binär: 51, 85, 204, 170
+    $dataCapacity = 4; // 4 Bytes
+    $level = ErrorCorrectionLevel::M;
+
+    // Wende Reed-Solomon an
+    $encoded = $rs->addErrorCorrection($data, $dataCapacity, $level);
+
+    // Überprüfe, dass das Ergebnis länger als die Eingabe ist (ECC wurde hinzugefügt)
+    expect(strlen($encoded))->toBeGreaterThan(strlen($data));
+
+    // Überprüfe, dass die ursprünglichen Daten am Anfang vorhanden sind
+    expect(substr($encoded, 0, strlen($data)))->toBe($data);
+});
+
+test('ReedSolomonEncoder kann Bytes kodieren', function () {
+    $encoder = new ReedSolomonEncoder();
+
+    // Testdaten: [0x32, 0x54, 0x67, 0x89]
+    $data = [0x32, 0x54, 0x67, 0x89];
+    $eccLength = 4; // 4 ECC Bytes hinzufügen
+
+    $encoded = $encoder->encode($data, $eccLength);
+
+    // Erwarte Originaldaten + ECC-Bytes
+    expect(count($encoded))->toBe(count($data) + $eccLength);
+
+    // Überprüfe, dass die ursprünglichen Daten am Anfang vorhanden sind
+    for ($i = 0; $i < count($data); $i++) {
+        expect($encoded[$i])->toBe($data[$i]);
+    }
+
+    // Überprüfe, dass die ECC-Bytes nicht alle 0 sind (echte Berechnung)
+    $allZero = true;
+    for ($i = count($data); $i < count($encoded); $i++) {
+        if ($encoded[$i] !== 0) {
+            $allZero = false;
+            break;
+        }
+    }
+    expect($allZero)->toBeFalse();
+});
+
+test('ReedSolomon kann Daten in Blöcke organisieren', function () {
+    $rs = new ReedSolomon();
+    $method = new ReflectionMethod($rs, 'organizeDataBlocks');
+    $method->setAccessible(true);
+
+    // Testdaten: 8 Bytes [1, 2, 3, 4, 5, 6, 7, 8]
+    $data = [1, 2, 3, 4, 5, 6, 7, 8];
+    $version = 1;
+    $level = ErrorCorrectionLevel::M; // 1 Block für Version 1-M
+
+    $blocks = $method->invoke($rs, $data, $version, $level);
+
+    // Version 1-M hat 1 Block
+    expect(count($blocks))->toBe(1);
+    expect($blocks[0])->toBe($data);
+});
+
+test('ReedSolomon kann Blöcke interleaven', function () {
+    $rs = new ReedSolomon();
+    $method = new ReflectionMethod($rs, 'interleaveBlocks');
+    $method->setAccessible(true);
+
+    // 2 Blöcke: [1, 2, 3] und [4, 5, 6]
+    $blocks = [[1, 2, 3], [4, 5, 6]];
+
+    $interleaved = $method->invoke($rs, $blocks);
+
+    // Erwartetes Ergebnis: [1, 4, 2, 5, 3, 6]
+    expect($interleaved)->toBe([1, 4, 2, 5, 3, 6]);
+});

tests/Domain/QrCode/ValueObject/GaloisFieldTest.php

@@ -0,0 +1,59 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Domain\QrCode\ValueObject\GaloisField;
+
+test('GaloisField Arithmetik funktioniert korrekt', function () {
+    $field = new GaloisField();
+
+    // Addition (XOR) Tests
+    expect($field->add(0, 0))->toBe(0);
+    expect($field->add(0, 1))->toBe(1);
+    expect($field->add(1, 0))->toBe(1);
+    expect($field->add(1, 1))->toBe(0);
+    expect($field->add(15, 32))->toBe(47);
+
+    // Multiplikation Tests
+    expect($field->multiply(0, 5))->toBe(0);
+    expect($field->multiply(5, 0))->toBe(0);
+    expect($field->multiply(1, 1))->toBe(1);
+    expect($field->multiply(2, 3))->toBe(6);
+
+    // Division Tests
+    expect($field->divide(0, 5))->toBe(0);
+    expect($field->divide(5, 1))->toBe(5);
+    expect($field->divide(6, 3))->toBe(2);
+
+    // Division durch Null sollte Exception werfen
+    expect(fn() => $field->divide(5, 0))->toThrow(\DivisionByZeroError::class);
+
+    // Potenzen Tests
+    expect($field->power(2, 0))->toBe(1);  // 2^0 = 1
+    expect($field->power(2, 1))->toBe(2);  // 2^1 = 2
+    expect($field->power(2, 2))->toBe(4);  // 2^2 = 4
+    expect($field->power(2, 3))->toBe(8);  // 2^3 = 8
+});
+
+test('GaloisField Tabellen sind korrekt initialisiert', function () {
+    $field = new GaloisField();
+
+    $expTable = $field->getExpTable();
+    $logTable = $field->getLogTable();
+
+    // Prüfe grundlegende Eigenschaften der Tabellen
+    expect(count($expTable))->toBe(256);
+    expect(count($logTable))->toBe(256);
+
+    // Prüfe spezifische Werte
+    expect($expTable[0])->toBe(1);
+    expect($expTable[1])->toBe(2);
+    expect($expTable[2])->toBe(4);
+    expect($expTable[3])->toBe(8);
+
+    // Prüfe Log-Tabelle
+    expect($logTable[1])->toBe(0);
+    expect($logTable[2])->toBe(1);
+    expect($logTable[4])->toBe(2);
+    expect($logTable[8])->toBe(3);
+});

tests/Domain/QrCode/ValueObject/PolynomialTest.php

@@ -0,0 +1,75 @@
+<?php
+
+declare(strict_types=1);
+
+use App\Domain\QrCode\ValueObject\GaloisField;
+use App\Domain\QrCode\ValueObject\Polynomial;
+
+test('Polynomial kann erstellt werden', function () {
+    $field = new GaloisField();
+    $poly = new Polynomial($field, [1, 2, 3]); // x^2 + 2x + 3
+
+    expect($poly->getCoefficients())->toBe([1, 2, 3]);
+    expect($poly->getDegree())->toBe(2);
+});
+
+test('Polynomial entfernt führende Nullen', function () {
+    $field = new GaloisField();
+    $poly = new Polynomial($field, [0, 0, 1, 2]); // x + 2
+
+    expect($poly->getCoefficients())->toBe([1, 2]);
+    expect($poly->getDegree())->toBe(1);
+});
+
+test('Polynomial kann an Stelle x ausgewertet werden', function () {
+    $field = new GaloisField();
+    $poly = new Polynomial($field, [1, 0, 1]); // x^2 + 1
+
+    expect($poly->evaluateAt(0))->toBe(1);
+    expect($poly->evaluateAt(1))->toBe(0); // 1^2 + 1 = 2 = 0 in GF(2)
+    expect($poly->evaluateAt(2))->toBe(5); // 2^2 + 1 = 5
+});
+
+test('Polynomial Addition funktioniert', function () {
+    $field = new GaloisField();
+    $poly1 = new Polynomial($field, [1, 2]); // x + 2
+    $poly2 = new Polynomial($field, [3, 4]); // 3x + 4
+
+    $sum = $poly1->add($poly2);
+
+    // In GF(2^8) ist Addition = XOR, daher 1⊕3=2, 2⊕4=6
+    expect($sum->getCoefficients())->toBe([2, 6]);
+});
+
+test('Polynomial Multiplikation funktioniert', function () {
+    $field = new GaloisField();
+    $poly1 = new Polynomial($field, [1, 1]); // x + 1
+    $poly2 = new Polynomial($field, [1, 0, 1]); // x^2 + 1
+
+    $product = $poly1->multiply($poly2);
+
+    // (x + 1)(x^2 + 1) = x^3 + x^2 + x + 1
+    expect($product->getCoefficients())->toBe([1, 1, 1, 1]);
+});
+
+test('Polynomial Division funktioniert', function () {
+    $field = new GaloisField();
+    $poly1 = new Polynomial($field, [1, 0, 1]); // x^2 + 1
+    $poly2 = new Polynomial($field, [1, 1]); // x + 1
+
+    $result = $poly1->divideAndRemainder($poly2);
+
+    // (x^2 + 1) ÷ (x + 1) = x - 1 + 2/(x+1)
+    // In GF(2^8): Quotient = x - 1 = x + 1, Rest = 2
+    expect($result['quotient']->getCoefficients())->toEqual([1, 1]);
+    expect($result['remainder']->getCoefficients())->toEqual([0]);
+});
+
+test('Generator Polynom kann korrekt erstellt werden', function () {
+    $field = new GaloisField();
+    $generator = Polynomial::buildGenerator($field, 3);
+
+    // Erwartetes Ergebnis für Grad 3
+    expect($generator->getDegree())->toBe(3);
+    expect(count($generator->getCoefficients()))->toBe(4);
+});