Fix #105 #106 #93 #94 #199 #200

.claude/commands/implement-extensions.md

@@ -380,6 +380,16 @@ Report to the user:
   knows the implementation is grounded in spec prose rather than OCL.
 - **Issue checklist sync**: `<issue-url>` — `<newly-ticked>` newly ticked,
   `<newly-added>` newly added, `<ticked>/<total>` total (filled in after step 11).
+- **Pre-filled commit message** (MANDATORY — append at the very end of the
+  final-summary message in a fenced code block, ready to copy):
+
+  ```
+  Fix #<n>
+  ```
+
+  Where `<n>` is the GitHub issue number handled by this run. Nothing else —
+  no body paragraphs, no per-method bullet list, no `Co-Authored-By` trailer,
+  no "🤖 Generated with …" footer. The single line is the entire message.
 
 Do NOT auto-commit. The user reviews and commits.
 

SysML2.NET.Tests/Extend/AnalysisCaseDefinitionExtensionsTestFixture.cs

@@ -1,38 +1,52 @@
-// -------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 // <copyright file="AnalysisCaseDefinitionExtensionsTestFixture.cs" company="Starion Group S.A.">
-// 
+//
 //   Copyright 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.Tests.Extend
 {
     using System;
-    
+
     using NUnit.Framework;
-
+
+    using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Extensions;
 
     [TestFixture]
     public class AnalysisCaseDefinitionExtensionsTestFixture
     {
         [Test]
-        public void ComputeResultExpression_ThrowsNotSupportedException()
+        public void VerifyComputeResultExpression()
         {
-            Assert.That(() => ((IAnalysisCaseDefinition)null).ComputeResultExpression(), Throws.TypeOf<NotSupportedException>());
+            Assert.That(() => ((IAnalysisCaseDefinition)null).ComputeResultExpression(), Throws.TypeOf<ArgumentNullException>());
+
+            var analysisCaseDefinition = new AnalysisCaseDefinition();
+
+            // Empty case: no ResultExpressionMembership in featureMembership → null.
+            Assert.That(analysisCaseDefinition.ComputeResultExpression(), Is.Null);
+
+            // Populated case: ResultExpressionMembership owns an Expression → returns the Expression.
+            var expression = new Expression();
+            var resultExpressionMembership = new ResultExpressionMembership();
+            analysisCaseDefinition.AssignOwnership(resultExpressionMembership, expression);
+
+            Assert.That(analysisCaseDefinition.ComputeResultExpression(), Is.SameAs(expression));
         }
     }
 }

SysML2.NET.Tests/Extend/AnalysisCaseUsageExtensionsTestFixture.cs

@@ -1,44 +1,78 @@
-// -------------------------------------------------------------------------------------------------
+// -------------------------------------------------------------------------------------------------
 // <copyright file="AnalysisCaseUsageExtensionsTestFixture.cs" company="Starion Group S.A.">
-// 
+//
 //   Copyright 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.Tests.Extend
 {
     using System;
-    
+
     using NUnit.Framework;
-
+
+    using SysML2.NET.Core.POCO.Core.Features;
+    using SysML2.NET.Core.POCO.Kernel.Functions;
     using SysML2.NET.Core.POCO.Systems.AnalysisCases;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Extensions;
 
     [TestFixture]
     public class AnalysisCaseUsageExtensionsTestFixture
     {
         [Test]
-        public void ComputeAnalysisCaseDefinition_ThrowsNotSupportedException()
+        public void VerifyComputeAnalysisCaseDefinition()
         {
-            Assert.That(() => ((IAnalysisCaseUsage)null).ComputeAnalysisCaseDefinition(), Throws.TypeOf<NotSupportedException>());
+            Assert.That(() => ((IAnalysisCaseUsage)null).ComputeAnalysisCaseDefinition(), Throws.TypeOf<ArgumentNullException>());
+
+            var analysisCaseUsage = new AnalysisCaseUsage();
+
+            // Empty case: no FeatureTyping whose Type is an IAnalysisCaseDefinition → null.
+            Assert.That(analysisCaseUsage.ComputeAnalysisCaseDefinition(), Is.Null);
+
+            // Negative case: FeatureTyping whose Type is a Usage (not IAnalysisCaseDefinition) — no match → null.
+            var nonDefinitionTyping = new FeatureTyping { Type = new Usage() };
+            analysisCaseUsage.AssignOwnership(nonDefinitionTyping);
+
+            Assert.That(analysisCaseUsage.ComputeAnalysisCaseDefinition(), Is.Null);
+
+            // Populated case: FeatureTyping whose Type is an AnalysisCaseDefinition → returns the AnalysisCaseDefinition.
+            var analysisCaseDefinition = new AnalysisCaseDefinition();
+            var analysisCaseDefinitionTyping = new FeatureTyping { Type = analysisCaseDefinition };
+            analysisCaseUsage.AssignOwnership(analysisCaseDefinitionTyping);
+
+            Assert.That(analysisCaseUsage.ComputeAnalysisCaseDefinition(), Is.SameAs(analysisCaseDefinition));
         }
-        
+
         [Test]
-        public void ComputeResultExpression_ThrowsNotSupportedException()
+        public void VerifyComputeResultExpression()
         {
-            Assert.That(() => ((IAnalysisCaseUsage)null).ComputeResultExpression(), Throws.TypeOf<NotSupportedException>());
+            Assert.That(() => ((IAnalysisCaseUsage)null).ComputeResultExpression(), Throws.TypeOf<ArgumentNullException>());
+
+            var analysisCaseUsage = new AnalysisCaseUsage();
+
+            // Empty case: no ResultExpressionMembership in featureMembership → null.
+            Assert.That(analysisCaseUsage.ComputeResultExpression(), Is.Null);
+
+            // Populated case: ResultExpressionMembership owns an Expression → returns the Expression.
+            var expression = new Expression();
+            var resultExpressionMembership = new ResultExpressionMembership();
+            analysisCaseUsage.AssignOwnership(resultExpressionMembership, expression);
+
+            Assert.That(analysisCaseUsage.ComputeResultExpression(), Is.SameAs(expression));
         }
     }
 }

