[Feature] implement EObject.EClass() (return the meta class); fixes #10

CLAUDE.md

@@ -71,6 +71,16 @@ Logging throughout uses optional injected `ILoggerFactory`, falling back to `Nul
 
 Sample models live in `TestData/` (`ecore.ecore`, `recipe.ecore`, `wizardEcore.ecore`) and are linked into test projects' output under `Data/` via `<None>` items with `CopyToOutputDirectory`. Test framework is **NUnit 4** with **Moq**; coverage via coverlet. `InternalsVisibleTo` exposes internals (e.g. `ECoreParser`) to each project's `.Tests` assembly.
 
+## Code coverage requirement
+
+**All new code must reach at least 80% line/branch coverage** — this is enforced by the SonarCloud quality gate on new code. When implementing a feature or fix, add tests that exercise every new branch (happy path *and* guard/error paths) so coverage on the changed lines is ≥ 80%. Verify locally before opening/updating a PR:
+
+```powershell
+dotnet test ECoreNetto.Tests/ECoreNetto.Tests.csproj --collect:"XPlat Code Coverage" --settings coverlet.runsettings
+```
+
+Then inspect the generated Cobertura report (or run ReportGenerator) and confirm the new members are covered. Do not consider an issue "done" until its new code clears the 80% bar.
+
 ## Code style (from .github/CONTRIBUTING.md)
 
 These differ from default .NET conventions — match them:

ECoreNetto.Tests/ModelElement/EObjectMetaClassTestFixture.cs

@@ -0,0 +1,133 @@
+// -------------------------------------------------------------------------------------------------
+// <copyright file="EObjectMetaClassTestFixture.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 ECoreNetto.Tests.ModelElement
+{
+    using System;
+    using System.IO;
+    using System.Linq;
+
+    using ECoreNetto.Resource;
+
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Suite of tests that verify <see cref="EObject.EClass"/> returns the Ecore meta class that
+    /// describes the runtime type of the model element (see issue #10).
+    /// </summary>
+    [TestFixture]
+    public class EObjectMetaClassTestFixture
+    {
+        private Resource resource = null!;
+
+        private EPackage rootPackage = null!;
+
+        [SetUp]
+        public void SetUp()
+        {
+            var path = Path.Combine(TestContext.CurrentContext.TestDirectory, "Data", "recipe.ecore");
+            var uri = new Uri(Path.GetFullPath(path));
+
+            var resourceSet = new ResourceSet();
+            this.resource = resourceSet.CreateResource(uri);
+            this.rootPackage = this.resource.Load(null);
+        }
+
+        [Test]
+        public void Verify_that_EClass_returns_the_expected_meta_class_for_each_element_kind()
+        {
+            var eClass = this.rootPackage.EClassifiers.OfType<EClass>().First();
+            var attribute = this.rootPackage.EClassifiers.OfType<EClass>()
+                .SelectMany(c => c.EStructuralFeatures).OfType<EAttribute>().First();
+            var reference = this.rootPackage.EClassifiers.OfType<EClass>()
+                .SelectMany(c => c.EStructuralFeatures).OfType<EReference>().First();
+            var eEnum = this.rootPackage.EClassifiers.OfType<EEnum>().First();
+            var literal = this.resource.GetEObject("recipe.ecore#//Unit/PIECE");
+
+            Assert.That(literal, Is.Not.Null);
+
+            Assert.Multiple(() =>
+            {
+                Assert.That(this.rootPackage.EClass().Name, Is.EqualTo("EPackage"));
+                Assert.That(eClass.EClass().Name, Is.EqualTo("EClass"));
+                Assert.That(attribute.EClass().Name, Is.EqualTo("EAttribute"));
+                Assert.That(reference.EClass().Name, Is.EqualTo("EReference"));
+                Assert.That(eEnum.EClass().Name, Is.EqualTo("EEnum"));
+                Assert.That(literal!.EClass().Name, Is.EqualTo("EEnumLiteral"));
+            });
+        }
+
+        [Test]
+        public void Verify_that_the_returned_meta_class_is_the_resource_registered_instance()
+        {
+            var eClass = this.rootPackage.EClassifiers.OfType<EClass>().First();
+
+            var metaClass = eClass.EClass();
+
+            Assert.Multiple(() =>
+            {
+                // the meta class is itself an EClass, and is the same instance the resource exposes for "//EClass"
+                Assert.That(metaClass, Is.InstanceOf<EClass>());
+                Assert.That(metaClass, Is.SameAs(this.resource.GetEObject("//EClass")));
+            });
+        }
+
+        [Test]
+        public void Verify_that_the_meta_class_is_consistent_across_instances_of_the_same_type()
+        {
+            var attributes = this.rootPackage.EClassifiers.OfType<EClass>()
+                .SelectMany(c => c.EStructuralFeatures).OfType<EAttribute>().Take(2).ToList();
+
+            Assert.That(attributes, Has.Count.EqualTo(2));
+            Assert.That(attributes[0].EClass(), Is.SameAs(attributes[1].EClass()));
+        }
+
+        [Test]
+        public void Verify_that_EClass_throws_when_no_meta_class_is_registered_for_the_runtime_type()
+        {
+            // a runtime type whose name is not present in the Ecore meta model registry
+            var unregistered = new UnregisteredEObject(this.resource);
+
+            Assert.That(() => unregistered.EClass(), Throws.TypeOf<InvalidOperationException>());
+        }
+
+        [Test]
+        public void Verify_that_GetMetaClass_returns_null_for_an_unknown_type_name()
+        {
+            Assert.That(this.resource.GetMetaClass("ThisTypeDoesNotExist"), Is.Null);
+        }
+
+        /// <summary>
+        /// A minimal <see cref="EObject"/> subtype whose runtime type name has no corresponding Ecore
+        /// meta class, used to exercise the guard path of <see cref="EObject.EClass"/>.
+        /// </summary>
+        private sealed class UnregisteredEObject : EObject
+        {
+            public UnregisteredEObject(Resource resource)
+                : base(resource)
+            {
+            }
+
+            internal override void SetProperties()
+            {
+            }
+        }
+    }
+}

ECoreNetto/ModelElement/EObject.cs

@@ -87,7 +87,15 @@
         /// </returns>
         public EClass EClass()
         {
-            throw new NotImplementedException();
+            var metaClass = this.EResource.GetMetaClass(this.GetType().Name);
+
+            if (metaClass == null)
+            {
+                throw new InvalidOperationException(
+                    $"No Ecore meta class is registered for '{this.GetType().Name}'.");
+            }
+
+            return metaClass;
         }
 
         /// <summary>
@@ -110,7 +118,7 @@
         /// <returns>
         /// The <see cref="EStructuralFeature"/> that actually contains the object.
         /// </returns>
         public EStructuralFeature EContainingFeature()
         {
             throw new NotImplementedException();
         }
@@ -123,7 +131,7 @@
         /// <returns>
         /// The feature that properly contains the object.
         /// </returns>
         public EReference EContainmentFeature()
         {
             throw new NotImplementedException();
         }
@@ -138,7 +146,7 @@
         /// <returns>
         /// A list view of the content objects.
         /// </returns>
         public IEnumerable<EObject> EContents()
         {
             throw new NotImplementedException();
         }
@@ -149,7 +157,7 @@
         /// <returns>
         /// A tree iterator that iterates over all contents.
         /// </returns>
         public IEnumerable<EObject> EAllContents()
         {
             throw new NotImplementedException();
         }
@@ -165,7 +173,7 @@
         /// <returns>
         /// true if this object is a proxy or false, otherwise.
         /// </returns>
         public bool EIsProxy()
         {
             throw new NotImplementedException();
         }
@@ -181,7 +189,7 @@
         /// <returns>
         /// A list view of the cross referenced objects. 
         /// </returns>
         public IEnumerable<EObject> ECrossReferences()
         {
             throw new NotImplementedException();
         }
@@ -220,7 +228,7 @@
         /// <exception cref="ArgumentException">
         /// If the <see cref="EStructuralFeature"/> is not one the meta class's features and is also not affiliated with one of the meta class's features. 
         /// </exception>        
         public object EGet(EStructuralFeature feature, bool resolve)
         {
             throw new NotImplementedException();
         }
@@ -248,7 +256,7 @@
         /// <exception cref="InvalidCastException">
         /// If there is a type conflict.
         /// </exception>
         public void ESet(EStructuralFeature feature, object newValue)
         {
             throw new NotImplementedException();
         }
@@ -272,7 +280,7 @@
         /// <exception cref="ArgumentException">
         /// If the feature is not one the meta class's <see cref="EStructuralFeature"/>s.
         /// </exception>
         public bool EIsSet(EStructuralFeature feature)
         {
             throw new NotImplementedException();
         }
@@ -291,7 +299,7 @@
         /// <exception cref="ArgumentException">
         /// If the feature is not one the meta class's <see cref="EStructuralFeature"/>s, or it isn't changeable.
         /// </exception>
         public void EUnSet(EStructuralFeature feature)
         {
             throw new NotImplementedException();
         }

ECoreNetto/Resource/Resource.cs

@@ -200,6 +200,26 @@ public IEnumerable<EObject> AllContents()
             return this.Cache.Values;
         }
 
+        /// <summary>
+        /// Gets the Ecore meta class registered for the provided simple type name.
+        /// </summary>
+        /// <param name="name">
+        /// The simple name of the meta class (e.g. <c>EClass</c>, <c>EAttribute</c>), which matches the
+        /// runtime type name of the model elements.
+        /// </param>
+        /// <returns>
+        /// The <see cref="EClass"/> meta class, or null when no meta class is registered for <paramref name="name"/>.
+        /// </returns>
+        internal EClass? GetMetaClass(string name)
+        {
+            if (this.eCoreTypes.TryGetValue($"//{name}", out var metaClass) && metaClass is EClass eClass)
+            {
+                return eClass;
+            }
+
+            return null;
+        }
+
         /// <summary>
         /// Returns the URI fragment that, when passed to <see cref="GetEObject(string)"/>, will return the given object.
         /// </summary>