Merge pull request #438 from DataObjects-NET/7.0-exp-types-registration-imp

Tests infrastructure improvements - domain types' registration with cache

Author: alex-kulakov

Orm/Xtensive.Orm.Tests.Framework/AssemblyExtensions.cs

@@ -1,19 +1,151 @@
-// Copyright (C) 2018 Xtensive LLC.
+// Copyright (C) 2018-2025 Xtensive LLC.
 // All rights reserved.
 // For conditions of distribution and use, see license.
 // Created by: Alexey Kulakov
 // Created:    2018.08.31
 
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
 using System.Configuration;
+using System.Linq;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 
 namespace Xtensive.Orm.Tests
 {
   public static class AssemblyExtensions
   {
+    private const string MainTestAsseblyNsPrefix = "Xtensive.Orm.Tests.";
+    private const string IssuesNsPrefix = "Xtensive.Orm.Tests.Issues.";
+    private const string UpgradeNsPrefix = "Xtensive.Orm.Tests.Upgrade.";
+
+    private static readonly byte[] ThisAssemblyPkt = typeof(AssemblyExtensions).Assembly.GetName().GetPublicKeyToken();
+    
+    private static readonly ConcurrentDictionary<Assembly, Type[]> TypesPerAssembly = new();
+    private static readonly ConcurrentDictionary<char, int> MainTestsAssemblyNsAlphabeticIndex = new();
+    private static readonly ConcurrentDictionary<char, int> MainTestsAssemblyIssuesNsAlphabeticIndex = new();
+    private static readonly ConcurrentDictionary<char, int> MainTestsAssemblyUpgradeNsAlphabeticIndex = new();
+
     public static System.Configuration.Configuration GetAssemblyConfiguration(this Assembly assembly)
     {
       return ConfigurationManager.OpenExeConfiguration(assembly.Location);
     }
+
+    public static IReadOnlyList<Type> GetTypesFromNamespaceCaching(this Assembly assembly, string @namespace)
+    {
+      if (string.IsNullOrWhiteSpace(@namespace))
+        throw new ArgumentException("Namespace cannot be null, empty or contain only white spaces");
+
+      // These two dummy mentions are here to not forget to sync filtration algorithm here and in the classes,
+      // in particular BaseType property, if the property changed result type then this algorighm should be updated as well
+      _ = nameof(Xtensive.IoC.ServiceTypeRegistrationProcessor.BaseType);
+      _ = nameof(Xtensive.Orm.Configuration.DomainTypeRegistrationHandler.BaseType);
+
+      var assemblyNameInfo = assembly.GetName();
+      var isMainTestAssembly = assemblyNameInfo.Name == "Xtensive.Orm.Tests"
+        && !ThisAssemblyPkt.Except(assemblyNameInfo.GetPublicKeyToken()).Any();
+
+      var assemblyTypes = TypesPerAssembly.GetOrAdd(assembly, static (a, isMain) => {
+        var allTypes = a.GetTypes();
+
+        var objectType = typeof(object);
+        var list = new List<Type>(allTypes.Length);
+        var currentIndex = 0;
+        foreach (var t in allTypes) {
+          if (t.IsSubclassOf(objectType) && t.GetCustomAttribute<CompilerGeneratedAttribute>() == null) {
+            list.Add(t);
+            if (isMain) {
+              var nSpace = t.Namespace;
+              if (nSpace != null && nSpace.StartsWith(MainTestAsseblyNsPrefix, StringComparison.Ordinal)) {
+                var firstLetter = nSpace[MainTestAsseblyNsPrefix.Length];
+
+                _ = MainTestsAssemblyNsAlphabeticIndex.TryAdd(firstLetter, currentIndex);
+                if (firstLetter == 'I'/*ssue*/ && nSpace.StartsWith(IssuesNsPrefix, StringComparison.Ordinal)) {
+                  var firstIssuesLetter = nSpace[IssuesNsPrefix.Length];
+                  _ = MainTestsAssemblyIssuesNsAlphabeticIndex.TryAdd(firstIssuesLetter, currentIndex);
+                }
+                if (firstLetter == 'U'/*pdate*/ && nSpace.StartsWith(UpgradeNsPrefix, StringComparison.Ordinal)) {
+                  var firstIssuesLetter = nSpace[UpgradeNsPrefix.Length];
+                  _ = MainTestsAssemblyUpgradeNsAlphabeticIndex.TryAdd(firstIssuesLetter, currentIndex);
+                }
+              }
+            }
+            currentIndex++;
+          }
+        }
+        return list.ToArray();
+      }, isMainTestAssembly);
+
+      return FindSegment(assemblyTypes, @namespace, isMainTestAssembly);
+    }
+
+    private static IReadOnlyList<Type> FindSegment(Type[] types, string ns, bool isMainAssembly)
+    {
+      // We rely on the fact that types are sorted by full name.
+      // That opens an opportunity to optimize search of types from given
+      // namespace and subnamespaces.
+
+      const int windowSize = 6;
+
+      var searchFrom = GetSearchStartPosition(ns, isMainAssembly);
+
+      var nsWithDot = ns + ".";
+      var startSearchBoundary = FindFirstEntry(types, searchFrom, nsWithDot);
+
+      var endSearchBoundary = startSearchBoundary;
+      var lastItemIndex = types.Length - 1;
+
+      bool wrongNsFound;
+      do {
+        endSearchBoundary += windowSize;
+        if (endSearchBoundary > lastItemIndex)
+          endSearchBoundary = lastItemIndex;
+
+        var tail = types[endSearchBoundary];
+        wrongNsFound = tail.FullName.IndexOf(nsWithDot, StringComparison.InvariantCulture) < 0;
+      }
+      while (!wrongNsFound && endSearchBoundary < lastItemIndex);
+
+      for (var tailIndex = endSearchBoundary; tailIndex >= startSearchBoundary; tailIndex--) {
+        var tail = types[tailIndex];
+        endSearchBoundary = tailIndex;
+        if (tail.FullName.IndexOf(nsWithDot, StringComparison.InvariantCulture) >= 0) {
+          break;
+        }
+      }
+
+      return new ArraySegment<Type>(types, startSearchBoundary, endSearchBoundary - startSearchBoundary + 1);
+    }
+
+    private static int GetSearchStartPosition(string ns, bool isMainAssembly)
+    {
+      if (!isMainAssembly)
+        return 0;
+      if (ns.StartsWith(IssuesNsPrefix, StringComparison.Ordinal))
+        return MainTestsAssemblyIssuesNsAlphabeticIndex[ns[IssuesNsPrefix.Length]];
+      else if (ns.StartsWith(UpgradeNsPrefix, StringComparison.Ordinal))
+        return MainTestsAssemblyUpgradeNsAlphabeticIndex[ns[UpgradeNsPrefix.Length]];
+      else if (ns.StartsWith(MainTestAsseblyNsPrefix, StringComparison.Ordinal))
+        return MainTestsAssemblyNsAlphabeticIndex [ns[MainTestAsseblyNsPrefix.Length]];
+      return 0;
+    }
+
+    private static int FindFirstEntry(Type[] types, in int serachFrom, in string nsAndDot)
+    {
+      var firstEntryIndex = -1;
+
+      for (int headIndex = serachFrom, count = types.Length; headIndex < count; headIndex++) {
+        var head = types[headIndex];
+        if (head.FullName.IndexOf(nsAndDot, StringComparison.InvariantCulture) >= 0) {
+          firstEntryIndex = headIndex;
+          break;
+        }
+      }
+
+      if (firstEntryIndex == -1)
+        throw new Exception($"There is no any entry for given namespace.");
+      return firstEntryIndex;
+    }
   }
 }

