Enable Native AOT compatibility (trimming support)

This is a squashed merge of PR #1070.

MoreLinq.Test.Aot/MoreLinq.Test.Aot.csproj

@@ -0,0 +1,32 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+ <PropertyGroup>
+ <TargetFramework>net8.0</TargetFramework>
+ <OutputType>exe</OutputType>
+ <IsPackable>false</IsPackable>
+ <PublishAot>true</PublishAot>
+ </PropertyGroup>
+
+ <ItemGroup>
+ <PackageReference Include="MSTest.Engine" Version="1.0.0-alpha.24266.1" />
+ <PackageReference Include="MSTest.SourceGeneration" Version="1.0.0-alpha.24266.1" />
+ <PackageReference Include="Microsoft.CodeCoverage.MSBuild" Version="17.10.4" />
+ <PackageReference Include="Microsoft.Testing.Extensions.CodeCoverage" Version="17.10.4" />
+ <PackageReference Include="Microsoft.Testing.Extensions.TrxReport" Version="1.2.0" />
+ <PackageReference Include="Microsoft.Testing.Platform.MSBuild" Version="1.2.0" />
+ <PackageReference Include="MSTest.TestFramework" Version="3.3.1" />
+ <PackageReference Include="MSTest.Analyzers" Version="3.3.1">
+ <PrivateAssets>all</PrivateAssets>
+ <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+ </PackageReference>
+ </ItemGroup>
+
+ <ItemGroup>
+ <ProjectReference Include="..\MoreLinq\MoreLinq.csproj" />
+ </ItemGroup>
+
+ <ItemGroup>
+ <Using Include="Microsoft.VisualStudio.TestTools.UnitTesting" />
+ </ItemGroup>
+
+</Project>

MoreLinq.Test.Aot/ToDataTableTest.cs

