[Improve] Code Coverage

Author: samatstariongroup

ReqIFSharp.Tests/AttributeValueTests/AttributeValueXHTMLTestFixture.cs

@@ -150,5 +150,20 @@ public void Verify_that_raw_text_can_be_extracted_from_xtml_value()
 
             Assert.That(unformattedText, Is.EqualTo("Description of the SpecObject that includes formatted tables and/or style: Element 1 Element 2"));
         }
+
+        [Test]
+        public void AttributeValueXhtml_ExtractsPlainTextAndDetectsExternalObjects()
+        {
+            var attributeValue = new AttributeValueXHTML();
+            attributeValue.TheValue = "<div>plain <b>text</b><object data=\"file%20name.bin\" type=\"application/octet-stream\"></object></div>";
+
+            var plain = attributeValue.ExtractUnformattedTextFromValue();
+
+            Assert.That(plain, Is.EqualTo("plain text"));
+
+            var objects = attributeValue.ExternalObjects;
+            Assert.That(objects, Has.Count.EqualTo(1));
+            Assert.That(objects[0].Uri, Is.EqualTo("file name.bin"));
+        }
     }
 }

ReqIFSharp.Tests/ReqIFTextFixture.cs

@@ -0,0 +1,110 @@
+// -------------------------------------------------------------------------------------------------
+//  <copyright file="ReqIFTextFixture.cs" company="Starion Group S.A.">
+// 
+//    Copyright 2017-2025 Starion Group S.A.
+// 
+//    Licensed under the Apache License, Version 2.0 (the "License");
+//    you may not use this file except in compliance with the License.
+//    You may obtain a copy of the License at
+// 
+//        http://www.apache.org/licenses/LICENSE-2.0
+// 
+//    Unless required by applicable law or agreed to in writing, software
+//    distributed under the License is distributed on an "AS IS" BASIS,
+//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//    See the License for the specific language governing permissions and
+//    limitations under the License.
+// 
+//  </copyright>
+//  -------------------------------------------------------------------------------------------------
+
+namespace ReqIFSharp.Tests
+{
+    using System;
+    using System.IO;
+    using System.Text;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using System.Xml;
+
+    using NUnit.Framework;
+
+    using ReqIFSharp;
+
+    [TestFixture]
+    public class ReqIFTextFixture
+    {
+        [Test]
+        public async Task ReqIF_ReadXmlAsync_RestoresHeaderAndToolExtensions()
+        {
+            var reqIf = CreateReqIfDocument();
+
+            var builder = new StringBuilder();
+            using (var writer = XmlWriter.Create(builder, new XmlWriterSettings { OmitXmlDeclaration = true }))
+            {
+                writer.WriteStartElement("REQ-IF");
+                reqIf.WriteXml(writer);
+                writer.WriteEndElement();
+            }
+
+            using var reader = XmlReader.Create(new StringReader(builder.ToString()), new XmlReaderSettings { Async = true });
+            await reader.MoveToContentAsync();
+
+            var roundTrip = new ReqIF();
+            await roundTrip.ReadXmlAsync(reader, CancellationToken.None);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(roundTrip.Lang, Is.EqualTo(reqIf.Lang));
+                Assert.That(roundTrip.TheHeader.Title, Is.EqualTo(reqIf.TheHeader.Title));
+                Assert.That(roundTrip.ToolExtension, Has.Count.EqualTo(1));
+                Assert.That(roundTrip.CoreContent.DataTypes.Count, Is.EqualTo(2));
+            });
+        }
+
+        private static ReqIF CreateReqIfDocument()
+        {
+            var reqIf = new ReqIF
+            {
+                Lang = "en",
+                TheHeader = new ReqIFHeader
+                {
+                    Identifier = "header",
+                    Comment = "comment",
+                    CreationTime = new DateTime(2024, 01, 01, 12, 00, 00, DateTimeKind.Utc),
+                    RepositoryId = "repo",
+                    ReqIFToolId = "tool",
+                    ReqIFVersion = "1.0",
+                    SourceToolId = "source",
+                    Title = "title"
+                },
+                CoreContent = new ReqIFContent()
+            };
+
+            var enumeration = new DatatypeDefinitionEnumeration(reqIf.CoreContent, null)
+            {
+                Identifier = "enum"
+            };
+
+            var enumValue = new EnumValue(enumeration, null)
+            {
+                Identifier = "enum-value"
+            };
+
+            _ = new EmbeddedValue(enumValue, null)
+            {
+                Key = 5,
+                OtherContent = "red"
+            };
+
+            var xhtmlDatatype = new DatatypeDefinitionXHTML(reqIf.CoreContent, null)
+            {
+                Identifier = "xhtml"
+            };
+
+            reqIf.ToolExtension.Add(new ReqIFToolExtension { InnerXml = "<extension />" });
+
+            return reqIf;
+        }
+    }
+}

ReqIFSharp.Tests/SpecElementWithAttributesTests/SpecHierarchyTestFixture.cs

@@ -23,6 +23,7 @@ namespace ReqIFSharp.Tests.SpecElementWithAttributesTests
     using System.IO;
     using System.Runtime.Serialization;
     using System.Threading;