Orm/Xtensive.Orm.Tests.Framework/TestHelper.cs

@@ -1,10 +1,11 @@
-// Copyright (C) 2008-2021 Xtensive LLC.
+// Copyright (C) 2008-2025 Xtensive LLC.
 // This code is distributed under MIT license terms.
 // See the License.txt file in the project root for more information.
 // Created by: Alex Yakunin
 // Created:    2008.02.09
 
 using System;
+using System.Reflection;
 using System.Threading;
 
 namespace Xtensive.Orm.Tests
@@ -82,5 +83,18 @@ public static DateTime FixDateTimeForProvider(this DateTime origin, StorageProvi
       var newTicks = ticks - (ticks % divider.Value);
       return new DateTime(newTicks);
     }
+
+    /// <summary>
+    /// Optimized Domain types registration of types from certain namespace.
+    /// </summary>
+    /// <param name="registry"><see cref="Configuration.DomainConfiguration.Types"/> registry</param>
+    /// <param name="assembly">Assembly which types should be registered</param>
+    /// <param name="namespace">Namespace within <paramref name="assembly"/>types should be registered.</param>
+    public static void RegisterCaching(this Xtensive.Orm.Configuration.DomainTypeRegistry registry, Assembly assembly, string @namespace)
+    {
+      foreach (var t in assembly.GetTypesFromNamespaceCaching(@namespace)) {
+        registry.Register(t);
+      }
+    }
   }
 }

Orm/Xtensive.Orm.Tests/Interfaces/DoubleIndexedInterfaceTest.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2011 Xtensive LLC.
+// Copyright (C) 2011 Xtensive LLC.
 // All rights reserved.
 // For conditions of distribution and use, see license.
 // Created by: Denis Krjuchkov
@@ -59,7 +59,7 @@ public class DoubleIndexedInterfaceTest : AutoBuildTest
     protected override DomainConfiguration BuildConfiguration()
     {
       var config = base.BuildConfiguration();
-      config.Types.Register(typeof (ITest).Assembly, typeof (ITest).Namespace);
+      config.Types.RegisterCaching(typeof (ITest).Assembly, typeof (ITest).Namespace);
       return config;
     }
 