@@ -0,0 +1,235 @@
+#region License and Terms
+// MoreLINQ - Extensions to LINQ to Objects
+// Copyright (c) 2024 Atif Aziz. All rights reserved.
+//
+// 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.
+#endregion
+
+namespace MoreLinq.Test
+{
+ using System;
+ using System.Collections;
+ using System.Collections.Generic;
+ using System.Data;
+ using System.Diagnostics.CodeAnalysis;
+ using System.Linq;
+ using System.Linq.Expressions;
+
+ [TestClass]
+ public class ToDataTableTest
+ {
+ sealed class TestObject(int key)
+ {
+ public int KeyField = key;
+ public Guid? ANullableGuidField = Guid.NewGuid();
+
+ public string AString { get; } = "ABCDEFGHIKKLMNOPQRSTUVWXYSZ";
+ public decimal? ANullableDecimal { get; } = key / 3;
+ public object Unreadable { set => throw new NotImplementedException(); }
+
+ public object this[int index] { get => new(); set { } }
+
+ public override string ToString() => nameof(TestObject);
+ }
+
+ readonly IReadOnlyCollection<TestObject> testObjects;
+
+ public ToDataTableTest() =>
+ this.testObjects = Enumerable.Range(0, 3)
+ .Select(i => new TestObject(i))
+ .ToArray();
+
+ [TestMethod]
+ public void ToDataTableNullMemberExpressionMethod()
+ {
+ Expression<Func<TestObject, object?>>? expression = null;
+
+ [UnconditionalSuppressMessage("Aot", "IL2026")]
+ void Act() => _ = this.testObjects.ToDataTable(expression!);
+
+ var e = Assert.ThrowsException<ArgumentException>(Act);
+ Assert.AreEqual("expressions", e.ParamName);
+ }
+
+ [TestMethod]
+ public void ToDataTableTableWithWrongColumnNames()
+ {
+ using var dt = new DataTable();
+ _ = dt.Columns.Add("Test");
+
+ [UnconditionalSuppressMessage("Aot", "IL2026")]
+ void Act() => _ = this.testObjects.ToDataTable(dt);
+
+ var e = Assert.ThrowsException<ArgumentException>(Act);
+ Assert.AreEqual("table", e.ParamName);
+ }
+
+ [TestMethod]
+ public void ToDataTableTableWithWrongColumnDataType()
+ {
+ using var dt = new DataTable();
+ _ = dt.Columns.Add("AString", typeof(int));
+
+ [UnconditionalSuppressMessage("Aot", "IL2026")]
+ void Act() => _ = this.testObjects.ToDataTable(dt, t => t.AString);
+
+ var e = Assert.ThrowsException<ArgumentException>(Act);
+ Assert.AreEqual("table", e.ParamName);
+ }
+
+ void TestDataTableMemberExpression(Expression<Func<TestObject, object?>> expression)
+ {
+ [UnconditionalSuppressMessage("Aot", "IL2026")]
+ void Act() => _ = this.testObjects.ToDataTable(expression);
+
+ var e = Assert.ThrowsException<ArgumentException>(Act);
+ Assert.AreEqual("expressions", e.ParamName);
+ var innerException = e.InnerException;
+ Assert.IsNotNull(innerException);
+ Assert.IsInstanceOfType<ArgumentException>(innerException);
+ Assert.AreEqual("lambda", ((ArgumentException)innerException).ParamName);
+ }
+
+ [TestMethod]
+ public void ToDataTableMemberExpressionMethod()
+ {
+ TestDataTableMemberExpression(t => t.ToString());
+ }
+
+ [TestMethod]
+ public void ToDataTableMemberExpressionNonMember()
+ {
+ TestDataTableMemberExpression(t => t.ToString().Length);
+ }
+
+ [TestMethod]
+ public void ToDataTableMemberExpressionIndexer()
+ {
+ TestDataTableMemberExpression(t => t[0]);
+ }
+
+ [TestMethod]
+ public void ToDataTableMemberExpressionStatic()
+ {
+ TestDataTableMemberExpression(_ => DateTime.Now);
+ }
+
+ [TestMethod]
+ public void ToDataTableSchemaInDeclarationOrder()
+ {
+ [UnconditionalSuppressMessage("Aot", "IL2026")]
+ DataTable Act() => this.testObjects.ToDataTable();
+
+ var dt = Act();
+
+ // Assert properties first, then fields, then in declaration order
+
+ Assert.AreEqual("KeyField", dt.Columns[2].Caption);
+ Assert.AreEqual(typeof(int), dt.Columns[2].DataType);
+
+ Assert.AreEqual("ANullableGuidField", dt.Columns[3].Caption);
+ Assert.AreEqual(typeof(Guid), dt.Columns[3].DataType);
+ Assert.IsTrue(dt.Columns[3].AllowDBNull);
+
+ Assert.AreEqual("AString", dt.Columns[0].Caption);
+ Assert.AreEqual(typeof(string), dt.Columns[0].DataType);
+
+ Assert.AreEqual("ANullableDecimal", dt.Columns[1].Caption);
+ Assert.AreEqual(typeof(decimal), dt.Columns[1].DataType);
+
+ Assert.AreEqual(4, dt.Columns.Count);
+ }
+
+ [TestMethod]
+ public void ToDataTableContainsAllElements()
+ {
+ [UnconditionalSuppressMessage("Aot", "IL2026")]
+ DataTable Act() => this.testObjects.ToDataTable();
+
+ var dt = Act();
+
+ Assert.AreEqual(this.testObjects.Count, dt.Rows.Count);
+ }
+
+ [TestMethod]
+ public void ToDataTableWithExpression()
+ {
+ [UnconditionalSuppressMessage("Aot", "IL2026")]
+ DataTable Act() => this.testObjects.ToDataTable(t => t.AString);
+
+ var dt = Act();
+
+ Assert.AreEqual("AString", dt.Columns[0].Caption);
+ Assert.AreEqual(typeof(string), dt.Columns[0].DataType);
+
+ Assert.AreEqual(1, dt.Columns.Count);
+ }
+
+ [TestMethod]
+ public void ToDataTableWithSchema()
+ {
+ using var dt = new DataTable();
+ var columns = dt.Columns;
+ _ = columns.Add("Column1", typeof(int));
+ _ = columns.Add("Value", typeof(string));
+ _ = columns.Add("Column3", typeof(int));
+ _ = columns.Add("Name", typeof(string));
+
+ var vars = Environment.GetEnvironmentVariables()
+ .Cast<DictionaryEntry>()
+ .ToArray();
+
+ [UnconditionalSuppressMessage("Aot", "IL2026")]
+ void Act() => _ = vars.Select(e => new { Name = e.Key.ToString(), Value = e.Value!.ToString() })
+ .ToDataTable(dt, e => e.Name, e => e.Value);
+
+ Act();
+
+ var rows = dt.Rows.Cast<DataRow>().ToArray();
+ Assert.AreEqual(vars.Length, rows.Length);
+ CollectionAssert.AreEqual(vars.Select(e => e.Key).ToArray(), rows.Select(r => r["Name"]).ToArray());
+ CollectionAssert.AreEqual(vars.Select(e => e.Value).ToArray(), rows.Select(r => r["Value"]).ToArray());
+ }
+
+ readonly struct Point(int x, int y)
+ {
+#pragma warning disable CA1805 // Do not initialize unnecessarily (avoids CS0649)
+ public static Point Empty = new();
+#pragma warning restore CA1805 // Do not initialize unnecessarily
+ public bool IsEmpty => X == 0 && Y == 0;
+ public int X { get; } = x;
+ public int Y { get; } = y;
+ }
+
+ [TestMethod]
+ public void ToDataTableIgnoresStaticMembers()
+ {
+ [UnconditionalSuppressMessage("Aot", "IL2026")]
+ static DataTable Act() => new[] { new Point(12, 34) }.ToDataTable();
+
+ var points = Act();
+
+ Assert.AreEqual(3, points.Columns.Count);
+ var x = points.Columns["X"];
+ var y = points.Columns["Y"];
+ var empty = points.Columns["IsEmpty"];
+ Assert.IsNotNull(x);
+ Assert.IsNotNull(y);
+ Assert.IsNotNull(empty);
+ var row = points.Rows.Cast<DataRow>().Single();
+ Assert.AreEqual(12, row[x]);
+ Assert.AreEqual(34, row[y]);
+ Assert.AreEqual(row[empty], false);
+ }
+ }
+}