SysML2.NET.Tests/Extend/CaseDefinitionExtensionsTestFixture.cs

@@ -1,50 +1,112 @@
 // -------------------------------------------------------------------------------------------------
 // <copyright file="CaseDefinitionExtensionsTestFixture.cs" company="Starion Group S.A.">
-// 
+//
 //   Copyright 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.Tests.Extend
 {
     using System;
-    
+
     using NUnit.Framework;
 
-    using SysML2.NET.Core.POCO.Systems.Cases ;
+    using SysML2.NET.Core.POCO.Kernel.Behaviors;
+    using SysML2.NET.Core.POCO.Systems.Cases;
+    using SysML2.NET.Core.POCO.Systems.Parts;
+    using SysML2.NET.Core.POCO.Systems.Requirements;
+    using SysML2.NET.Core.POCO.Systems.DefinitionAndUsage;
+    using SysML2.NET.Extensions;
 
     [TestFixture]
     public class CaseDefinitionExtensionsTestFixture
     {
         [Test]
-        public void ComputeActorParameter_ThrowsNotSupportedException()
+        public void VerifyComputeActorParameter()
         {
-            Assert.That(() => ((ICaseDefinition)null).ComputeActorParameter(), Throws.TypeOf<NotSupportedException>());
+            Assert.That(() => ((ICaseDefinition)null).ComputeActorParameter(), Throws.TypeOf<ArgumentNullException>());
+
+            var caseDefinition = new CaseDefinition();
+
+            Assert.That(caseDefinition.ComputeActorParameter(), Is.Empty);
+
+            // Discrimination: add a ParameterMembership (not ActorMembership) — must be excluded from result.
+            var parameterMembership = new ParameterMembership();
+            var parameterUsage = new Usage();
+            caseDefinition.AssignOwnership(parameterMembership, parameterUsage);
+
+            Assert.That(caseDefinition.ComputeActorParameter(), Is.Empty);
+
+            // For Later: populated case depends on IActorMembership.ComputeOwnedActorParameter, which is still a stub.
+            var actorMembership = new ActorMembership();
+            var actorPartUsage = new PartUsage();
+            caseDefinition.AssignOwnership(actorMembership, actorPartUsage);
+
+            Assert.That(() => caseDefinition.ComputeActorParameter(), Throws.TypeOf<NotSupportedException>());
         }
-        
+
         [Test]
-        public void ComputeObjectiveRequirement_ThrowsNotSupportedException()
+        public void VerifyComputeObjectiveRequirement()
         {
-            Assert.That(() => ((ICaseDefinition)null).ComputeObjectiveRequirement(), Throws.TypeOf<NotSupportedException>());
+            Assert.That(() => ((ICaseDefinition)null).ComputeObjectiveRequirement(), Throws.TypeOf<ArgumentNullException>());
+
+            var caseDefinition = new CaseDefinition();
+
+            // Empty case: no ObjectiveMembership in featureMembership → null.
+            Assert.That(caseDefinition.ComputeObjectiveRequirement(), Is.Null);
+
+            // Discrimination: add a ParameterMembership (not ObjectiveMembership) — still null.
+            var parameterMembership = new ParameterMembership();
+            var parameterUsage = new Usage();
+            caseDefinition.AssignOwnership(parameterMembership, parameterUsage);
+
+            Assert.That(caseDefinition.ComputeObjectiveRequirement(), Is.Null);
+
+            // Populated case: ObjectiveMembership owns a RequirementUsage → returns the RequirementUsage.
+            var objectiveMembership = new ObjectiveMembership();
+            var requirementUsage = new RequirementUsage();
+            caseDefinition.AssignOwnership(objectiveMembership, requirementUsage);
+
+            Assert.That(caseDefinition.ComputeObjectiveRequirement(), Is.SameAs(requirementUsage));
         }
-        
+
         [Test]
-        public void ComputeSubjectParameter_ThrowsNotSupportedException()
+        public void VerifyComputeSubjectParameter()
         {
-            Assert.That(() => ((ICaseDefinition)null).ComputeSubjectParameter(), Throws.TypeOf<NotSupportedException>());
+            Assert.That(() => ((ICaseDefinition)null).ComputeSubjectParameter(), Throws.TypeOf<ArgumentNullException>());
+
+            var caseDefinition = new CaseDefinition();
+
+            // Empty case: no SubjectMembership in featureMembership → null.
+            Assert.That(caseDefinition.ComputeSubjectParameter(), Is.Null);
+
+            // Discrimination: add a ParameterMembership (not SubjectMembership) → still null.
+            var parameterMembership = new ParameterMembership();
+            var parameterUsage = new Usage();
+            caseDefinition.AssignOwnership(parameterMembership, parameterUsage);
+
+            Assert.That(caseDefinition.ComputeSubjectParameter(), Is.Null);
+
+            // Populated case: SubjectMembership is present alongside the earlier ParameterMembership.
+            // OfType<ISubjectMembership> must discriminate — only the subject's ownedSubjectParameter surfaces.
+            var subjectMembership = new SubjectMembership();
+            var subjectUsage = new Usage();
+            caseDefinition.AssignOwnership(subjectMembership, subjectUsage);
+
+            Assert.That(caseDefinition.ComputeSubjectParameter(), Is.SameAs(subjectUsage));
         }
     }
 }