Orm/Xtensive.Orm.Tests/Interfaces/InterfaceImplementationTest.cs

@@ -70,7 +70,7 @@ public class InterfaceImplementationTest
     public void CompsiteIndexTest()
     {
       var config = DomainConfigurationFactory.Create();
-      config.Types.Register(typeof(IHasName).Assembly, typeof(IHasName).Namespace);
+      config.Types.RegisterCaching(typeof(IHasName).Assembly, typeof(IHasName).Namespace);
       var domain = GetClassTableDomain(config);
       using (var session = domain.OpenSession())
       using (var t = session.OpenTransaction()) {
@@ -99,7 +99,7 @@ public void CombinedTest()
     public void InternalTest(Func<DomainConfiguration, Domain> generator)
     {
       var config = DomainConfigurationFactory.Create();
-      config.Types.Register(typeof(IHasName).Assembly, typeof(IHasName).Namespace);
+      config.Types.RegisterCaching(typeof(IHasName).Assembly, typeof(IHasName).Namespace);
       var domain = generator(config);
       using (var session = domain.OpenSession())
       using (var t = session.OpenTransaction()) {

Orm/Xtensive.Orm.Tests/Interfaces/InterfaceTest.cs

@@ -109,7 +109,7 @@ public class InterfaceTest : AutoBuildTest
     protected override DomainConfiguration BuildConfiguration()
     {
       var config = base.BuildConfiguration();
-      config.Types.Register(typeof (Person1).Assembly, typeof (Person1).Namespace);
+      config.Types.RegisterCaching(typeof (Person1).Assembly, typeof (Person1).Namespace);
       return config;
     }
 

Orm/Xtensive.Orm.Tests/Interfaces/KeyStructureConflictTest.cs

@@ -50,7 +50,7 @@ public class KeyStructureConflictTest : AutoBuildTest
     protected override DomainConfiguration BuildConfiguration()
     {
       var config = base.BuildConfiguration();
-      config.Types.Register(typeof (Root1).Assembly, typeof (Root1).Namespace);
+      config.Types.RegisterCaching(typeof (Root1).Assembly, typeof (Root1).Namespace);
       return config;
     }
 

Orm/Xtensive.Orm.Tests/Interfaces/TypeIdModeConflictTest.cs

@@ -39,7 +39,7 @@ public class TypeIdModeConflictTest : AutoBuildTest
     protected override DomainConfiguration BuildConfiguration()
     {
       var config = base.BuildConfiguration();
-      config.Types.Register(typeof (Root1).Assembly, typeof (Root1).Namespace);
+      config.Types.RegisterCaching(typeof (Root1).Assembly, typeof (Root1).Namespace);
       return config;
     }
 

Orm/Xtensive.Orm.Tests/Interfaces/UnusedTypeRemovalTest.cs

@@ -62,7 +62,7 @@ public void MainTest()
     protected override DomainConfiguration BuildConfiguration()
     {
       var config = base.BuildConfiguration();
-      config.Types.Register(typeof (IFirst).Assembly, typeof (IFirst).Namespace);
+      config.Types.RegisterCaching(typeof (IFirst).Assembly, typeof (IFirst).Namespace);
       return config;
     }
 

Orm/Xtensive.Orm.Tests/Issues/BatchingCommandProcessorFrenzy.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2012 Xtensive LLC.
+// Copyright (C) 2012 Xtensive LLC.
 // All rights reserved.
 // For conditions of distribution and use, see license.
 // Created by: Denis Krjuchkov
@@ -27,7 +27,7 @@ public class BatchingCommandProcessorFrenzy : AutoBuildTest
     protected override DomainConfiguration BuildConfiguration()
     {
       var configuration = base.BuildConfiguration();
-      configuration.Types.Register(typeof (FrenzyEntity).Assembly, typeof (FrenzyEntity).Namespace);
+      configuration.Types.RegisterCaching(typeof (FrenzyEntity).Assembly, typeof (FrenzyEntity).Namespace);
       return configuration;
     }
 

Orm/Xtensive.Orm.Tests/Issues/ClientProfileEntitySetTest.cs

@@ -1,4 +1,4 @@
-// Copyright (C) 2012 Xtensive LLC.
+// Copyright (C) 2012 Xtensive LLC.
 // All rights reserved.
 // For conditions of distribution and use, see license.
 // Created by: Denis Krjuchkov
@@ -48,7 +48,7 @@ public class ClientProfileEntitySetTest : AutoBuildTest
     protected override DomainConfiguration BuildConfiguration()
     {
       var configuration = base.BuildConfiguration();
-      configuration.Types.Register(typeof (Owner).Assembly, typeof (Owner).Namespace);
+      configuration.Types.RegisterCaching(typeof (Owner).Assembly, typeof (Owner).Namespace);
       configuration.Sessions.Default.Options = SessionOptions.ClientProfile;
       return configuration;
     }