" + markup + "";
- try {
- DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
- factory.setNamespaceAware(true);
- return factory.newDocumentBuilder()
- .parse(new ByteArrayInputStream(namespaced.getBytes(StandardCharsets.UTF_8)))
- .getDocumentElement();
- } catch (SAXException | IOException | ParserConfigurationException e) {
- throw new ReqIFWriteException("XHTML attribute value is not well-formed: " + markup, e);
- }
- }
-
-
private Element definitionRef(Document xml, AttributeDefinition definition) {
Element definitionElement = element(xml, ReqIFConst.DEFINITION);
- Element ref = element(xml, ReqIFElements.attributeDefinitionRef(definition.getDataType().getType()));
+ String refName = ReqIFElements.attributeDefinitionRef(definition.getDataType().getType());
+ if (refName == null && definition.getSourceElementName() != null) {
+ refName = definition.getSourceElementName() + "-REF";
+ }
+ Element ref = element(xml, refName);
ref.setTextContent(nullToEmpty(definition.getID()));
definitionElement.appendChild(ref);
return definitionElement;
@@ -564,6 +586,54 @@ private Element objectRef(Document xml, String wrapper, String specObjectID) {
return element;
}
+ private Element relationGroup(Document xml, RelationGroup relationGroup) {
+
+ Element element = element(xml, ReqIFConst.RELATION_GROUP);
+ element.setAttribute(ReqIFConst.IDENTIFIER, nullToEmpty(relationGroup.getID()));
+ element.setAttribute(ReqIFConst.LONG_NAME, nullToEmpty(relationGroup.getName()));
+ appendAlternativeID(xml, element, relationGroup.getAlternativeID());
+
+ element.appendChild(wrappedRef(xml, ReqIFConst.TYPE, ReqIFConst.RELATION_GROUP_TYPE_REF,
+ relationGroup.getRelationGroupTypeRef()));
+ element.appendChild(wrappedRef(xml, ReqIFConst.SOURCE_SPECIFICATION, ReqIFConst.SPECIFICATION_REF,
+ relationGroup.getSourceSpecificationRef()));
+ element.appendChild(wrappedRef(xml, ReqIFConst.TARGET_SPECIFICATION, ReqIFConst.SPECIFICATION_REF,
+ relationGroup.getTargetSpecificationRef()));
+
+ if (!relationGroup.getSpecRelationRefs().isEmpty()) {
+ Element relations = element(xml, ReqIFConst.SPEC_RELATIONS);
+ for (String ref : relationGroup.getSpecRelationRefs()) {
+ Element relationRef = element(xml, ReqIFConst.SPEC_RELATION_REF);
+ relationRef.setTextContent(ref);
+ relations.appendChild(relationRef);
+ }
+ element.appendChild(relations);
+ }
+ return element;
+ }
+
+ private Element wrappedRef(Document xml, String wrapper, String refName, String id) {
+
+ Element element = element(xml, wrapper);
+ Element ref = element(xml, refName);
+ ref.setTextContent(nullToEmpty(id));
+ element.appendChild(ref);
+ return element;
+ }
+
+ /**
+ * ALTERNATIVE-ID is the first child of an identifiable element.
+ */
+ private void appendAlternativeID(Document xml, Element parent, String alternativeID) {
+
+ if (alternativeID == null || alternativeID.isEmpty()) {
+ return;
+ }
+ Element element = element(xml, ReqIFConst.ALTERNATIVE_ID);
+ element.setAttribute(ReqIFConst.IDENTIFIER, alternativeID);
+ parent.appendChild(element);
+ }
+
private Element element(Document xml, String name) {
return xml.createElementNS(REQIF_NAMESPACE, name);
}
@@ -584,10 +654,7 @@ private static String nullToEmpty(String value) {
private Document newDocument() {
try {
- DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
- factory.setNamespaceAware(true);
- DocumentBuilder builder = factory.newDocumentBuilder();
- return builder.newDocument();
+ return SecureXml.newDocumentBuilder().newDocument();
} catch (ParserConfigurationException e) {
throw new ReqIFWriteException("Failed to create an XML document", e);
}
@@ -595,7 +662,7 @@ private Document newDocument() {
private Transformer transformer() {
try {
- Transformer transformer = TransformerFactory.newInstance().newTransformer();
+ Transformer transformer = SecureXml.newTransformer();
transformer.setOutputProperty(OutputKeys.ENCODING, StandardCharsets.UTF_8.name());
transformer.setOutputProperty(OutputKeys.INDENT, this.indent ? "yes" : "no");
if (this.indent) {
diff --git a/src/main/java/de/uni_stuttgart/ils/reqif4j/write/ReqIFzWriter.java b/src/main/java/de/uni_stuttgart/ils/reqif4j/write/ReqIFzWriter.java
new file mode 100644
index 0000000..edbc8ac
--- /dev/null
+++ b/src/main/java/de/uni_stuttgart/ils/reqif4j/write/ReqIFzWriter.java
@@ -0,0 +1,163 @@
+package de.uni_stuttgart.ils.reqif4j.write;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+import de.uni_stuttgart.ils.reqif4j.reqif.ReqIFDocument;
+import de.uni_stuttgart.ils.reqif4j.reqif.ReqIFz;
+
+/**
+ * Writes a .reqifz archive: one or more ReqIF documents together with the
+ * images they reference.
+ *
+ * Image entries are stored under the path the XHTML {@code object} elements
+ * reference (forward slashes), so a written archive resolves its images the
+ * same way a tool-generated one does:
+ *
+ *
+ * Map<String, byte[]> pictures = Map.of("files/diagram.png", pngBytes);
+ * new ReqIFzWriter().write(document, "spec.reqif", pictures, Path.of("spec.reqifz"));
+ *
+ *
+ * An archive that was read can be re-packed without consuming its picture
+ * streams, because {@link ReqIFz} keeps the extracted files:
+ *
+ *
+ * try (ReqIFz source = new ReqIFz("in.reqifz")) {
+ * new ReqIFzWriter().write(source, Path.of("out.reqifz"));
+ * }
+ *
+ */
+public class ReqIFzWriter {
+
+ private final ReqIFWriter documentWriter;
+
+ public ReqIFzWriter() {
+ this(new ReqIFWriter());
+ }
+
+ /**
+ * @param documentWriter writer used for the contained ReqIF documents
+ */
+ public ReqIFzWriter(ReqIFWriter documentWriter) {
+ this.documentWriter = documentWriter;
+ }
+
+
+ /**
+ * Writes a single document without images.
+ */
+ public void write(ReqIFDocument document, String entryName, Path archive) throws IOException {
+ write(document, entryName, null, archive);
+ }
+
+ /**
+ * Writes a single document together with its images.
+ *
+ * @param entryName name of the ReqIF entry inside the archive,
+ * e.g. {@code spec.reqif}
+ * @param pictures image data keyed by the archive path referenced from the
+ * XHTML object elements, e.g. {@code files/diagram.png};
+ * may be null
+ */
+ public void write(ReqIFDocument document, String entryName, Map pictures, Path archive)
+ throws IOException {
+
+ Map documents = new LinkedHashMap();
+ documents.put(normalizeEntryName(entryName), document);
+ write(documents, pictures, archive);
+ }
+
+ /**
+ * Writes several documents and their images into one archive.
+ */
+ public void write(Map documents, Map pictures, Path archive)
+ throws IOException {
+
+ if (documents == null || documents.isEmpty()) {
+ throw new ReqIFWriteException("A .reqifz archive must contain at least one ReqIF document");
+ }
+
+ // Collect and check the names first: a zip cannot hold the same entry
+ // twice, and the raw ZipException would not say which name clashed.
+ Map entries = new LinkedHashMap();
+ for (Map.Entry document : documents.entrySet()) {
+ addEntry(entries, normalizeEntryName(document.getKey()), documentBytes(document.getValue()));
+ }
+ if (pictures != null) {
+ for (Map.Entry picture : pictures.entrySet()) {
+ addEntry(entries, normalizeEntryName(picture.getKey()), picture.getValue());
+ }
+ }
+
+ try (ZipOutputStream zip = new ZipOutputStream(Files.newOutputStream(archive))) {
+ for (Map.Entry entry : entries.entrySet()) {
+ writeEntry(zip, entry.getKey(), entry.getValue());
+ }
+ }
+ }
+
+ /**
+ * Re-packs an archive that was read: the documents are serialized from the
+ * object model (so modifications are included) while the images are copied
+ * from the extracted files.
+ */
+ public void write(ReqIFz source, Path archive) throws IOException {
+
+ Map pictures = new LinkedHashMap();
+ for (Map.Entry picture : source.getPictureFiles().entrySet()) {
+ pictures.put(picture.getKey(), Files.readAllBytes(picture.getValue().toPath()));
+ }
+ write(source.getReqIFDocuments(), pictures, archive);
+ }
+
+
+ private static void addEntry(Map entries, String name, byte[] content) {
+
+ if (entries.containsKey(name)) {
+ throw new ReqIFWriteException("Archive entry '" + name + "' is added twice; "
+ + "document and picture names must be unique within the archive");
+ }
+ entries.put(name, content);
+ }
+
+ private byte[] documentBytes(ReqIFDocument document) throws IOException {
+
+ ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+ this.documentWriter.write(document, (OutputStream) bytes);
+ return bytes.toByteArray();
+ }
+
+ private static void writeEntry(ZipOutputStream zip, String name, byte[] content) throws IOException {
+
+ zip.putNextEntry(new ZipEntry(name));
+ if (content != null) {
+ zip.write(content);
+ }
+ zip.closeEntry();
+ }
+
+ /**
+ * Zip entries always use forward slashes, independent of the platform the
+ * archive is written on.
+ */
+ private static String normalizeEntryName(String name) {
+
+ if (name == null || name.isBlank()) {
+ throw new ReqIFWriteException("Archive entry name must not be empty");
+ }
+ String normalized = name.replace('\\', '/');
+ if (normalized.startsWith("/") || normalized.contains("../")) {
+ throw new ReqIFWriteException("Archive entry name must be a relative path without '..': " + name);
+ }
+ return normalized;
+ }
+}
diff --git a/src/test/java/de/uni_stuttgart/ils/reqif4j/ModelCoverageTest.java b/src/test/java/de/uni_stuttgart/ils/reqif4j/ModelCoverageTest.java
new file mode 100644
index 0000000..48ff620
--- /dev/null
+++ b/src/test/java/de/uni_stuttgart/ils/reqif4j/ModelCoverageTest.java
@@ -0,0 +1,116 @@
+package de.uni_stuttgart.ils.reqif4j;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.nio.file.Path;
+import java.util.List;
+
+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.RelationGroup;
+import de.uni_stuttgart.ils.reqif4j.write.ReqIFWriter;
+
+/**
+ * ReqIF elements the parser used to ignore: ALTERNATIVE-ID on identifiable
+ * elements, relation groups and tool extensions. They must be readable and
+ * survive a round trip, otherwise writing a document silently drops content.
+ */
+class ModelCoverageTest {
+
+ private ReqIF original;
+ private ReqIF roundTripped;
+
+ @BeforeEach
+ void roundTrip(@TempDir Path tempDir) throws Exception {
+ this.original = new ReqIF(TestFixtures.writeDefaultFixture(tempDir).toString());
+
+ Path out = tempDir.resolve("written.reqif");
+ new ReqIFWriter().write(original.getReqIFDocument(), out);
+ this.roundTripped = new ReqIF(out.toString());
+ }
+
+
+ @Test
+ void alternativeIdsAreRead() {
+ assertEquals("alt-dt-string", original.getReqIFCoreContent().getDatatype("dt-string").getAlternativeID());
+ assertEquals("alt-st-req", original.getReqIFCoreContent().getSpecType("st-req").getAlternativeID());
+ assertEquals("alt-so-1", original.getReqIFCoreContent().getSpecObject("so-1").getAlternativeID());
+ assertEquals("alt-spec-1", original.getReqIFCoreContent().getSpecification("spec-1").getAlternativeID());
+ }
+
+ @Test
+ void elementsWithoutAlternativeIdReportNull() {
+ assertNull(original.getReqIFCoreContent().getSpecObject("so-2").getAlternativeID());
+ assertNull(original.getReqIFCoreContent().getDatatype("dt-bool").getAlternativeID());
+ }
+
+ @Test
+ void alternativeIdsSurviveTheRoundTrip() {
+ assertEquals("alt-dt-string", roundTripped.getReqIFCoreContent().getDatatype("dt-string").getAlternativeID());
+ assertEquals("alt-st-req", roundTripped.getReqIFCoreContent().getSpecType("st-req").getAlternativeID());
+ assertEquals("alt-so-1", roundTripped.getReqIFCoreContent().getSpecObject("so-1").getAlternativeID());
+ assertEquals("alt-spec-1", roundTripped.getReqIFCoreContent().getSpecification("spec-1").getAlternativeID());
+ assertEquals("alt-rg-1", roundTripped.getReqIFCoreContent().getRelationGroup("rg-1").getAlternativeID());
+ }
+
+ @Test
+ void relationGroupIsRead() {
+ RelationGroup group = original.getReqIFCoreContent().getRelationGroup("rg-1");
+
+ assertNotNull(group, "SPEC-RELATION-GROUPS were formerly ignored entirely");
+ assertEquals("System to Software", group.getName());
+ assertEquals("st-relgroup", group.getRelationGroupTypeRef());
+ assertEquals("spec-1", group.getSourceSpecificationRef());
+ assertEquals("spec-1", group.getTargetSpecificationRef());
+ assertEquals(List.of("sr-1"), group.getSpecRelationRefs());
+ }
+
+ @Test
+ void relationGroupSurvivesTheRoundTrip() {
+ RelationGroup group = roundTripped.getReqIFCoreContent().getRelationGroup("rg-1");
+
+ assertNotNull(group);
+ assertEquals("System to Software", group.getName());
+ assertEquals("st-relgroup", group.getRelationGroupTypeRef());
+ assertEquals(List.of("sr-1"), group.getSpecRelationRefs());
+ }
+
+ @Test
+ void relationGroupTypeKeepsItsKind() {
+ assertEquals(ReqIFConst.RELATION_GROUP_TYPE,
+ original.getReqIFCoreContent().getSpecType("st-relgroup").getType(),
+ "a RELATION-GROUP-TYPE must not be mistaken for a spec object type");
+ assertEquals(ReqIFConst.RELATION_GROUP_TYPE,
+ roundTripped.getReqIFCoreContent().getSpecType("st-relgroup").getType(),
+ "and it must be written back under the right element name");
+ }
+
+ @Test
+ void toolExtensionsAreKept() {
+ assertEquals(1, original.getReqIFDocument().getToolExtensions().size(),
+ "TOOL-EXTENSIONS must be captured");
+ }
+
+ @Test
+ void toolExtensionsSurviveTheRoundTrip() {
+ assertEquals(1, roundTripped.getReqIFDocument().getToolExtensions().size(),
+ "tool extensions must be written back verbatim");
+
+ String xml = new ReqIFWriter().toXml(original.getReqIFDocument());
+ assertTrue(xml.contains("REQ-IF-TOOL-EXTENSION"), "the extension element must appear in the output");
+ assertTrue(xml.contains("view=\"table\""), "the extension content must be copied unchanged: " + xml);
+ }
+
+ @Test
+ void writingStaysIdempotentWithTheNewElements() {
+ assertEquals(new ReqIFWriter().toXml(original.getReqIFDocument()),
+ new ReqIFWriter().toXml(roundTripped.getReqIFDocument()));
+ }
+}
diff --git a/src/test/java/de/uni_stuttgart/ils/reqif4j/PrefixedNamespaceTest.java b/src/test/java/de/uni_stuttgart/ils/reqif4j/PrefixedNamespaceTest.java
new file mode 100644
index 0000000..0635500
--- /dev/null
+++ b/src/test/java/de/uni_stuttgart/ils/reqif4j/PrefixedNamespaceTest.java
@@ -0,0 +1,152 @@
+package de.uni_stuttgart.ils.reqif4j;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.nio.file.Path;
+import java.util.List;
+
+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.attributes.AttributeValueEnumeration;
+import de.uni_stuttgart.ils.reqif4j.reqif.ReqIF;
+import de.uni_stuttgart.ils.reqif4j.reqif.ReqIFConst;
+import de.uni_stuttgart.ils.reqif4j.specification.SpecHierarchy;
+import de.uni_stuttgart.ils.reqif4j.specification.SpecObject;
+import de.uni_stuttgart.ils.reqif4j.specification.Specification;
+import de.uni_stuttgart.ils.reqif4j.write.ReqIFWriter;
+
+/**
+ * The ReqIF elements themselves may sit in a prefixed namespace
+ * ({@code }) instead of the default one. Such a document used to
+ * fail with "Document contains no CORE-CONTENT", because elements were looked
+ * up by their qualified name.
+ */
+class PrefixedNamespaceTest {
+
+ /** The shared fixture, with every ReqIF element moved to a "rif" prefix. */
+ private static String prefixedFixture() {
+
+ return TestFixtures.REQIF_FIXTURE
+ .replace("", "")
+ // prefix all remaining ReqIF elements (upper case names), but
+ // leave the xhtml ones and the xml declaration alone
+ .replaceAll("<(/?)(?!rif:|xhtml:|myTool:|\\?|!)([A-Z][A-Z0-9-]*)", "<$1rif:$2");
+ }
+
+ private ReqIF prefixed;
+
+ @BeforeEach
+ void parsePrefixedDocument(@TempDir Path tempDir) throws Exception {
+ prefixed = new ReqIF(TestFixtures.write(tempDir, "prefixed.reqif", prefixedFixture()).toString());
+ }
+
+
+ @Test
+ void headerIsRead() {
+ assertEquals("header-1", prefixed.getReqIFHeader().getID());
+ assertEquals("TestDoc", prefixed.getReqIFHeader().getTitle());
+ assertEquals("reqif4j", prefixed.getReqIFHeader().getToolID());
+ assertEquals("2026-07-23T10:00:00Z", prefixed.getReqIFHeader().getCreationTime());
+ assertEquals("Tester", prefixed.getReqIFHeader().getAuthor());
+ }
+
+ @Test
+ void datatypesAreRead() {
+ assertEquals(prefixedIdsOf(), List.copyOf(prefixed.getReqIFCoreContent().getDatatypes().keySet()));
+ assertEquals(ReqIFConst.ENUMERATION, prefixed.getReqIFCoreContent().getDatatype("dt-enum").getType());
+ assertEquals("alt-dt-string", prefixed.getReqIFCoreContent().getDatatype("dt-string").getAlternativeID());
+ }
+
+ private static List prefixedIdsOf() {
+ return List.of("dt-string", "dt-bool", "dt-int", "dt-int-unbounded", "dt-string-unbounded",
+ "dt-date", "dt-xhtml", "dt-custom", "dt-enum");
+ }
+
+ @Test
+ void specTypesAndTheirKindsAreRead() {
+ assertEquals(ReqIFConst.SPEC_OBJECT_TYPE, prefixed.getReqIFCoreContent().getSpecType("st-req").getType());
+ assertEquals(ReqIFConst.SPEC_RELATION_TYPE, prefixed.getReqIFCoreContent().getSpecType("st-rel").getType());
+ assertEquals(ReqIFConst.RELATION_GROUP_TYPE,
+ prefixed.getReqIFCoreContent().getSpecType("st-relgroup").getType());
+ assertEquals(ReqIFConst.SPECIFICATION_TYPE,
+ prefixed.getReqIFCoreContent().getSpecType("st-spec").getType());
+ }
+
+ @Test
+ void specObjectValuesAreRead() {
+ SpecObject so1 = prefixed.getReqIFCoreContent().getSpecObject("so-1");
+
+ assertEquals("First requirement", so1.getAttribute("Title"));
+ assertEquals(5, so1.getAttribute("Priority"));
+
+ AttributeValueEnumeration colors = (AttributeValueEnumeration) so1.getAttributes().get("Colors");
+ assertEquals(List.of("Red", "Green"), colors.getValues());
+ }
+
+ @Test
+ void xhtmlContentIsRead() {
+ String description = (String) prefixed.getReqIFCoreContent().getSpecObject("so-1").getAttribute("Description");
+
+ assertTrue(description.contains("span content"), description);
+ assertTrue(description.contains("files/image.png"), description);
+ }
+
+ @Test
+ void relationsAndGroupsAreRead() {
+ assertEquals("so-1", prefixed.getReqIFCoreContent().getSpecRelation("sr-1").getSourceObjID());
+ assertEquals("so-2", prefixed.getReqIFCoreContent().getSpecRelation("sr-1").getTargetObjID());
+
+ assertNotNull(prefixed.getReqIFCoreContent().getRelationGroup("rg-1"));
+ assertEquals(List.of("sr-1"),
+ prefixed.getReqIFCoreContent().getRelationGroup("rg-1").getSpecRelationRefs());
+ }
+
+ @Test
+ void specificationHierarchyIsRead() {
+ Specification spec = prefixed.getReqIFCoreContent().getSpecification("spec-1");
+
+ assertEquals("Main Spec", spec.getName());
+ List children = spec.getChildren();
+ assertEquals(1, children.size());
+ assertEquals("so-1", children.get(0).getSpecObjectID());
+ assertEquals("so-2", children.get(0).getChildren().get(0).getSpecObjectID());
+ }
+
+ @Test
+ void toolExtensionsAreRead() {
+ assertEquals(1, prefixed.getReqIFDocument().getToolExtensions().size());
+ }
+
+ @Test
+ void prefixedAndDefaultNamespaceYieldTheSameContent(@TempDir Path tempDir) throws Exception {
+ ReqIF plain = new ReqIF(TestFixtures.writeDefaultFixture(tempDir).toString());
+
+ // The writer always emits the ReqIF elements in the default namespace,
+ // so the whole core content must render identically. Tool extensions are
+ // excluded here: they are copied verbatim and therefore keep the prefix
+ // of the source document (see the test below).
+ assertEquals(coreContentOf(new ReqIFWriter().toXml(plain.getReqIFDocument())),
+ coreContentOf(new ReqIFWriter().toXml(prefixed.getReqIFDocument())),
+ "a prefixed document must produce the same content as the default-namespace one");
+ }
+
+ @Test
+ void toolExtensionsKeepThePrefixOfTheSourceDocument() {
+ String xml = new ReqIFWriter().toXml(prefixed.getReqIFDocument());
+
+ assertTrue(xml.contains("rif:TOOL-EXTENSIONS"),
+ "tool extensions are not interpreted, so they are copied unchanged: " + xml);
+ assertTrue(xml.contains("view=\"table\""), "their content must survive: " + xml);
+ }
+
+ /** @return everything up to and including the closing CORE-CONTENT tag */
+ private static String coreContentOf(String xml) {
+ return xml.substring(0, xml.indexOf("") + "".length());
+ }
+}
diff --git a/src/test/java/de/uni_stuttgart/ils/reqif4j/ReqIFValidatorTest.java b/src/test/java/de/uni_stuttgart/ils/reqif4j/ReqIFValidatorTest.java
new file mode 100644
index 0000000..5bf04e7
--- /dev/null
+++ b/src/test/java/de/uni_stuttgart/ils/reqif4j/ReqIFValidatorTest.java
@@ -0,0 +1,192 @@
+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.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.nio.file.Path;
+import java.util.List;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import de.uni_stuttgart.ils.reqif4j.attributes.AttributeValue;
+import de.uni_stuttgart.ils.reqif4j.build.ReqIFBuilder;
+import de.uni_stuttgart.ils.reqif4j.reqif.ReqIF;
+import de.uni_stuttgart.ils.reqif4j.reqif.ReqIFDocument;
+import de.uni_stuttgart.ils.reqif4j.specification.RelationGroup;
+import de.uni_stuttgart.ils.reqif4j.specification.SpecObject;
+import de.uni_stuttgart.ils.reqif4j.validate.ReqIFValidator;
+import de.uni_stuttgart.ils.reqif4j.validate.ValidationIssue;
+import de.uni_stuttgart.ils.reqif4j.validate.ValidationResult;
+
+/**
+ * The validator catches referential problems before a document is written.
+ * The OMG XSD is not bundled, so this is a model-level check; XSD validation
+ * is available separately against a schema the caller supplies.
+ */
+class ReqIFValidatorTest {
+
+ private static ValidationResult validate(ReqIFDocument document) {
+ return new ReqIFValidator().validate(document);
+ }
+
+ private static boolean hasError(ValidationResult result, String fragment) {
+ return result.getErrors().stream().anyMatch(issue -> issue.getMessage().contains(fragment));
+ }
+
+ /** A minimal, valid document built with the builder. */
+ private static ReqIFBuilder validBuilder() {
+ return ReqIFBuilder.create()
+ .header(h -> h.id("hdr-1").title("Spec").toolID("reqif4j"))
+ .stringDatatype("dt-string", "String", 255)
+ .enumerationDatatype("dt-enum", "Color", e -> e
+ .value("ev-red", "Red", "1")
+ .value("ev-blue", "Blue", "2"))
+ .specObjectType("st-req", "Requirement Type", t -> t
+ .stringAttribute("ad-title", "Title", "dt-string")
+ .enumerationAttribute("ad-color", "Colors", "dt-enum", false))
+ .specificationType("st-spec", "Spec Type", t -> { })
+ .specRelationType("st-rel", "satisfies", t -> { })
+ .specObject("so-1", "st-req", o -> o.set("ad-title", "First"))
+ .specObject("so-2", "st-req")
+ .specRelation("sr-1", "st-rel", "so-1", "so-2")
+ .specification("spec-1", "Main", "st-spec", s -> s.child("sh-1", "so-1"));
+ }
+
+
+ @Test
+ void parsedFixtureIsValid(@TempDir Path tempDir) throws Exception {
+ ReqIF reqif = new ReqIF(TestFixtures.writeDefaultFixture(tempDir).toString());
+
+ ValidationResult result = validate(reqif.getReqIFDocument());
+
+ assertTrue(result.isValid(), "the fixture must validate cleanly, got:\n" + result);
+ }
+
+ @Test
+ void generatedDocumentIsValid() {
+ assertTrue(validate(validBuilder().build()).isValid());
+ }
+
+ @Test
+ void missingSpecObjectOfARelationIsReported() {
+ ReqIFDocument document = validBuilder().build();
+ // remove the relation target after building
+ document.getCoreContent().getSpecObjects().remove("so-2");
+
+ ValidationResult result = validate(document);
+
+ assertFalse(result.isValid());
+ assertTrue(hasError(result, "Relation target so-2 is not a known spec object"), result.toString());
+ }
+
+ @Test
+ void unknownSpecHierarchyTargetIsReported() {
+ ReqIFDocument document = validBuilder().build();
+ document.getCoreContent().getSpecObjects().remove("so-1");
+
+ ValidationResult result = validate(document);
+
+ assertTrue(hasError(result, "not declared in SPEC-OBJECTS"), result.toString());
+ }
+
+ @Test
+ void attributeValueFromAForeignSpecTypeIsReported() {
+ ReqIFDocument document = validBuilder().build();
+
+ // move a value of so-1 onto a spec object of a different type
+ SpecObject so1 = document.getCoreContent().getSpecObject("so-1");
+ AttributeValue title = so1.getAttributes().get("Title");
+ document.getCoreContent().addSpecType(
+ new de.uni_stuttgart.ils.reqif4j.specification.SpecObjectType("st-other", "Other Type"));
+ document.getCoreContent().addSpecObject(new SpecObject("so-3",
+ document.getCoreContent().getSpecType("st-other"), List.of(title)));
+
+ ValidationResult result = validate(document);
+
+ assertTrue(hasError(result, "does not belong to spec type st-other"), result.toString());
+ }
+
+ @Test
+ void singleValuedEnumWithSeveralValuesIsReported() {
+ ReqIFDocument document = validBuilder()
+ .specObject("so-multi", "st-req", o -> o.setEnum("ad-color", "ev-red", "ev-blue"))
+ .build();
+
+ ValidationResult result = validate(document);
+
+ assertTrue(hasError(result, "is not MULTI-VALUED but has 2 values"), result.toString());
+ }
+
+ @Test
+ void identifierUsedTwiceAcrossCategoriesIsReported() {
+ ReqIFDocument document = validBuilder().build();
+ // reuse the datatype id for a relation group
+ document.getCoreContent().addRelationGroup(
+ new RelationGroup("dt-string", "Clash", "st-rel", "spec-1", "spec-1", List.of()));
+
+ ValidationResult result = validate(document);
+
+ assertTrue(hasError(result, "Identifier is used twice"), result.toString());
+ }
+
+ @Test
+ void relationGroupWithUnknownReferencesIsReported() {
+ ReqIFDocument document = validBuilder().build();
+ document.getCoreContent().addRelationGroup(
+ new RelationGroup("rg-1", "Group", "st-nope", "spec-nope", "spec-1", List.of("sr-nope")));
+
+ ValidationResult result = validate(document);
+
+ assertTrue(hasError(result, "references type st-nope"), result.toString());
+ assertTrue(hasError(result, "source specification spec-nope"), result.toString());
+ assertTrue(hasError(result, "references relation sr-nope"), result.toString());
+ }
+
+ @Test
+ void missingHeaderIsOnlyAWarning() {
+ ReqIFDocument document = new ReqIFDocument(null,
+ validBuilder().build().getCoreContent());
+
+ ValidationResult result = validate(document);
+
+ assertTrue(result.isValid(), "a missing header must not make the document invalid");
+ assertEquals(1, result.getIssues().size());
+ assertEquals(ValidationIssue.Severity.WARNING, result.getIssues().get(0).getSeverity());
+ }
+
+ @Test
+ void throwIfInvalidReportsEveryError() {
+ ReqIFDocument document = validBuilder().build();
+ document.getCoreContent().getSpecObjects().remove("so-2");
+
+ IllegalStateException failure = assertThrows(IllegalStateException.class,
+ () -> validate(document).throwIfInvalid());
+
+ assertTrue(failure.getMessage().contains("ReqIF document is invalid"));
+ assertTrue(failure.getMessage().contains("so-2"), failure.getMessage());
+ }
+
+ @Test
+ void schemaValidationRunsAgainstASuppliedXsd(@TempDir Path tempDir) throws Exception {
+ // a deliberately narrow schema: the root element must be REQ-IF
+ String xsd = """
+
+
+
+
+ """;
+ Path schema = TestFixtures.write(tempDir, "narrow.xsd", xsd);
+
+ ValidationResult result = new ReqIFValidator()
+ .validateAgainstSchema(validBuilder().build(), schema);
+
+ assertFalse(result.isValid(),
+ "a document whose root the schema does not declare must be reported");
+ }
+}
diff --git a/src/test/java/de/uni_stuttgart/ils/reqif4j/ReqIFzWriterTest.java b/src/test/java/de/uni_stuttgart/ils/reqif4j/ReqIFzWriterTest.java
new file mode 100644
index 0000000..6001070
--- /dev/null
+++ b/src/test/java/de/uni_stuttgart/ils/reqif4j/ReqIFzWriterTest.java
@@ -0,0 +1,171 @@
+package de.uni_stuttgart.ils.reqif4j;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.ByteArrayOutputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+import java.util.zip.ZipOutputStream;
+
+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.ReqIFz;
+import de.uni_stuttgart.ils.reqif4j.write.ReqIFWriteException;
+import de.uni_stuttgart.ils.reqif4j.write.ReqIFzWriter;
+
+/**
+ * Writing .reqifz archives: images travel with the document, and an archive
+ * that was read can be re-packed without consuming its picture streams.
+ */
+class ReqIFzWriterTest {
+
+ private static final byte[] PNG = {(byte) 0x89, 'P', 'N', 'G', 1, 2, 3};
+
+ private static List entriesOf(Path archive) throws IOException {
+ List names = new ArrayList<>();
+ try (ZipFile zip = new ZipFile(archive.toFile())) {
+ zip.stream().forEach(entry -> names.add(entry.getName()));
+ }
+ return names;
+ }
+
+ private static byte[] entryBytes(Path archive, String name) throws IOException {
+ try (ZipFile zip = new ZipFile(archive.toFile());
+ InputStream in = zip.getInputStream(new ZipEntry(name))) {
+ ByteArrayOutputStream bytes = new ByteArrayOutputStream();
+ in.transferTo(bytes);
+ return bytes.toByteArray();
+ }
+ }
+
+ /** A .reqifz built by hand, as a tool would produce it. */
+ private static Path createSourceArchive(Path dir) throws IOException {
+ Path archive = dir.resolve("source.reqifz");
+ try (ZipOutputStream zos = new ZipOutputStream(new FileOutputStream(archive.toFile()))) {
+ zos.putNextEntry(new ZipEntry("spec.reqif"));
+ zos.write(TestFixtures.REQIF_FIXTURE.getBytes(StandardCharsets.UTF_8));
+ zos.closeEntry();
+ zos.putNextEntry(new ZipEntry("files/image.png"));
+ zos.write(PNG);
+ zos.closeEntry();
+ }
+ return archive;
+ }
+
+
+ @Test
+ void archiveContainsDocumentAndPictures(@TempDir Path tempDir) throws Exception {
+ ReqIF reqif = new ReqIF(TestFixtures.writeDefaultFixture(tempDir).toString());
+ Path archive = tempDir.resolve("out.reqifz");
+
+ new ReqIFzWriter().write(reqif.getReqIFDocument(), "spec.reqif",
+ Map.of("files/image.png", PNG), archive);
+
+ assertTrue(entriesOf(archive).contains("spec.reqif"));
+ assertTrue(entriesOf(archive).contains("files/image.png"),
+ "images must be stored under the path the XHTML object references");
+ assertArrayEquals(PNG, entryBytes(archive, "files/image.png"));
+ }
+
+ @Test
+ void writtenArchiveIsReadableByTheParser(@TempDir Path tempDir) throws Exception {
+ ReqIF reqif = new ReqIF(TestFixtures.writeDefaultFixture(tempDir).toString());
+ Path archive = tempDir.resolve("readable.reqifz");
+ new ReqIFzWriter().write(reqif.getReqIFDocument(), "spec.reqif",
+ Map.of("files/image.png", PNG), archive);
+
+ try (ReqIFz read = new ReqIFz(archive.toString())) {
+ assertEquals(1, read.getReqIFDocumentsCount());
+ assertEquals("First requirement", read.getReqIFDocuments().get("spec.reqif")
+ .getCoreContent().getSpecObject("so-1").getAttribute("Title"));
+
+ InputStream picture = read.getPictureInputStream("spec.reqif", "files/image.png");
+ assertNotNull(picture, "the image must be resolvable by its object data URI");
+ }
+ }
+
+ @Test
+ void archiveCanBeRepackedWithoutConsumingTheStreams(@TempDir Path tempDir) throws Exception {
+ Path source = createSourceArchive(tempDir);
+ Path target = tempDir.resolve("repacked.reqifz");
+
+ try (ReqIFz read = new ReqIFz(source.toString())) {
+ new ReqIFzWriter().write(read, target);
+
+ // the source object stays usable afterwards
+ assertNotNull(read.getPictureInputStream("spec.reqif", "files/image.png"));
+ }
+
+ assertTrue(entriesOf(target).contains("spec.reqif"));
+ assertArrayEquals(PNG, entryBytes(target, "files/image.png"),
+ "pictures must be copied from the extracted files, not from consumed streams");
+
+ try (ReqIFz repacked = new ReqIFz(target.toString())) {
+ assertEquals("First requirement", repacked.getReqIFDocuments().get("spec.reqif")
+ .getCoreContent().getSpecObject("so-1").getAttribute("Title"));
+ }
+ }
+
+ @Test
+ void severalDocumentsCanShareOneArchive(@TempDir Path tempDir) throws Exception {
+ ReqIF reqif = new ReqIF(TestFixtures.writeDefaultFixture(tempDir).toString());
+
+ Map documents = new LinkedHashMap<>();
+ documents.put("a.reqif", reqif.getReqIFDocument());
+ documents.put("sub/b.reqif", reqif.getReqIFDocument());
+
+ Path archive = tempDir.resolve("multi.reqifz");
+ new ReqIFzWriter().write(documents, null, archive);
+
+ assertTrue(entriesOf(archive).containsAll(List.of("a.reqif", "sub/b.reqif")));
+
+ try (ReqIFz read = new ReqIFz(archive.toString())) {
+ assertEquals(2, read.getReqIFDocumentsCount());
+ }
+ }
+
+ @Test
+ void backslashesInEntryNamesAreNormalized(@TempDir Path tempDir) throws Exception {
+ ReqIF reqif = new ReqIF(TestFixtures.writeDefaultFixture(tempDir).toString());
+ Path archive = tempDir.resolve("slashes.reqifz");
+
+ new ReqIFzWriter().write(reqif.getReqIFDocument(), "spec.reqif",
+ Map.of("files\\image.png", PNG), archive);
+
+ assertTrue(entriesOf(archive).contains("files/image.png"),
+ "zip entries always use forward slashes: " + entriesOf(archive));
+ }
+
+ @Test
+ void invalidEntryNamesAreRejected(@TempDir Path tempDir) throws Exception {
+ ReqIF reqif = new ReqIF(TestFixtures.writeDefaultFixture(tempDir).toString());
+ Path archive = tempDir.resolve("bad.reqifz");
+
+ assertThrows(ReqIFWriteException.class, () -> new ReqIFzWriter()
+ .write(reqif.getReqIFDocument(), "../escape.reqif", archive),
+ "entry names must not escape the archive");
+ assertThrows(ReqIFWriteException.class, () -> new ReqIFzWriter()
+ .write(reqif.getReqIFDocument(), "", archive));
+ }
+
+ @Test
+ void emptyArchiveIsRejected(@TempDir Path tempDir) {
+ assertThrows(ReqIFWriteException.class, () -> new ReqIFzWriter()
+ .write(Map.of(), null, tempDir.resolve("empty.reqifz")));
+ }
+}
diff --git a/src/test/java/de/uni_stuttgart/ils/reqif4j/SelfReviewFixesTest.java b/src/test/java/de/uni_stuttgart/ils/reqif4j/SelfReviewFixesTest.java
new file mode 100644
index 0000000..cd37a10
--- /dev/null
+++ b/src/test/java/de/uni_stuttgart/ils/reqif4j/SelfReviewFixesTest.java
@@ -0,0 +1,205 @@
+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.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Map;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import de.uni_stuttgart.ils.reqif4j.build.ReqIFBuildException;
+import de.uni_stuttgart.ils.reqif4j.build.ReqIFBuilder;
+import de.uni_stuttgart.ils.reqif4j.reqif.ReqIF;
+import de.uni_stuttgart.ils.reqif4j.reqif.ReqIFDocument;
+import de.uni_stuttgart.ils.reqif4j.write.ReqIFWriteException;
+import de.uni_stuttgart.ils.reqif4j.write.ReqIFzWriter;
+
+/**
+ * Findings of the self review:
+ * 4 - the builder silently overwrote duplicate identifiers,
+ * 5 - markup starting with "div" (e.g. divider) was mangled by string surgery,
+ * 6 - the XML parsers of the write path were not hardened,
+ * 7 - a duplicate archive entry surfaced as a raw ZipException.
+ */
+class SelfReviewFixesTest {
+
+ private static ReqIFBuilder minimal() {
+ return ReqIFBuilder.create()
+ .header(h -> h.id("hdr").toolID("reqif4j"))
+ .stringDatatype("dt", "String", 255)
+ .xhtmlDatatype("dt-xhtml", "XHTML")
+ .specObjectType("st", "Type", t -> t
+ .stringAttribute("ad", "Title", "dt")
+ .xhtmlAttribute("ad-text", "Text", "dt-xhtml"))
+ .specificationType("st-spec", "Spec Type", t -> { });
+ }
+
+
+ // ---------------------------------------------------------- finding 4
+
+ @Test
+ void duplicateDatatypeIdIsRejected() {
+ ReqIFBuildException failure = assertThrows(ReqIFBuildException.class, () -> ReqIFBuilder.create()
+ .stringDatatype("dt", "A", 10)
+ .stringDatatype("dt", "B", 20));
+
+ assertTrue(failure.getMessage().contains("already used by a datatype"), failure.getMessage());
+ }
+
+ @Test
+ void duplicateSpecObjectIdIsRejected() {
+ assertThrows(ReqIFBuildException.class, () -> minimal()
+ .specObject("so", "st", o -> o.set("ad", "first"))
+ .specObject("so", "st", o -> o.set("ad", "second")));
+ }
+
+ @Test
+ void identifierClashAcrossCategoriesIsRejected() {
+ assertThrows(ReqIFBuildException.class, () -> minimal().specObject("dt", "st"),
+ "a spec object must not reuse a datatype identifier");
+ assertThrows(ReqIFBuildException.class, () -> minimal()
+ .specObject("so", "st")
+ .specification("so", "Main", "st-spec", s -> { }));
+ }
+
+ @Test
+ void duplicateAttributeDefinitionAndHierarchyIdsAreRejected() {
+ assertThrows(ReqIFBuildException.class, () -> ReqIFBuilder.create()
+ .stringDatatype("dt", "String", 10)
+ .specObjectType("st", "Type", t -> t
+ .stringAttribute("ad", "A", "dt")
+ .stringAttribute("ad", "B", "dt")));
+
+ assertThrows(ReqIFBuildException.class, () -> minimal()
+ .specObject("so-1", "st")
+ .specObject("so-2", "st")
+ .specification("spec", "Main", "st-spec", s -> s
+ .child("sh", "so-1")
+ .child("sh", "so-2")));
+ }
+
+ @Test
+ void duplicateEnumValueIsRejected() {
+ assertThrows(ReqIFBuildException.class, () -> ReqIFBuilder.create()
+ .enumerationDatatype("dt-enum", "Color", e -> e
+ .value("ev", "Red", "1")
+ .value("ev", "Blue", "2")));
+ }
+
+ @Test
+ void blankIdentifierIsRejected() {
+ assertThrows(ReqIFBuildException.class, () -> ReqIFBuilder.create().stringDatatype("", "A", 10));
+ }
+
+ @Test
+ void distinctIdentifiersStillWork() {
+ ReqIFDocument document = minimal()
+ .specObject("so-1", "st", o -> o.set("ad", "first"))
+ .specObject("so-2", "st", o -> o.set("ad", "second"))
+ .build();
+
+ assertEquals(2, document.getCoreContent().getSpecObjects().size());
+ }
+
+
+ // ---------------------------------------------------------- finding 5
+
+ @Test
+ void markupWhoseRootMerelyStartsWithDivIsNotMangled() {
+ ReqIFDocument document = minimal()
+ .specObject("so", "st", o -> o.setXhtml("ad-text", "x"))
+ .build();
+
+ String text = (String) document.getCoreContent().getSpecObject("so").getAttribute("Text");
+ assertEquals("", text,
+ "a divider element must be wrapped, not turned into a broken div");
+ }
+
+ @Test
+ void surroundingDivIsStillReused() {
+ ReqIFDocument document = minimal()
+ .specObject("so", "st", o -> o.setXhtml("ad-text", ""))
+ .build();
+
+ assertEquals("",
+ document.getCoreContent().getSpecObject("so").getAttribute("Text"),
+ "an existing div must not be wrapped a second time");
+ }
+
+ @Test
+ void severalTopLevelElementsAreWrapped() {
+ ReqIFDocument document = minimal()
+ .specObject("so", "st", o -> o.setXhtml("ad-text", "a
b
"))
+ .build();
+
+ assertEquals("",
+ document.getCoreContent().getSpecObject("so").getAttribute("Text"));
+ }
+
+ @Test
+ void malformedMarkupStillFails() {
+ assertThrows(IllegalArgumentException.class, () -> minimal()
+ .specObject("so", "st", o -> o.setXhtml("ad-text", "unclosed")));
+ }
+
+
+ // ---------------------------------------------------------- finding 6
+
+ @Test
+ void doctypeInAGeneratedXhtmlValueIsRejected(@TempDir Path tempDir) throws Exception {
+ Path secret = tempDir.resolve("secret.txt");
+ Files.writeString(secret, "TOP-SECRET-CONTENT");
+
+ String evil = "]>"
+ + "
";
+
+ assertThrows(IllegalArgumentException.class, () -> minimal()
+ .specObject("so", "st", o -> o.setXhtml("ad-text", evil)),
+ "the XHTML parser must reject DOCTYPEs instead of resolving entities");
+ }
+
+ @Test
+ void xxeIsNotResolvedInAParsedDocument(@TempDir Path tempDir) throws Exception {
+ Path secret = tempDir.resolve("secret.txt");
+ Files.writeString(secret, "TOP-SECRET-CONTENT");
+
+ String xxe = "\n"
+ + "]>\n"
+ + "&xxe;";
+ Path file = TestFixtures.write(tempDir, "xxe.reqif", xxe);
+
+ assertThrows(RuntimeException.class, () -> new ReqIF(file.toString()));
+ }
+
+
+ // ---------------------------------------------------------- finding 7
+
+ @Test
+ void duplicateArchiveEntryGivesAClearError(@TempDir Path tempDir) throws Exception {
+ ReqIF reqif = new ReqIF(TestFixtures.writeDefaultFixture(tempDir).toString());
+
+ ReqIFWriteException failure = assertThrows(ReqIFWriteException.class, () -> new ReqIFzWriter()
+ .write(reqif.getReqIFDocument(), "spec.reqif",
+ Map.of("spec.reqif", new byte[] {1}), tempDir.resolve("dup.reqifz")));
+
+ assertTrue(failure.getMessage().contains("spec.reqif"), failure.getMessage());
+ assertTrue(failure.getMessage().contains("added twice"), failure.getMessage());
+ }
+
+ @Test
+ void noArchiveIsLeftBehindOnADuplicateEntry(@TempDir Path tempDir) throws Exception {
+ ReqIF reqif = new ReqIF(TestFixtures.writeDefaultFixture(tempDir).toString());
+ Path archive = tempDir.resolve("dup.reqifz");
+
+ assertThrows(ReqIFWriteException.class, () -> new ReqIFzWriter()
+ .write(reqif.getReqIFDocument(), "spec.reqif", Map.of("spec.reqif", new byte[] {1}), archive));
+
+ assertFalse(Files.exists(archive),
+ "the name clash must be detected before the archive file is created");
+ }
+}
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 e7b6cb4..869bf2e 100644
--- a/src/test/java/de/uni_stuttgart/ils/reqif4j/TestFixtures.java
+++ b/src/test/java/de/uni_stuttgart/ils/reqif4j/TestFixtures.java
@@ -31,7 +31,9 @@ private TestFixtures() {
-
+
+
+
@@ -61,6 +63,7 @@ private TestFixtures() {
+
dt-string
@@ -89,6 +92,9 @@ private TestFixtures() {
+
+
+
@@ -99,6 +105,7 @@ private TestFixtures() {
+
st-req
@@ -143,8 +150,18 @@ private TestFixtures() {
so-2
+
+
+
+ st-relgroup
+ spec-1
+ spec-1
+ sr-1
+
+
+
st-spec
@@ -165,6 +182,11 @@ private TestFixtures() {
+
+
+
+
+