implemented ConcernUsageExtensions and corresponding test

SysML2.NET.Tests/Extend/ConcernUsageExtensionsTestFixture.cs

@@ -1,7 +1,7 @@
 // -------------------------------------------------------------------------------------------------
 // <copyright file="ConcernUsageExtensionsTestFixture.cs" company="Starion Group S.A.">
 // 
-//   Copyright 2022-2026 Starion Group S.A.
+//   Copyright (C) 2022-2026 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.
@@ -21,18 +21,44 @@
 namespace SysML2.NET.Tests.Extend
 {
     using System;
-    
+
     using NUnit.Framework;
-
+
+    using SysML2.NET.Core.POCO.Core.Features;
     using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Extensions;
 
     [TestFixture]
     public class ConcernUsageExtensionsTestFixture
     {
         [Test]
-        public void ComputeConcernDefinition_ThrowsNotSupportedException()
+        public void VerifyComputeConcernDefinition()
         {
-            Assert.That(() => ((IConcernUsage)null).ComputeConcernDefinition(), Throws.TypeOf<NotSupportedException>());
+            // Null subject:
+            Assert.That(() => ((IConcernUsage)null).ComputeConcernDefinition(), Throws.TypeOf<ArgumentNullException>());
+
+            // Empty subject: no FeatureTyping relationships, so no ConcernDefinition:
+            var concernUsage = new ConcernUsage();
+            Assert.That(concernUsage.ComputeConcernDefinition(), Is.Null);
+
+            // Typed by FeatureTyping, but not an IConcernDefinition:
+            var requirementDefinition = new RequirementDefinition();
+            var typingToRequirement = new FeatureTyping { Type = requirementDefinition };
+            concernUsage.AssignOwnership(typingToRequirement);
+            Assert.That(concernUsage.ComputeConcernDefinition(), Is.Null);
+
+            // Correct typing: FeatureTyping.Type is a ConcernDefinition:
+            var concernDefinition = new ConcernDefinition();
+            var typingToConcern = new FeatureTyping { Type = concernDefinition };
+            concernUsage.AssignOwnership(typingToConcern);
+            Assert.That(concernUsage.ComputeConcernDefinition(), Is.SameAs(concernDefinition));
+
+            // Multiple matching typings: FirstOrDefault is used so even breaking the multiplicity, it works;
+            // *not sure if this test step should be removed or not*:
+            var secondConcernDefinition = new ConcernDefinition();
+            var typingToSecondConcern = new FeatureTyping { Type = secondConcernDefinition };
+            concernUsage.AssignOwnership(typingToSecondConcern);
+            Assert.That(concernUsage.ComputeConcernDefinition(), Is.SameAs(concernDefinition));
         }
     }
 }

SysML2.NET/Extend/ConcernUsageExtensions.cs

@@ -1,82 +1,54 @@
 // -------------------------------------------------------------------------------------------------
 // <copyright file="ConcernUsageExtensions.cs" company="Starion Group S.A.">
-//
-//    Copyright (C) 2022-2026 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
-//
+// 
+//   Copyright (C) 2022-2026 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 SysML2.NET.Core.POCO.Systems.Requirements
 {
     using System;
-    using System.Collections.Generic;
+    using System.Linq;
 
-    using SysML2.NET.Core.Core.Types;
-    using SysML2.NET.Core.Root.Namespaces;
-    using SysML2.NET.Core.Systems.Occurrences;
-    using SysML2.NET.Core.POCO.Core.Classifiers;
     using SysML2.NET.Core.POCO.Core.Features;
-    using SysML2.NET.Core.POCO.Core.Types;
-    using SysML2.NET.Core.POCO.Kernel.Behaviors;
-    using SysML2.NET.Core.POCO.Kernel.Classes;
-    using SysML2.NET.Core.POCO.Kernel.Functions;
-    using SysML2.NET.Core.POCO.Root.Annotations;
-    using SysML2.NET.Core.POCO.Root.Elements;
-    using SysML2.NET.Core.POCO.Root.Namespaces;
-    using SysML2.NET.Core.POCO.Systems.Actions;
-    using SysML2.NET.Core.POCO.Systems.Allocations;
-    using SysML2.NET.Core.POCO.Systems.AnalysisCases;
-    using SysML2.NET.Core.POCO.Systems.Attributes;
-    using SysML2.NET.Core.POCO.Systems.Calculations;
-    using SysML2.NET.Core.POCO.Systems.Cases;
-    using SysML2.NET.Core.POCO.Systems.Connections;
-    using SysML2.NET.Core.POCO.Systems.Constraints;
-    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
-    using SysML2.NET.Core.POCO.Systems.Enumerations;
-    using SysML2.NET.Core.POCO.Systems.Flows;
-    using SysML2.NET.Core.POCO.Systems.Interfaces;
-    using SysML2.NET.Core.POCO.Systems.Items;
-    using SysML2.NET.Core.POCO.Systems.Metadata;
-    using SysML2.NET.Core.POCO.Systems.Occurrences;
-    using SysML2.NET.Core.POCO.Systems.Parts;
-    using SysML2.NET.Core.POCO.Systems.Ports;
-    using SysML2.NET.Core.POCO.Systems.States;
-    using SysML2.NET.Core.POCO.Systems.UseCases;
-    using SysML2.NET.Core.POCO.Systems.VerificationCases;
-    using SysML2.NET.Core.POCO.Systems.Views;
 
     /// <summary>
-    /// The <see cref="ConcernUsageExtensions"/> class provides extensions methods for
-    /// the <see cref="IConcernUsage"/> interface
+    /// The <see cref="ConcernUsageExtensions" /> class provides extensions methods for
+    /// the <see cref="IConcernUsage" /> interface
     /// </summary>
     internal static class ConcernUsageExtensions
     {
         /// <summary>
         /// Computes the derived property.
         /// </summary>
         /// <param name="concernUsageSubject">
-        /// The subject <see cref="IConcernUsage"/>
+        /// The subject <see cref="IConcernUsage" />
         /// </param>
         /// <returns>
         /// the computed result
         /// </returns>
-        [System.Diagnostics.CodeAnalysis.ExcludeFromCodeCoverage]
         internal static IConcernDefinition ComputeConcernDefinition(this IConcernUsage concernUsageSubject)
         {
-            throw new NotSupportedException("Create a GitHub issue when this method is required");
+            return concernUsageSubject == null
+                ? throw new ArgumentNullException(nameof(concernUsageSubject))
+                : concernUsageSubject.OwnedRelationship
+                    .OfType<IFeatureTyping>()
+                    .Select(featureTyping => featureTyping.Type)
+                    .OfType<IConcernDefinition>()
+                    .FirstOrDefault();
         }
-
     }
 }