Update Readme.md

Author: Nice3point

Readme.md

@@ -21,7 +21,6 @@ You can install this library as a [NuGet package](https://www.nuget.org/packages
 The packages are compiled for specific versions of Revit. To support different versions of libraries in one project, use the `RevitVersion` property:
 
 ```xml
-
 <PackageReference Include="Nice3point.TUnit.Revit" Version="$(RevitVersion).*"/>
 ```
 
@@ -52,28 +51,6 @@ public class MyTestClass : RevitApiTest
 
 This is your runnable test. The `[TestExecutor<RevitThreadExecutor>]` attribute ensures the test executes within Revit's single-threaded API context.
 
-### Global executor configuration
-
-To avoid repeating the `TestExecutor` attribute for every test, you can [register](https://tunit.dev/docs/advanced/extension-points/#registering-a-test-executor) the executor globally using one of the following methods:
-
-- Add the attribute to any .cs file in your project (e.g., AssemblyInfo.cs):
-    ```csharp
-    using Nice3point.TUnit.Revit.Executors;
-    using TUnit.Core.Executors;
-    
-    [assembly: TestExecutor<RevitThreadExecutor>]
-    ```
-- Add the attribute directly to your .csproj file:
-    ```xml
-    <!-- Global Test Executor Registration -->
-    <ItemGroup>
-        <AssemblyAttribute Include="TUnit.Core.Executors.TestExecutorAttribute">
-            <_Parameter1>typeof(Nice3point.TUnit.Revit.Executors.RevitThreadExecutor)</_Parameter1>
-            <_Parameter1_IsLiteral>true</_Parameter1_IsLiteral>
-        </AssemblyAttribute>
-    </ItemGroup>
-    ```
-
 ## Running your tests
 
 **TUnit** is built on top of the **Microsoft.Testing.Platform**. Combined with source-generated tests, running your tests is available in multiple ways.
@@ -108,14 +85,14 @@ Settings > Build, Execution, Deployment > Unit Testing > Testing Platform.
 
 ## Application testing
 
-Test Revit application-level functionality:
+Test Revit application-level functionality using the `Application` property exposed by `RevitApiTest`:
 
 ```csharp
-public sealed class RevitApplicationTests : RevitApiTest
+public sealed class ApplicationTests : RevitApiTest
 {
     [Test]
     [TestExecutor<RevitThreadExecutor>]
-    public async Task Cities_Startup_IsNotEmpty()
+    public async Task Cities_BuiltinSet_IsNotEmpty()
     {
         var cities = Application.Cities.Cast<City>();
 
@@ -135,62 +112,135 @@ public sealed class RevitApplicationTests : RevitApiTest
 
 ## Document testing
 
-Test document-specific operations with setup and cleanup:
+Tests that pass alone but fail together are a classic sign of shared state. Give each test its own document — created in `[Before(Test)]`, closed in `[After(Test)]` — and that problem disappears entirely.
+Use the setup hook to seed the document with exactly the state each test needs.
+The `[HookExecutor<RevitThreadExecutor>]` attribute ensures hooks also run on Revit's thread:
 
 ```csharp
-public sealed class RevitDocumentTests : RevitApiTest
+public sealed class ModelSeedTests : RevitApiTest
 {
-    private static Document _documentFile = null!;
+    private Document _document = null!;
+    private IList<Wall> _exteriorWalls = null!;
 
-    [Before(Class)]
+    [Before(Test)]
     [HookExecutor<RevitThreadExecutor>]
-    public static void Setup()
+    public void SeedModel()
     {
-        _documentFile = Application.OpenDocumentFile($@"C:\Program Files\Autodesk\Revit {Application.VersionNumber}\Samples\rac_basic_sample_family.rfa");
+        _document = Application.NewProjectDocument(UnitSystem.Metric);
+
+        using var transaction = new Transaction(_document, "Seed model");
+        transaction.Start();
+
+        _exteriorWalls =
+        [
+            Wall.Create(_document, Line.CreateBound(new XYZ(0, 0, 0), new XYZ(10, 0, 0)), level.Id, false),
+            Wall.Create(_document, Line.CreateBound(new XYZ(10, 0, 0), new XYZ(10, 6, 0)), level.Id, false),
+            Wall.Create(_document, Line.CreateBound(new XYZ(10, 6, 0), new XYZ(0, 6, 0)), level.Id, false),
+            Wall.Create(_document, Line.CreateBound(new XYZ(0, 6, 0), new XYZ(0, 0, 0)), level.Id, false),
+        ];
+
+        transaction.Commit();
     }
 
-    [After(Class)]
+    [After(Test)]
     [HookExecutor<RevitThreadExecutor>]
-    public static void Cleanup()
+    public void CloseModel()
     {
-        _documentFile.Close(false);
+        _document.Close(false);
     }
 
     [Test]
     [TestExecutor<RevitThreadExecutor>]
-    public async Task FilteredElementCollector_ElementTypes_ValidAssignable()
+    public async Task FilteredElementCollector_ExteriorWalls_MatchSeededCount()
     {
-        var elements = new FilteredElementCollector(_documentFile)
-            .WhereElementIsElementType()
-            .ToElements();
-        
-        using (Assert.Multiple())
-        {
-            await Assert.That(elements).IsNotEmpty();
-            await Assert.That(elements).All().Satisfy(element => element.IsAssignableTo<ElementType>());
-        }
+        var walls = new FilteredElementCollector(_document)
+            .WhereElementIsNotElementType()
+            .OfClass(typeof(Wall))
+            .ToList();
+
+        await Assert.That(walls.Count).IsEqualTo(_exteriorWalls.Count);
     }
 
     [Test]
     [TestExecutor<RevitThreadExecutor>]
-    public async Task Delete_Dimensions_ElementsWithDependenciesDeleted()
+    public async Task Transaction_DemolishWall_RemainingWallCountDecreases()
     {
-        var elementIds = new FilteredElementCollector(_documentFile)
-            .WhereElementIsNotElementType()
-            .OfCategory(BuiltInCategory.OST_Dimensions)
-            .OfClass(typeof(RadialDimension))
-            .ToElementIds();
+        var targetId = _exteriorWalls[0].Id;
 
-        using var transaction = new Transaction(_documentFile);
-        transaction.Start("Delete dimensions");
-        var deletedElements = _documentFile.Delete(elementIds);
+        using var transaction = new Transaction(_document, "Demolish wall");
+        transaction.Start();
+        _document.Delete(targetId);
         transaction.Commit();
 
-        await Assert.That(deletedElements.Count).IsGreaterThanOrEqualTo(elementIds.Count);
+        var remainingWalls = new FilteredElementCollector(_document)
+            .WhereElementIsNotElementType()
+            .OfClass(typeof(Wall))
+            .ToElementIds();
+
+        await Assert.That(remainingWalls.Count).IsEqualTo(_exteriorWalls.Count - 1);
     }
 }
 ```
 
 > [!NOTE]
 > The examples demonstrate basic testing functionality. This library **only adds support for working within the Revit API context**. For comprehensive documentation on assertions, attributes, test configuration, and
 > advanced features, please refer to the official [TUnit documentation](https://thomhurst.github.io/TUnit/).
+
+More examples, including parametrized model and family tests, are available in the [test project](https://github.com/Nice3point/RevitUnit/tree/main/Nice3point.TUnit.Revit.Tests).
+
+## Test configuration
+
+### Global executor
+
+To avoid repeating the `TestExecutor` attribute for every test, you can [register](https://tunit.dev/docs/advanced/extension-points/#registering-a-test-executor) the executor globally using one of the following methods:
+
+- Add the attribute to any .cs file in your project (e.g., TestsConfiguration.cs):
+
+    ```csharp
+    using Nice3point.TUnit.Revit.Executors;
+    using TUnit.Core.Executors;
+    
+    [assembly: TestExecutor<RevitThreadExecutor>]
+    ```
+
+- Add the attribute directly to your .csproj file:
+
+    ```xml
+    <!-- Global Test Executor Registration -->
+    <ItemGroup>
+        <AssemblyAttribute Include="TUnit.Core.Executors.TestExecutorAttribute">
+            <_Parameter1>typeof(Nice3point.TUnit.Revit.Executors.RevitThreadExecutor)</_Parameter1>
+            <_Parameter1_IsLiteral>true</_Parameter1_IsLiteral>
+        </AssemblyAttribute>
+    </ItemGroup>
+    ```
+
+### Revit Environment
+
+TUnit initializes Revit with the `English - United States` language and the `C:\Program Files\Autodesk\Revit {version}` installation path. To override these defaults, use assembly-level attributes:
+
+- Add the attributes to any .cs file in your project (e.g., TestsConfiguration.cs):
+
+    ```csharp
+    using Nice3point.Revit.Injector.Attributes;
+    
+    [assembly: RevitLanguage("ENG")]
+    [assembly: RevitInstallationPath("D:\Autodesk\Revit Preview")]
+    ```
+
+- Add the attributes directly to your .csproj file:
+
+    ```xml
+    <!-- Revit Environment Configuration -->
+    <ItemGroup>
+        <AssemblyAttribute Include="Nice3point.Revit.Injector.Attributes.RevitLanguageAttribute">
+            <_Parameter1>ENG</_Parameter1>
+        </AssemblyAttribute>
+        <AssemblyAttribute Include="Nice3point.Revit.Injector.Attributes.RevitInstallationPathAttribute">
+            <_Parameter1>D:\Autodesk\Revit $(RevitVersion)</_Parameter1>
+        </AssemblyAttribute>
+    </ItemGroup>
+    ```
+
+The `RevitLanguage` attribute accepts a [language](https://help.autodesk.com/view/RVT/2026/ENU/?guid=GUID-BD09C1B4-5520-475D-BE7E-773642EEBD6C) name (e.g., "English - United States"), code (e.g., "ENU")
+or [LanguageType](https://www.revitapidocs.com/2026/dfda33cf-cbff-9fde-6672-38402e87510f.htm) enum value (e.g., "English_GB" or "15").