MoreLinq.Test/Throws.cs

@@ -36,16 +36,19 @@ public static ExactTypeConstraint TypeOf<T>()
  NUnit.Framework.Throws.TypeOf<T>();
 
  public static EqualConstraint ArgumentException(string expectedParamName) =>
- NUnit.Framework.Throws.ArgumentException.With.ParamName().EqualTo(expectedParamName);
+ NUnit.Framework.Throws.ArgumentException.With.ParamName(expectedParamName);
 
  public static EqualConstraint ArgumentNullException(string expectedParamName) =>
- NUnit.Framework.Throws.ArgumentNullException.With.ParamName().EqualTo(expectedParamName);
+ NUnit.Framework.Throws.ArgumentNullException.With.ParamName(expectedParamName);
 
  public static ExactTypeConstraint ArgumentOutOfRangeException() =>
  TypeOf<ArgumentOutOfRangeException>();
 
  public static EqualConstraint ArgumentOutOfRangeException(string expectedParamName) =>
- ArgumentOutOfRangeException().With.ParamName().EqualTo(expectedParamName);
+ ArgumentOutOfRangeException().With.ParamName(expectedParamName);
+
+ public static EqualConstraint ParamName(this ConstraintExpression constraint, string expectedParamName) =>
+ constraint.ParamName().EqualTo(expectedParamName);
 
  static ResolvableConstraintExpression ParamName(this ConstraintExpression constraint) =>
  constraint.Property(nameof(System.ArgumentException.ParamName));

MoreLinq.Test/ToDataTableTest.cs

@@ -77,33 +77,35 @@ public void ToDataTableTableWithWrongColumnDataType()
  Throws.ArgumentException("table"));
  }
 
+ void TestDataTableMemberExpression(Expression<Func<TestObject, object?>> expression)
+ {
+ Assert.That(() => this.testObjects.ToDataTable(expression),
+ Throws.ArgumentException("expressions")
+ .And.InnerException.With.ParamName("lambda"));
+ }
+
  [Test]
  public void ToDataTableMemberExpressionMethod()
  {
- Assert.That(() => this.testObjects.ToDataTable(t => t.ToString()),
- Throws.ArgumentException("lambda"));
+ TestDataTableMemberExpression(t => t.ToString());
  }
 
