The system shall boot.
")) + .specObject("so-2", "st-req") + .specRelation("sr-1", "st-rel", "so-1", "so-2") + .specification("spec-1", "Main Spec", "st-spec", s -> s + .child("sh-1", "so-1", c -> c.child("sh-2", "so-2"))) + .build(); + +new ReqIFWriter().write(document, Path.of("out.reqif")); +``` + +XHTML values may be passed with or without a surrounding `div`; the +markup is parsed, so the node tree and the token list work on generated +values too. The content category of generated spec objects is derived by +the same `TypeClassifier` used when reading (`typeClassifier(...)` to +override). + +Not covered yet: writing .reqifz archives and ReqIF elements the parser +does not model (alternative ids, relation groups, tool extensions). diff --git a/src/main/java/de/uni_stuttgart/ils/reqif4j/attributes/AttributeDefinition.java b/src/main/java/de/uni_stuttgart/ils/reqif4j/attributes/AttributeDefinition.java index 433f586..32c10c3 100644 --- a/src/main/java/de/uni_stuttgart/ils/reqif4j/attributes/AttributeDefinition.java +++ b/src/main/java/de/uni_stuttgart/ils/reqif4j/attributes/AttributeDefinition.java @@ -40,6 +40,18 @@ public String getDefaultValue() { + /** + * Creates an attribute definition from plain values, for documents that are + * generated instead of parsed. + */ + public AttributeDefinition(String id, String name, Datatype type, String defaultValue) { + + this.id = id; + this.name = name; + this.type = type; + this.defaultValue = defaultValue; + } + public AttributeDefinition(Node attributeDefinition, Map
+ * element type content tokens
+ * ------------ ----------------------------------------------------------
+ * "P" / "H" "TXT" text | "VAR" name [guid] | "BR" | "OBJ" path
+ * "TBL" "TR" ( ("TH"|"TC") text ("OBJ" path)* )*
+ * "L" "LE" ( inline | "L" ... "/L" | "TBL" ... )*
+ * "OBJ" path
+ *
+ *
+ * Header cells are reported as {@code "TH"}, data cells as {@code "TC"}; the
+ * cell text contains the complete cell content, and images inside a cell are
+ * appended as {@code "OBJ"} pairs. Nested lists are wrapped in balanced
+ * {@code "L"} / {@code "/L"} markers. Ordered lists ({@code ol}) are treated
+ * like unordered ones.
+ */
public class AttributeValueXHTML extends AttributeValue {
+ // element type tokens
+ private static final String T_PARAGRAPH = "P";
+ private static final String T_TABLE = "TBL";
+ private static final String T_LIST = "L";
+ private static final String T_HEADING = "H";
+ private static final String T_OBJECT = "OBJ";
+
+ // content tokens
+ private static final String T_TEXT = "TXT";
+ private static final String T_VAR = "VAR";
+ private static final String T_BREAK = "BR";
+ private static final String T_ROW = "TR";
+ private static final String T_HEADER_CELL = "TH";
+ private static final String T_CELL = "TC";
+ private static final String T_LIST_ENTRY = "LE";
+ private static final String T_LIST_END = "/L";
+
+ private static final String VARIABLE_NAME_MISSING = "VARIABLE_NAME_MISSING";
+ private static final String XHTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+
XHTMLElementDiv divValue;
@Override
@@ -29,15 +82,40 @@ public AttributeValueXHTML(Node xhtmlContent, AttributeDefinition type) {
// so it has to be located by local name.
Node div = XmlUtils.firstDescendantByLocalName(xhtmlContent, XHTML.DIV);
this.divValue = div == null ? null : new XHTMLElementDiv(div);
- this.value = deconstructXHTML(xhtmlContent);
+ this.value = deconstructXHTML(this.divValue);
}
-
+
+ /**
+ * Creates an XHTML value from markup, for documents that are generated
+ * instead of parsed. The markup is parsed so the node tree and the token
+ * list are available just like for a parsed value; it may be given with or
+ * without a surrounding div.
+ */
public AttributeValueXHTML(String value, AttributeDefinition type) {
super(value, type);
-
-
+
+ Node div = value == null || value.isBlank() ? null : parseDiv(value);
+ this.divValue = div == null ? null : new XHTMLElementDiv(div);
+ this.value = deconstructXHTML(this.divValue);
}
-
+
+ private static Node parseDiv(String markup) {
+
+ String trimmed = markup.trim();
+ String document = trimmed.startsWith("
+ * ReqIFDocument document = ReqIFBuilder.create()
+ * .header(h -> h.id("hdr-1").title("My Spec").toolID("reqif4j"))
+ * .stringDatatype("dt-string", "String", 4096)
+ * .xhtmlDatatype("dt-xhtml", "XHTML")
+ * .specObjectType("st-req", "Requirement Type", t -> t
+ * .stringAttribute("ad-title", "ReqIF.Name", "dt-string")
+ * .xhtmlAttribute("ad-text", "ReqIF.Text", "dt-xhtml"))
+ * .specificationType("st-spec", "Specification Type", t -> {})
+ * .specObject("so-1", "st-req", o -> o
+ * .set("ad-title", "First requirement")
+ * .setXhtml("ad-text", "<p>The system shall boot.</p>"))
+ * .specification("spec-1", "Main Spec", "st-spec", s -> s
+ * .child("sh-1", "so-1"))
+ * .build();
+ *
+ * new ReqIFWriter().write(document, Path.of("out.reqif"));
+ *
+ *
+ * Identifiers are validated while building: referencing an unknown datatype,
+ * spec type or spec object fails immediately with a
+ * {@link ReqIFBuildException} instead of producing a broken document.
+ */
+public class ReqIFBuilder {
+
+ private final Map
+ * ReqIF reqif = new ReqIF("in.reqif");
+ * new ReqIFWriter().write(reqif.getReqIFDocument(), Path.of("out.reqif"));
+ *
+ *
+ * Attribute values are emitted sorted by their definition id so the output is
+ * reproducible. XHTML values keep their original nodes when the document was
+ * read from a file, otherwise the rendered markup is parsed back in.
+ */
+public class ReqIFWriter {
+
+ public static final String REQIF_NAMESPACE = "http://www.omg.org/spec/ReqIF/20110401/reqif.xsd";
+ public static final String XHTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+
+ private static final String XHTML_PREFIX = "xhtml";
+
+ private boolean indent = false;
+
+ /**
+ * Enables pretty-printing.
+ *
+ * Off by default on purpose: the indenter inserts whitespace into mixed
+ * content, which changes XHTML attribute values (a paragraph would gain
+ * leading and trailing blanks). Only switch it on when readability of the
+ * output matters more than exact XHTML content.
+ */
+ public ReqIFWriter setIndent(boolean indent) {
+ this.indent = indent;
+ return this;
+ }
+
+
+ /**
+ * Writes the document to the given file.
+ */
+ public void write(ReqIFDocument document, Path file) throws IOException {
+ try (OutputStream out = Files.newOutputStream(file)) {
+ write(document, out);
+ }
+ }
+
+ /**
+ * Writes the document to the given stream. The stream is not closed.
+ */
+ public void write(ReqIFDocument document, OutputStream out) throws IOException {
+ try {
+ transformer().transform(new DOMSource(buildDocument(document)), new StreamResult(out));
+ } catch (TransformerException e) {
+ throw new IOException("Failed to write ReqIF document", e);
+ }
+ }
+
+ /**
+ * @return the document serialized as an XML string
+ */
+ public String toXml(ReqIFDocument document) {
+ try {
+ StringWriter writer = new StringWriter();
+ transformer().transform(new DOMSource(buildDocument(document)), new StreamResult(writer));
+ return writer.toString();
+ } catch (TransformerException e) {
+ throw new ReqIFWriteException("Failed to serialize ReqIF document", e);
+ }
+ }
+
+
+ /**
+ * Builds the output DOM from the object model.
+ */
+ public Document buildDocument(ReqIFDocument document) {
+
+ if (document == null) {
+ throw new ReqIFWriteException("Cannot write a null ReqIF document");
+ }
+
+ Document xml = newDocument();
+ Element root = xml.createElementNS(REQIF_NAMESPACE, "REQ-IF");
+ root.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:" + XHTML_PREFIX, XHTML_NAMESPACE);
+ xml.appendChild(root);
+
+ if (document.getHeader() != null) {
+ root.appendChild(header(xml, document.getHeader()));
+ }
+ root.appendChild(coreContent(xml, document.getCoreContent()));
+
+ return xml;
+ }
+
+
+ private Element header(Document xml, ReqIFHeader header) {
+
+ Element theHeader = element(xml, ReqIFConst.THE_HEADER);
+ Element reqifHeader = element(xml, ReqIFConst.REQ_IF_HEADER);
+ reqifHeader.setAttribute(ReqIFConst.IDENTIFIER, nullToEmpty(header.getID()));
+ theHeader.appendChild(reqifHeader);
+
+ appendTextIfPresent(xml, reqifHeader, ReqIFConst.COMMENT, header.getComment());
+ appendTextIfPresent(xml, reqifHeader, ReqIFConst.CREATION_TIME, header.getCreationTime());
+ appendTextIfPresent(xml, reqifHeader, ReqIFConst.REQ_IF_TOOL_ID, header.getToolID());
+ appendTextIfPresent(xml, reqifHeader, ReqIFConst.REQ_IF_VERSION, header.getReqIFVersion());
+ appendTextIfPresent(xml, reqifHeader, ReqIFConst.SOURCE_TOOL_ID, header.getSourceToolID());
+ appendTextIfPresent(xml, reqifHeader, ReqIFConst.TITLE, header.getTitle());
+
+ return theHeader;
+ }
+
+ private Element coreContent(Document xml, ReqIFCoreContent content) {
+
+ Element coreContent = element(xml, ReqIFConst.CORE_CONTENT);
+ Element reqifContent = element(xml, "REQ-IF-CONTENT");
+ coreContent.appendChild(reqifContent);
+
+ if (content == null) {
+ return coreContent;
+ }
+
+ Element datatypes = element(xml, ReqIFConst.DATATYPES);
+ for (Datatype datatype : content.getDatatypes().values()) {
+ Element written = datatype(xml, datatype);
+ if (written != null) {
+ datatypes.appendChild(written);
+ }
+ }
+ reqifContent.appendChild(datatypes);
+
+ Element specTypes = element(xml, ReqIFConst.SPEC_TYPES);
+ for (SpecType specType : content.getSpecTypes().values()) {
+ Element written = specType(xml, specType);
+ if (written != null) {
+ specTypes.appendChild(written);
+ }
+ }
+ reqifContent.appendChild(specTypes);
+
+ Element specObjects = element(xml, ReqIFConst.SPEC_OBJECTS);
+ for (SpecObject specObject : content.getSpecObjects().values()) {
+ specObjects.appendChild(specObject(xml, specObject));
+ }
+ reqifContent.appendChild(specObjects);
+
+ Element specRelations = element(xml, ReqIFConst.SPEC_RELATIONS);
+ for (SpecRelation specRelation : content.getSpecRelation().values()) {
+ specRelations.appendChild(specRelation(xml, specRelation));
+ }
+ reqifContent.appendChild(specRelations);
+
+ Element specifications = element(xml, ReqIFConst.SPECIFICATIONS);
+ for (Specification specification : content.getSpecifications().values()) {
+ specifications.appendChild(specification(xml, specification));
+ }
+ reqifContent.appendChild(specifications);
+
+ return coreContent;
+ }
+
+
+ private Element datatype(Document xml, Datatype datatype) {
+
+ String elementName = ReqIFElements.datatypeDefinition(datatype.getType());
+ if (elementName == null) {
+ // datatype kinds the parser does not model are written back under
+ // their original element name
+ elementName = datatype.getSourceElementName();
+ }
+ if (elementName == null) {
+ return null;
+ }
+
+ Element definition = element(xml, elementName);
+ definition.setAttribute(ReqIFConst.IDENTIFIER, nullToEmpty(datatype.getID()));
+ definition.setAttribute(ReqIFConst.LONG_NAME, nullToEmpty(datatype.getName()));
+
+ if (datatype instanceof DatatypeInteger) {
+ DatatypeInteger integer = (DatatypeInteger) datatype;
+ definition.setAttribute(ReqIFConst.MIN, Long.toString(integer.getMin()));
+ definition.setAttribute(ReqIFConst.MAX, Long.toString(integer.getMax()));
+
+ } else if (datatype instanceof DatatypeString) {
+ definition.setAttribute(ReqIFConst.MAX_LENGTH,
+ Integer.toString(((DatatypeString) datatype).getMaxLength()));
+
+ } else if (datatype instanceof DatatypeEnumeration) {
+ Element specifiedValues = element(xml, ReqIFConst.SPECIFIED_VALUES);
+ for (DatatypeEnumerationValue value : ((DatatypeEnumeration) datatype).getEnumValues().values()) {
+ specifiedValues.appendChild(enumValue(xml, value));
+ }
+ definition.appendChild(specifiedValues);
+ }
+
+ return definition;
+ }
+
+ private Element enumValue(Document xml, DatatypeEnumerationValue value) {
+
+ Element enumValue = element(xml, ReqIFConst.ENUM_VALUE);
+ enumValue.setAttribute(ReqIFConst.IDENTIFIER, nullToEmpty(value.getID()));
+ enumValue.setAttribute(ReqIFConst.LONG_NAME, nullToEmpty(value.getName()));
+
+ Element embedded = element(xml, ReqIFConst.EMBEDDED_VALUE);
+ embedded.setAttribute(ReqIFConst.KEY, nullToEmpty(value.getKey()));
+ if (value.getOtherContent() != null && !value.getOtherContent().isEmpty()) {
+ embedded.setAttribute(ReqIFConst.OTHER_CONTENT, value.getOtherContent());
+ }
+
+ Element properties = element(xml, ReqIFConst.PROPERTIES);
+ properties.appendChild(embedded);
+ enumValue.appendChild(properties);
+
+ return enumValue;
+ }
+
+
+ private Element specType(Document xml, SpecType specType) {
+
+ String elementName = specType.getType();
+ if (elementName == null || ReqIFConst.UNDEFINED.equals(elementName)) {
+ elementName = ReqIFConst.SPEC_OBJECT_TYPE;
+ }
+
+ Element type = element(xml, elementName);
+ type.setAttribute(ReqIFConst.IDENTIFIER, nullToEmpty(specType.getID()));
+ type.setAttribute(ReqIFConst.LONG_NAME, nullToEmpty(specType.getName()));
+
+ Element specAttributes = element(xml, ReqIFConst.SPEC_ATTRIBUTES);
+ for (AttributeDefinition definition : specType.getAttributeDefinitions().values()) {
+ Element written = attributeDefinition(xml, definition);
+ if (written != null) {
+ specAttributes.appendChild(written);
+ }
+ }
+ type.appendChild(specAttributes);
+
+ return type;
+ }
+
+ private Element attributeDefinition(Document xml, AttributeDefinition definition) {
+
+ Datatype datatype = definition.getDataType();
+ if (datatype == null) {
+ return null;
+ }
+ String elementName = ReqIFElements.attributeDefinition(datatype.getType());
+ if (elementName == null) {
+ return null;
+ }
+
+ Element attributeDefinition = element(xml, elementName);
+ attributeDefinition.setAttribute(ReqIFConst.IDENTIFIER, nullToEmpty(definition.getID()));
+ attributeDefinition.setAttribute(ReqIFConst.LONG_NAME, nullToEmpty(definition.getName()));
+
+ if (definition instanceof AttributeDefinitionEnumeration
+ && ((AttributeDefinitionEnumeration) definition).isMultiValued()) {
+ attributeDefinition.setAttribute(ReqIFConst.MULTI_VALUED, "true");
+ }
+
+ Element type = element(xml, ReqIFConst.TYPE);
+ Element datatypeRef = element(xml, ReqIFElements.datatypeDefinitionRef(
+ ReqIFElements.datatypeDefinition(datatype.getType())));
+ datatypeRef.setTextContent(nullToEmpty(datatype.getID()));
+ type.appendChild(datatypeRef);
+ attributeDefinition.appendChild(type);
+
+ Element defaultValue = defaultValue(xml, definition, datatype);
+ if (defaultValue != null) {
+ attributeDefinition.appendChild(defaultValue);
+ }
+
+ return attributeDefinition;
+ }
+
+ private Element defaultValue(Document xml, AttributeDefinition definition, Datatype datatype) {
+
+ if (definition instanceof AttributeDefinitionEnumeration) {
+ ListThe system shall boot within 5 seconds.
")) + .specObject("so-2", "st-req", o -> o + .set("ad-title", "Second requirement")) + .specRelation("sr-1", "st-rel", "so-1", "so-2", r -> r + .set("ad-comment", "derived during review")) + .specification("spec-1", "Main Spec", "st-spec", s -> s + .set("ad-owner", "Tester") + .child("sh-1", "so-1", c -> c + .child("sh-2", "so-2"))) + .build(); + } + + @BeforeEach + void buildWriteAndRead(@TempDir Path tempDir) throws Exception { + this.tempDir = tempDir; + Path file = tempDir.resolve("generated.reqif"); + new ReqIFWriter().write(buildDocument(), file); + this.written = new ReqIF(file.toString()); + } + + + @Test + void generatedDocumentIsReadableAgain() { + assertNotNull(written.getReqIFHeader()); + assertNotNull(written.getReqIFCoreContent()); + } + + @Test + void headerIsWrittenFromTheBuilder() { + assertEquals("hdr-1", written.getReqIFHeader().getID()); + assertEquals("Generated Spec", written.getReqIFHeader().getTitle()); + assertEquals("reqif4j", written.getReqIFHeader().getToolID()); + assertEquals("unit test", written.getReqIFHeader().getSourceToolID()); + assertEquals("2026-07-23T10:00:00Z", written.getReqIFHeader().getCreationTime()); + assertEquals("23.07.2026", written.getReqIFHeader().getCreationDate(), + "the formatted date is derived like when parsing"); + assertEquals("reqif4j", written.getReqIFHeader().getAuthor(), + "the author is derived from the comment like when parsing"); + } + + @Test + void datatypesAreWritten() { + assertEquals(List.of("dt-string", "dt-int", "dt-bool", "dt-date", "dt-real", "dt-xhtml", "dt-enum"), + List.copyOf(written.getReqIFCoreContent().getDatatypes().keySet())); + + DatatypeEnumeration colors = (DatatypeEnumeration) written.getReqIFCoreContent().getDatatype("dt-enum"); + assertEquals("Red", colors.getEnumValueName("ev-red")); + assertEquals("#ff0000", colors.getEnumValueOtherContent("ev-red")); + } + + @Test + void scalarValuesOfEveryKindSurvive() { + SpecObject so1 = written.getReqIFCoreContent().getSpecObject("so-1"); + + assertEquals("First requirement", so1.getAttribute("ReqIF.Name")); + assertEquals(5, so1.getAttribute("Priority")); + assertEquals(true, so1.getAttribute("Done")); + assertEquals("2026-12-31", so1.getAttribute("Due")); + assertEquals(2.5, so1.getAttribute("Effort")); + } + + @Test + void multiselectEnumValuesSurvive() { + SpecObject so1 = written.getReqIFCoreContent().getSpecObject("so-1"); + AttributeValueEnumeration colors = (AttributeValueEnumeration) so1.getAttributes().get("Colors"); + + assertEquals(List.of("ev-red", "ev-green"), colors.getValueRefs()); + assertEquals(List.of("Red", "Green"), colors.getValues()); + } + + @Test + void enumDefaultIsAppliedToObjectsWithoutAValue() { + SpecObject so2 = written.getReqIFCoreContent().getSpecObject("so-2"); + AttributeValueEnumeration colors = (AttributeValueEnumeration) so2.getAttributes().get("Colors"); + + assertEquals(List.of("Blue"), colors.getValues(), + "the enum DEFAULT-VALUE declared in the builder must be written"); + } + + @Test + void xhtmlValueGivenAsMarkupIsWritten() { + String text = (String) written.getReqIFCoreContent().getSpecObject("so-1").getAttribute("ReqIF.Text"); + + assertEquals("The system shall boot within 5 seconds.
Text with"),
+ "indenting injects whitespace into mixed content - this is why it is opt-in: " + withIndent);
+ }
+
+ @Test
+ void writingIsStableAcrossRepeatedRoundTrips() throws Exception {
+ String once = new ReqIFWriter().toXml(original.getReqIFDocument());
+ String twice = new ReqIFWriter().toXml(roundTripped.getReqIFDocument());
+
+ assertEquals(once, twice, "writing an already round-tripped document must be idempotent");
+ }
+}
diff --git a/src/test/java/de/uni_stuttgart/ils/reqif4j/SpecRelationTest.java b/src/test/java/de/uni_stuttgart/ils/reqif4j/SpecRelationTest.java
new file mode 100644
index 0000000..de3c785
--- /dev/null
+++ b/src/test/java/de/uni_stuttgart/ils/reqif4j/SpecRelationTest.java
@@ -0,0 +1,72 @@
+package de.uni_stuttgart.ils.reqif4j;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+
+import java.nio.file.Path;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import de.uni_stuttgart.ils.reqif4j.reqif.ReqIF;
+import de.uni_stuttgart.ils.reqif4j.reqif.ReqIFConst;
+import de.uni_stuttgart.ils.reqif4j.specification.SpecRelation;
+
+/**
+ * Bug: SpecRelation overwrote the inherited {@code type} field — which carries
+ * a content category (REQ/HEADLINE/TEXT) — with the raw
+ * SPEC-RELATION-TYPE-REF id, so the inherited category methods returned
+ * nonsense. The relation's own attribute values were not parsed at all.
+ */
+class SpecRelationTest {
+
+ private SpecRelation relation;
+
+ @BeforeEach
+ void parseFixture(@TempDir Path tempDir) throws Exception {
+ ReqIF reqif = new ReqIF(TestFixtures.writeDefaultFixture(tempDir).toString());
+ relation = reqif.getReqIFCoreContent().getSpecRelation("sr-1");
+ assertNotNull(relation, "the fixture's spec relation must be parsed");
+ }
+
+ @Test
+ void sourceAndTargetAreParsed() {
+ // regression guard for the original DOORS relationship reader
+ assertEquals("so-1", relation.getSourceObjID());
+ assertEquals("so-2", relation.getTargetObjID());
+ }
+
+ @Test
+ void inheritedTypeIsUndefinedInsteadOfTheRelationTypeRef() {
+ assertEquals(ReqIFConst.UNDEFINED, relation.getType(),
+ "a relation has no content category; the type ref must not leak into type");
+ }
+
+ @Test
+ void relationTypeIsExposedSeparately() {
+ assertEquals("st-rel", relation.getRelationTypeRef());
+ assertEquals("satisfies", relation.getRelationTypeName());
+ }
+
+ @Test
+ void structuralKindIsStillAvailable() {
+ assertEquals(ReqIFConst.SPEC_RELATION_TYPE, relation.getSpecType(),
+ "the information 'this is a relation' lives in getSpecType()");
+ }
+
+ @Test
+ void contentCategoryMethodsAreAllFalse() {
+ assertFalse(relation.isReq());
+ assertFalse(relation.isSubReq());
+ assertFalse(relation.isHeadline());
+ assertFalse(relation.isText(), "a relation is not text (formerly reported true)");
+ }
+
+ @Test
+ void relationAttributeValuesAreParsed() {
+ assertEquals("derived during review", relation.getAttribute("LinkComment"),
+ "attribute values of a relation were formerly ignored");
+ }
+}
diff --git a/src/test/java/de/uni_stuttgart/ils/reqif4j/TestFixtures.java b/src/test/java/de/uni_stuttgart/ils/reqif4j/TestFixtures.java
index 0287d2e..e7b6cb4 100644
--- a/src/test/java/de/uni_stuttgart/ils/reqif4j/TestFixtures.java
+++ b/src/test/java/de/uni_stuttgart/ils/reqif4j/TestFixtures.java
@@ -82,6 +82,13 @@ private TestFixtures() {
+
}, elements without a
+ * dedicated class lost their entire content, and trimming ran words together
+ * across inline elements.
+ */
+class XHTMLRenderingTest {
+
+ private static final String RENDER_FIXTURE = """
+
+
"), "br must be self-closing, got: " + rendered);
+ assertFalse(rendered.contains(""),
+ "
is read as two line breaks by HTML5 parsers: " + rendered);
+ }
+
+ @Test
+ void elementsWithoutDedicatedClassKeepTheirContent() {
+ assertTrue(rendered.contains(">diesen Link"),
+ "link text must not be dropped, got: " + rendered);
+ assertTrue(rendered.contains("Betonung"),
+ "emphasized text must not be dropped, got: " + rendered);
+ }
+
+ @Test
+ void inlineSpacingIsPreserved() {
+ assertTrue(rendered.contains("Siehe