DateTime/DateOnly/TimeOnly ctor usage within LINQ tests

Author: alex-kulakov

Orm/Xtensive.Orm.Tests/Linq/DateTimeAndDateTimeOffset/DateOnly/ConstructorTest.cs

@@ -0,0 +1,29 @@
+// Copyright (C) 2023 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+
+#if NET6_0_OR_GREATER //DO_DATEONLY
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using Xtensive.Core;
+using Xtensive.Orm.Tests.Linq.DateTimeAndDateTimeOffset.Model;
+
+namespace Xtensive.Orm.Tests.Linq.DateTimeAndDateTimeOffset.DateOnlys
+{
+  public class ConstructorTest : DateTimeBaseTest
+  {
+    [Test]
+    public void CtorYMD()
+    {
+      ExecuteInsideSession((s) => {
+        var result = s.Query.All<AllPossiblePartsEntity>()
+          .Select(e => new { Entity = e, ConstructedDate = new DateOnly(e.Year, e.Month, e.Day) })
+          .Where(a => a.ConstructedDate == FirstDateOnly).OrderBy(a => a.Entity.Id).ToList(3);
+        Assert.That(result.Count, Is.EqualTo(1));
+      });
+    }
+  }
+}
+#endif

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

@@ -0,0 +1,53 @@
+// Copyright (C) 2023 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using Xtensive.Core;
+using Xtensive.Orm.Tests.Linq.DateTimeAndDateTimeOffset.Model;
+
+namespace Xtensive.Orm.Tests.Linq.DateTimeAndDateTimeOffset.DateTimes
+{
+  public class ConstructorTest : DateTimeBaseTest
+  {
+    [Test]
+    public void CtorYMDHMSM()
+    {
+      ExecuteInsideSession((s) => {
+        var result = s.Query.All<AllPossiblePartsEntity>()
+          .Select(e => new {
+            Entity = e,
+            ConstructedDate = new DateTime(e.Year, e.Month, e.Day, e.Hour, e.Minute, e.Second, e.Millisecond) })
+          .Where(a => a.ConstructedDate == FirstMillisecondDateTime).OrderBy(a => a.Entity.Id).ToList(3);
+        Assert.That(result.Count, Is.EqualTo(1));
+      });
+    }
+
+    [Test]
+    public void CtorYMDHMS()
+    {
+      ExecuteInsideSession((s) => {
+        var result = s.Query.All<AllPossiblePartsEntity>()
+          .Select(e => new {
+            Entity = e,
+            ConstructedDate = new DateTime(e.Year, e.Month, e.Day, e.Hour, e.Minute, e.Second)
+          })
+          .Where(a => a.ConstructedDate == FirstDateTime).OrderBy(a => a.Entity.Id).ToList(3);
+        Assert.That(result.Count, Is.EqualTo(1));
+      });
+    }
+
+    [Test]
+    public void CtorYMD()
+    {
+      ExecuteInsideSession((s) => {
+        var result = s.Query.All<AllPossiblePartsEntity>()
+          .Select(e => new { Entity = e, ConstructedDate = new DateTime(e.Year, e.Month, e.Day) })
+          .Where(a => a.ConstructedDate == FirstDateTime.Date).OrderBy(a => a.Entity.Id).ToList(3);
+        Assert.That(result.Count, Is.EqualTo(1));
+      });
+    }
+  }
+}

Orm/Xtensive.Orm.Tests/Linq/DateTimeAndDateTimeOffset/DateTimeBaseTest.cs

@@ -47,6 +47,7 @@ protected override void RegisterTypes(DomainConfiguration configuration)
       configuration.Types.Register(typeof(DateTimeEntity));
       configuration.Types.Register(typeof(MillisecondDateTimeEntity));
       configuration.Types.Register(typeof(NullableDateTimeEntity));
+      configuration.Types.Register(typeof(AllPossiblePartsEntity));
 #if NET6_0_OR_GREATER
       configuration.Types.Register(typeof(DateOnlyEntity));
       configuration.Types.Register(typeof(SingleDateOnlyEntity));
@@ -202,6 +203,8 @@ protected override void PopulateEntities(Session session)
 
       _ = new NullableDateTimeEntity(session) { DateTime = null };
       _ = new NullableDateTimeEntity(session) { DateTime = null };
+
+      _ = AllPossiblePartsEntity.FromDateTime(session, FirstMillisecondDateTime, 321);
     }
   }
 }

Orm/Xtensive.Orm.Tests/Linq/DateTimeAndDateTimeOffset/Model.cs

@@ -5,6 +5,8 @@
 // Created:    2016.08.01
 
 using System;
+using System.Net.Sockets;
+using Org.BouncyCastle.Crypto.Digests;
 
 namespace Xtensive.Orm.Tests.Linq.DateTimeAndDateTimeOffset.Model
 {
@@ -153,6 +155,95 @@ public NullableDateTimeOffsetEntity(DateTimeOffsetEntity dateTimeOffsetEntity)
   }
 
 
