Test framework: FixDateTimeForProvider() -> AdjustDateTimeForProvider()

and apply it to some tests

Author: alex-kulakov

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

@@ -50,36 +50,75 @@ public static System.Configuration.Configuration GetConfigurationForAssembly(thi
       return instanceOfTypeFromAssembly.GetType().Assembly.GetAssemblyConfiguration();
     }
 
+    /// <summary>
+    /// Cuts down resolution of <see cref="DateTime"/> value if needed, according to current <see cref="StorageProviderInfo.Instance"/>.
+    /// </summary>
+    /// <param name="origin">The value to adjust.</param>
+    /// <returns>New value with less resolution if the provider requires it, otherwise, untouched <paramref name="origin"/>.</returns>
+    public static DateTime AdjustDateTimeForCurrentProvider(this DateTime origin)
+    {
+      var provider = StorageProviderInfo.Instance;
+      return AdjustDateTimeForProvider(origin, provider);
+    }
+
     /// <summary>
     /// Cuts down resolution of <see cref="DateTime"/> value if needed.
     /// </summary>
     /// <param name="origin">The value to fix.</param>
     /// <param name="provider">Type of provider.</param>
     /// <returns>New value with less resolution if <paramref name="provider"/> requires it or untouched <paramref name="origin"/> if the provider doesn't</returns>
-    public static DateTime FixDateTimeForProvider(this DateTime origin, StorageProviderInfo providerInfo)
+    public static DateTime AdjustDateTimeForProvider(this DateTime origin, StorageProviderInfo providerInfo)
     {
-      long? divider;
       var provider = providerInfo.Provider;
       switch (provider) {
         case StorageProvider.MySql:
-          divider = providerInfo.Info.StorageVersion < StorageProviderVersion.MySql56 ? 10000000 : 10;
-          break;
+          return providerInfo.Info.StorageVersion < StorageProviderVersion.MySql56
+            ? AdjustDateTime(origin, 0)
+            : AdjustDateTime(origin, 6);
         case StorageProvider.Firebird:
-          divider = 1000;
-          break;
+          return AdjustDateTime(origin, 4);
         case StorageProvider.PostgreSql:
-          divider = 10;
-          break;
+          return AdjustDateTime(origin, 6);
+        case StorageProvider.Oracle:
+          return AdjustDateTime(origin, 7);
         default:
-          divider = null;
-          break;
+          return origin;
       }
+    }
 
-      if (!divider.HasValue) {
+    /// <summary>
+    /// Cuts down fractions of <see cref="DateTime"/> value (nanoseconds, milliseconds, etc) to desired value.
+    /// </summary>
+    /// <param name="origin"></param>
+    /// <param name="desiredFractions">Number of fractional points to keep (from 0 to 7).</param>
+    /// <param name="requireRound">Indicates whether value should be rounded after cutting off.</param>
+    /// <returns>Result value.</returns>
+    /// <exception cref="ArgumentOutOfRangeException">Valid fractions should be between 0 and 7 (7 included).</exception>
+    public static DateTime AdjustDateTime(this DateTime origin, byte desiredFractions, bool requireRound = false)
+    {
+      if (desiredFractions == 7) {
         return origin;
       }
+
+      const int baseDivider = 10_000_000; // no fractions
+      var currentDivider = baseDivider / (desiredFractions switch {
+        0 => 1,
+        1 => 10,
+        2 => 100,
+        3 => 1000,
+        4 => 10000,
+        5 => 100000,
+        6 => 1000000,
+        _ => throw new ArgumentOutOfRangeException(nameof(desiredFractions))
+      });
+
       var ticks = origin.Ticks;
-      var newTicks = ticks - (ticks % divider.Value);
+
+      var newTicks = requireRound
+        ? ((ticks % currentDivider) / (currentDivider / 10)) >= 5
+          ? ticks - (ticks % currentDivider) + currentDivider
+          : ticks - (ticks % currentDivider)
+        : ticks - (ticks % currentDivider);
       return new DateTime(newTicks);
     }
   }

Orm/Xtensive.Orm.Tests/Issues/IssueJira0593_AggregateForSingleColumnTest.cs

