Das Werkzeug schreibt fortan die Sprache, die es liest

Der Klartext des Landesrechts war Eingabeformat und kein Ausgabeformat. Das
Erzeugnis kannte die fortgeschriebene Fassung — sie steht als vollständiges
Gesetz in der Anwendung —, gab sie aber nur als halbe Spalte einer Synopse
heraus. Damit fehlte dreierlei: die Kette (Heft auf Heft), die Prüfbarkeit von
außen (wer gegen die amtliche Nachfassung hält, braucht Text, nicht Auszeichnung)
und der Rückfluss.

Der LandesRechtTextAusgeber kehrt den LandesRechtTextParser um. Er erfindet
nichts: Die Abkürzungszeile tritt nur auf, wenn die Quelle eine geführt hat; das
doppelte Leerzeichen zwischen Bezeichnung und Überschrift ist kanonisch, weil an
ihm der Lader den Normkopf vom angeklebten Querverweis scheidet; die Nummer einer
Anlage erscheint als „Nummer 6“, weil die vorangehende Anlagen-Norm den Bezug
schon herstellt. Zwei Grenzen des Formats sind im Quelltext benannt: Der Normkopf
einer Anlage nimmt keinen Titel auf, und eine Gliederungseinheit hinter der
letzten Norm des Textteils hat keinen anderen Ort als eben diesen.

Der Beleg ist nicht der Augenschein, sondern der Rundlauf: Was der Ausgeber
schreibt, muss der Lader wieder zu demselben Gesetz lesen. Geprüft wird das an
sämtlichen dreiundzwanzig Klartext-Stammfassungen des Beispielkorpus.

Der Rundlauf hat sogleich einen Mangel des Lesers aufgedeckt. Eine nummerierte
Zeile gilt als Unter-Überschrift, wenn ihr eine weitere Überschrift folgt — als
solche zählten aber nur drei der fünf Formen. Der sächsischen Katalogzeile
„1. Januar 2023 …“ folgt „Unterabschnitt 12 …“, und das ist ebenso eine
Überschrift wie ein Normkopf. Die arabische und die ordinalwörtliche Form treten
hinzu.

Geprüft: 373 Tests (zuvor 350), darunter dreiundzwanzig Rundläufe; kein
Akzeptanzfall ist zurückgefallen.

Change-Id: I6bdacae8638a894ca9ba0a01f1865e0c93e9718c

1 files changed, 69 insertions, 0 deletions

diff --git a/src/test/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextAusgeberTest.java b/src/test/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextAusgeberTest.java
new file mode 100644
index 0000000..e620a03
--- /dev/null
+++ b/src/test/java/eu/mulk/aendggner/gesetz/land/LandesRechtTextAusgeberTest.java
@@ -0,0 +1,69 @@
+// SPDX-FileCopyrightText: 2026 Matthias Andreas Benkard <code@mail.matthias.benkard.de>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+package eu.mulk.aendggner.gesetz.land;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assumptions.assumeTrue;
+
+import eu.mulk.aendggner.gesetz.Gesetz;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+import java.util.stream.Stream;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+/**
+ * Der Beleg des Textausgebers ist der Rundlauf, nicht der Augenschein: Was er schreibt, muss der
+ * Lader wieder zu demselben Gesetz lesen. Geprüft wird das an sämtlichen Klartext-Stammfassungen
+ * des Beispielkorpus — dreizehn Länder, jede Eigenheit des Formats mindestens einmal (Superskripte
+ * und „Art.“-Sigel in Bayern, titellose Paragraphen und ausgeschriebene Ordinale in Hessen, die
+ * Nummern einer Anlage als eigene Normen in Berlin, Zwischentitel, Fußnoten, Inhaltsübersicht).
+ */
+class LandesRechtTextAusgeberTest {
+
+  private static final Path SAMPLEDATA = Path.of("src/test/resources/sampledata");
+
+  static Stream<Path> klartextFassungen() throws IOException {
+    if (!Files.isDirectory(SAMPLEDATA)) {
+      return Stream.of();
+    }
+    try (var pfade = Files.walk(SAMPLEDATA)) {
+      return pfade
+          .filter(p -> p.getFileName().toString().endsWith(".txt"))
+          .sorted()
+          .toList()
+          .stream();
+    }
+  }
+
+  @ParameterizedTest(name = "{0}")
+  @MethodSource("klartextFassungen")
+  void rundlaufErhaeltDasGesetz(Path datei) throws IOException {
+    assumeTrue(Files.exists(datei), "Beispieldaten fehlen");
+    var gelesen = new LandesRechtLoader().load(datei);
+
+    var geschrieben = LandesRechtTextAusgeber.ausgeben(gelesen);
+    var wiederGelesen = LandesRechtTextParser.parse(geschrieben);
+
+    assertThat(wiederGelesen.langue()).isEqualTo(gelesen.langue());
+    assertThat(wiederGelesen.jurabk()).isEqualTo(gelesen.jurabk());
+    assertThat(wiederGelesen.kurzue()).isEqualTo(gelesen.kurzue());
+    assertThat(bezeichnungen(wiederGelesen)).isEqualTo(bezeichnungen(gelesen));
+    assertThat(wiederGelesen.gliederungen()).isEqualTo(gelesen.gliederungen());
+
+    for (var soll : gelesen.normen()) {
+      var ist = wiederGelesen.norm(soll.enbez()).orElseThrow();
+      assertThat(ist.titel()).as("Titel von %s", soll.enbez()).isEqualTo(soll.titel());
+      assertThat(ist.weggefallen())
+          .as("Wegfall von %s", soll.enbez())
+          .isEqualTo(soll.weggefallen());
+      assertThat(ist.absaetze()).as("Absätze von %s", soll.enbez()).isEqualTo(soll.absaetze());
+    }
+  }
+
+  private static List<String> bezeichnungen(Gesetz gesetz) {
+    return gesetz.normen().stream().map(n -> n.enbez()).toList();
+  }
+}