-
  [Test]
  public void ToDataTableMemberExpressionNonMember()
  {
- Assert.That(() => this.testObjects.ToDataTable(t => t.ToString().Length),
- Throws.ArgumentException("lambda"));
+ TestDataTableMemberExpression(t => t.ToString().Length);
  }
 
  [Test]
  public void ToDataTableMemberExpressionIndexer()
  {
- Assert.That(() => this.testObjects.ToDataTable(t => t[0]),
- Throws.ArgumentException("lambda"));
+ TestDataTableMemberExpression(t => t[0]);
  }
 
  [Test]
  public void ToDataTableMemberExpressionStatic()
  {
- Assert.That(() => _ = this.testObjects.ToDataTable(_ => DateTime.Now),
- Throws.ArgumentException("lambda"));
+ TestDataTableMemberExpression(_ => DateTime.Now);
  }
 
  [Test]
@@ -113,19 +115,19 @@ public void ToDataTableSchemaInDeclarationOrder()
 
  // Assert properties first, then fields, then in declaration order
 
- Assert.That(dt.Columns[0].Caption, Is.EqualTo("AString"));
- Assert.That(dt.Columns[0].DataType, Is.EqualTo(typeof(string)));
-
- Assert.That(dt.Columns[1].Caption, Is.EqualTo("ANullableDecimal"));
- Assert.That(dt.Columns[1].DataType, Is.EqualTo(typeof(decimal)));
-
  Assert.That(dt.Columns[2].Caption, Is.EqualTo("KeyField"));
  Assert.That(dt.Columns[2].DataType, Is.EqualTo(typeof(int)));
 
  Assert.That(dt.Columns[3].Caption, Is.EqualTo("ANullableGuidField"));
  Assert.That(dt.Columns[3].DataType, Is.EqualTo(typeof(Guid)));
  Assert.That(dt.Columns[3].AllowDBNull, Is.True);
 
+ Assert.That(dt.Columns[0].Caption, Is.EqualTo("AString"));
+ Assert.That(dt.Columns[0].DataType, Is.EqualTo(typeof(string)));
+
+ Assert.That(dt.Columns[1].Caption, Is.EqualTo("ANullableDecimal"));
+ Assert.That(dt.Columns[1].DataType, Is.EqualTo(typeof(decimal)));
+
  Assert.That(dt.Columns.Count, Is.EqualTo(4));
  }
 

MoreLinq.sln

@@ -25,6 +25,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MoreLinq.Test", "MoreLinq.T
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MoreLinq.ExtensionsGenerator", "bld\ExtensionsGenerator\MoreLinq.ExtensionsGenerator.csproj", "{5FA8F0E8-648A-4C4F-B1BB-B0C46959A36E}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MoreLinq.Test.Aot", "MoreLinq.Test.Aot\MoreLinq.Test.Aot.csproj", "{776973A3-AC2E-423E-8106-B4E296CE7752}"
+EndProject
 Global
  GlobalSection(SolutionConfigurationPlatforms) = preSolution
  Debug|Any CPU = Debug|Any CPU
@@ -43,6 +45,10 @@ Global
  {5FA8F0E8-648A-4C4F-B1BB-B0C46959A36E}.Debug|Any CPU.Build.0 = Debug|Any CPU
  {5FA8F0E8-648A-4C4F-B1BB-B0C46959A36E}.Release|Any CPU.ActiveCfg = Release|Any CPU
  {5FA8F0E8-648A-4C4F-B1BB-B0C46959A36E}.Release|Any CPU.Build.0 = Release|Any CPU
+ {776973A3-AC2E-423E-8106-B4E296CE7752}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+ {776973A3-AC2E-423E-8106-B4E296CE7752}.Debug|Any CPU.Build.0 = Debug|Any CPU
+ {776973A3-AC2E-423E-8106-B4E296CE7752}.Release|Any CPU.ActiveCfg = Release|Any CPU
+ {776973A3-AC2E-423E-8106-B4E296CE7752}.Release|Any CPU.Build.0 = Release|Any CPU
  EndGlobalSection
  GlobalSection(SolutionProperties) = preSolution
  HideSolutionNode = FALSE