@@ -768,10 +768,10 @@ private static void CheckQueryable(IQueryable<TimeSpan?> query)
     private static void CheckQueryable(IQueryable<DateTime> query)
     {
       var localArray = query.ToArray();
-      Assert.AreEqual(localArray.Min().FixDateTimeForProvider(StorageProviderInfo.Instance), query.Min(c => c));
-      Assert.AreEqual(localArray.Min().FixDateTimeForProvider(StorageProviderInfo.Instance), query.Min());
-      Assert.AreEqual(localArray.Max().FixDateTimeForProvider(StorageProviderInfo.Instance), query.Max(c => c));
-      Assert.AreEqual(localArray.Max().FixDateTimeForProvider(StorageProviderInfo.Instance), query.Max());
+      Assert.AreEqual(localArray.Min().AdjustDateTimeForCurrentProvider(), query.Min(c => c));
+      Assert.AreEqual(localArray.Min().AdjustDateTimeForCurrentProvider(), query.Min());
+      Assert.AreEqual(localArray.Max().AdjustDateTimeForCurrentProvider(), query.Max(c => c));
+      Assert.AreEqual(localArray.Max().AdjustDateTimeForCurrentProvider(), query.Max());
       Assert.AreEqual(localArray.Count(), query.Count());
     }
 

Orm/Xtensive.Orm.Tests/Linq/DateTimeAndDateTimeOffset/DateTime/OperationsTest.cs

@@ -196,10 +196,10 @@ public void MysqlMinisDateTimeTest()
     {
       Require.ProviderIs(StorageProvider.MySql);
       ExecuteInsideSession(() => {
-        var firstDateTime = FirstDateTime.FixDateTimeForProvider(StorageProviderInfo.Instance);
-        var firstMillisecondDateTime = FirstMillisecondDateTime.FixDateTimeForProvider(StorageProviderInfo.Instance);
-        var secondDateTime = SecondDateTime.FixDateTimeForProvider(StorageProviderInfo.Instance);
-        var nullableDateTime = NullableDateTime.FixDateTimeForProvider(StorageProviderInfo.Instance);
+        var firstDateTime = FirstDateTime.AdjustDateTimeForCurrentProvider();
+        var firstMillisecondDateTime = FirstMillisecondDateTime.AdjustDateTimeForCurrentProvider();
+        var secondDateTime = SecondDateTime.AdjustDateTimeForCurrentProvider();
+        var nullableDateTime = NullableDateTime.AdjustDateTimeForCurrentProvider();
 
         RunTest<SingleDateTimeEntity>(c => c.DateTime - secondDateTime == firstDateTime - secondDateTime);
         RunTest<SingleDateTimeEntity>(c => c.MillisecondDateTime - secondDateTime == firstMillisecondDateTime - secondDateTime);

Orm/Xtensive.Orm.Tests/Linq/DateTimeAndDateTimeOffset/DateTime/PartsExtractionTest.cs

@@ -111,7 +111,7 @@ public void MysqlExtractMillisecondTest()
     {
       Require.ProviderIs(StorageProvider.MySql);
       ExecuteInsideSession(() => {
-        var firstMillisecondDateTime = FirstMillisecondDateTime.FixDateTimeForProvider(StorageProviderInfo.Instance);
+        var firstMillisecondDateTime = FirstMillisecondDateTime.AdjustDateTimeForProvider(StorageProviderInfo.Instance);
         RunTest<SingleDateTimeEntity>(c => c.MillisecondDateTime.Millisecond == firstMillisecondDateTime.Millisecond);
         RunWrongTest<SingleDateTimeEntity>(c => c.MillisecondDateTime.Second == WrongMillisecondDateTime.Millisecond);
       });
@@ -152,7 +152,7 @@ public void ExtractTimeOfDayTest()
     {
       ExecuteInsideSession(() => {
         RunTest<SingleDateTimeEntity>(c => c.DateTime.TimeOfDay == FirstDateTime.TimeOfDay);
-        RunTest<SingleDateTimeEntity>(c => c.MillisecondDateTime.TimeOfDay == FirstMillisecondDateTime.TimeOfDay);
+        RunTest<SingleDateTimeEntity>(c => c.MillisecondDateTime.TimeOfDay == FirstMillisecondDateTime.AdjustDateTimeForCurrentProvider().TimeOfDay);
         RunTest<SingleDateTimeEntity>(c => c.NullableDateTime.Value.TimeOfDay == NullableDateTime.TimeOfDay);
 
         RunWrongTest<SingleDateTimeEntity>(c => c.DateTime.TimeOfDay == WrongDateTime.TimeOfDay);