+    using System.Threading.Tasks;
     using System.Xml;
 
     using NUnit.Framework;
@@ -80,5 +81,47 @@ public void Verify_that_When_Object_is_null_WriteXmlAsync_throws_exception()
                 Throws.Exception.TypeOf<SerializationException>()
                     .With.Message.Contains("The Object property of SpecHierarchy identifier:longname may not be null"));
         }
+
+        [Test]
+        public async Task SpecHierarchy_ReadXmlAsync_InitialisesContainerAndChildren()
+        {
+            var content = new ReqIFContent();
+            var rootSpecification = new Specification(content, null) { Identifier = "root" };
+            var existingObject = new SpecObject(content, null) { Identifier = "existing-object" };
+
+            var specHierarchy = new SpecHierarchy(rootSpecification, content, null)
+            {
+                Identifier = "hierarchy"
+            };
+
+            var xml = """
+                      <SPEC-HIERARCHY IDENTIFIER="hierarchy" IS-TABLE-INTERNAL="true">
+                        <OBJECT>
+                          <SPEC-OBJECT-REF>missing-object</SPEC-OBJECT-REF>
+                        </OBJECT>
+                        <CHILDREN>
+                          <SPEC-HIERARCHY IDENTIFIER="child">
+                            <OBJECT>
+                              <SPEC-OBJECT-REF>existing-object</SPEC-OBJECT-REF>
+                            </OBJECT>
+                          </SPEC-HIERARCHY>
+                        </CHILDREN>
+                      </SPEC-HIERARCHY>
+                      """;
+
+            using var reader = XmlReader.Create(new StringReader(xml), new XmlReaderSettings { Async = true });
+            await reader.MoveToContentAsync();
+
+            await specHierarchy.ReadXmlAsync(reader, CancellationToken.None);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(specHierarchy.IsTableInternal, Is.True);
+                Assert.That(specHierarchy.Object, Is.Null, "Missing objects should yield null reference");
+                Assert.That(specHierarchy.Children, Has.Count.EqualTo(1));
+                Assert.That(specHierarchy.Children[0].Object, Is.SameAs(existingObject));
+                Assert.That(specHierarchy.Children[0].Container, Is.SameAs(specHierarchy));
+            });
+        }
     }
 }

ReqIFSharp/SpecElementWithAttributes/SpecHierarchy.cs

@@ -20,16 +20,16 @@
 
 namespace ReqIFSharp
 {
+    using Microsoft.Extensions.Logging;
+    using Microsoft.Extensions.Logging.Abstractions;
+    using System;
     using System.Collections.Generic;
     using System.Linq;
     using System.Runtime.Serialization;
     using System.Threading;
     using System.Threading.Tasks;
     using System.Xml;
 
-    using Microsoft.Extensions.Logging;
-    using Microsoft.Extensions.Logging.Abstractions;
-
     /// <summary>
     /// The <see cref="SpecHierarchy"/> class represents a node in a hierarchically structured requirements specification.
     /// </summary>
@@ -172,6 +172,8 @@ internal override void ReadXml(XmlReader reader)
         {
             base.ReadXml(reader);
 
+            this.ReadXmlAttributes(reader);
+
             using (var specHierarchySubtree = reader.ReadSubtree())
             {
                 while (specHierarchySubtree.Read())
@@ -221,6 +223,8 @@ internal async Task ReadXmlAsync(XmlReader reader, CancellationToken token)
         {
             base.ReadXml(reader);
 
+            this.ReadXmlAttributes(reader);
+
             while (await reader.ReadAsync())
             {
                 if (token.IsCancellationRequested)
@@ -259,6 +263,32 @@ internal async Task ReadXmlAsync(XmlReader reader, CancellationToken token)
             }
         }
 
+        /// <summary>
+        /// Reads the properties that are defined as XML Attributes (MAX-LENGTH)
+        /// </summary>
+        /// <param name="reader">
+        /// an instance of <see cref="XmlReader"/>
+        /// </param>
+        private void ReadXmlAttributes(XmlReader reader)
+        {
+            var xmlLineInfo = reader as IXmlLineInfo;
+
+            this.logger.LogTrace("reading IS-TABLE-INTERNAL at line:position {LineNumber}:{LinePosition}", xmlLineInfo?.LineNumber, xmlLineInfo?.LinePosition);
+
+            var isTableInternal = reader.GetAttribute("IS-TABLE-INTERNAL");
+            if (!string.IsNullOrWhiteSpace(isTableInternal))
+            {
+                try
+                {
+                    this.IsTableInternal = XmlConvert.ToBoolean(isTableInternal);
+                }
+                catch (Exception e)
+                {
+                    throw new SerializationException($"The SpecHierarchy.IS-TABLE-INTERNAL: {isTableInternal} at line:position {xmlLineInfo?.LineNumber}:{xmlLineInfo?.LinePosition} could not be converted to an INTEGER", e);
+                }
+            }
+        }
+
         /// <summary>
         /// Converts a <see cref="AttributeDefinition"/> object into its XML representation.
         /// </summary>