+  [HierarchyRoot]
+  public class AllPossiblePartsEntity : Entity
+  {
+    [Field, Key]
+    public long Id { get; private set; }
+
+    [Field]
+    [Validation.RangeConstraint(Min = 0, Max = 3000)]
+    public int Year { get; set; }
+
+    [Field]
+    [Validation.RangeConstraint(Min = 1, Max = 12)]
+    public int Month { get; set; }
+
+    [Field]
+    [Validation.RangeConstraint(Min = 1, Max = 31)]
+    public int Day { get; set; }
+
+    [Field]
+    [Validation.RangeConstraint(Min = 0, Max = 23)]
+    public int Hour { get; set; }
+
+    [Field]
+    [Validation.RangeConstraint(Min = 0, Max = 59)]
+    public int Minute { get; set; }
+
+    [Field]
+    [Validation.RangeConstraint(Min = 0, Max = 59)]
+    public int Second { get; set; }
+
+    [Field]
+    [Validation.RangeConstraint(Min = 0, Max = 999)]
+    public int Millisecond { get; set; }
+
+    [Field]
+    [Validation.RangeConstraint(Min = 0, Max = 999)]
+    public int Microsecond { get; set; }
+
+    [Field]
+    public long Ticks { get; set; }
+
+    [Field]
+    [Validation.RangeConstraint(Min = -23, Max = 23)]
+    public int OffsetHour { get; set; }
+
+    [Field]
+    [Validation.RangeConstraint(Min = 0, Max = 59)]
+    public int OffsetMinute { get; set; }
+
+    public static AllPossiblePartsEntity FromDateTime(Session session, DateTime dateTime, int microsecond)
+    {
+      return new AllPossiblePartsEntity(session) {
+        Year = dateTime.Year,
+        Month = dateTime.Month,
+        Day = dateTime.Day,
+        Hour = dateTime.Hour,
+        Minute = dateTime.Minute,
+        Second = dateTime.Second,
+        Millisecond = dateTime.Millisecond,
+        Microsecond = microsecond,
+        OffsetHour = 0,
+        OffsetMinute = 0,
+        Ticks = dateTime.Ticks
+      };
+    }
+
+    public static AllPossiblePartsEntity FromDateTimeOffset(Session session, DateTimeOffset dateTimeOffset, int microsecond)
+    {
+      return new AllPossiblePartsEntity(session) {
+        Year = dateTimeOffset.Year,
+        Month = dateTimeOffset.Month,
+        Day = dateTimeOffset.Day,
+        Hour = dateTimeOffset.Hour,
+        Minute = dateTimeOffset.Minute,
+        Second = dateTimeOffset.Second,
+        Millisecond = dateTimeOffset.Millisecond,
+        Microsecond = microsecond,
+        OffsetHour = dateTimeOffset.Offset.Hours,
+        OffsetMinute = dateTimeOffset.Offset.Minutes,
+        Ticks = dateTimeOffset.Ticks
+      };
+    }
+
+    private AllPossiblePartsEntity(Session session)
+      : base(session)
+    {
+    }
+  }
+
 #if NET6_0_OR_GREATER //DO_DATEONLY
   [HierarchyRoot]
   public class DateOnlyEntity : Entity

Orm/Xtensive.Orm.Tests/Linq/DateTimeAndDateTimeOffset/TimeOnly/ConstructorTest.cs

@@ -0,0 +1,57 @@
+// Copyright (C) 2023 Xtensive LLC.
+// This code is distributed under MIT license terms.
+// See the License.txt file in the project root for more information.
+
+#if NET6_0_OR_GREATER //DO_DATEONLY
+
+using System;
+using System.Linq;
+using NUnit.Framework;
+using Xtensive.Core;
+using Xtensive.Orm.Tests.Linq.DateTimeAndDateTimeOffset.Model;
+
+namespace Xtensive.Orm.Tests.Linq.DateTimeAndDateTimeOffset.TimeOnlys
+{
+  public class ConstructorTest : DateTimeBaseTest
+  {
+    [Test]
+    public void CtorHMSM()
+    {
+      ExecuteInsideSession((s) => {
+        var result = s.Query.All<AllPossiblePartsEntity>()
+          .Select(e => new {
+            Entity = e,
+            ConstructedTime = new TimeOnly(e.Hour, e.Minute, e.Second, e.Millisecond) })
+          .Where(a => a.ConstructedTime == FirstMillisecondTimeOnly).OrderBy(a => a.Entity.Id).ToList(3);
+        Assert.That(result.Count, Is.EqualTo(1));
+      });
+    }
+
+    [Test]
+    public void CtorHMS()
+    {
+      ExecuteInsideSession((s) => {
+        var result = s.Query.All<AllPossiblePartsEntity>()
+          .Select(e => new {
+            Entity = e,
+            ConstructedTime = new TimeOnly(e.Hour, e.Minute, e.Second)
+          })
+          .Where(a => a.ConstructedTime == FirstTimeOnly).OrderBy(a => a.Entity.Id).ToList(3);
+        Assert.That(result.Count, Is.EqualTo(1));
+      });
+    }
+
+    [Test]
+    public void CtorHM()
+    {
+      ExecuteInsideSession((s) => {
+        var result = s.Query.All<AllPossiblePartsEntity>()
+          .Select(e => new { Entity = e, ConstructedTime = new TimeOnly(e.Hour, e.Minute) })
+          .Where(a => a.ConstructedTime == FirstTimeOnly.Add(TimeSpan.FromSeconds(-5)))
+          .OrderBy(a => a.Entity.Id).ToList(3);
+        Assert.That(result.Count, Is.EqualTo(1));
+      });
+    }
+  }
+}
+#endif

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

@@ -40,7 +40,7 @@ public void AddMinutesTest()
       });
     }
 
-    [Test]
+    [Test, Ignore("Compiler's not implemented yet")]
     public void AddTimeSpanTest()
     {
       ExecuteInsideSession((s) => {