text
stringlengths 9
39.2M
| dir
stringlengths 25
226
| lang
stringclasses 163
values | created_date
timestamp[s] | updated_date
timestamp[s] | repo_name
stringclasses 751
values | repo_full_name
stringclasses 752
values | star
int64 1.01k
183k
| len_tokens
int64 1
18.5M
|
|---|---|---|---|---|---|---|---|---|
```smalltalk
#if EFCORE
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.DynamicLinq;
#else
using System.Data.Entity;
using EntityFramework.DynamicLinq;
#endif
using System.Threading.Tasks;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests;
public partial class EntitiesTests
{
[Fact]
public async Task Entities_AnyAsync()
{
// Arrange
var expectedQueryable1 = _context.Blogs.Where(b => b.BlogId > 0);
bool expectedAny1 = await expectedQueryable1.AnyAsync();
var expectedQueryable2 = _context.Blogs.Where(b => b.BlogId > 9999);
bool expectedAny2 = await expectedQueryable2.AnyAsync();
// Act
IQueryable queryable1 = _context.Blogs.Where("BlogId > 0");
bool any1 = await queryable1.AnyAsync();
IQueryable queryable2 = _context.Blogs.Where("BlogId > 9999");
bool any2 = await queryable2.AnyAsync();
// Assert
Assert.Equal(expectedAny1, any1);
Assert.Equal(expectedAny2, any2);
}
[Fact]
public async Task Entities_AnyAsync_Predicate()
{
// Arrange
#if EFCORE
bool expectedAny1 = await Microsoft.EntityFrameworkCore.EntityFrameworkQueryableExtensions.AnyAsync(_context.Blogs, b => b.BlogId > 0);
bool expectedAny2 = await Microsoft.EntityFrameworkCore.EntityFrameworkQueryableExtensions.AnyAsync(_context.Blogs, b => b.BlogId > 9999);
#else
bool expectedAny1 = await System.Data.Entity.QueryableExtensions.AnyAsync(_context.Blogs, b => b.BlogId > 0);
bool expectedAny2 = await System.Data.Entity.QueryableExtensions.AnyAsync(_context.Blogs, b => b.BlogId > 9999);
#endif
// Act
bool any1 = await _context.Blogs.AsQueryable().AnyAsync("it.BlogId > 0");
bool any2 = await _context.Blogs.AsQueryable().AnyAsync("it.BlogId > 9999");
// Assert
Assert.Equal(expectedAny1, any1);
Assert.Equal(expectedAny2, any2);
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/EntitiesTests.AnyAsync.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 464
|
```smalltalk
using System.Collections.Generic;
using FluentAssertions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests;
public partial class QueryableTests
{
public class DataRecord
{
public List<Dictionary<string, string>> ListOfDictionaries { get; }
public Dictionary<string, string> FirstDict { get; }
public List<string> ListOfKeys { get; }
public DataRecord(List<Dictionary<string, string>> listOfDictionaries, Dictionary<string, string> firstDict, List<string> listOfKeys)
{
ListOfDictionaries = listOfDictionaries;
FirstDict = firstDict;
ListOfKeys = listOfKeys;
}
}
// #793
[Theory]
[InlineData("FirstDict.ContainsKey(\"test\")")]
[InlineData("ListOfKeys.Any(x => x.Contains(\"test\"))")]
[InlineData("ListOfDictionaries.Any(it.ContainsKey(\"test\"))")]
[InlineData("ListOfDictionaries.Any(ContainsKey(\"test\"))")]
[InlineData("ListOfDictionaries.Any(x => x.ContainsKey(\"test\"))")]
[InlineData("ListOfDictionaries.Any(x => x.ContainsKey(\"te\" + \"st\"))")]
public void ContainsKey_Dynamic(string expression)
{
// Arrange
var dataList = new List<Dictionary<string, string>>
{
new()
{
["test"] = "value1"
},
new()
{
["otherKey"] = "value2"
},
new()
{
["test"] = "value3"
},
};
var data = new DataRecord(dataList, dataList[0], dataList.SelectMany(d => d.Keys).ToList());
var queryableDataRecord = new[] { data }.AsQueryable();
// Act
var result = queryableDataRecord.Any(expression);
// Assert
result.Should().BeTrue();
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.ContainsKey.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 392
|
```smalltalk
using System.Collections.Generic;
using NFluent;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
[Fact]
public void GroupByMany_Dynamic_LambdaExpressions()
{
var lst = new List<Tuple<int, int, int>>
{
new Tuple<int, int, int>(1, 1, 1),
new Tuple<int, int, int>(1, 1, 2),
new Tuple<int, int, int>(1, 1, 3),
new Tuple<int, int, int>(2, 2, 4),
new Tuple<int, int, int>(2, 2, 5),
new Tuple<int, int, int>(2, 2, 6),
new Tuple<int, int, int>(2, 3, 7)
};
var sel = lst.AsQueryable().GroupByMany(x => x.Item1, x => x.Item2);
Assert.Equal(2, sel.Count());
Assert.Single(sel.First().Subgroups);
Assert.Equal(2, sel.Skip(1).First().Subgroups.Count());
}
[Fact]
public void GroupByMany_Dynamic_StringExpressions()
{
var lst = new List<Tuple<int, int, int>>
{
new Tuple<int, int, int>(1, 1, 1),
new Tuple<int, int, int>(1, 1, 2),
new Tuple<int, int, int>(1, 1, 3),
new Tuple<int, int, int>(2, 2, 4),
new Tuple<int, int, int>(2, 2, 5),
new Tuple<int, int, int>(2, 2, 6),
new Tuple<int, int, int>(2, 3, 7)
};
var sel = lst.AsQueryable().GroupByMany("Item1", "Item2").ToList();
Check.That(sel.Count).Equals(2);
var firstGroupResult = sel.First();
Check.That(firstGroupResult.ToString()).Equals("1 (3)");
Check.That(firstGroupResult.Subgroups.Count()).Equals(1);
var skippedGroupResult = sel.Skip(1).First();
Check.That(skippedGroupResult.ToString()).Equals("2 (4)");
Check.That(skippedGroupResult.Subgroups.Count()).Equals(2);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.GroupByMany.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 515
|
```smalltalk
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
[Fact]
public void Count()
{
//Arrange
IQueryable testListFull = User.GenerateSampleModels(100).AsQueryable();
IQueryable testListOne = User.GenerateSampleModels(1).AsQueryable();
IQueryable testListNone = User.GenerateSampleModels(0).AsQueryable();
//Act
var resultFull = testListFull.Count();
var resultOne = testListOne.Count();
var resultNone = testListNone.Count();
//Assert
Assert.Equal(100, resultFull);
Assert.Equal(1, resultOne);
Assert.Equal(0, resultNone);
}
[Fact]
public void Count_Predicate()
{
//Arrange
var queryable = User.GenerateSampleModels(100).AsQueryable();
//Act
int expected = queryable.Count(u => u.Income > 50);
int result = queryable.Count("Income > 50");
//Assert
Assert.Equal(expected, result);
}
[Fact]
public void Count_Predicate_WithArgs()
{
const int value = 50;
//Arrange
var queryable = User.GenerateSampleModels(100).AsQueryable();
//Act
int expected = queryable.Count(u => u.Income > value);
int result = queryable.Count("Income > @0", value);
//Assert
Assert.Equal(expected, result);
}
[Fact]
public void Count_Dynamic_Select()
{
// Arrange
IQueryable<User> queryable = User.GenerateSampleModels(1).AsQueryable();
// Act
var expected = queryable.Select(x => x.Roles.Count()).ToArray();
var result = queryable.Select("Roles.Count()").ToDynamicArray<int>();
// Assert
Assert.Equal(expected, result);
}
[Fact]
public void Count_Dynamic_Where()
{
const string search = "e";
// Arrange
var testList = User.GenerateSampleModels(10);
var queryable = testList.AsQueryable();
// Act
var expected = queryable.Where(u => u.Roles.Count(r => r.Name.Contains(search)) > 0).ToArray();
var result = queryable.Where("Roles.Count(Name.Contains(@0)) > 0", search).ToArray();
Assert.Equal(expected, result);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Count.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 526
|
```smalltalk
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
[Fact]
public void Min()
{
// Arrange
var incomes = User.GenerateSampleModels(100).Select(u => u.Income);
// Act
var expected = incomes.Min();
var actual = incomes.AsQueryable().Min();
// Assert
Assert.Equal(expected, actual);
}
[Fact]
public void Min_Selector()
{
// Arrange
var users = User.GenerateSampleModels(100);
// Act
var expected = users.Min(u => u.Income);
var result = users.AsQueryable().Min("Income");
// Assert
Assert.Equal(expected, result);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Min.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 170
|
```smalltalk
using System.Collections.Generic;
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
[Fact]
public void All_Predicate()
{
//Arrange
var queryable = User.GenerateSampleModels(100).AsQueryable();
//Act
bool expected = queryable.All(u => u.Income > 50);
bool result = queryable.All("Income > 50");
//Assert
Assert.Equal(expected, result);
}
[Fact]
public void All_Predicate_WithArgs()
{
const int value = 50;
//Arrange
var queryable = User.GenerateSampleModels(100).AsQueryable();
//Act
bool expected = queryable.All(u => u.Income > value);
bool result = queryable.All("Income > @0", value);
//Assert
Assert.Equal(expected, result);
}
[Fact]
public void All_Dynamic_Select()
{
// Arrange
IQueryable<User> queryable = User.GenerateSampleModels(1).AsQueryable();
// Act
var expected = queryable.Select(x => x.Roles.All(r => r.Name != null)).ToArray();
var result = queryable.Select("Roles.All(Name != null)").ToDynamicArray<bool>();
// Assert
Assert.Equal(expected, result);
}
[Fact]
public void All_Dynamic_Where()
{
const string search = "e";
// Arrange
var testList = User.GenerateSampleModels(10);
var queryable = testList.AsQueryable();
// Act
var expected = queryable.Where(u => u.Roles.All(r => r.Name.Contains(search))).ToArray();
var result = queryable.Where("Roles.All(Name.Contains(@0))", search).ToArray();
Assert.Equal(expected, result);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.All.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 402
|
```smalltalk
using System.Collections.Generic;
using FluentAssertions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
[Fact]
public void Union_Dynamic_ListOfStrings()
{
// Arrange
var list1 = new List<bool> { true };
var list2 = new List<string> { "User3", "User4" };
var list3 = new List<string> { "User3", "User6", "User7" };
// Act
var testQuery = list1.AsQueryable().Select("@0.Union(@1).ToList()", list2, list3);
// Assert
var result = testQuery.ToDynamicArray<List<string>>();
result.First().Should().BeEquivalentTo(list2.Union(list3));
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Union.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 172
|
```smalltalk
using System.Linq.Dynamic.Core.Exceptions;
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using NFluent;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public class OperatorTests
{
[Fact]
public void Operator_NullPropagation()
{
// Arrange
var users = new[]
{
new User { Income = 1, Profile = new UserProfile { FirstName = "F1" } },
new User { Income = 2, Profile = new UserProfile { FirstName = "F2" } },
new User { Income = 3, Profile = null }
}.AsQueryable();
// Act
Check.ThatCode(() => users.Select("Profile?.Age")).Throws<NotSupportedException>();
}
[Fact]
public void Operator_Multiplication_Single_Float_ParseException()
{
//Arrange
var models = new[] { new SimpleValuesModel() }.AsQueryable();
//Act + Assert
Assert.Throws<ParseException>(() => models.Select("FloatValue * DecimalValue"));
}
[Fact]
public void Operator_Multiplication_Single_Float_Cast()
{
//Arrange
var models = new[] { new SimpleValuesModel { FloatValue = 2, DecimalValue = 3 } }.AsQueryable();
//Act
var result = models.Select("Decimal(FloatValue) * DecimalValue").First();
//Assert
Assert.Equal(6.0m, result);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/OperatorTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 306
|
```smalltalk
using System.Collections.Generic;
using System.Linq.Dynamic.Core.CustomTypeProviders;
using Moq;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests;
public partial class QueryableTests
{
[Fact]
public void CallMethod()
{
// Arrange
var customTypeProvider = new Mock<IDynamicLinkCustomTypeProvider>();
customTypeProvider.Setup(c => c.GetCustomTypes()).Returns(new HashSet<Type> { typeof(Test) });
var config = new ParsingConfig
{
CustomTypeProvider = customTypeProvider.Object
};
var query = new[] { new Test() }.AsQueryable();
// Act
var result = query.Select<decimal>(config, "t => t.GetDecimal()").First();
// Assert
Assert.Equal(42, result);
}
[Fact]
public void CallMethodWhichReturnsNullable()
{
// Arrange
var customTypeProvider = new Mock<IDynamicLinkCustomTypeProvider>();
customTypeProvider.Setup(c => c.GetCustomTypes()).Returns(new HashSet<Type> { typeof(Test) });
var config = new ParsingConfig
{
CustomTypeProvider = customTypeProvider.Object
};
var query = new[] { new Test() }.AsQueryable();
// Act
var result = query.Select<decimal?>(config, "t => t.GetNullableDecimal()").First();
// Assert
Assert.Equal(null, result);
}
[Fact]
public void CallMethodWhichReturnsNullable_WithValue()
{
// Arrange
var customTypeProvider = new Mock<IDynamicLinkCustomTypeProvider>();
customTypeProvider.Setup(c => c.GetCustomTypes()).Returns(new HashSet<Type> { typeof(Test) });
var config = new ParsingConfig
{
CustomTypeProvider = customTypeProvider.Object
};
var query = new[] { new Test() }.AsQueryable();
// Act
var result = query.Select<decimal?>(config, "t => t.GetNullableDecimalWithValue()").First();
// Assert
Assert.Equal(100, result);
}
}
class Test
{
public decimal GetDecimal()
{
return 42;
}
public decimal? GetNullableDecimal()
{
return null;
}
public decimal? GetNullableDecimalWithValue()
{
return 100;
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Methods.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 485
|
```smalltalk
using System.Collections;
using System.Collections.Generic;
using System.Linq.Dynamic.Core.Exceptions;
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
public class IntComparerT : IComparer<int>
{
public int Compare(int x, int y)
{
return new CaseInsensitiveComparer().Compare(y, x);
}
}
public class StringComparerT : IComparer<string>
{
public int Compare(string x, string y)
{
return new CaseInsensitiveComparer().Compare(y, x);
}
}
public class ObjectComparer : IComparer
{
public int Compare(object x, object y)
{
return new CaseInsensitiveComparer().Compare(y, x);
}
}
[Fact]
public void OrderBy_Dynamic_IComparer_StringComparer()
{
// Arrange
var testList = User.GenerateSampleModels(2);
var qry = testList.AsQueryable();
// Act
var orderBy = testList.OrderBy(x => x.UserName, StringComparer.OrdinalIgnoreCase).ToArray();
var orderByDynamic = qry.OrderBy("UserName", StringComparer.OrdinalIgnoreCase).ToArray();
// Assert
Assert.Equal(orderBy, orderByDynamic);
}
[Fact]
public void OrderBy_Dynamic_IComparer_ObjectComparer_Int()
{
// Arrange
var testList = User.GenerateSampleModels(3);
var qry = testList.AsQueryable();
// Act
var orderBy = testList.OrderBy(x => x.Income, new IntComparerT()).ToArray();
var orderByDynamic = qry.OrderBy("Income", new ObjectComparer()).ToArray();
// Assert
Assert.Equal(orderBy, orderByDynamic);
}
[Fact]
public void OrderBy_Dynamic_IComparer_ObjectComparer_String()
{
// Arrange
var testList = User.GenerateSampleModels(3);
var qry = testList.AsQueryable();
// Act
var orderBy = testList.OrderBy(x => x.UserName, new StringComparerT()).ToArray();
var orderByDynamic = qry.OrderBy("UserName", new ObjectComparer()).ToArray();
// Assert
Assert.Equal(orderBy, orderByDynamic);
}
[Fact]
public void OrderBy_Dynamic_IComparer_IntComparerT()
{
// Arrange
var testList = User.GenerateSampleModels(3);
var qry = testList.AsQueryable();
// Act
var orderBy = testList.OrderBy(x => x.Income, new IntComparerT()).ToArray();
var orderByDynamic = qry.OrderBy("Income", new IntComparerT()).ToArray();
// Assert
Assert.Equal(orderBy, orderByDynamic);
}
[Fact]
public void OrderBy_Dynamic_IComparer_IntComparerT_Asc()
{
// Arrange
var testList = User.GenerateSampleModels(2);
var qry = testList.AsQueryable();
// Act
var orderBy = testList.OrderBy(x => x.Income, new IntComparerT()).ToArray();
var orderByDynamic = qry.OrderBy("Income asc", new IntComparerT()).ToArray();
// Assert
Assert.Equal(orderBy, orderByDynamic);
}
[Fact]
public void OrderBy_Dynamic_IComparer_IntComparerT_Desc()
{
// Arrange
var testList = User.GenerateSampleModels(2);
var qry = testList.AsQueryable();
// Act
var orderBy = testList.OrderByDescending(x => x.Income, new IntComparerT()).ToArray();
var orderByDynamic = qry.OrderBy("Income desc", new IntComparerT()).ToArray();
// Assert
Assert.Equal(orderBy, orderByDynamic);
}
[Fact]
public void OrderBy_Dynamic()
{
// Arrange
var testList = User.GenerateSampleModels(100);
var qry = testList.AsQueryable();
// Act
var orderById = qry.OrderBy("Id");
var orderByAge = qry.OrderBy("Profile.Age");
var orderByComplex1 = qry.OrderBy("Profile.Age, Id");
// Assert
Assert.Equal(testList.OrderBy(x => x.Id).ToArray(), orderById.ToArray());
Assert.Equal(testList.OrderBy(x => x.Profile.Age).ToArray(), orderByAge.ToArray());
Assert.Equal(testList.OrderBy(x => x.Profile.Age).ThenBy(x => x.Id).ToArray(), orderByComplex1.ToArray());
}
[Fact]
public void OrderBy_Dynamic_AsStringExpression()
{
// Arrange
var testList = User.GenerateSampleModels(100);
var qry = testList.AsQueryable();
// Act
var expected = qry.SelectMany(x => x.Roles.OrderBy(y => y.Name)).Select(x => x.Name);
var orderById = qry.SelectMany("Roles.OrderBy(Name)").Select("Name");
// Assert
Assert.Equal(expected.ToArray(), orderById.Cast<string>().ToArray());
}
[Fact]
public void OrderBy_Dynamic_Exceptions()
{
// Arrange
var testList = User.GenerateSampleModels(100, allowNullableProfiles: true);
var qry = testList.AsQueryable();
// Act
Assert.Throws<ParseException>(() => qry.OrderBy("Bad=3"));
Assert.Throws<ParseException>(() => qry.Where("Id=123"));
Assert.Throws<ArgumentNullException>(() => DynamicQueryableExtensions.OrderBy(null, "Id"));
Assert.Throws<ArgumentNullException>(() => qry.OrderBy(null));
Assert.Throws<ArgumentException>(() => qry.OrderBy(""));
Assert.Throws<ArgumentException>(() => qry.OrderBy(" "));
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.OrderBy.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,148
|
```smalltalk
using System.Collections.Generic;
using NFluent;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public class DynamicEnumerableExtensionsTests
{
[Fact]
public void DynamicEnumerableExtensions_ToDynamicArray_int_to_int()
{
// Act
var result = new List<int> { 0, 1 }.ToDynamicList(typeof(int));
// Assert
Check.That(result).ContainsExactly(0, 1);
}
[Fact]
public void DynamicEnumerableExtensions_ToDynamicArray_dynamic_to_int()
{
// Act
var result = new List<dynamic> { 0, 1 }.ToDynamicList(typeof(int));
// Assert
Check.That(result).ContainsExactly(0, 1);
}
[Fact]
public void DynamicEnumerableExtensions_ToDynamicArray_object_to_int()
{
// Act
var result = new List<object> { 0, 1 }.ToDynamicList(typeof(int));
// Assert
Check.That(result).ContainsExactly(0, 1);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/DynamicEnumerableExtensionsTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 224
|
```smalltalk
using System.Collections.Generic;
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
[Fact]
public void Distinct()
{
//Arrange
var list = new[] { 1, 2, 2, 3 };
IQueryable queryable = list.AsQueryable();
//Act
var expected = Queryable.Distinct(list.AsQueryable());
var result = queryable.Distinct();
//Assert
Assert.Equal(expected, result);
}
[Fact]
public void Distinct_Dynamic_1()
{
//Arrange
var list = new[]
{
new { x = "a", list = new[] { 1, 2, 2, 3 } },
new { x = "b", list = new[] { 5, 6, 6, 8 } },
};
IQueryable queryable = list.AsQueryable();
//Act
var expected = list.Select(l => l.list.Distinct()).ToArray<object>();
var result = queryable.Select("list.Distinct()").ToDynamicArray();
//Assert
Assert.Equal(expected, result);
}
[Fact]
public void Distinct_Dynamic_2()
{
//Arrange
var list = new[]
{
new User { UserName = "a", Income = 1 },
new User { UserName = "a", Income = 2 },
new User { UserName = "b", Income = 1 }
};
//Act
var expected = list.Select(u => u.UserName).Distinct().ToArray();
IQueryable queryable = list.AsQueryable();
var result = queryable.Select("UserName").Distinct().ToDynamicArray<string>();
//Assert
Assert.Equal(expected, result);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Distinct.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 396
|
```smalltalk
using FluentAssertions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests;
public partial class ExpressionTests
{
[Fact]
public void ExpressionTests_Add_Number()
{
// Arrange
var values = new[] { -1, 2 }.AsQueryable();
// Act
var result = values.Select<int>("it + 1");
var expected = values.Select(i => i + 1);
// Assert
result.Should().Contain(expected);
}
[Fact]
public void ExpressionTests_Add_String()
{
// Arrange
var values = new[] { "a", "b" }.AsQueryable();
// Act
var result = values.Select<string>("it + \"z\"");
var expected = values.Select(i => i + "z");
// Assert
result.Should().Contain(expected);
}
[Fact]
public void your_sha256_hashTime_Subtracts_DateTime()
{
// Arrange
var values = new[]
{
new
{
Value1 = new DateTime(2023, 1, 4),
Value2 = new DateTime(2023, 1, 3)
}
}.AsQueryable();
// Act
var result = values.Select<TimeSpan>("Value1 - Value2");
var expected = values.Select(x => x.Value1 - x.Value2);
// Assert
result.Should().Contain(expected);
}
[Fact]
public void your_sha256_hashTime_Adds_TimeSpan()
{
// Arrange
var values = new[]
{
new
{
Value1 = new DateTime(2023, 1, 4),
Value2 = TimeSpan.FromDays(1)
}
}.AsQueryable();
// Act
var result = values.Select<DateTime>("Value1 + Value2");
var expected = values.Select(x => x.Value1 + x.Value2);
// Assert
result.Should().Contain(expected);
}
[Fact]
public void your_sha256_hashTime_Subtracts_TimeSpan()
{
// Arrange
var values = new[]
{
new
{
Value1 = new DateTime(2023, 1, 4),
Value2 = TimeSpan.FromDays(1)
}
}.AsQueryable();
// Act
var result = values.Select<DateTime>("Value1 - Value2");
var expected = values.Select(x => x.Value1 - x.Value2);
// Assert
result.Should().Contain(expected);
}
[Fact]
public void your_sha256_hashSpan_Adds_TimeSpan()
{
// Arrange
var values = new[]
{
new
{
Value1 = TimeSpan.FromDays(1),
Value2 = TimeSpan.FromDays(1)
}
}.AsQueryable();
// Act
var result = values.Select<TimeSpan>("Value1 + Value2");
var expected = values.Select(x => x.Value1 + x.Value2);
// Assert
result.Should().Contain(expected);
}
[Fact]
public void your_sha256_hashSpan_Subtracts_TimeSpan()
{
// Arrange
var values = new[]
{
new
{
Value1 = TimeSpan.FromDays(7),
Value2 = TimeSpan.FromDays(1)
}
}.AsQueryable();
// Act
var result = values.Select<TimeSpan>("Value1 - Value2");
var expected = values.Select(x => x.Value1 - x.Value2);
// Assert
result.Should().Contain(expected);
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/ExpressionTests.AddAndSubstract.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 758
|
```smalltalk
using System.Threading.Tasks;
using Testcontainers.MsSql;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests;
/// <summary>
/// path_to_url
/// </summary>
public class EntitiesTestsDatabaseFixture : IAsyncLifetime
{
private readonly MsSqlContainer _msSqlContainer = new MsSqlBuilder().Build();
public string ConnectionString => _msSqlContainer.GetConnectionString();
public string ContainerId => $"{_msSqlContainer.Id}";
public bool UseInMemory
{
get
{
var useInMemory = Environment.GetEnvironmentVariable("UseInMemory");
return bool.TryParse(useInMemory, out var value) && value;
}
}
public async Task InitializeAsync()
{
if (UseInMemory)
{
return;
}
await _msSqlContainer.StartAsync();
}
public async Task DisposeAsync()
{
if (UseInMemory)
{
return;
}
await _msSqlContainer.DisposeAsync();
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/EntitiesTests.DatabaseFixture.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 209
|
```smalltalk
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
[Fact]
public void Take()
{
//Arrange
var testList = User.GenerateSampleModels(100);
IQueryable testListQry = testList.AsQueryable();
//Act
var resultFull = testListQry.Take(100);
var resultMinus1 = testListQry.Take(99);
var resultHalf = testListQry.Take(50);
var resultOne = testListQry.Take(1);
//Assert
Assert.Equal(testList.Take(100).ToArray(), resultFull.Cast<User>().ToArray());
Assert.Equal(testList.Take(99).ToArray(), resultMinus1.Cast<User>().ToArray());
Assert.Equal(testList.Take(50).ToArray(), resultHalf.Cast<User>().ToArray());
Assert.Equal(testList.Take(1).ToArray(), resultOne.Cast<User>().ToArray());
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Take.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 209
|
```smalltalk
#if EFCORE
using Microsoft.EntityFrameworkCore;
using Microsoft.EntityFrameworkCore.DynamicLinq;
#else
using System.Data.Entity;
using EntityFramework.DynamicLinq;
#endif
using System.Threading.Tasks;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class EntitiesTests
{
// [Maybe not supported : path_to_url
#if LASTSUPPORTED
[Fact]
public async Task Entities_LastAsync()
{
//Arrange
PopulateTestData(1, 0);
var expectedQueryable1 = _context.Blogs.Where(b => b.BlogId > 0);
var expected = await expectedQueryable1.LastAsync();
//Act
IQueryable queryable1 = _context.Blogs.Where("BlogId > 0");
var result = await queryable1.LastAsync();
//Assert
Assert.Equal(expected, result);
}
[Fact]
public async Task Entities_LastAsync_Predicate()
{
//Arrange
PopulateTestData(1, 0);
var expected = await EntityFrameworkQueryableExtensions.LastAsync(_context.Blogs, b => b.BlogId > 0);
//Act
var result = await (_context.Blogs.AsQueryable() as IQueryable).LastAsync("it.BlogId > 0");
//Assert
Assert.Equal(expected, result);
}
#endif
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/EntitiesTests.LastAsync.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 282
|
```smalltalk
using System.Collections.Generic;
using System.Linq.Dynamic.Core.Exceptions;
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using FluentAssertions;
using NFluent;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
#if NET46_OR_GREATER || NET5_0_OR_GREATER || NETCOREAPP2_1_OR_GREATER || NETSTANDARD1_3_OR_GREATER || UAP10_0
public partial class QueryableTests
{
[Fact]
public void All_WithArgs_FS()
{
// Arrange
const int value = 50;
const string username = "test123";
var queryable = User.GenerateSampleModels(100).AsQueryable();
// Act
var expected = queryable.All(u => u.Income > value && u.UserName != username);
var result = queryable.AllInterpolated($"Income > {value} && UserName != {username}");
// Assert
Assert.Equal(expected, result);
}
[Fact]
public void Any_Predicate_FS()
{
// Arrange
var queryable = User.GenerateSampleModels(100).AsQueryable();
var value = 50;
// Act
var expected = queryable.Any(u => u.Income > value);
var result = queryable.AnyInterpolated($"Income > {value}");
// Assert
Assert.Equal(expected, result);
}
[Fact]
public void Any_Predicate_WithArgs_FS()
{
const int value = 50;
// Arrange
var queryable = User.GenerateSampleModels(100).AsQueryable();
// Act
var expected = queryable.Any(u => u.Income > value);
var result = queryable.AnyInterpolated($"Income > {value}");
// Assert
Assert.Equal(expected, result);
}
[Fact]
public void Any_Dynamic_Where_FS()
{
const string search = "e";
// Arrange
var testList = User.GenerateSampleModels(10);
var queryable = testList.AsQueryable();
// Act
var expected = queryable.Where(u => u.Roles.Any(r => r.Name.Contains(search))).ToArray();
var result = queryable.WhereInterpolated($"Roles.Any(Name.Contains({search}))").ToArray();
Assert.Equal(expected, result);
}
// path_to_url
[Fact]
public void Any_Dynamic_Where_Nested_FS()
{
const string search = "a";
// Arrange
var testList = User.GenerateSampleModels(10);
var queryable = testList.AsQueryable();
// Act
var expected = queryable.Where(u => u.Roles.Any(r => r.Permissions.Any(p => p.Name.Contains(search)))).ToArray();
var result = queryable.WhereInterpolated($"Roles.Any(Permissions.Any(Name.Contains({search})))").ToArray();
Assert.Equal(expected, result);
}
// path_to_url
[Fact]
public void Any_Dynamic_Where_Nested2_FS()
{
// arrange
var list = new List<A>
{
new A {Bs = new List<B> {new B {A = new A(), Cs = new List<C> {new C {B = new B()}}}}}
};
var queryable = list.AsQueryable();
// act : 1
var result1 = queryable.WhereInterpolated($"(Name = \"\") && (Bs.Any(Cs.Any()))").ToList();
var expected1 = queryable.Where(a => a.Name == "" && a.Bs.Any(b => b.Cs.Any()));
Assert.Equal(expected1, result1);
// act : 2
var result2 = queryable.WhereInterpolated($"(Bs.Any(Cs.Any())) && (Name = \"\")").ToList();
var expected2 = queryable.Where(a => a.Bs.Any(b => b.Cs.Any() && a.Name == ""));
Assert.Equal(expected2, result2);
}
[Fact]
public void First_Predicate_FS()
{
// Arrange
var income = 1000;
var testList = User.GenerateSampleModels(100);
var queryable = testList.AsQueryable();
// Act
var expected = queryable.First(u => u.Income > income);
var result = queryable.FirstInterpolated($"Income > {income}");
// Assert
Assert.Equal(expected as object, result);
}
[Fact]
public void First_Predicate_WithArgs_FS()
{
// Arrange
var income = 1000;
var testList = User.GenerateSampleModels(100);
var queryable = testList.AsQueryable();
// Act
var expected = queryable.First(u => u.Income > income);
var result = queryable.FirstInterpolated($"Income > {income}");
// Assert
Assert.Equal(expected as object, result);
}
[Fact]
public void FirstOrDefault_Predicate_FS()
{
// Arrange
var testList = User.GenerateSampleModels(100);
var queryable = testList.AsQueryable();
// Act
var value = 1000;
var expected = queryable.FirstOrDefault(u => u.Income > value);
var result = queryable.FirstOrDefaultInterpolated($"Income > {value}");
// Assert
Check.That(result).Equals(expected);
}
[Fact]
public void FirstOrDefault_Predicate_WithArgs_FS()
{
const int value = 1000;
// Arrange
var testList = User.GenerateSampleModels(100);
var queryable = testList.AsQueryable();
// Act
var expected = queryable.FirstOrDefault(u => u.Income > value);
var result = queryable.FirstOrDefaultInterpolated($"Income > {value}");
// Assert
Check.That(result).Equals(expected);
}
[Fact]
public void Last_Predicate_FS()
{
// Arrange
var testList = User.GenerateSampleModels(100);
var queryable = testList.AsQueryable();
// Act
var value = 1000;
var expected = queryable.Last(u => u.Income > value);
var result = queryable.LastInterpolated($"Income > {value}");
// Assert
Assert.Equal(expected as object, result);
}
[Fact]
public void LastOrDefault_Predicate_FS()
{
// Arrange
var testList = User.GenerateSampleModels(100);
var queryable = testList.AsQueryable();
// Act
var value = 1000;
var expected = queryable.LastOrDefault(u => u.Income > value);
var result = queryable.LastOrDefaultInterpolated($"Income > {value}");
// Assert
Assert.Equal(expected as object, result);
}
[Fact]
public void LongCount_Predicate_FS()
{
// Arrange
var queryable = User.GenerateSampleModels(100).AsQueryable();
// Act
var expected = queryable.LongCount(u => u.Income > 50);
var result = queryable.LongCount("Income > 50");
// Assert
Assert.Equal(expected, result);
}
[Fact]
public void LongCount_Predicate_WithArgs_FS()
{
const int value = 50;
// Arrange
var queryable = User.GenerateSampleModels(100).AsQueryable();
// Act
var expected = queryable.LongCount(u => u.Income > value);
var result = queryable.LongCountInterpolated($"Income >{value}");
// Assert
Assert.Equal(expected, result);
}
[Fact]
public void LongCount_Dynamic_Where_FS()
{
const string search = "e";
// Arrange
var testList = User.GenerateSampleModels(10);
var queryable = testList.AsQueryable();
// Act
var expected = queryable.Where(u => u.Roles.LongCount(r => r.Name.Contains(search)) > 0).ToArray();
var result = queryable.WhereInterpolated($"Roles.LongCount(Name.Contains({search})) > 0").ToArray();
Assert.Equal(expected, result);
}
[Fact]
public void OrderBy_Dynamic_Exceptions_FS()
{
// Arrange
var testList = User.GenerateSampleModels(100, allowNullableProfiles: true);
var qry = testList.AsQueryable();
// Act
var bad = 3;
var id = 123;
Assert.Throws<ParseException>(() => qry.OrderByInterpolated($"Bad={bad}"));
Assert.Throws<ParseException>(() => qry.WhereInterpolated($"Id={id}"));
Assert.Throws<ArgumentNullException>(() => DynamicQueryableExtensions.OrderBy(null, "Id"));
Assert.Throws<ArgumentException>(() => qry.OrderByInterpolated($""));
Assert.Throws<ArgumentException>(() => qry.OrderByInterpolated($" "));
}
[Fact]
public void Single_Predicate_FS()
{
// Arrange
var testList = User.GenerateSampleModels(100);
var testListQry = testList.AsQueryable();
// Act
var value = "User4";
var expected = testListQry.Single(u => u.UserName == value);
var result = testListQry.SingleInterpolated($"UserName == {value}");
// Assert
Assert.Equal(expected as object, result);
}
[Fact]
public void SingleOrDefault_Predicate_FS()
{
// Arrange
var testList = User.GenerateSampleModels(100);
var testListQry = testList.AsQueryable();
// Act
var value = "User4";
var expected = testListQry.SingleOrDefault(u => u.UserName == value);
var result = testListQry.SingleOrDefaultInterpolated($"UserName == {value}");
// Assert
Assert.Equal(expected as object, result);
}
[Fact]
public void SkipWhile_Predicate_FS()
{
// Arrange
var testList = User.GenerateSampleModels(100);
IQueryable testListQry = testList.AsQueryable();
// Act
var value = 1000;
var expected = testList.SkipWhile(u => u.Income > value);
var result = testListQry.SkipWhileInterpolated($"Income > {value}");
// Assert
Assert.Equal(expected.ToArray(), result.Cast<User>().ToArray());
}
[Fact]
public void SkipWhile_Predicate_Args_FS()
{
// Arrange
var income = 1000;
var testList = User.GenerateSampleModels(100);
IQueryable testListQry = testList.AsQueryable();
// Act
var expected = testList.SkipWhile(u => u.Income > income);
var result = testListQry.SkipWhileInterpolated($"Income > {income}");
// Assert
Assert.Equal(expected.ToArray(), result.Cast<User>().ToArray());
}
[Fact]
public void TakeWhile_Predicate_FS()
{
// Arrange
var testList = User.GenerateSampleModels(100);
IQueryable testListQry = testList.AsQueryable();
// Act
var value = 1000;
var expected = testList.TakeWhile(u => u.Income > 1000);
var result = testListQry.TakeWhileInterpolated($"Income > {value}");
// Assert
Assert.Equal(expected.ToArray(), result.Cast<User>().ToArray());
}
[Fact]
public void TakeWhile_Predicate_Args_FS()
{
const int income = 1000;
// Arrange
var testList = User.GenerateSampleModels(100);
IQueryable testListQry = testList.AsQueryable();
// Act
var expected = testList.TakeWhile(u => u.Income > income);
var result = testListQry.TakeWhileInterpolated($"Income > {income}");
// Assert
Assert.Equal(expected.ToArray(), result.Cast<User>().ToArray());
}
[Fact]
public void ThenBy_Dynamic_Exceptions_FS()
{
// Arrange
var testList = User.GenerateSampleModels(100, allowNullableProfiles: true);
var qry = testList.AsQueryable();
// Act
var bad = 3;
var id = 123;
var ordered = qry.OrderBy("Id");
Assert.Throws<ParseException>(() => ordered.ThenByInterpolated($"Bad={bad}"));
Assert.Throws<ParseException>(() => ordered.WhereInterpolated($"Id={id}"));
Assert.Throws<ArgumentNullException>(() => DynamicQueryableExtensions.ThenBy(null, "Id"));
Assert.Throws<ArgumentException>(() => ordered.ThenByInterpolated($""));
Assert.Throws<ArgumentException>(() => ordered.ThenByInterpolated($" "));
}
[Fact]
public void Where_Dynamic_Exceptions_FS()
{
// Arrange
var testList = User.GenerateSampleModels(100, allowNullableProfiles: true);
var qry = testList.AsQueryable();
// Act
var bad = 3;
var id = 123;
Assert.Throws<InvalidOperationException>(() => qry.WhereInterpolated($"Id"));
Assert.Throws<ParseException>(() => qry.WhereInterpolated($"Bad={bad}"));
Assert.Throws<ParseException>(() => qry.WhereInterpolated($"Id={id}"));
Assert.Throws<ArgumentNullException>(() => DynamicQueryableExtensions.Where(null, "Id=1"));
Assert.Throws<ArgumentException>(() => qry.WhereInterpolated($""));
Assert.Throws<ArgumentException>(() => qry.WhereInterpolated($" "));
}
[Fact]
public void Where_Dynamic_StringQuoted_FS()
{
// Arrange
var testList = User.GenerateSampleModels(2, allowNullableProfiles: true);
testList[0].UserName = @"This \""is\"" a test.";
var qry = testList.AsQueryable();
// Act
// var result1a = qry.Where(@"UserName == ""This \\""is\\"" a test.""").ToArray();
var result1b = qry.WhereInterpolated($"UserName == \"This \\\\\\\"is\\\\\\\" a test.\"").ToArray();
var s1 = @"This \""is\"" a test.";
var s2 = "This \\\"is\\\" a test.";
var result2a = qry.WhereInterpolated($"UserName == {s1}").ToArray();
var result2b = qry.WhereInterpolated($"UserName == {s2}").ToArray();
var expected = qry.Where(x => x.UserName == @"This \""is\"" a test.").ToArray();
// Assert
Assert.Single(expected);
// Assert.Equal(expected, result1a);
Assert.Equal(expected, result1b);
Assert.Equal(expected, result2a);
Assert.Equal(expected, result2b);
}
[Fact]
public void Where_Dynamic_SelectNewObjects_FS()
{
// Arrange
var testList = User.GenerateSampleModels(100, allowNullableProfiles: true);
var qry = testList.AsQueryable();
// Act
var value = 4000;
var expectedResult = testList.Where(x => x.Income > value).Select(x => new { Id = x.Id, Income = x.Income + 1111 });
var dynamicList = qry.WhereInterpolated($"Income > {value}").ToDynamicList();
var newUsers = dynamicList.Select(x => new { Id = x.Id, Income = x.Income + 1111 });
Assert.Equal(newUsers.Cast<object>().ToList(), expectedResult);
}
[Fact]
public void your_sha256_hashnvalidOperationException_FS()
{
// Arrange
var productsQuery = new[] { new ProductDynamic { ProductId = 1 } }.AsQueryable();
// Act
var s = "First Product";
Action action = () => productsQuery.WhereInterpolated($"Properties.Name == {s}").ToDynamicList();
// Assert
action.Should().Throw<InvalidOperationException>();
}
[Fact(Skip = "NP does not work here")]
public void your_sha256_hashgating_FS()
{
// Arrange
var productsQuery = new[] { new ProductDynamic { ProductId = 1 } }.AsQueryable();
// Act
var s = "First Product";
var results = productsQuery.WhereInterpolated($"np(Properties.Name, \"no\") == {s}").ToDynamicList();
// Assert
results.Should().HaveCount(0);
}
[Fact]
public void Where_Dynamic_ExpandoObject_As_Dictionary_FS()
{
// Arrange
var productsQuery = new[] { new ProductDynamic { ProductId = 1, Properties = new Dictionary<string, object> { { "Name", "test" } } } }.AsQueryable();
// Act
var s = "test";
var results = productsQuery.WhereInterpolated($"Properties.Name == {s}").ToDynamicList();
// Assert
results.Should().HaveCount(1);
}
[Fact]
public void Where_Dynamic_Object_As_Dictionary_FS()
{
// Arrange
var productsQuery = new[] { new ProductDynamic { ProductId = 1, PropertiesAsObject = new Dictionary<string, object> { { "Name", "test" } } } }.AsQueryable();
// Act
var s = "test";
var results = productsQuery.WhereInterpolated($"PropertiesAsObject.Name == {s}").ToDynamicList();
// Assert
results.Should().HaveCount(1);
}
[Fact]
public void Where_Dynamic_ExpandoObject_As_AnonymousType_FS()
{
// Arrange
var productsQuery = new[] { new ProductDynamic { ProductId = 1, Properties = new { Name = "test" } } }.AsQueryable();
// Act
var s = "test";
var results = productsQuery.WhereInterpolated($"Properties.Name == {s}").ToDynamicList<ProductDynamic>();
// Assert
results.Should().HaveCount(1);
}
}
#endif
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.FormattableString.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 3,810
|
```smalltalk
using System.IO;
using System.Linq.Dynamic.Core.CustomTypeProviders;
using FluentAssertions;
using NFluent;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests;
public class DefaultDynamicLinqCustomTypeProviderTests
{
private readonly IDynamicLinkCustomTypeProvider _sut;
public DefaultDynamicLinqCustomTypeProviderTests()
{
_sut = new DefaultDynamicLinqCustomTypeProvider(ParsingConfig.Default);
}
[Fact]
public void DefaultDynamicLinqCustomTypeProvider_ResolveSystemType()
{
// Act
var type = _sut.ResolveType(typeof(DirectoryInfo).FullName);
// Assert
type.Should().Be(typeof(DirectoryInfo));
}
[Fact]
public void DefaultDynamicLinqCustomTypeProvider_GetCustomTypes()
{
// Act
var types = _sut.GetCustomTypes();
// Assert
Check.That(types.Count).IsStrictlyGreaterThan(0);
}
[Fact]
public void your_sha256_hashull()
{
// Act
var result = _sut.ResolveType("dummy");
// Assert
Check.That(result).IsNull();
}
[Fact]
public void your_sha256_hashype()
{
// Act
var result = _sut.ResolveType(typeof(DefaultDynamicLinqCustomTypeProviderTests).FullName);
// Assert
Check.That(result).IsNotNull();
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/DefaultDynamicLinqCustomTypeProviderTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 295
|
```smalltalk
using System.Collections.Generic;
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using FluentAssertions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests;
public partial class QueryableTests
{
[Fact]
public void Any()
{
//Arrange
IQueryable testListFull = User.GenerateSampleModels(100).AsQueryable();
IQueryable testListOne = User.GenerateSampleModels(1).AsQueryable();
IQueryable testListNone = User.GenerateSampleModels(0).AsQueryable();
//Act
var resultFull = testListFull.Any();
var resultOne = testListOne.Any();
var resultNone = testListNone.Any();
//Assert
Assert.True(resultFull);
Assert.True(resultOne);
Assert.False(resultNone);
}
[Fact]
public void Any_Predicate()
{
//Arrange
var queryable = User.GenerateSampleModels(100).AsQueryable();
//Act
bool expected = queryable.Any(u => u.Income > 50);
bool result = queryable.Any("Income > 50");
//Assert
Assert.Equal(expected, result);
}
[Fact]
public void Any_Predicate_WithArgs()
{
const int value = 50;
//Arrange
var queryable = User.GenerateSampleModels(100).AsQueryable();
//Act
bool expected = queryable.Any(u => u.Income > value);
bool result = queryable.Any("Income > @0", value);
//Assert
Assert.Equal(expected, result);
}
[Fact]
public void Any_Dynamic_Select()
{
// Arrange
IQueryable<User> queryable = User.GenerateSampleModels(1).AsQueryable();
// Act
var expected = queryable.Select(x => x.Roles.Any()).ToArray();
var result = queryable.Select("Roles.Any()").ToDynamicArray<bool>();
// Assert
Assert.Equal(expected, result);
}
[Fact]
public void Any_Dynamic_Where()
{
const string search = "e";
// Arrange
var testList = User.GenerateSampleModels(10);
var queryable = testList.AsQueryable();
// Act
var expected = queryable.Where(u => u.Roles.Any(r => r.Name.Contains(search))).ToArray();
var result = queryable.Where("Roles.Any(Name.Contains(@0))", search).ToArray();
Assert.Equal(expected, result);
}
// path_to_url
[Fact]
public void Any_Dynamic_Where_Nested()
{
const string search = "a";
// Arrange
var testList = User.GenerateSampleModels(10);
var queryable = testList.AsQueryable();
// Act
var expected = queryable.Where(u => u.Roles.Any(r => r.Permissions.Any(p => p.Name.Contains(search)))).ToArray();
var result = queryable.Where("Roles.Any(Permissions.Any(Name.Contains(@0)))", search).ToArray();
Assert.Equal(expected, result);
}
// path_to_url
[Fact]
public void Any_Dynamic_Where_Nested2()
{
// arrange
var list = new List<A>
{
new A {Bs = new List<B> {new B {A = new A(), Cs = new List<C> {new C {B = new B()}}}}}
};
var queryable = list.AsQueryable();
// act : 1
var result1 = queryable.Where("(Name = \"\") && (Bs.Any(Cs.Any()))").ToList();
var expected1 = queryable.Where(a => a.Name == "" && a.Bs.Any(b => b.Cs.Any()));
Assert.Equal(expected1, result1);
// act : 2
var result2 = queryable.Where("(Bs.Any(Cs.Any())) && (Name = \"\")").ToList();
var expected2 = queryable.Where(a => a.Bs.Any(b => b.Cs.Any() && a.Name == ""));
Assert.Equal(expected2, result2);
}
// #540
[Fact]
public void Any_SubList()
{
var organizations = new List<Organization>
{
new()
{
Code = "OrganizationA",
Sites = new List<Site>
{
new()
{
Code = "SiteNorth1"
},
new()
{
Code = "SiteNorth2"
}
}
},
new()
{
Code = "OrganizationB",
Sites = new List<Site>
{
new()
{
Code = "SiteNorth3"
},
new()
{
Code = "SiteNorth4"
}
}
},
new()
{
Code = "OrganizationC",
Sites = new List<Site>
{
new()
{
Code = "SiteNorth1"
},
new()
{
Code = "SiteNorth5"
}
}
}
}.AsQueryable();
var siteFilters = new List<string> { "SiteNorth1", "SiteNorth5" };
// Working by accessing from organizations with predicate params for an equal expression
var test2 = organizations.Where("Sites.Any(Code = @0)", siteFilters.First()).ToDynamicArray();
test2.Should().HaveCount(2);
// Working by accessing from organizations with classic LINQ
var test3 = organizations.Where(_ => _.Sites.Any(_ => siteFilters.Contains(_.Code))).ToDynamicArray();
test3.Should().HaveCount(2);
// Working by accessing from organizations with string predicate
var test5 = organizations.Where("Sites.Any(Code in (\"SiteNorth1\", \"SiteNorth5\"))").ToDynamicArray();
test5.Should().HaveCount(2);
// Not working : error : System.Linq.Dynamic.Core.Exceptions.ParseException: '')' or ',' expected'
var test6 = organizations.Where("Sites.Any(Code in @0)", siteFilters).ToDynamicArray();
test6.Should().HaveCount(2);
}
public class Organization
{
public string Code { get; set; }
public ICollection<Site> Sites { get; set; }
}
public class Site
{
public string Code { get; set; }
}
class A
{
public string Name { get; set; }
public IList<B> Bs
{
get { return bs; }
set { bs = value; }
}
private IList<B> bs = new List<B>(0);
}
class B
{
public A A { get; set; }
public IList<C> Cs
{
get { return cs; }
set { cs = value; }
}
private IList<C> cs = new List<C>(0);
}
class C
{
public B B { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Any.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,457
|
```smalltalk
#if EFCORE
using Microsoft.EntityFrameworkCore.DynamicLinq;
#else
using EntityFramework.DynamicLinq;
#endif
using System.Threading.Tasks;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests;
public partial class EntitiesTests
{
[Fact]
public async Task Entities_FirstAsync()
{
// rrange
var expectedQueryable1 = _context.Blogs.Where(b => b.BlogId > 0);
var expected = await expectedQueryable1.FirstAsync();
// Act
IQueryable queryable1 = _context.Blogs.Where("BlogId > 0");
var result = await queryable1.FirstAsync();
// Assert
Assert.Equal(expected, result);
}
[Fact]
public async Task Entities_FirstAsync_Predicate()
{
// Arrange
#if EFCORE
var expected = await Microsoft.EntityFrameworkCore.EntityFrameworkQueryableExtensions.FirstAsync(_context.Blogs, b => b.BlogId > 0);
#else
var expected = await System.Data.Entity.QueryableExtensions.FirstAsync(_context.Blogs, b => b.BlogId > 0);
#endif
// Act
var result = await (_context.Blogs.AsQueryable() as IQueryable).FirstAsync("it.BlogId > 0");
// Assert
Assert.Equal(expected, result);
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/EntitiesTests.FirstAsync.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 271
|
```smalltalk
using System.IO;
using System.Linq.Dynamic.Core.Exceptions;
using System.Net;
using System.Reflection;
using FluentAssertions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests;
public class SecurityTests
{
class Message
{
public string Sender { get; }
public string Receiver { get; }
public Message(string sender, string receiver)
{
Sender = sender;
Receiver = receiver;
}
}
[Fact]
public void MethodsShouldOnlyBeCallableOnPredefinedTypes_Test1()
{
// Arrange
var baseQuery = new[] { 1, 2, 3 }.AsQueryable();
string predicate = "\"\".GetType().Assembly.DefinedTypes.Where(it.name == \"Assembly\").First().DeclaredMethods.Where(it.Name == \"GetName\").First().Invoke(\"\".GetType().Assembly, new Object[] {} ).Name.ToString() != \"Test\"";
// Act
Action action = () => baseQuery.OrderBy(predicate);
// Assert
action.Should().Throw<ParseException>().WithMessage("Methods on type 'MethodBase' are not accessible");
}
[Fact]
public void MethodsShouldOnlyBeCallableOnPredefinedTypes_Test2()
{
// Arrange
var messages = new[]
{
new Message("Alice", "Bob"),
new Message("Bob", "Alice")
}.AsQueryable();
Action action = () => messages.Where(
"\"\".GetType().Assembly.GetType(\"System.AppDomain\").GetMethods()[104].Invoke(\"\".GetType().Assembly.GetType(\"System.AppDomain\").GetProperty(\"CurrentDomain\").GetValue(null), \"System, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;System.Diagnostics.Process\".Split(\";\".ToCharArray())).GetType().GetMethods()[80].Invoke(null, \"cmd;/T:4A /K whoami && echo was HACKED\".Split(\";\".ToCharArray()))"
);
// Assert
action.Should().Throw<ParseException>().WithMessage($"Methods on type 'Assembly' are not accessible");
}
[Theory]
[InlineData(typeof(FileStream), "Close()", "Stream")]
[InlineData(typeof(Assembly), "GetName().Name.ToString()", "Assembly")]
public void your_sha256_hashption(Type itType, string expression, string type)
{
// Act
Action action = () => DynamicExpressionParser.ParseLambda(itType, null, expression);
// Assert
action.Should().Throw<ParseException>().WithMessage($"Methods on type '{type}' are not accessible");
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/SecurityTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 549
|
```smalltalk
using System.Linq.Dynamic.Core.Exceptions;
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
[Fact]
public void OrderByDescending_Dynamic()
{
//Arrange
var testList = User.GenerateSampleModels(100);
var qry = testList.AsQueryable();
//Act
var orderByIdDesc = qry.OrderBy("Id DESC");
var orderByAgeDesc = qry.OrderBy("Profile.Age DESC");
var orderByComplex2 = qry.OrderBy("Profile.Age DESC, Id");
//Assert
Assert.Equal(testList.OrderByDescending(x => x.Id).ToArray(), orderByIdDesc.ToArray());
Assert.Equal(testList.OrderByDescending(x => x.Profile.Age).ToArray(), orderByAgeDesc.ToArray());
Assert.Equal(testList.OrderByDescending(x => x.Profile.Age).ThenBy(x => x.Id).ToArray(), orderByComplex2.ToArray());
}
[Fact]
public void OrderByDescending_Dynamic_AsStringExpression()
{
//Arrange
var testList = User.GenerateSampleModels(100);
var qry = testList.AsQueryable();
//Act
var expectedDesc = qry.SelectMany(x => x.Roles.OrderByDescending(y => y.Name)).Select(x => x.Name);
var orderByIdDesc = qry.SelectMany("Roles.OrderByDescending(Name)").Select("Name");
//Assert
Assert.Equal(expectedDesc.ToArray(), orderByIdDesc.Cast<string>().ToArray());
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.OrderByDescending.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 304
|
```smalltalk
using NFluent;
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
[Fact]
public void FirstOrDefault()
{
// Arrange
var testList = User.GenerateSampleModels(100);
var queryable = testList.AsQueryable();
// Act
var expected = Queryable.FirstOrDefault(queryable);
var expectedDefault = Queryable.FirstOrDefault(Enumerable.Empty<User>().AsQueryable());
var result = (queryable as IQueryable).FirstOrDefault();
var resultDefault = (Enumerable.Empty<User>().AsQueryable() as IQueryable).FirstOrDefault();
// Assert
Check.That(result).Equals(expected);
Assert.Null(expectedDefault);
Assert.Null(resultDefault);
}
[Fact]
public void FirstOrDefault_Predicate()
{
//Arrange
var testList = User.GenerateSampleModels(100);
var queryable = testList.AsQueryable();
// Act
var expected = queryable.FirstOrDefault(u => u.Income > 1000);
var result = queryable.FirstOrDefault("Income > 1000");
// Assert
Check.That(result).Equals(expected);
}
[Fact]
public void FirstOrDefault_Predicate_WithArgs()
{
const int value = 1000;
// Arrange
var testList = User.GenerateSampleModels(100);
var queryable = testList.AsQueryable();
// Act
var expected = queryable.FirstOrDefault(u => u.Income > value);
var result = queryable.FirstOrDefault("Income > @0", value);
// Assert
Check.That(result).Equals(expected);
}
[Fact]
public void FirstOrDefault_Dynamic()
{
// Arrange
var testList = User.GenerateSampleModels(100);
IQueryable testListQry = testList.AsQueryable();
// Act
var realResult = testList.OrderBy(x => x.Roles.First().Name).Select(x => x.Id).ToArray();
var result = testListQry.OrderBy("Roles.FirstOrDefault().Name").Select("Id");
// Assert
Check.That(result.ToDynamicArray().Cast<Guid>()).ContainsExactly(realResult);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.FirstOrDefault.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 464
|
```smalltalk
using NFluent;
using System.Collections.Generic;
using System.Linq.Dynamic.Core.Tests.Entities;
using Xunit;
using User = System.Linq.Dynamic.Core.Tests.Helpers.Models.User;
namespace System.Linq.Dynamic.Core.Tests
{
public class ComplexTests
{
public class Claim
{
public decimal? Balance { get; set; }
public List<string> Tags { get; set; }
}
[Fact]
// path_to_url
public void OuterIt_StackOverFlow_Question_43272152()
{
var claim1 = new Claim { Balance = 100, Tags = new List<string> { "Blah", "Blah Blah" } };
var claim2 = new Claim { Balance = 500, Tags = new List<string> { "Dummy Tag", "Dummy tag 1", "New" } };
var claims = new List<Claim> { claim1, claim2 };
var tags = new List<string> { "New", "Blah" };
var parameters = new List<object> { tags };
var query = claims.AsQueryable().Where("Tags.Any(@0.Contains(it)) AND Balance > 100", parameters.ToArray()).ToArray();
Check.That(query).ContainsExactly(claim2);
}
/// <summary>
/// groupByExpressionX "new (new (Company.Name as CompanyName) as GroupByFields)" string
/// </summary>
[Fact]
public void your_sha256_hashested_branch_was_143()
{
var testList = new List<Employee>();
var qry = testList.AsQueryable();
string keySelector = "new (new (Company.Name as CompanyName) as GroupByFields)";
var group = qry.GroupBy(keySelector);
Assert.NotNull(group);
var result = group.ToDynamicList();
Assert.NotNull(result);
}
/// <summary>
/// groupByExpressionX "new (new (Company.Name as CompanyName) as GroupByFields)" string
/// string.Format("new (it AS TEntity__{0})", includesX) "new (it AS TEntity__, it.Company as TEntity__Company, it.Company.MainCompany as TEntity__Company_MainCompany, it.Country as TEntity__Country, it.Function as TEntity__Function, it.SubFunction as TEntity__SubFunction)" string
/// selectExpressionBeforeOrderByX = "new (Key.GroupByFields, it as Grouping , new (Count() as count__CompanyName, Min(TEntity__.EmployeeNumber) as min__Number, Max(TEntity__.EmployeeNumber) as max__Number, Average(TEntity__.EmployeeNumber) as average__Number, Sum(TEntity__.EmployeeNumber) as sum__Number) as Aggregates)";
/// </summary>
[Fact]
public void GroupByAndSelect_Test_GroupByWithSelect()
{
var testList = new List<Employee>();
var qry = testList.AsQueryable();
string keySelector = "new (new (Company.Name as CompanyName) as GroupByFields)";
string resultSelector = "new (it AS TEntity__, it.Company as TEntity__Company, it.Company.MainCompany as TEntity__Company_MainCompany, it.Country as TEntity__Country, it.Function as TEntity__Function, it.SubFunction as TEntity__SubFunction)";
var group = qry.GroupBy(keySelector, resultSelector);
Assert.NotNull(group);
var result = group.ToDynamicList();
Assert.NotNull(result);
string selectExpressionBeforeOrderByX = "new (Key.GroupByFields, it as Grouping , new (Count() as count__CompanyName, Min(TEntity__.EmployeeNumber) as min__Number, Max(TEntity__.EmployeeNumber) as max__Number, Average(TEntity__.EmployeeNumber) as average__Number, Sum(TEntity__.EmployeeNumber) as sum__Number) as Aggregates)";
var selectQ = group.Select(selectExpressionBeforeOrderByX);
Assert.NotNull(selectQ);
var resultSelect = selectQ.ToDynamicList();
Assert.NotNull(resultSelect);
}
/// <summary>
/// The purpose of this test is to verify that after a group by of a dynamically created
/// key, the Select clause can access the key's members
/// </summary>
[Fact]
public void GroupByAndSelect_TestDynamicSelectMember()
{
//Arrange
var testList = User.GenerateSampleModels(51);
var qry = testList.AsQueryable();
//Act
var byAgeReturnAllReal = qry.GroupBy(x => new { x.Profile.Age });
var groupReal = byAgeReturnAllReal.OrderBy(gg => gg.Key.Age).ToList();
var byAgeReturnAll = qry.GroupBy("new (Profile.Age)");
var group = byAgeReturnAll.OrderBy("Key.Age").ToDynamicArray();
var selectQry = byAgeReturnAll.Select("new (Key.Age, Sum(Income) As TotalIncome)");
//Real Comparison
var realQry = qry.GroupBy(x => new { x.Profile.Age }).Select(x => new { x.Key.Age, TotalIncome = x.Sum(y => y.Income) });
//Assert
Assert.Equal(realQry.Count(), selectQry.Count());
#if NET35
Assert.Equal(
realQry.Select(x => x.Age).ToArray(),
selectQry.Cast<object>().Select(x => ((object)x).GetDynamicProperty<int?>("Age")).ToArray());
Assert.Equal(
realQry.Select(x => x.TotalIncome).ToArray(),
selectQry.Cast<object>().Select(x => ((object)x).GetDynamicProperty<int>("TotalIncome")).ToArray());
#else
Assert.Equal(
realQry.Select(x => x.Age).ToArray(),
selectQry.AsDynamicEnumerable().Select(x => x.Age).Cast<int?>().ToArray());
Assert.Equal(
realQry.Select(x => x.TotalIncome).ToArray(),
selectQry.AsDynamicEnumerable().Select(x => x.TotalIncome).Cast<int>().ToArray());
#endif
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/ComplexTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,252
|
```smalltalk
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
[Fact]
public void Last()
{
//Arrange
var testList = User.GenerateSampleModels(100);
IQueryable testListQry = testList.AsQueryable();
//Act
var realResult = testList.Last();
var result = testListQry.Last();
//Assert
#if NET35
Assert.Equal(realResult.Id, result.GetDynamicProperty<Guid>("Id"));
#else
Assert.Equal(realResult.Id, result.Id);
#endif
}
[Fact]
public void Last_Predicate()
{
//Arrange
var testList = User.GenerateSampleModels(100);
var queryable = testList.AsQueryable();
//Act
var expected = queryable.Last(u => u.Income > 1000);
var result = queryable.Last("Income > 1000");
//Assert
Assert.Equal(expected as object, result);
}
[Fact]
public void LastOrDefault()
{
//Arrange
var testList = User.GenerateSampleModels(100);
IQueryable testListQry = testList.AsQueryable();
//Act
var realResult = testList.LastOrDefault();
var singleResult = testListQry.LastOrDefault();
var defaultResult = Enumerable.Empty<User>().AsQueryable().FirstOrDefault();
//Assert
#if NET35
Assert.Equal(realResult.Id, singleResult.GetDynamicProperty<Guid>("Id"));
#else
Assert.Equal(realResult.Id, singleResult.Id);
#endif
Assert.Null(defaultResult);
}
[Fact]
public void LastOrDefault_Predicate()
{
//Arrange
var testList = User.GenerateSampleModels(100);
var queryable = testList.AsQueryable();
//Act
var expected = queryable.LastOrDefault(u => u.Income > 1000);
var result = queryable.LastOrDefault("Income > 1000");
//Assert
Assert.Equal(expected as object, result);
}
[Fact]
public void Last_Dynamic()
{
//Arrange
var testList = User.GenerateSampleModels(100);
IQueryable testListQry = testList.AsQueryable();
//Act
var realResult = testList.OrderBy(x => x.Roles.Last().Name).Select(x => x.Id).ToArray();
var testResult = testListQry.OrderBy("Roles.Last().Name").Select("Id");
//Assert
#if NET35 || NETSTANDARD
Assert.Equal(realResult, testResult.Cast<Guid>().ToArray());
#else
Assert.Equal(realResult, testResult.ToDynamicArray().Cast<Guid>());
#endif
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Last.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 578
|
```smalltalk
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using NFluent;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
[Fact]
public void ExpressionOptimizerIsNull()
{
ExtensibilityPoint.QueryOptimizer = null;
//Arrange
var testListQry = User.GenerateSampleModels(10).AsQueryable();
//Act
var result = testListQry.Select<User>("it").ToArray();
//Assert
Check.That(result).IsNotNull();
ExtensibilityPoint.QueryOptimizer = x => x;
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.ExpressionOptimizer.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 128
|
```smalltalk
using System.Collections.Generic;
using System.Linq.Dynamic.Core.Exceptions;
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using FluentAssertions;
using NFluent;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests
{
public partial class QueryableTests
{
[Fact]
public void Join_InheritedClasses()
{
// Arrange
var magnus = new Person { Name = "Hedlund, Magnus" };
var terry = new Person { Name = "Adams, Terry" };
var charlotte = new Person { Name = "Weiss, Charlotte" };
var barley = new Pet { Name = "Barley", Owner = terry };
var boots = new Pet { Name = "Boots", Owner = terry };
var whiskers = new Pet { Name = "Whiskers", Owner = charlotte };
var daisy = new SpecialPet { Name = "Daisy", Owner = magnus, IsSpecial = true };
var people = new List<Person> { magnus, terry, charlotte };
var pets = new List<Pet> { barley, boots, whiskers, daisy };
// Act 1
var realQuery = people.AsQueryable()
.Join(
pets,
person => person,
pet => pet.Owner,
(person, pet) => new { OwnerName = person.Name, Pet = pet.Name }
);
var realResult = realQuery.ToList();
// Act 2
var dynamicQuery = people.AsQueryable()
.Join(
pets,
"it",
"Owner",
"new(outer.Name as OwnerName, inner.Name as Pet)"
);
var dynamicResult = dynamicQuery.ToDynamicList();
// Assert
realResult.Should().BeEquivalentTo(dynamicResult);
}
[Fact]
public void Join()
{
// Arrange
var magnus = new Person { Name = "Hedlund, Magnus" };
var terry = new Person { Name = "Adams, Terry" };
var charlotte = new Person { Name = "Weiss, Charlotte" };
var barley = new Pet { Name = "Barley", Owner = terry };
var boots = new Pet { Name = "Boots", Owner = terry };
var whiskers = new Pet { Name = "Whiskers", Owner = charlotte };
var daisy = new Pet { Name = "Daisy", Owner = magnus };
var people = new List<Person> { magnus, terry, charlotte };
var pets = new List<Pet> { barley, boots, whiskers, daisy };
// Act 1
var realQuery = people.AsQueryable()
.Join(
pets,
person => person,
pet => pet.Owner,
(person, pet) => new { OwnerName = person.Name, Pet = pet.Name }
);
var realResult = realQuery.ToList();
// Act 2
var dynamicQuery = people.AsQueryable()
.Join(
pets,
"it",
"Owner",
"new(outer.Name as OwnerName, inner.Name as Pet)");
var dynamicResult = dynamicQuery.ToDynamicList();
// Assert
realResult.Should().BeEquivalentTo(dynamicResult);
}
[Fact]
public void JoinOnNullableType_RightNullable()
{
//Arrange
Person magnus = new Person { Id = 1, Name = "Hedlund, Magnus" };
Person terry = new Person { Id = 2, Name = "Adams, Terry" };
Person charlotte = new Person { Id = 3, Name = "Weiss, Charlotte" };
Pet barley = new Pet { Name = "Barley", NullableOwnerId = terry.Id };
Pet boots = new Pet { Name = "Boots", NullableOwnerId = terry.Id };
Pet whiskers = new Pet { Name = "Whiskers", NullableOwnerId = charlotte.Id };
Pet daisy = new Pet { Name = "Daisy", NullableOwnerId = magnus.Id };
var people = new List<Person> { magnus, terry, charlotte };
var pets = new List<Pet> { barley, boots, whiskers, daisy };
//Act
var realQuery = people.AsQueryable()
.Join(
pets,
person => person.Id,
pet => pet.NullableOwnerId,
(person, pet) => new { OwnerName = person.Name, Pet = pet.Name });
var dynamicQuery = people.AsQueryable()
.Join(
pets,
"it.Id",
"NullableOwnerId",
"new(outer.Name as OwnerName, inner.Name as Pet)");
//Assert
var realResult = realQuery.ToArray();
var dynamicResult = dynamicQuery.ToDynamicArray<DynamicClass>();
Assert.Equal(realResult.Length, dynamicResult.Length);
for (int i = 0; i < realResult.Length; i++)
{
Assert.Equal(realResult[i].OwnerName, dynamicResult[i].GetDynamicPropertyValue<string>("OwnerName"));
Assert.Equal(realResult[i].Pet, dynamicResult[i].GetDynamicPropertyValue<string>("Pet"));
}
}
[Fact]
public void JoinOnNullableType_LeftNullable()
{
//Arrange
Person magnus = new Person { NullableId = 1, Name = "Hedlund, Magnus" };
Person terry = new Person { NullableId = 2, Name = "Adams, Terry" };
Person charlotte = new Person { NullableId = 3, Name = "Weiss, Charlotte" };
Pet barley = new Pet { Name = "Barley", OwnerId = terry.Id };
Pet boots = new Pet { Name = "Boots", OwnerId = terry.Id };
Pet whiskers = new Pet { Name = "Whiskers", OwnerId = charlotte.Id };
Pet daisy = new Pet { Name = "Daisy", OwnerId = magnus.Id };
var people = new List<Person> { magnus, terry, charlotte };
var pets = new List<Pet> { barley, boots, whiskers, daisy };
//Act
var realQuery = people.AsQueryable()
.Join(
pets,
person => person.NullableId,
pet => pet.OwnerId,
(person, pet) => new { OwnerName = person.Name, Pet = pet.Name });
var dynamicQuery = people.AsQueryable()
.Join(
pets,
"it.NullableId",
"OwnerId",
"new(outer.Name as OwnerName, inner.Name as Pet)");
//Assert
var realResult = realQuery.ToArray();
var dynamicResult = dynamicQuery.ToDynamicArray<DynamicClass>();
Assert.Equal(realResult.Length, dynamicResult.Length);
for (int i = 0; i < realResult.Length; i++)
{
Assert.Equal(realResult[i].OwnerName, dynamicResult[i].GetDynamicPropertyValue<string>("OwnerName"));
Assert.Equal(realResult[i].Pet, dynamicResult[i].GetDynamicPropertyValue<string>("Pet"));
}
}
[Fact]
public void JoinOnNullableType_NotSameTypesThrowsException()
{
var person = new Person { Id = 1, Name = "Hedlund, Magnus" };
var people = new List<Person> { person };
var pets = new List<Pet> { new Pet { Name = "Daisy", OwnerId = person.Id } };
Check.ThatCode(() =>
people.AsQueryable()
.Join(
pets,
"it.Id",
"Name", // This is wrong
"new(outer.Name as OwnerName, inner.Name as Pet)")).Throws<ParseException>();
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/QueryableTests.Join.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,646
|
```smalltalk
#if !NET452
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Linq.Dynamic.Core.CustomTypeProviders;
using System.Reflection;
using FluentAssertions;
using NodaTime;
using NodaTime.Text;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.TypeConvertors
{
public class NodaTimeConverterTests
{
private class Entity
{
public Guid Id { get; set; }
public string FirstName { get; set; }
public DateTime? MyDateTimeNullable { get; set; }
public LocalDate BirthDate { get; set; }
public LocalDate? BirthDateNullable { get; set; }
public LocalTime? Time { get; set; }
}
private readonly IQueryable<Entity> entities;
public NodaTimeConverterTests()
{
entities = new List<Entity>()
{
new Entity { Id = Guid.NewGuid(), FirstName = "Paul", MyDateTimeNullable = new DateTime(1987, 10, 12), BirthDate = new LocalDate(1987, 10, 12), BirthDateNullable = new LocalDate(1987, 10, 12), Time = new LocalTime(11, 1) },
new Entity { Id = Guid.NewGuid(), FirstName = "Abigail", BirthDate = new LocalDate(1970, 02, 13), Time = new LocalTime(12, 2) },
new Entity { Id = Guid.NewGuid(), FirstName = "Sophia", BirthDate = new LocalDate(1983, 05, 01), Time = new LocalTime(13, 3) }
}.AsQueryable();
}
[Fact]
public void FilterByLocalDate_WithTypeConverter()
{
// Arrange
var config = new ParsingConfig
{
TypeConverters = new Dictionary<Type, TypeConverter>
{
{ typeof(LocalDate), new LocalDateConverter() }
}
};
// Act
var result = entities.AsQueryable().Where(config, "BirthDate == @0", "1987-10-12").ToList();
// Assert
Assert.Single(result);
}
[Fact]
public void FilterByNullableLocalDate_WithTypeConverter()
{
// Arrange
var config = new ParsingConfig
{
TypeConverters = new Dictionary<Type, TypeConverter>
{
{ typeof(LocalDate), new LocalDateConverter() }
}
};
// Act
var result = entities.AsQueryable().Where(config, "BirthDateNullable == @0", "1987-10-12").ToList();
// Assert
Assert.Single(result);
}
[Fact]
public void FilterByLocalDate_WithDynamicExpressionParser()
{
// Arrange
var config = new ParsingConfig
{
TypeConverters = new Dictionary<Type, TypeConverter>
{
{ typeof(LocalDate), new LocalDateConverter() }
}
};
// Act
var expr = DynamicExpressionParser.ParseLambda<Entity, bool>(config, false, "BirthDate == @0", "1987-10-12");
var result = entities.AsQueryable().Where(expr).ToList();
// Assert
Assert.Single(result);
}
[Fact]
public void FilterByNullableLocalDate_WithDynamicExpressionParser()
{
// Arrange
var config = new ParsingConfig
{
TypeConverters = new Dictionary<Type, TypeConverter>
{
{ typeof(LocalDate), new LocalDateConverter() }
}
};
// Act
var expr = DynamicExpressionParser.ParseLambda<Entity, bool>(config, false, "BirthDateNullable == \"1987-10-12\"");
var result = entities.AsQueryable().Where(expr).ToList();
// Assert
Assert.Single(result);
}
[Theory]
[InlineData("!= null", 1)]
[InlineData("== null", 2)]
public void your_sha256_hashNull(string equal, int numberOfEntities)
{
// Arrange
var config = new ParsingConfig
{
TypeConverters = new Dictionary<Type, TypeConverter>
{
{ typeof(LocalDate), new LocalDateConverter() }
}
};
// Act
var expr = DynamicExpressionParser.ParseLambda<Entity, bool>(config, false, $"MyDateTimeNullable {equal}");
var result = entities.AsQueryable().Where(expr).ToList();
// Assert
result.Should().HaveCount(numberOfEntities);
}
[Theory]
[InlineData("!= null", 1)]
[InlineData("== null", 2)]
public void your_sha256_hashhNull(string equal, int numberOfEntities)
{
// Arrange
var config = new ParsingConfig
{
TypeConverters = new Dictionary<Type, TypeConverter>
{
{ typeof(LocalDate), new LocalDateConverter() }
}
};
// Act
var expr = DynamicExpressionParser.ParseLambda<Entity, bool>(config, false, $"BirthDateNullable {equal}");
var result = entities.AsQueryable().Where(expr).ToList();
// Assert
result.Should().HaveCount(numberOfEntities);
}
public class LocalDateConverter : TypeConverter
{
public override bool CanConvertFrom(ITypeDescriptorContext context, Type sourceType) => sourceType == typeof(string);
public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
{
var result = LocalDatePattern.Iso.Parse(value as string);
return result.Success
? result.Value
: throw new FormatException(value?.ToString());
}
protected ParseResult<LocalDate> Convert(object value) => LocalDatePattern.Iso.Parse(value as string);
}
}
}
#endif
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/TypeConvertors/NodaTimeConverterTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,193
|
```smalltalk
using FluentAssertions;
using System.Linq.Dynamic.Core.TypeConverters;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.TypeConvertors
{
public class CustomDateTimeConverterTests
{
private readonly CustomDateTimeConverter _sut;
public CustomDateTimeConverterTests()
{
_sut = new CustomDateTimeConverter();
}
[Theory]
[InlineData("Fri, 10 May 2019 11:03:17 GMT", 11)]
[InlineData("Fri, 10 May 2019 11:03:17 -07:00", 18)]
public void ConvertFromInvariantString_ReturnsCorrectDateTime(string value, int hours)
{
// Act
DateTime? result = _sut.ConvertFromInvariantString(value) as DateTime?;
// Assert
result.Should().Be(new DateTime(2019, 5, 10, hours, 3, 17));
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/TypeConvertors/CustomDateTimeConverterTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 193
|
```smalltalk
using FluentAssertions;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq.Dynamic.Core.TypeConverters;
using Xunit;
#if !NET452
using static System.Linq.Dynamic.Core.Tests.TypeConvertors.NodaTimeConverterTests;
using NodaTime;
#endif
namespace System.Linq.Dynamic.Core.Tests.TypeConvertors
{
public class TypeConverterFactoryTests
{
[Theory]
[InlineData(typeof(DateTimeOffset), typeof(DateTimeOffsetConverter))]
[InlineData(typeof(DateTime), typeof(DateTimeConverter))]
[InlineData(typeof(DateTime?), typeof(NullableConverter))]
[InlineData(typeof(int), typeof(Int32Converter))]
public void your_sha256_hashr(Type type, Type expected)
{
// Arrange
var factory = new TypeConverterFactory(ParsingConfig.Default);
// Act
var typeConverter = factory.GetConverter(type);
// Assert
typeConverter.Should().BeOfType(expected);
}
[Theory]
[InlineData(typeof(DateTimeOffset), typeof(DateTimeOffsetConverter))]
[InlineData(typeof(DateTime), typeof(CustomDateTimeConverter))]
[InlineData(typeof(DateTime?), typeof(CustomDateTimeConverter))]
[InlineData(typeof(int), typeof(Int32Converter))]
public void your_sha256_hashonverter(Type type, Type expected)
{
// Arrange
var parsingConfig = new ParsingConfig
{
DateTimeIsParsedAsUTC = true
};
var factory = new TypeConverterFactory(parsingConfig);
// Act
var typeConverter = factory.GetConverter(type);
// Assert
typeConverter.Should().BeOfType(expected);
}
#if !NET452
[Theory]
[InlineData(typeof(LocalDate), typeof(LocalDateConverter))]
[InlineData(typeof(LocalDate?), typeof(LocalDateConverter))]
public void GetConverter_WithCustomConverter_ReturnsCorrectTypeConverter(Type type, Type expected)
{
// Arrange
var parsingConfig = new ParsingConfig
{
TypeConverters = new Dictionary<Type, TypeConverter>
{
{ typeof(LocalDate), new LocalDateConverter() }
}
};
var factory = new TypeConverterFactory(parsingConfig);
// Act
var typeConverter = factory.GetConverter(type);
// Assert
typeConverter.Should().BeOfType(expected);
}
#endif
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/TypeConvertors/TypeConverterFactoryTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 456
|
```smalltalk
using System.Collections.Generic;
using System.Linq.Dynamic.Core.CustomTypeProviders;
using System.Reflection;
using System.Runtime.CompilerServices;
namespace System.Linq.Dynamic.Core.Tests
{
public class TestCustomTypeProvider : AbstractDynamicLinqCustomTypeProvider, IDynamicLinkCustomTypeProvider
{
private HashSet<Type>? _customTypes;
public virtual HashSet<Type> GetCustomTypes()
{
if (_customTypes != null)
{
return _customTypes;
}
_customTypes = new HashSet<Type>(FindTypesMarkedWithDynamicLinqTypeAttribute(new[] { GetType().GetTypeInfo().Assembly }))
{
typeof(CustomClassWithStaticMethod),
typeof(StaticHelper),
typeof(StaticHelper.Nested)
};
return _customTypes;
}
public Dictionary<Type, List<MethodInfo>> GetExtensionMethods()
{
var types = GetCustomTypes();
var list = new List<Tuple<Type, MethodInfo>>();
foreach (var type in types)
{
var extensionMethods = type.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic)
.Where(x => x.IsDefined(typeof(ExtensionAttribute), false)).ToList();
extensionMethods.ForEach(x => list.Add(new Tuple<Type, MethodInfo>(x.GetParameters()[0].ParameterType, x)));
}
return list.GroupBy(x => x.Item1, tuple => tuple.Item2).ToDictionary(key => key.Key, methods => methods.ToList());
}
public Type ResolveType(string typeName)
{
return Type.GetType(typeName)!;
}
public Type ResolveTypeBySimpleName(string typeName)
{
var assemblies = AppDomain.CurrentDomain.GetAssemblies();
return ResolveTypeBySimpleName(assemblies, typeName)!;
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/TestClasses/TestCustomTypeProvider.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 360
|
```smalltalk
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using System.Linq.Expressions;
namespace System.Linq.Dynamic.Core.Tests
{
public class StaticHelperSqlExpression
{
public Expression<Func<User, bool>>? Filter { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/TestClasses/StaticHelperSqlExpression.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 52
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests
{
public class CustomClassWithStaticMethod
{
public static int GetAge(int x) => x;
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/TestClasses/CustomClassWithStaticMethod.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 35
|
```smalltalk
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using System.Linq.Expressions;
namespace System.Linq.Dynamic.Core.Tests
{
public static class StaticHelper
{
public static Guid NewStaticGuid => new("43b17e59-2b66-4697-a3ab-7b45baedee72");
public static class Nested
{
public static Guid NewNestedStaticProperty => new("954692b3-6a37-4c9c-ad55-07fbb593f046");
public static Guid NewNestedStaticMethod() => new ("954692b3-6a37-4c9c-ad55-07fbb593f046");
public static bool IsNull(object? value) => value != null;
}
public static Guid? GetGuid(string name)
{
return Guid.NewGuid();
}
public static string Filter(string filter)
{
return filter;
}
public static StaticHelperSqlExpression SubSelect(string columnName, string objectClassName, string? filter, string order)
{
Expression<Func<User, bool>>? expFilter = null;
if (filter != null)
{
var config = new ParsingConfig
{
CustomTypeProvider = new TestCustomTypeProvider()
};
expFilter = DynamicExpressionParser.ParseLambda<User, bool>(config, true, filter);
}
return new StaticHelperSqlExpression
{
Filter = expFilter
};
}
public static bool In(Guid? value, StaticHelperSqlExpression expression)
{
return value != Guid.Empty;
}
public static Guid First(StaticHelperSqlExpression staticHelperSqlExpression)
{
return Guid.NewGuid();
}
public static string ToExpressionString(Guid? value, int subQueryLevel)
{
if (value == null)
{
return "NULL";
}
var quote = GetQuote(subQueryLevel);
return $"Guid.Parse({quote}{value}{quote})";
}
public static Guid Get(string settingName)
{
return Guid.NewGuid();
}
private static string GetQuote(int subQueryLevel)
{
var quoteCount = (int)Math.Pow(2, subQueryLevel - 1);
return new string('"', quoteCount);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/TestClasses/StaticHelper.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 479
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public abstract class Entity : IEntity
{
public long Id { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/Entity.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 33
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class BaseEmployee
{
public string Name { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/BaseEmployee.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 31
|
```smalltalk
using NFluent;
using System.Linq.Dynamic.Core.Tests.Helpers.Models;
using FluentAssertions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests;
public partial class QueryableTests
{
[Fact]
public void Issue775a()
{
// Arrange
var users = User.GenerateSampleModels(10);
// Act
var realResult = users.Where(x => x.Income == users.Select(p => p.Income).Min()).Select(x => x.Id).ToArray();
var result = users.AsQueryable().Where("Income == @0.Select(Income).Min()", users).Select("Id");
// Assert
Check.That(result.ToDynamicArray().Cast<Guid>()).ContainsExactly(realResult);
}
[Fact]
public void Issue775b()
{
// Arrange
var users = User.GenerateSampleModels(10);
var pets = new[] { new Pet() }.AsQueryable();
// Act
var realResult = users.Where(x => x.Income == pets.Select(p => p.Id).FirstOrDefault()).Select(x => x.Id).ToArray();
var result = users.AsQueryable().Where("Income == @0.Select(Id).FirstOrDefault()", pets).Select("Id");
// Assert
Check.That(result.ToDynamicArray().Cast<Guid>()).ContainsExactly(realResult);
}
[Fact]
public void Issue775_Exception()
{
// Arrange
var users = User.GenerateSampleModels(10);
var pets = new[] { new Pet() }.AsQueryable();
// Act
Action act = () => users.AsQueryable().Where("Income == @0.Select(Id).XXX()", pets);
// Assert
act.Should().Throw<InvalidOperationException>();
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Issues/Issue775.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 357
|
```smalltalk
using System.Collections.Generic;
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class Function : Entity
{
public string Code { get; set; }
public string Name { get; set; }
public ICollection<SubFunction> SubFunctions { get; set; }
public ICollection<Employee> Employees { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/Function.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 74
|
```smalltalk
using System.Collections.Generic;
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class Role : Entity
{
public string Name { get; set; }
public string Description { get; set; }
public ICollection<User> Users { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/Role.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 59
|
```smalltalk
using System.Collections.Generic;
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class Country : Entity
{
public string Code { get; set; }
public string Name { get; set; }
public ICollection<Employee> Employees { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/Country.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 59
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class EmployeeWrapper
{
public BaseEmployee Employee { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/EmployeeWrapper.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 32
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public interface IEntity
{
long Id { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/IEntity.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 30
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class Department
{
public BaseEmployee Employee { get; set; }
public BaseEmployee? NullableEmployee { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/Department.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 44
|
```smalltalk
using System.ComponentModel.DataAnnotations.Schema;
using Linq.PropertyTranslator.Core;
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class Employee : Entity
{
private static readonly CompiledExpressionMap<Employee, string> FullNameExpr =
DefaultTranslationOf<Employee>.Property(e => e.FullName).Is(e => e.FirstName + " " + e.LastName);
public int EmployeeNumber { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public string Email { get; set; }
public DateTime HireDate { get; set; }
public long? CompanyId { get; set; }
public long? CountryId { get; set; }
public long? FunctionId { get; set; }
public long? SubFunctionId { get; set; }
public Company Company { get; set; }
public Country Country { get; set; }
public Function Function { get; set; }
public SubFunction SubFunction { get; set; }
public int? Assigned { get; set; }
[NotMapped]
public string FullName => FullNameExpr.Evaluate(this);
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/Employee.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 244
|
```smalltalk
using System.Collections.Generic;
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class CompanyWithBaseEmployees
{
public ICollection<BaseEmployee> Employees { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/CompanyWithBaseEmployees.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 41
|
```smalltalk
using System.Collections.Generic;
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class User : Entity
{
public string IdentityName { get; set; }
public string DisplayName { get; set; }
public string EmailAddress { get; set; }
public ICollection<Role> Roles { get; set; }
public bool HasRole(string role)
{
return Roles.Any(r => r.Name == role);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/User.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 94
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class Product : Entity
{
public string Code { get; set; }
public string Name { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/Product.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 43
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class Worker : BaseEmployee
{
public string Other { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/Worker.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 33
|
```smalltalk
using System.Collections.Generic;
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class SubFunction : Entity
{
public string Code { get; set; }
public string Name { get; set; }
public long? FunctionId { get; set; }
public Function Function { get; set; }
public ICollection<Employee> Employees { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/SubFunction.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 82
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class Boss : BaseEmployee
{
public string Function { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/Boss.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 33
|
```smalltalk
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations.Schema;
namespace System.Linq.Dynamic.Core.Tests.Entities
{
[Table("KendoGrid_MainCompany")]
public class MainCompany : Entity
{
public string Name { get; set; }
public ICollection<Company> Companies { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/MainCompany.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 67
|
```smalltalk
using System.Collections.Generic;
namespace System.Linq.Dynamic.Core.Tests.Entities;
public class Company : Entity
{
public string Name { get; set; }
public long? MainCompanyId { get; set; }
public MainCompany MainCompany { get; set; }
public ICollection<Employee> Employees { get; set; }
public DateTime DateTime { get; set; }
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/Company.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 78
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Entities
{
public class OU : Entity
{
public string Code { get; set; }
public string Name { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Entities/OU.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 43
|
```smalltalk
using System.Linq.Expressions;
using System.Reflection;
namespace System.Linq.Dynamic.Core.Tests.Helpers
{
public static class ExpressionExtensions
{
public static string ToDebugView(this Expression exp)
{
if (exp == null)
{
return null;
}
var propertyInfo = typeof(Expression).GetProperty("DebugView", BindingFlags.Instance | BindingFlags.NonPublic);
return propertyInfo.GetValue(exp) as string;
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/ExpressionExtensions.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 91
|
```smalltalk
using System.Linq.Dynamic.Core.CustomTypeProviders;
namespace System.Linq.Dynamic.Core.Tests.Helpers
{
[DynamicLinqType]
public enum TestEnum
{
Var1 = 0,
Var2 = 1,
Var3 = 2,
Var4 = 4,
Var5 = 8,
Var6 = 16,
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/TestEnum.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 79
|
```smalltalk
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace System.Linq.Dynamic.Core.Tests.Helpers.Entities;
public class Blog
{
[Key]
[DatabaseGenerated(DatabaseGeneratedOption.None)]
public int BlogId { get; set; }
public string? X { get; set; }
public string Name { get; set; }
public int? NullableInt { get; set; }
public virtual ICollection<Post> Posts { get; set; }
#if NET461 || NET48
public DateTime Created { get; set; }
#else
public DateTimeOffset Created { get; set; }
#endif
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Entities/Blog.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 133
|
```smalltalk
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
namespace System.Linq.Dynamic.Core.Tests.Helpers.Entities;
public class Post
{
[Key]
[DatabaseGenerated(DatabaseGeneratedOption.None)]
public int PostId { get; set; }
public string Title { get; set; }
public string Content { get; set; }
public int BlogId { get; set; }
public virtual Blog Blog { get; set; }
public int NumberOfReads { get; set; }
public DateTime PostDate { get; set; }
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Entities/Post.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 116
|
```smalltalk
#if EFCORE
using System.Linq.Dynamic.Core.Tests.Logging;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;
using Microsoft.EntityFrameworkCore.Infrastructure;
using Microsoft.Extensions.DependencyInjection;
#else
using System.Data.Entity;
#endif
namespace System.Linq.Dynamic.Core.Tests.Helpers.Entities
{
#if EFCORE
public class BlogContext : DbContext
{
public BlogContext(DbContextOptions options)
: base(options)
{
}
public void EnableLogging()
{
var serviceProvider = this.GetInfrastructure();
var loggerFactory = serviceProvider.GetService<ILoggerFactory>();
loggerFactory.AddProvider(new DbLoggerProvider());
}
public DbSet<Blog> Blogs { get; set; }
public DbSet<Post> Posts { get; set; }
}
#else
[DbConfigurationType(typeof(CodeConfig))]
public class BlogContext : DbContext
{
// path_to_url
// path_to_url
public BlogContext(string nameOrConnectionString) : base(nameOrConnectionString)
{
AppDomain.CurrentDomain.SetData("DataDirectory", System.IO.Directory.GetCurrentDirectory());
}
//protected override void OnModelCreating(DbModelBuilder modelBuilder)
//{
// System.Data.Entity.SqlServer.SqlProviderServices.
// //var sqliteConnectionInitializer = new SqliteDropCreateDatabaseAlways<BlogContext>(modelBuilder);
// //Database.SetInitializer(sqliteConnectionInitializer);
//}
public DbSet<Blog> Blogs { get; set; }
public DbSet<Post> Posts { get; set; }
}
public class CodeConfig : DbConfiguration
{
public CodeConfig()
{
SetProviderServices("System.Data.SqlClient", System.Data.Entity.SqlServer.SqlProviderServices.Instance);
}
}
#endif
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Entities/BlogContext.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 353
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
{
public class Person
{
public int Id { get; set; }
public int? NullableId { get; set; }
public string Name { get; set; }
public DateTime D { get; set; }
public DateTimeOffset O { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/Person.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 74
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
{
public class SpecialPet : Pet
{
public bool IsSpecial { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/SpecialPet.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 36
|
```smalltalk
using System.Collections.Generic;
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
{
public class Role
{
public static readonly Role[] StandardRoles = {
new Role { Name="Admin", Permissions = new List<Permission> { new Permission { Name = "Admin" } } },
new Role { Name="User", Permissions = new List<Permission> { new Permission { Name = "User" } } },
new Role { Name="Guest", Permissions = new List<Permission> { new Permission { Name = "Guest" } } },
new Role { Name="G", Permissions = new List<Permission> { new Permission { Name = "G" } } },
new Role { Name="J", Permissions = new List<Permission> { new Permission { Name = "J" } } },
new Role { Name="A", Permissions = new List<Permission> { new Permission { Name = "A" } } }
};
public Role()
{
Id = Guid.NewGuid();
}
public Guid Id { get; set; }
public string Name { get; set; }
public List<Permission> Permissions { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/Role.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 247
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models;
public readonly struct BooleanVariable : IEquatable<bool>, IEquatable<BooleanVariable>, IConvertible
{
private readonly bool _innerValue;
public BooleanVariable(bool innerValue)
{
_innerValue = innerValue;
}
public override bool Equals(object obj)
{
return obj is bool val && Equals(val);
}
public bool Equals(bool other)
{
return _innerValue == other;
}
public bool Equals(BooleanVariable other)
{
return Equals(other._innerValue);
}
public override int GetHashCode()
{
return _innerValue.GetHashCode();
}
public static implicit operator bool(BooleanVariable v) => v._innerValue;
public static implicit operator BooleanVariable(bool b) => new BooleanVariable(b);
public static bool operator true(BooleanVariable v) => v._innerValue;
public static bool operator false(BooleanVariable v) => !v._innerValue;
// comparison to bool
public static bool operator ==(BooleanVariable a, bool b) => a._innerValue == b;
public static bool operator !=(BooleanVariable a, bool b) => a._innerValue != b;
// comparison to int
public static bool operator ==(BooleanVariable a, int b) => a._innerValue == (b != 0);
public static bool operator !=(BooleanVariable a, int b) => a._innerValue != (b != 0);
// comparison to decimal
public static bool operator ==(BooleanVariable a, decimal b) => a._innerValue == (b != 0);
public static bool operator !=(BooleanVariable a, decimal b) => a._innerValue != (b != 0);
// To/from self
public static bool operator ==(BooleanVariable a, BooleanVariable b) => a._innerValue == b._innerValue;
public static bool operator !=(BooleanVariable a, BooleanVariable b) => a._innerValue != b._innerValue;
#region IConvertible
public TypeCode GetTypeCode()
{
return _innerValue.GetTypeCode();
}
public bool ToBoolean(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToBoolean(provider);
}
public byte ToByte(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToByte(provider);
}
public char ToChar(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToChar(provider);
}
public DateTime ToDateTime(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToDateTime(provider);
}
public decimal ToDecimal(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToDecimal(provider);
}
public double ToDouble(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToDouble(provider);
}
public short ToInt16(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToInt16(provider);
}
public int ToInt32(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToInt32(provider);
}
public long ToInt64(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToInt64(provider);
}
public sbyte ToSByte(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToSByte(provider);
}
public float ToSingle(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToSingle(provider);
}
public string ToString(IFormatProvider provider)
{
return _innerValue.ToString(provider);
}
public object ToType(Type conversionType, IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToType(conversionType, provider);
}
public ushort ToUInt16(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToUInt16(provider);
}
public uint ToUInt32(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToUInt32(provider);
}
public ulong ToUInt64(IFormatProvider provider)
{
return ((IConvertible)_innerValue).ToUInt64(provider);
}
#endregion
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/BooleanVariable.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 898
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
{
public class Methods
{
public bool Method1(int value)
{
return value == 1;
}
public bool Method2(object value)
{
return value != null && (int)value == 1;
}
public bool Method3(object value)
{
Item item = value as Item;
return item != null && item.Value == 1;
}
public class Item
{
public int Value { get; set; }
}
public static bool StaticGenericMethod<T>(T value) => value is Item item && item.Value == 1;
public bool GenericMethod<T>(T value) => value is Item item && item.Value == 1;
}
public static class MethodsItemExtension
{
public class DummyFunctions { }
public static DummyFunctions Functions => new DummyFunctions();
public static T EfCoreCollate<T>(this DummyFunctions _, T value, string collation) => value;
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/Methods.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 216
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
{
public class UserProfileDetails
{
public long Id { get; set; }
private long Id2 { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/UserProfileDetails.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 43
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
{
public class Permission
{
public string Name { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/Permission.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 32
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
{
public class ModelWithEnum
{
public string Name { get; set; }
public TestEnum TestEnum { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/ModelWithEnum.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 46
|
```smalltalk
using System.Linq.Dynamic.Core.CustomTypeProviders;
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
{
public enum SimpleValuesModelEnum
{
A,
B
}
[DynamicLinqType]
public enum SimpleValuesModelEnumAsDynamicLinqType
{
A,
B
}
public class SimpleValuesModel
{
public int IntValue { get; set; }
public float FloatValue { get; set; }
public decimal DecimalValue { get; set; }
public double DoubleValue { get; set; }
public int? NullableIntValue { get; set; }
public double? NullableDoubleValue { get; set; }
public SimpleValuesModelEnum EnumValue { get; set; }
public SimpleValuesModelEnumAsDynamicLinqType EnumValueDynamicLinqType { get; set; }
public DateTime DateTime { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/SimpleValuesModel.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 197
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
{
public class UserProfile
{
public string FirstName { get; set; }
public string LastName { get; set; }
public int? Age { get; set; }
public UserProfileDetails UserProfileDetails { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/UserProfile.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 64
|
```smalltalk
using System.Collections.Generic;
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models;
public class User
{
public bool UserInfo { get; set; }
public Guid Id { get; set; }
public Guid? ParentId { get; set; }
public Guid? LegalPersonId { get; set; }
public Guid? PointSiteTD { get; set; }
public SnowflakeId SnowflakeId { get; set; }
public string UserName { get; set; }
public DateTime BirthDate { get; set; }
public DateTime? EndDate { get; set; }
public int? NullableInt { get; set; }
public int Income { get; set; }
public char C { get; set; }
public UserProfile? Profile { get; set; }
public UserState State { get; set; }
public List<Role> Roles { get; set; }
public bool TestMethod1()
{
return true;
}
public bool TestMethod2(User other)
{
return true;
}
public bool TestMethod3(User other)
{
return Id == other.Id;
}
public bool TryParseWithoutArgument(out string xxx)
{
return TryParseWithArgument(UserName, out xxx);
}
public bool TryParseWithArgument(string s, out string xxx)
{
if (s.EndsWith("1") || s.EndsWith("2"))
{
xxx = UserName;
return true;
}
xxx = "";
return false;
}
public bool TryParseWithArgumentAndTwoOut(string s, out string xxx, out int x)
{
x = 0;
return TryParseWithArgument(s, out xxx) && int.TryParse(s, out x);
}
public static IList<User> GenerateSampleModels(int total, bool allowNullableProfiles = false)
{
var list = new List<User>();
for (int i = 0; i < total; i++)
{
var user = new User
{
Id = Guid.NewGuid(),
SnowflakeId = new SnowflakeId(((ulong)long.MaxValue + (ulong)i + 2UL)),
UserName = "User" + i,
Income = 1 + (i % 15) * 100,
BirthDate = DateTime.UtcNow.AddYears(-50),
EndDate = i % 2 == 0 ? DateTime.UtcNow.AddYears(99) : null
};
if (!allowNullableProfiles || i % 8 != 5)
{
user.Profile = new UserProfile
{
FirstName = "FirstName" + i,
LastName = "LastName" + i,
Age = (i % 50) + 18
};
}
user.Roles = new List<Role>(Role.StandardRoles);
list.Add(user);
}
return list.ToArray();
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/User.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 605
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models;
public static class UserInfo
{
public static Guid Key => new("43b17e59-2b66-4697-a3ab-7b45baedee72");
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/UserInfo.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 49
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
{
public class Pet
{
public int Id { get; set; }
public string Name { get; set; }
public Person Owner { get; set; }
public int OwnerId { get; set; }
public int? NullableOwnerId { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/Pet.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 75
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
{
public class UserState
{
public Guid StatusCode { get; set; }
public string Description { get; set; }
public static implicit operator Guid(UserState state) => state?.StatusCode ?? Guid.Empty;
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/UserState.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 60
|
```smalltalk
namespace System.Linq.Dynamic.Core.Tests.Helpers.Models
{
public struct SnowflakeId : IEquatable<SnowflakeId>
{
public bool Equals(SnowflakeId other)
{
return Value == other.Value;
}
public override bool Equals(object obj)
{
return obj is SnowflakeId other && Equals(other);
}
public override int GetHashCode()
{
return Value.GetHashCode();
}
public static bool operator ==(SnowflakeId left, SnowflakeId right)
{
return left.Equals(right);
}
public static bool operator !=(SnowflakeId left, SnowflakeId right)
{
return !left.Equals(right);
}
public static bool operator ==(SnowflakeId left, int right)
{
return (int)left.Value == right;
}
public static bool operator !=(SnowflakeId left, int right)
{
return (int)left.Value != right;
}
public static bool operator ==(SnowflakeId left, ulong right)
{
return left.Value == right;
}
public static bool operator !=(SnowflakeId left, ulong right)
{
return left.Value != right;
}
public ulong Value { get; }
public SnowflakeId(ulong value)
{
Value = value;
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Helpers/Models/SnowflakeId.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 279
|
```smalltalk
using System.Reflection;
using Xunit.Sdk;
namespace System.Linq.Dynamic.Core.Tests.TestHelpers
{
#if !NET452
class DisplayTestMethodNameAttribute : BeforeAfterTestAttribute
{
public override void Before(MethodInfo methodUnderTest)
{
Console.WriteLine("Setup for test '{0}.'", methodUnderTest.Name);
}
public override void After(MethodInfo methodUnderTest)
{
Console.WriteLine("TearDown for test '{0}.'", methodUnderTest.Name);
}
}
#endif
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/TestHelpers/DisplayTestMethodNameAttribute.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 105
|
```smalltalk
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.TestHelpers;
internal class SkipIfGitHubActionsAttribute : FactAttribute
{
public SkipIfGitHubActionsAttribute()
{
if (IsRunningOnGitHubActions())
{
// ReSharper disable once VirtualMemberCallInConstructor
Skip = "This test is skipped on GitHub Actions";
}
}
/// <summary>
/// According to ChatGPT:
///
/// The GITHUB_ACTIONS environment variable is not officially documented by GitHub, but it is mentioned in the GitHub Actions documentation in a few places. Here are some relevant links:
/// [Context and expression syntax for GitHub Actions](path_to_url#github-context) - This page lists all the GitHub-specific context variables that are available in a GitHub Actions workflow, including GITHUB_ACTIONS.
/// [Virtual environments for GitHub-hosted runners](path_to_url#virtual-environments-for-github-hosted-runners) - This page explains the environment variables that are available on GitHub-hosted runners, including GITHUB_ACTIONS.
/// [Actions virtual environments](path_to_url#operating-systems) - This page provides more information about the virtual environments used by GitHub Actions, including the operating systems and software versions used on each environment.
/// </summary>
private static bool IsRunningOnGitHubActions()
{
return GetBool("GITHUB_ACTIONS") || GetBool("IsRunningOnGitHubActions");
}
private static bool GetBool(string variable)
{
return bool.TryParse(Environment.GetEnvironmentVariable(variable), out var value) && value;
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/TestHelpers/SkipIfGitHubActionsAttribute.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 325
|
```smalltalk
#if EFCORE
using Microsoft.EntityFrameworkCore.Storage.Internal;
using Microsoft.Extensions.Logging;
#if EFCORE_3X
using Microsoft.EntityFrameworkCore.Storage;
#endif
namespace System.Linq.Dynamic.Core.Tests.Logging
{
public class DbLoggerProvider : ILoggerProvider
{
private static readonly string[] Categories =
{
typeof(RelationalCommandBuilderFactory).FullName,
// typeof(SqliteRelationalConnection).FullName
};
public ILogger CreateLogger(string name)
{
if (Categories.Contains(name))
{
return new DbLogger();
}
return new NullLogger();
}
public void Dispose()
{
}
}
}
#endif
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Logging/DbLoggerProvider.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 135
|
```smalltalk
#if EFCORE
using Microsoft.Extensions.Logging;
namespace System.Linq.Dynamic.Core.Tests.Logging
{
public class DbLogger : ILogger
{
public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
{
var message = $"{Environment.NewLine}{formatter(state, exception)}";
if (message.ToLower().Contains("pi"))
Console.WriteLine(message);
}
public bool IsEnabled(LogLevel logLevel)
{
return true;
}
public IDisposable BeginScope<TState>(TState state)
{
return null;
}
}
}
#endif
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Logging/DbLogger.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 136
|
```smalltalk
#if EFCORE
using Microsoft.Extensions.Logging;
namespace System.Linq.Dynamic.Core.Tests.Logging
{
internal class NullLogger : ILogger
{
public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception exception, Func<TState, Exception, string> formatter)
{
}
public bool IsEnabled(LogLevel logLevel)
{
return false;
}
public IDisposable BeginScope<TState>(TState state)
{
return null;
}
}
}
#endif
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Logging/NullLogger.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 107
|
```smalltalk
using NFluent;
using System.Globalization;
using System.Linq.Dynamic.Core.Exceptions;
using System.Linq.Dynamic.Core.Tokenizer;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Tokenizer
{
public class TextParserTests
{
private readonly ParsingConfig _config = new ParsingConfig();
[Fact]
public void TextParser_Parse_Bar()
{
// Assign + Act
var textParser = new TextParser(_config, " | ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.Bar);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("|");
}
[Fact]
public void TextParser_Parse_Colon()
{
// Assign + Act
var textParser = new TextParser(_config, " : ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.Colon);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals(":");
}
[Fact]
public void TextParser_Parse_Exclamation()
{
// Assign + Act
var textParser = new TextParser(_config, " !x");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.Exclamation);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("!");
}
[Fact]
public void TextParser_Parse_ExclamationEqual()
{
// Assign + Act
var textParser = new TextParser(_config, " != 1");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.ExclamationEqual);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("!=");
}
[Fact]
public void TextParser_Parse_GreaterThanEqual()
{
// Assign + Act
var textParser = new TextParser(_config, " >= ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.GreaterThanEqual);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals(">=");
}
[Fact]
public void TextParser_Parse_HexadecimalIntegerLiteral()
{
// Assign + Act
var textParser = new TextParser(_config, " 0x1234567890AbCdEfL ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.IntegerLiteral);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("0x1234567890AbCdEfL");
Check.ThatCode(() => new TextParser(_config, "0xz1234")).Throws<ParseException>();
}
[Fact]
public void TextParser_Parse_LessGreater()
{
// Assign + Act
var textParser = new TextParser(_config, " <> ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.LessGreater);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("<>");
}
[Fact]
public void TextParser_Parse_NullPropagation()
{
// Assign + Act
var textParser = new TextParser(_config, " ?. ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.NullPropagation);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("?.");
}
[Fact]
public void TextParser_Parse_RealLiteral()
{
// Assign + Act
var textParser = new TextParser(_config, " 1.0E25 ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.RealLiteral);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("1.0E25");
Check.ThatCode(() => new TextParser(_config, "1.e25")).Throws<ParseException>();
}
[Fact]
public void TextParser_Parse_RealLiteralDecimalQualifier()
{
// Assign + Act
var textParser = new TextParser(_config, " 12.5m ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.RealLiteral);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("12.5m");
}
[Fact]
public void your_sha256_hashSeparator()
{
// Assign
var config = new ParsingConfig
{
NumberParseCulture = CultureInfo.CreateSpecificCulture("de-DE")
};
// Act
var textParser = new TextParser(config, " 12,5m ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.RealLiteral);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("12,5m");
}
[Fact]
public void TextParser_Parse_RealLiteralFloatQualifier()
{
// Assign + Act
var textParser = new TextParser(_config, " 12.5f ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.RealLiteral);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("12.5f");
}
[Fact]
public void TextParser_Parse_RealLiteralMinus()
{
// Assign + Act
var textParser = new TextParser(_config, " 1.0E-25 ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.RealLiteral);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("1.0E-25");
}
[Fact]
public void TextParser_Parse_RealLiteralPlus()
{
// Assign + Act
var textParser = new TextParser(_config, " 1.0E+25 ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.RealLiteral);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("1.0E+25");
}
[Fact]
public void TextParser_Parse_Percent()
{
// Assign + Act
var textParser = new TextParser(_config, " % ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.Percent);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("%");
}
[Fact]
public void TextParser_Parse_Slash()
{
// Assign + Act
var textParser = new TextParser(_config, " / ");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.Slash);
Check.That(textParser.CurrentToken.Pos).Equals(1);
Check.That(textParser.CurrentToken.Text).Equals("/");
}
[Fact]
public void TextParser_Parse_StringLiteral_WithSingleQuotes_Backslash()
{
// Assign + Act
var textParser = new TextParser(_config, "'\\'");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.StringLiteral);
Check.That(textParser.CurrentToken.Pos).Equals(0);
Check.That(textParser.CurrentToken.Text[1]).Equals('\\');
}
[Fact]
public void TextParser_Parse_StringLiteral_WithSingleQuotes_DoubleQuote()
{
// Assign + Act
var textParser = new TextParser(_config, "'\"'");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.StringLiteral);
Check.That(textParser.CurrentToken.Pos).Equals(0);
Check.That(textParser.CurrentToken.Text[1]).Equals('"');
}
[Fact]
public void TextParser_Parse_StringLiteral_WithSingleQuotes_SingleQuote()
{
// Assign + Act
var textParser = new TextParser(_config, "'\''");
// Assert
Check.That(textParser.CurrentToken.Id).Equals(TokenId.StringLiteral);
Check.That(textParser.CurrentToken.Pos).Equals(0);
Check.That(textParser.CurrentToken.Text[1]).Equals('\'');
}
[Fact]
public void TextParser_Parse_ThrowsException()
{
// Assign + Act + Assert
//Check.ThatCode(() => { new TextParser(""); }).Throws<ParseException>();
Check.ThatCode(() => { new TextParser(_config, ";"); }).Throws<ParseException>();
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Tokenizer/TextParserTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,859
|
```smalltalk
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq.Expressions;
using FluentAssertions;
using NFluent;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.MikArea
{
public class Dictionary
{
public class Customer
{
public string City { get; set; }
public Dictionary<string, Order> Orders { get; set; }
public IReadOnlyDictionary<string, Order> ReadOnlyOrders { get; set; }
public string CompanyName { get; set; }
public string Phone { get; set; }
}
public class Order
{
}
[Fact]
public void ReadOnlyDictionary_ContainsKey_1()
{
var orders = new ReadOnlyDictionary<string, Order>(new Dictionary<string, Order>
{
{ "TEST", new Order() }
});
var customers = new List<Customer>
{
new Customer { City = "abc", CompanyName = "ZZZ", ReadOnlyOrders = orders }
};
var data = customers.AsQueryable()
.Where("ReadOnlyOrders.ContainsKey(\"TEST\")")
.ToList();
data.Should().HaveCount(1);
}
[Fact]
public void Dictionary_ContainsKey_1()
{
var customers = new List<Customer>
{
new Customer { City = "ZZZ1", CompanyName = "ZZZ", Orders = new Dictionary<string, Order>() },
new Customer { City = "ZZZ2", CompanyName = "ZZZ", Orders = new Dictionary<string, Order>() },
new Customer { City = "ZZZ3", CompanyName = "ZZZ", Orders = new Dictionary<string, Order>() }
};
customers.ForEach(x => x.Orders.Add(x.City + "TEST", new Order()));
var data = customers.AsQueryable()
.Where("Orders.ContainsKey(\"ZZZ2TEST\")")
.OrderBy("CompanyName")
.Select("new(City as City, Phone)").ToDynamicList();
Check.That("ZZZ2").IsEqualTo((string)data.First().City);
}
[Fact]
public void Dictionary_ContainsKey_2()
{
var customers = new List<Customer>
{
new Customer { City = "ZZZ1", CompanyName = "ZZZ", Orders = new Dictionary<string, Order>() },
new Customer { City = "ZZZ2", CompanyName = "ZZZ", Orders = new Dictionary<string, Order>() },
new Customer { City = "ZZZ3", CompanyName = "ZZZ", Orders = new Dictionary<string, Order>() }
};
customers.ForEach(x => x.Orders.Add(x.City + "TEST", new Order()));
var data = customers.AsQueryable()
.Where("Orders.ContainsKey(it.City + \"TEST\")")
.OrderBy("City")
.Select("new(City as City, Phone)").ToDynamicList();
Check.That("ZZZ1").IsEqualTo((string)data.First().City);
Check.That(3).IsEqualTo(data.Count);
}
[Fact]
public void Dictionary_ContainsKey_3()
{
var customers = new List<Customer>
{
new Customer { City = "ZZZ1", CompanyName = "ZZZ", Orders = new Dictionary<string, Order>() },
new Customer { City = "ZZZ2", CompanyName = "ZZZ", Orders = new Dictionary<string, Order>() },
new Customer { City = "ZZZ3", CompanyName = "ZZZ", Orders = new Dictionary<string, Order>() }
};
customers.ForEach(x => x.Orders.Add(x.City + "TEST1", new Order()));
customers.ForEach(x => x.Orders.Add(x.City + "TEST2", new Order()));
var noDynamicList = customers
.Where(x => x.Orders.Skip(1).First().Key == (x.City + "TEST2"))
.OrderBy(x => x.City)
.ToList();
var data = customers.AsQueryable()
.Where("Orders.Skip(1).First().Key == (it.City + \"TEST2\")")
.OrderBy("City")
.Select("new(City as City, Phone)").ToDynamicList();
Check.That(3).IsEqualTo(noDynamicList.Count);
Check.That("ZZZ1").IsEqualTo((string)data.First().City);
Check.That(3).IsEqualTo(data.Count);
}
[Fact(Skip = "Fails sometimes in GitHub CI build")]
public void DynamicIndexCall() // path_to_url
{
object CreateDicParameter(string name) => new Dictionary<string, object>
{
{ "Name", new Dictionary<string, object> { { "FirstName", name }, { "LastName", name + "Test" } } }
};
var parType = new Dictionary<string, object>().GetType();
var lambda = DynamicExpressionParser.ParseLambda(new[] { Expression.Parameter(parType, "item") },
typeof(object), "item.Name.FirstName + \"7\" + item.Name.LastName ").Compile();
var x1 = lambda.DynamicInvoke(CreateDicParameter("Julio"));
var x2 = lambda.DynamicInvoke(CreateDicParameter("John"));
Check.That(x1).IsEqualTo("Julio7JulioTest");
Check.That(x2).IsEqualTo("John7JohnTest");
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/MikArea/Dictionary.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,104
|
```smalltalk
using NFluent;
using System.Linq.Dynamic.Core.Util;
using System.Linq.Expressions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Util
{
public class ParameterExpressionRenamerTests
{
[Theory]
[InlineData("test", "(test + 42)")]
public void ParameterExpressionRenamer_Rename_ToNewName(string newName, string resultString)
{
// Assign
var expression = Expression.Add(Expression.Parameter(typeof(int), ""), Expression.Constant(42));
var sut = new ParameterExpressionRenamer(newName);
// Act
string result = sut.Rename(expression, out ParameterExpression parameterExpression).ToString();
// Assert
Check.That(result).IsEqualTo(resultString);
Check.That(parameterExpression.Name).IsEqualTo(newName);
}
[Theory]
[InlineData("", "test", "(test + 42)")]
[InlineData("x", "test", "(test + 42)")]
public void ParameterExpressionRenamer_Rename_OldNameInNewName(string oldName, string newName, string resultString)
{
// Assign
var expression = Expression.Add(Expression.Parameter(typeof(int), oldName), Expression.Constant(42));
var sut = new ParameterExpressionRenamer(oldName, newName);
// Act
string result = sut.Rename(expression, out ParameterExpression parameterExpression).ToString();
// Assert
Check.That(result).IsEqualTo(resultString);
Check.That(parameterExpression.Name).IsEqualTo(newName);
}
[Fact]
public void ParameterExpressionRenamer_Rename_NoParameterExpressionPresent()
{
// Assign
var expression = Expression.Add(Expression.Constant(1), Expression.Constant(2));
var sut = new ParameterExpressionRenamer("test");
// Act
string result = sut.Rename(expression, out ParameterExpression parameterExpression).ToString();
// Assert
Check.That(result).IsEqualTo("(1 + 2)");
Check.That(parameterExpression).IsNull();
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Util/ParameterExpressionRenamerTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 412
|
```smalltalk
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
using System.Linq.Expressions;
using NFluent;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.MikArea
{
public class Comparer
{
public class Customer
{
public string City { get; set; }
public List<Order> Orders { get; set; }
public string CompanyName { get; set; }
public string Phone { get; set; }
}
public class Order
{
}
class DataClass1
{
public bool IsTrue;
public string Name;
}
class DataClass2
{
public bool ISTrue;
public bool IsTrue;
public string Name;
}
[Fact]
public void Comparer_OrderBy_And_ThenBy()
{
var customers = new List<Customer>
{
new Customer { CompanyName = "" },
new Customer { CompanyName = "Bbb" },
new Customer { CompanyName = "" },
new Customer { CompanyName = "Bbb" },
new Customer { CompanyName = "Aaa" },
new Customer { CompanyName = "Aaa" }
};
var culture = new CultureInfo("nb-NO");
var test1 = customers.AsQueryable().OrderBy(x => x.CompanyName, StringComparer.Create(culture, true)).ToList();
var test2 = customers.AsQueryable().OrderBy(x => x.CompanyName).ToList();
var test3 = customers.AsQueryable().OrderBy(x => x.City).ThenBy(x => x.CompanyName, StringComparer.Create(culture, true)).ToList();
var test2_V2 = customers.AsQueryable()
.OrderBy("CompanyName");
var test3_V2 = customers.AsQueryable()
.OrderBy("City").ThenBy("CompanyName", StringComparer.Create(culture, true));
var test1_V2 = customers.AsQueryable()
.OrderBy("CompanyName", StringComparer.Create(culture, true));
for (var i = 0; i < test2.Count; i++)
{
Check.That(test2.ElementAt(i).CompanyName).IsEqualTo(test2_V2.ElementAt(i).CompanyName);
}
for (var i = 0; i < test1.Count; i++)
{
Check.That(test1.ElementAt(i).CompanyName).IsEqualTo(test1_V2.ElementAt(i).CompanyName);
}
for (var i = 0; i < test3.Count; i++)
{
Check.That(test3.ElementAt(i).CompanyName).IsEqualTo(test3_V2.ElementAt(i).CompanyName);
}
}
[Fact]
public void Comparer_GroupBy()
{
var customers = new List<Customer> { new Customer { City = "ZZZ" }, new Customer { City = "ZzZ" } };
var check = customers.GroupBy(x => x.City, StringComparer.InvariantCultureIgnoreCase).ToList();
var check2 = customers.GroupBy(x => x.City, x => new { Name = x.CompanyName, Phone = x.Phone }, StringComparer.InvariantCultureIgnoreCase).ToList();
var check3 = customers.GroupBy(x => x.City, x => new { Name = x.CompanyName, Phone = x.Phone }).ToList();
var check_V2 = customers.AsQueryable().GroupBy("City", StringComparer.InvariantCultureIgnoreCase);
var check2_V2 = customers.AsQueryable().GroupBy("City", "new(CompanyName as Name, Phone)", StringComparer.InvariantCultureIgnoreCase);
var check3_V2 = customers.AsQueryable().GroupBy("City", "new(CompanyName as Name, Phone)");
Check.That(check.Count).IsEqualTo(check_V2.Count());
Check.That(check2.Count).IsEqualTo(check2_V2.Count());
Check.That(check3.Count).IsEqualTo(check3_V2.Count());
}
[Fact]
public void Comparer_Parameter_1()
{
var isTrue = false;
var abc = new List<DataClass1> { new DataClass1 { IsTrue = true, Name = "1" } };
var x = new List<ParameterExpression>
{
Expression.Parameter(isTrue.GetType(), "isTrue"),
Expression.Parameter(abc.GetType(), "abc")
};
var config = new ParsingConfig();
var query = "abc.Where(IsTrue == true)";
config.IsCaseSensitive = true;
var e = DynamicExpressionParser.ParseLambda(config, x.ToArray(), null, query);
var del = e.Compile();
var result = ((IEnumerable)del.DynamicInvoke(isTrue, abc)).GetEnumerator();
result.MoveNext();
var t = result.Current;
Check.That(t).IsNotNull();
}
[Fact]
public void Comparer_Parameter_2()
{
var isTrue = false;
var abc = new List<DataClass1> { new DataClass1 { IsTrue = true, Name = "1" } };
var x = new List<ParameterExpression>
{
Expression.Parameter(isTrue.GetType(), "isTrue"),
Expression.Parameter(abc.GetType(), "abc")
};
var config = new ParsingConfig();
var query = "abc.Where(IsTrue == true)";
var e = DynamicExpressionParser.ParseLambda(config, x.ToArray(), null, query);
var del = e.Compile();
var result = ((IEnumerable)del.DynamicInvoke(isTrue, abc)).GetEnumerator();
result.MoveNext();
var t = result.Current;
Check.That(t).IsNull();
}
[Fact]
public void Comparer_Property_1()
{
var abc = new List<DataClass2> { new DataClass2 { IsTrue = true, Name = "1" } };
var x = new List<ParameterExpression> { Expression.Parameter(abc.GetType(), "abc") };
var config = new ParsingConfig();
var query = "abc.Where(IsTrue == true)";
config.IsCaseSensitive = true;
var e = DynamicExpressionParser.ParseLambda(config, x.ToArray(), null, query);
var del = e.Compile();
var result = ((IEnumerable)del.DynamicInvoke(abc)).GetEnumerator();
result.MoveNext();
var t = result.Current;
Check.That(t).IsNotNull();
}
[Fact]
public void Comparer_Property_2()
{
var abc = new List<DataClass2> { new DataClass2 { IsTrue = true, Name = "1" } };
var x = new List<ParameterExpression> { Expression.Parameter(abc.GetType(), "abc") };
var config = new ParsingConfig();
var query = "abc.Where(IsTrue == true)";
object t;
try
{
var e = DynamicExpressionParser.ParseLambda(config, x.ToArray(), null, query);
var del = e.Compile();
var result = ((IEnumerable)del.DynamicInvoke(abc)).GetEnumerator();
result.MoveNext();
t = result.Current;
}
catch
{
return;
}
Check.That(t).IsNull();
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/MikArea/Comparer.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,452
|
```smalltalk
using System.Linq.Dynamic.Core.Parser;
using FluentAssertions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser;
public class WrappedValueTests
{
[Fact]
public void WrappedValue_OfTypeString_OperatorEquals_String()
{
// Arrange
var wrapped = new WrappedValue<string>("str");
// Act
var result1A = wrapped == "str";
var result1B = "str" == wrapped;
var result2A = wrapped == "x";
var result2B = "x" == wrapped;
// Assert
result1A.Should().BeTrue();
result1B.Should().BeTrue();
result2A.Should().BeFalse();
result2B.Should().BeFalse();
}
[Fact]
public void WrappedValue_OfTypeString_OperatorNotEquals_String()
{
// Arrange
var wrapped = new WrappedValue<string>("str");
// Act
var result1A = wrapped != "str";
var result1B = "str" != wrapped;
var result2A = wrapped == "x";
var result2B = "x" == wrapped;
// Assert
result1A.Should().BeFalse();
result1B.Should().BeFalse();
result2A.Should().BeFalse();
result2B.Should().BeFalse();
}
[Fact]
public void your_sha256_hashng()
{
// Arrange
var wrapped = new WrappedValue<string>("str");
var testEqual = new WrappedValue<string>("str");
var testNotEqual = new WrappedValue<string>("x");
// Act
var result1A = wrapped == testEqual;
var result1B = testEqual == wrapped;
var result2A = wrapped == testNotEqual;
var result2B = testNotEqual == wrapped;
// Assert
result1A.Should().BeTrue();
result1B.Should().BeTrue();
result2A.Should().BeFalse();
result2B.Should().BeFalse();
}
[Fact]
public void your_sha256_hashtring()
{
// Arrange
var wrapped = new WrappedValue<string>("str");
var testEqual = new WrappedValue<string>("str");
var testNotEqual = new WrappedValue<string>("x");
// Act
var result1A = wrapped != testEqual;
var result1B = testEqual != wrapped;
var result2A = wrapped != testNotEqual;
var result2B = testNotEqual != wrapped;
// Assert
result1A.Should().BeFalse();
result1B.Should().BeFalse();
result2A.Should().BeTrue();
result2B.Should().BeTrue();
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/WrappedValueTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 578
|
```smalltalk
using Moq;
using System.Linq.Dynamic.Core.Util;
using System.Linq.Dynamic.Core.Util.Cache;
using System.Linq.Expressions;
using System.Threading;
using FluentAssertions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Util.Cache;
public class SlidingCacheTests
{
private static readonly DateTime UtcNow = new(2024, 1, 1, 0, 0, 0);
[Fact]
public void SlidingCache_CacheOperations()
{
var dateTimeUtilsMock = new Mock<IDateTimeUtils>();
// Configure Mock with SetupGet since SlidingCache can be non-deterministic; don't use SetupSequence
dateTimeUtilsMock.SetupGet(d => d.UtcNow).Returns(UtcNow);
// Arrange
var cache = new SlidingCache<int, string>(
TimeSpan.FromSeconds(1),
dateTimeProvider: dateTimeUtilsMock.Object);
// Add
cache.AddOrUpdate(1, "one");
cache.AddOrUpdate(2, "two");
cache.AddOrUpdate(3, "three");
// Replace
cache.AddOrUpdate(1, "oneone");
cache.Count.Should().Be(3, $"Expected 3 items in the cache, only had {cache.Count}");
// Test retrieval
Assert.True(cache.TryGetValue(1, out _), "Expected to find the value, but did not");
Assert.True(cache.TryGetValue(2, out _), "Expected to find the value, but did not");
Assert.True(cache.TryGetValue(3, out _), "Expected to find the value, but did not");
// Test Removal
cache.Remove(1);
cache.Count.Should().Be(2, $"Expected 2 items in the cache, only had {cache.Count}");
}
[Fact]
public void SlidingCache_TestExpire()
{
var dateTimeUtilsMock = new Mock<IDateTimeUtils>();
// Configure Mock with SetupGet since SlidingCache can be non-deterministic; don't use SetupSequence
dateTimeUtilsMock.SetupGet(d => d.UtcNow).Returns(UtcNow);
// Arrange
var cache = new SlidingCache<int, string>(TimeSpan.FromMinutes(10),
dateTimeProvider: dateTimeUtilsMock.Object);
// Act
cache.AddOrUpdate(1, "one");
// move the time forward
var newDateTime = UtcNow.AddMinutes(11);
dateTimeUtilsMock.SetupGet(d => d.UtcNow).Returns(newDateTime);
// Ensure that the element has expired
cache.TryGetValue(1, out var value).Should().BeFalse($"Expected to not find the value, but found {value}");
}
[Fact]
public void SlidingCache_TestReturnExpiredItems()
{
var dateTimeUtilsMock = new Mock<IDateTimeUtils>();
// Configure Mock with SetupGet since SlidingCache can be non-deterministic; don't use SetupSequence
dateTimeUtilsMock.SetupGet(d => d.UtcNow).Returns(UtcNow);
// Arrange
var cache = new SlidingCache<int, string>(TimeSpan.FromMinutes(10),
dateTimeProvider: dateTimeUtilsMock.Object, returnExpiredItems: true);
// Act
cache.AddOrUpdate(1, "one");
// move the time forward
var newDateTime = UtcNow.AddMinutes(11);
dateTimeUtilsMock.SetupGet(d => d.UtcNow).Returns(newDateTime);
// Ensure the expired item is returned from the cache
cache.TryGetValue(1, out _).Should().BeTrue("Expected to return expired item");
}
[Fact]
public void SlidingCache_TestAutoExpire()
{
var dateTimeUtilsMock = new Mock<IDateTimeUtils>();
// Configure Mock with SetupGet since SlidingCache can be non-deterministic; don't use SetupSequence
dateTimeUtilsMock.SetupGet(d => d.UtcNow).Returns(UtcNow);
// Arrange
var cache = new SlidingCache<int, string>(
TimeSpan.FromMinutes(10),
dateTimeProvider: dateTimeUtilsMock.Object);
// Act
cache.AddOrUpdate(1, "one");
// Ensure one item is in the cache
cache.Count.Should().Be(1, $"Expected 1 items in the cache, had {cache.Count}");
// move the time forward
var newDateTime = UtcNow.AddMinutes(11);
dateTimeUtilsMock.SetupGet(d => d.UtcNow).Returns(newDateTime);
// Trigger the cleanup, asking for non-existing key
cache.TryGetValue(10, out _);
// Since the cache cleanup is triggered by a Task and not on the same thread,
// give it a moment for the cleanup to happen
Sleep();
// Ensure no item is in the cache
cache.Count.Should().Be(0, $"Expected 0 items in the cache, had {cache.Count}");
}
[Fact]
public void SlidingCache_TestNull()
{
// Arrange
var cache = new SlidingCache<Expression, string>(TimeSpan.FromMinutes(10));
// Expect an ArgumentNullException
Assert.Throws<ArgumentNullException>(() => { cache.AddOrUpdate(null, "one"); });
}
[Fact]
public void SlidingCache_TestMinNumberBeforeTests()
{
var dateTimeUtilsMock = new Mock<IDateTimeUtils>();
// Configure Mock with SetupGet since SlidingCache can be non-deterministic; don't use SetupSequence
dateTimeUtilsMock.SetupGet(d => d.UtcNow).Returns(UtcNow);
// Arrange
var cache = new SlidingCache<int, string>(
TimeSpan.FromMinutes(10),
minCacheItemsBeforeCleanup: 2,
dateTimeProvider: dateTimeUtilsMock.Object);
// Act
cache.AddOrUpdate(1, "one");
// Ensure one item is in the cache
cache.Count.Should().Be(1, $"Expected 1 items in the cache, only had {cache.Count}");
// move the time forward
var newDateTime = UtcNow.AddMinutes(11);
dateTimeUtilsMock.SetupGet(d => d.UtcNow).Returns(newDateTime);
// Trigger the cleanup, asking for non-existing key
cache.TryGetValue(10, out _);
// Since the cache cleanup is triggered by a Task and not on the same thread,
// give it a moment for the cleanup to happen
Sleep();
// Ensure one item is in the cache
cache.Count.Should().Be(1, $"Expected 1 items in the cache, only had {cache.Count}");
// Act
cache.AddOrUpdate(2, "two");
// Since the cache cleanup is triggered by a Task and not on the same thread,
// give it a moment for the cleanup to happen
Sleep();
// Ensure one item is in the cache
cache.Count.Should().Be(1, $"Expected 1 items in the cache, had {cache.Count}");
}
private static void Sleep()
{
Thread.Sleep(1000);
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Util/Cache/SlidingCacheTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,465
|
```smalltalk
using NFluent;
using System.Linq.Dynamic.Core.Parser;
using System.Linq.Expressions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser
{
public class ParameterExpressionHelperTests
{
[Theory]
[InlineData(typeof(int), "it", "x", "x", false)]
[InlineData(typeof(int), "it == 1", @"\(x == 1\)", "x", false)]
[InlineData(typeof(int), "it eq 1", @"\(x == 1\)", "x", false)]
[InlineData(typeof(int), "it equal 1", @"\(x == 1\)", "x", false)]
[InlineData(typeof(int), "it != 1", @"\(x != 1\)", "x", false)]
[InlineData(typeof(int), "it ne 1", @"\(x != 1\)", "x", false)]
[InlineData(typeof(int), "it neq 1", @"\(x != 1\)", "x", false)]
[InlineData(typeof(int), "it notequal 1", @"\(x != 1\)", "x", false)]
[InlineData(typeof(int), "it lt 1", @"\(x < 1\)", "x", false)]
[InlineData(typeof(int), "it LessThan 1", @"\(x < 1\)", "x", false)]
[InlineData(typeof(int), "it le 1", @"\(x <= 1\)", "x", false)]
[InlineData(typeof(int), "it LessThanEqual 1", @"\(x <= 1\)", "x", false)]
[InlineData(typeof(int), "it gt 1", @"\(x > 1\)", "x", false)]
[InlineData(typeof(int), "it GreaterThan 1", @"\(x > 1\)", "x", false)]
[InlineData(typeof(int), "it ge 1", @"\(x >= 1\)", "x", false)]
[InlineData(typeof(int), "it GreaterThanEqual 1", @"\(x >= 1\)", "x", false)]
[InlineData(typeof(int), "it", "x", "x", true)]
[InlineData(typeof(int), "it == 1", @"\(x == 1\)", "x", true)]
[InlineData(typeof(int), "it eq 1", @"\(x == 1\)", "x", true)]
[InlineData(typeof(int), "it equal 1", @"\(x == 1\)", "x", true)]
[InlineData(typeof(int), "it != 1", @"\(x != 1\)", "x", true)]
[InlineData(typeof(int), "it ne 1", @"\(x != 1\)", "x", true)]
[InlineData(typeof(int), "it neq 1", @"\(x != 1\)", "x", true)]
[InlineData(typeof(int), "it notequal 1", @"\(x != 1\)", "x", true)]
[InlineData(typeof(int), "it lt 1", @"\(x < 1\)", "x", true)]
[InlineData(typeof(int), "it LessThan 1", @"\(x < 1\)", "x", true)]
[InlineData(typeof(int), "it le 1", @"\(x <= 1\)", "x", true)]
[InlineData(typeof(int), "it LessThanEqual 1", @"\(x <= 1\)", "x", true)]
[InlineData(typeof(int), "it gt 1", @"\(x > 1\)", "x", true)]
[InlineData(typeof(int), "it GreaterThan 1", @"\(x > 1\)", "x", true)]
[InlineData(typeof(int), "it ge 1", @"\(x >= 1\)", "x", true)]
[InlineData(typeof(int), "it GreaterThanEqual 1", @"\(x >= 1\)", "x", true)]
[InlineData(typeof(int), "it", "Param_0", "", false)]
[InlineData(typeof(int), "it == 1", @"\(Param_0 == 1\)", "", false)]
[InlineData(typeof(int), "it eq 1", @"\(Param_0 == 1\)", "", false)]
[InlineData(typeof(int), "it equal 1", @"\(Param_0 == 1\)", "", false)]
[InlineData(typeof(int), "it != 1", @"\(Param_0 != 1\)", "", false)]
[InlineData(typeof(int), "it ne 1", @"\(Param_0 != 1\)", "", false)]
[InlineData(typeof(int), "it neq 1", @"\(Param_0 != 1\)", "", false)]
[InlineData(typeof(int), "it notequal 1", @"\(Param_0 != 1\)", "", false)]
[InlineData(typeof(int), "it lt 1", @"\(Param_0 < 1\)", "", false)]
[InlineData(typeof(int), "it LessThan 1", @"\(Param_0 < 1\)", "", false)]
[InlineData(typeof(int), "it le 1", @"\(Param_0 <= 1\)", "", false)]
[InlineData(typeof(int), "it LessThanEqual 1", @"\(Param_0 <= 1\)", "", false)]
[InlineData(typeof(int), "it gt 1", @"\(Param_0 > 1\)", "", false)]
[InlineData(typeof(int), "it GreaterThan 1", @"\(Param_0 > 1\)", "", false)]
[InlineData(typeof(int), "it ge 1", @"\(Param_0 >= 1\)", "", false)]
[InlineData(typeof(int), "it GreaterThanEqual 1", @"\(Param_0 >= 1\)", "", false)]
[InlineData(typeof(int), "it", "[a-z]{16}", "", true)]
[InlineData(typeof(int), "it == 1", @"\([a-z]{16} == 1\)", "", true)]
[InlineData(typeof(int), "it eq 1", @"\([a-z]{16} == 1\)", "", true)]
[InlineData(typeof(int), "it equal 1", @"\([a-z]{16} == 1\)", "", true)]
[InlineData(typeof(int), "it != 1", @"\([a-z]{16} != 1\)", "", true)]
[InlineData(typeof(int), "it ne 1", @"\([a-z]{16} != 1\)", "", true)]
[InlineData(typeof(int), "it neq 1", @"\([a-z]{16} != 1\)", "", true)]
[InlineData(typeof(int), "it notequal 1", @"\([a-z]{16} != 1\)", "", true)]
[InlineData(typeof(int), "it lt 1", @"\([a-z]{16} < 1\)", "", true)]
[InlineData(typeof(int), "it LessThan 1", @"\([a-z]{16} < 1\)", "", true)]
[InlineData(typeof(int), "it le 1", @"\([a-z]{16} <= 1\)", "", true)]
[InlineData(typeof(int), "it LessThanEqual 1", @"\([a-z]{16} <= 1\)", "", true)]
[InlineData(typeof(int), "it gt 1", @"\([a-z]{16} > 1\)", "", true)]
[InlineData(typeof(int), "it GreaterThan 1", @"\([a-z]{16} > 1\)", "", true)]
[InlineData(typeof(int), "it ge 1", @"\([a-z]{16} >= 1\)", "", true)]
[InlineData(typeof(int), "it GreaterThanEqual 1", @"\([a-z]{16} >= 1\)", "", true)]
[InlineData(typeof(bool), "it || true", @"\(x OrElse True\)", "x", false)]
[InlineData(typeof(bool), "it or true", @"\(x OrElse True\)", "x", false)]
[InlineData(typeof(bool), "it OrElse true", @"\(x OrElse True\)", "x", false)]
[InlineData(typeof(bool), "it || true", @"\(x OrElse True\)", "x", true)]
[InlineData(typeof(bool), "it or true", @"\(x OrElse True\)", "x", true)]
[InlineData(typeof(bool), "it OrElse true", @"\(x OrElse True\)", "x", true)]
[InlineData(typeof(bool), "it || true", @"\(Param_0 OrElse True\)", "", false)]
[InlineData(typeof(bool), "it or true", @"\(Param_0 OrElse True\)", "", false)]
[InlineData(typeof(bool), "it OrElse true", @"\(Param_0 OrElse True\)", "", false)]
[InlineData(typeof(bool), "it || true", @"\([a-z]{16} OrElse True\)", "", true)]
[InlineData(typeof(bool), "it or true", @"\([a-z]{16} OrElse True\)", "", true)]
[InlineData(typeof(bool), "it OrElse true", @"\([a-z]{16} OrElse True\)", "", true)]
[InlineData(typeof(bool), "it && true", @"\(x AndAlso True\)", "x", false)]
[InlineData(typeof(bool), "it and true", @"\(x AndAlso True\)", "x", false)]
[InlineData(typeof(bool), "it AndAlso true", @"\(x AndAlso True\)", "x", false)]
[InlineData(typeof(bool), "it && true", @"\(x AndAlso True\)", "x", true)]
[InlineData(typeof(bool), "it and true", @"\(x AndAlso True\)", "x", true)]
[InlineData(typeof(bool), "it AndAlso true", @"\(x AndAlso True\)", "x", true)]
[InlineData(typeof(bool), "it && true", @"\(Param_0 AndAlso True\)", "", false)]
[InlineData(typeof(bool), "it and true", @"\(Param_0 AndAlso True\)", "", false)]
[InlineData(typeof(bool), "it AndAlso true", @"\(Param_0 AndAlso True\)", "", false)]
[InlineData(typeof(bool), "it && true", @"\([a-z]{16} AndAlso True\)", "", true)]
[InlineData(typeof(bool), "it and true", @"\([a-z]{16} AndAlso True\)", "", true)]
[InlineData(typeof(bool), "it AndAlso true", @"\([a-z]{16} AndAlso True\)", "", true)]
public void ParameterExpressionHelper_CreateParameterExpression(Type type, string expression, string expectedResult, string substitute, bool renameEmpty)
{
// Arrange
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(type, substitute, renameEmpty) };
var sut = new ExpressionParser(parameters, expression, null, null);
// Act
var parsedExpression = sut.Parse(null).ToString();
// Assert
Check.That(parsedExpression).Matches(expectedResult);
}
[Theory]
[InlineData(null, true)]
[InlineData("", true)]
[InlineData(" ", true)]
[InlineData(" ", true)]
[InlineData(" ", true)]
[InlineData(" ", true)]
[InlineData("\t", true)]
[InlineData("\n", true)]
[InlineData("x", false)]
[InlineData("xx", false)]
[InlineData("xxx", false)]
[InlineData("xxxx", false)]
[InlineData("!", false)]
[InlineData("\"", false)]
[InlineData("$", false)]
[InlineData("_", false)]
[InlineData("-", false)]
public void ParameterExpressionHelper_IsNullOrWhiteSpace(string input, bool expectedResult)
{
// Arrange and Act
bool result = input.IsNullOrWhiteSpace();
// Assert
Check.That(result).IsEqualTo(expectedResult);
}
[Fact]
public void ParameterExpressionHelper_GenerateRandom16CharWord()
{
// Arrange and Act
string result = ParameterExpressionHelper.GenerateRandomWord();
// Assert
Check.That(result).Matches(@"[a-z]{16}");
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/ParameterExpressionHelperTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 2,587
|
```smalltalk
using System.Linq.Dynamic.Core.Parser;
using FluentAssertions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser;
public class PredefinedTypesHelperTests
{
[Fact]
public void IsPredefinedType_ShouldReturnFalse_ForNonPredefinedTypes()
{
// Arrange
var config = new ParsingConfig();
// Act & Assert
PredefinedTypesHelper.IsPredefinedType(config, typeof(IO.File)).Should().BeFalse();
}
[Fact]
public void IsPredefinedType_ShouldReturnTrue_ForPredefinedTypes()
{
// Arrange
var config = new ParsingConfig();
var predefinedTypes = PredefinedTypesHelper.PredefinedTypes.Keys;
// Act & Assert
foreach (var predefinedType in predefinedTypes)
{
PredefinedTypesHelper.IsPredefinedType(config, predefinedType).Should().BeTrue();
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/PredefinedTypesHelperTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 185
|
```smalltalk
using System.Collections.Generic;
using System.Linq.Dynamic.Core.CustomTypeProviders;
using System.Linq.Dynamic.Core.Exceptions;
using System.Linq.Dynamic.Core.Parser;
using System.Linq.Dynamic.Core.Tests.Entities;
using System.Linq.Expressions;
using FluentAssertions;
using Moq;
using NFluent;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser;
public partial class ExpressionParserTests
{
private readonly Mock<IDynamicLinkCustomTypeProvider> _dynamicTypeProviderMock;
private readonly ParsingConfig _parsingConfig;
[Flags]
public enum ExampleFlags
{
None = 0,
A = 1,
B = 2,
C = 4,
D = 8,
};
public ExpressionParserTests()
{
_dynamicTypeProviderMock = new Mock<IDynamicLinkCustomTypeProvider>();
_dynamicTypeProviderMock.Setup(dt => dt.GetCustomTypes()).Returns(new HashSet<Type>() { typeof(Company), typeof(MainCompany) });
_dynamicTypeProviderMock.Setup(dt => dt.ResolveType(typeof(Company).FullName!)).Returns(typeof(Company));
_dynamicTypeProviderMock.Setup(dt => dt.ResolveType(typeof(MainCompany).FullName!)).Returns(typeof(MainCompany));
_dynamicTypeProviderMock.Setup(dt => dt.ResolveTypeBySimpleName("Company")).Returns(typeof(Company));
_dynamicTypeProviderMock.Setup(dt => dt.ResolveTypeBySimpleName("MainCompany")).Returns(typeof(MainCompany));
_parsingConfig = new ParsingConfig
{
CustomTypeProvider = _dynamicTypeProviderMock.Object
};
}
[Fact]
public void Parse_BitwiseOperatorOr_On_2EnumFlags()
{
// Arrange
var expression = "@0 | @1";
#if NET48
var expected = "Convert((Convert(A) | Convert(B)))";
#else
var expected = "Convert((Convert(A, Int32) | Convert(B, Int32)), ExampleFlags)";
#endif
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(int), "x") };
var sut = new ExpressionParser(parameters, expression, new object[] { ExampleFlags.A, ExampleFlags.B }, null);
// Act
var parsedExpression = sut.Parse(null).ToString();
// Assert
parsedExpression.Should().Be(expected);
// Arrange
var query = new[] { 0 }.AsQueryable();
// Act
var result = query.Select(expression, ExampleFlags.A, ExampleFlags.B).First();
// Assert
Assert.IsType<ExampleFlags>(result);
Assert.Equal(ExampleFlags.A | ExampleFlags.B, result);
}
[Fact]
public void Parse_BitwiseOperatorAnd_On_2EnumFlags()
{
// Arrange
var expression = "@0 & @1";
#if NET48
var expected = "Convert((Convert(A) & Convert(B)))";
#else
var expected = "Convert((Convert(A, Int32) & Convert(B, Int32)), ExampleFlags)";
#endif
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(int), "x") };
var sut = new ExpressionParser(parameters, expression, new object[] { ExampleFlags.A, ExampleFlags.B }, null);
// Act
var parsedExpression = sut.Parse(null).ToString();
// Assert
parsedExpression.Should().Be(expected);
// Arrange
var query = new[] { 0 }.AsQueryable();
// Act
var result = query.Select(expression, ExampleFlags.A, ExampleFlags.B).First();
// Assert
Assert.IsType<ExampleFlags>(result);
Assert.Equal(ExampleFlags.A & ExampleFlags.B, result);
}
[Fact]
public void Parse_BitwiseOperatorOr_On_3EnumFlags()
{
// Arrange
var expression = "@0 | @1 | @2";
#if NET48
var expected = "Convert(((Convert(A) | Convert(B)) | Convert(C)))";
#else
var expected = "Convert(((Convert(A, Int32) | Convert(B, Int32)) | Convert(C, Int32)), ExampleFlags)";
#endif
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(int), "x") };
var sut = new ExpressionParser(parameters, expression, new object[] { ExampleFlags.A, ExampleFlags.B, ExampleFlags.C }, null);
// Act
var parsedExpression = sut.Parse(null).ToString();
// Assert
parsedExpression.Should().Be(expected);
// Arrange
var query = new[] { 0 }.AsQueryable();
// Act
var result = query.Select(expression, ExampleFlags.A, ExampleFlags.B, ExampleFlags.C).First();
// Assert
Assert.IsType<ExampleFlags>(result);
Assert.Equal(ExampleFlags.A | ExampleFlags.B | ExampleFlags.C, result);
}
[Fact]
public void Parse_BitwiseOperatorAnd_On_3EnumFlags()
{
// Arrange
var expression = "@0 & @1 & @2";
#if NET48
var expected = "Convert(((Convert(A) & Convert(B)) & Convert(C)))";
#else
var expected = "Convert(((Convert(A, Int32) & Convert(B, Int32)) & Convert(C, Int32)), ExampleFlags)";
#endif
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(int), "x") };
var sut = new ExpressionParser(parameters, expression, new object[] { ExampleFlags.A, ExampleFlags.B, ExampleFlags.C }, null);
// Act
var parsedExpression = sut.Parse(null).ToString();
// Assert
parsedExpression.Should().Be(expected);
// Arrange
var query = new[] { 0 }.AsQueryable();
// Act
var result = query.Select(expression, ExampleFlags.A, ExampleFlags.B, ExampleFlags.C).First();
// Assert
Assert.IsType<ExampleFlags>(result);
Assert.Equal(ExampleFlags.A & ExampleFlags.B & ExampleFlags.C, result);
}
[Fact]
public void Parse_ParseBinaryInteger()
{
// Arrange
var expression = "0b1100000011101";
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(int), "x") };
var sut = new ExpressionParser(parameters, expression, null, null);
// Act
var parsedExpression = sut.Parse(null).ToString();
// Assert
parsedExpression.Should().Be("6173");
}
[Fact]
public void Parse_ParseHexadecimalInteger()
{
// Arrange
var expression = "0xFF";
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(int), "x") };
var sut = new ExpressionParser(parameters, expression, null, null);
// Act
var parsedExpression = sut.Parse(null).ToString();
// Assert
parsedExpression.Should().Be("255");
}
[Theory]
[InlineData("it == 1", "(x == 1)")]
[InlineData("it eq 1", "(x == 1)")]
[InlineData("it equal 1", "(x == 1)")]
[InlineData("it != 1", "(x != 1)")]
[InlineData("it ne 1", "(x != 1)")]
[InlineData("it neq 1", "(x != 1)")]
[InlineData("it notequal 1", "(x != 1)")]
[InlineData("it lt 1", "(x < 1)")]
[InlineData("it LessThan 1", "(x < 1)")]
[InlineData("it le 1", "(x <= 1)")]
[InlineData("it LessThanEqual 1", "(x <= 1)")]
[InlineData("it gt 1", "(x > 1)")]
[InlineData("it GreaterThan 1", "(x > 1)")]
[InlineData("it ge 1", "(x >= 1)")]
[InlineData("it GreaterThanEqual 1", "(x >= 1)")]
public void Parse_ParseComparisonOperator(string expression, string result)
{
// Arrange
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(int), "x") };
var sut = new ExpressionParser(parameters, expression, null, null);
// Act
var parsedExpression = sut.Parse(null).ToString();
// Assert
Check.That(parsedExpression).Equals(result);
}
[Theory]
[InlineData("it || true", "(x OrElse True)")]
[InlineData("it or true", "(x OrElse True)")]
[InlineData("it OrElse true", "(x OrElse True)")]
public void Parse_ParseOrOperator(string expression, string result)
{
// Arrange
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(bool), "x") };
var sut = new ExpressionParser(parameters, expression, null, null);
// Act
var parsedExpression = sut.Parse(null).ToString();
// Assert
Check.That(parsedExpression).Equals(result);
}
[Theory]
[InlineData("it && true", "(x AndAlso True)")]
[InlineData("it and true", "(x AndAlso True)")]
[InlineData("it AndAlso true", "(x AndAlso True)")]
public void Parse_ParseAndOperator(string expression, string result)
{
// Arrange
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(bool), "x") };
var sut = new ExpressionParser(parameters, expression, null, null);
// Act
var parsedExpression = sut.Parse(null).ToString();
// Assert
Check.That(parsedExpression).Equals(result);
}
[Fact]
public void Parse_ParseMultipleInOperators()
{
// Arrange
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(Company), "x") };
var sut = new ExpressionParser(parameters, "MainCompanyId in (1, 2) and Name in (\"A\", \"B\")", null, null);
// Act
var parsedExpression = sut.Parse(null).ToString();
// Assert
Check.That(parsedExpression).Equals("(((x.MainCompanyId == 1) OrElse (x.MainCompanyId == 2)) AndAlso ((x.Name == \"A\") OrElse (x.Name == \"B\")))");
}
[Fact]
public void Parse_ParseInWrappedInParenthesis()
{
// Arrange
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(Company), "x") };
var sut = new ExpressionParser(parameters, "(MainCompanyId in @0)", new object[] { new long?[] { 1, 2 } }, null);
// Act
var parsedExpression = sut.Parse(null).ToString();
// Assert
Check.That(parsedExpression).Equals("value(System.Nullable`1[System.Int64][]).Contains(x.MainCompanyId)");
}
[Fact]
public void Parse_CastActingOnIt()
{
// Arrange
var parameters = new[] { ParameterExpressionHelper.CreateParameterExpression(typeof(User), "u") };
var sut = new ExpressionParser(parameters, "DisplayName.Any(int(it) > 109)", null, null);
// Act
var result = sut.Parse(null);
// Assert
result.Should().NotBeNull();
}
[Theory]
[InlineData("string(\"\")", "")]
[InlineData("string(\"a\")", "a")]
[InlineData("int(42)", 42)]
public void Parse_CastStringIntShouldReturnConstantExpression(string expression, object result)
{
// Arrange
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(bool), "x") };
var sut = new ExpressionParser(parameters, expression, null, null);
// Act
var constantExpression = (ConstantExpression)sut.Parse(null);
// Assert
Check.That(constantExpression.Value).Equals(result);
}
[Theory]
#if NET48
[InlineData("int?(5)", typeof(int?), "Convert(5)")]
[InlineData("int?(null)", typeof(int?), "Convert(null)")]
[InlineData("string(null)", typeof(string), "Convert(null)")]
#else
[InlineData("int?(5)", typeof(int?), "Convert(5, Nullable`1)")]
[InlineData("int?(null)", typeof(int?), "Convert(null, Nullable`1)")]
[InlineData("string(null)", typeof(string), "Convert(null, String)")]
#endif
public void Parse_NullableShouldReturnNullable(string expression, object resultType, object result)
{
// Arrange
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(bool), "x") };
var sut = new ExpressionParser(parameters, expression, null, null);
// Act
var unaryExpression = (UnaryExpression)sut.Parse(null);
// Assert
Check.That(unaryExpression.Type).Equals(resultType);
Check.That(unaryExpression.ToString()).Equals(result);
}
[Theory]
[InlineData("it.MainCompany.Name != null", "(company.MainCompany.Name != null)")]
[InlineData("@MainCompany.Companies.Count() > 0", "(company.MainCompany.Companies.Count() > 0)")]
[InlineData("Company.Equals(null, null)", "Equals(null, null)")]
[InlineData("MainCompany.Name", "company.MainCompany.Name")]
[InlineData("Name", "company.Name")]
[InlineData("company.Name", "company.Name")]
[InlineData("DateTime", "company.DateTime")]
public void Parse_When_PrioritizePropertyOrFieldOverTheType_IsTrue(string expression, string result)
{
// Arrange
var config = new ParsingConfig
{
IsCaseSensitive = true,
CustomTypeProvider = _dynamicTypeProviderMock.Object
};
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(Company), "company") };
var sut = new ExpressionParser(parameters, expression, null, config);
// Act
string parsedExpression;
try
{
parsedExpression = sut.Parse(null).ToString();
}
catch (ParseException e)
{
parsedExpression = e.Message;
}
// Assert
parsedExpression.Should().Be(result);
}
[Theory]
[InlineData("it.MainCompany.Name != null", "(company.MainCompany.Name != null)")]
[InlineData("@MainCompany.Companies.Count() > 0", "(company.MainCompany.Companies.Count() > 0)")]
[InlineData("Company.Equals(null, null)", "No applicable method 'Equals' exists in type 'Company'")] // Exception
[InlineData("MainCompany.Name", "company.MainCompany.Name")]
[InlineData("Name", "company.Name")]
[InlineData("it.DateTime", "company.DateTime")]
[InlineData("DateTime", "'.' or '(' or string literal expected")] // Exception
public void Parse_When_PrioritizePropertyOrFieldOverTheType_IsFalse(string expression, string result)
{
// Arrange
var config = new ParsingConfig
{
PrioritizePropertyOrFieldOverTheType = false
};
ParameterExpression[] parameters = { ParameterExpressionHelper.CreateParameterExpression(typeof(Company), "company") };
// Act
string parsedExpression;
try
{
var sut = new ExpressionParser(parameters, expression, null, config);
parsedExpression = sut.Parse(null).ToString();
}
catch (Exception e)
{
parsedExpression = e.Message;
}
// Assert
parsedExpression.Should().StartWith(result);
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/ExpressionParserTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 3,297
|
```smalltalk
using System.Linq.Dynamic.Core.CustomTypeProviders;
using FluentAssertions;
using NFluent;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser
{
[DynamicLinqType]
public static class Utils
{
public static string[] ConvertToArray(params string[] values)
{
if (values == null)
{
return null;
}
return values.ToArray();
}
public static string[] ConvertToArray(int a, params string[] values)
{
if (values == null)
{
return null;
}
return values.ToArray();
}
public static int IncrementMe(this int value)
{
return value + 1;
}
public static int IncrementMe(this int value, int y)
{
return value + y;
}
public static int IncrementMeAlso(this int value)
{
return value + 1;
}
public static string EmptyIfNull(this string? s)
{
return s ?? string.Empty;
}
public static string DefaultIfNull(this string? s, string defaultValue)
{
return s ?? defaultValue;
}
}
public class DynamicLinqTypeTest
{
public class EntityValue
{
public string[] Values { get; set; }
public int ValueInt { get; set; }
}
[Flags]
public enum Status
{
Inactive = 0,
Active = 1,
Other = 2,
ActiveOther = 3
}
[Fact]
public void ParamArray_EmptyValue()
{
var query = "Utils.ConvertToArray()";
var expression = DynamicExpressionParser.ParseLambda(null, query, null);
var del = expression.Compile();
var result = (string[])del.DynamicInvoke();
Check.That(result).IsNull();
}
[Fact]
public void ParamArray_NullValue()
{
var query = "Utils.ConvertToArray(null)";
var expression = DynamicExpressionParser.ParseLambda(null, query, null);
var del = expression.Compile();
var result = (string[])del.DynamicInvoke();
Check.That(result).IsNull();
}
[Fact]
public void ParamArray_WithManyValue()
{
var query = "Utils.ConvertToArray(\"a\", \"b\")";
var expression = DynamicExpressionParser.ParseLambda(null, query, null);
var del = expression.Compile();
var result = (string[])del.DynamicInvoke();
Check.That(result.Length).Equals(2);
Check.That(result[0]).Equals("a");
Check.That(result[1]).Equals("b");
}
[Fact]
public void ParamArray_WithSingleValue()
{
var query = "Utils.ConvertToArray(\"a\")";
var expression = DynamicExpressionParser.ParseLambda(null, query, null);
var del = expression.Compile();
var result = (string[])del.DynamicInvoke();
Check.That(result.Length).Equals(1);
Check.That(result[0]).Equals("a");
}
[Fact]
public void ParamArray_NullValue2()
{
var query = "Utils.ConvertToArray(0, null)";
var expression = DynamicExpressionParser.ParseLambda(null, query, null);
var del = expression.Compile();
var result = (string[])del.DynamicInvoke();
Check.That(result).IsNull();
}
[Fact]
public void ParamArray_WithManyValue2()
{
var query = "Utils.ConvertToArray(0, \"a\", \"b\")";
var expression = DynamicExpressionParser.ParseLambda(null, query, null);
var del = expression.Compile();
var result = (string[])del.DynamicInvoke();
Check.That(result.Length).Equals(2);
Check.That(result[0]).Equals("a");
Check.That(result[1]).Equals("b");
}
[Fact]
public void ParamArray_WithSingleValue2()
{
var query = "Utils.ConvertToArray(0, \"a\")";
var expression = DynamicExpressionParser.ParseLambda(null, query, null);
var del = expression.Compile();
var result = (string[])del.DynamicInvoke();
Check.That(result.Length).Equals(1);
Check.That(result[0]).Equals("a");
}
[Fact]
public void ParamArray_Array()
{
var list = new[] { new EntityValue { }, new EntityValue { Values = new[] { "a", "b" } } }.AsQueryable();
var result = list.Select("Utils.ConvertToArray(Values)").ToDynamicList<string[]>();
Check.That(result.Count).Equals(2);
Check.That(result[0]).IsNull();
Check.That(result[1][0]).Equals("a");
Check.That(result[1][1]).Equals("b");
}
[Fact]
public void ExtensionMethod_OnString_NoParameter()
{
var list = new[] { "a", "", null }.AsQueryable();
var result = list.Select("it.EmptyIfNull()").ToDynamicList<string?>();
result.Should().Equal("a", "", "");
}
[Fact]
public void ExtensionMethod_OnString_OneParameter()
{
var list = new[] { "a", "", null }.AsQueryable();
var result = list.Select("it.DefaultIfNull(\"x\")").ToDynamicList<string?>();
result.Should().Equal("a", "", "x");
}
[Fact]
public void ExtensionMethod_OnInt_NoParameter()
{
var list = new[] { new EntityValue { ValueInt = 1 }, new EntityValue { ValueInt = 2 } }.AsQueryable();
var result = list.Select("ValueInt.IncrementMe()").ToDynamicList<int>();
Check.That(result.Count).Equals(2);
Check.That(result[0]).Equals(2);
Check.That(result[1]).Equals(3);
}
[Fact]
public void ExtensionMethod_OnInt_SingleParameter()
{
var list = new[] { new EntityValue { ValueInt = 1 }, new EntityValue { ValueInt = 2 } }.AsQueryable();
var result = list.Select("ValueInt.IncrementMe(5)").ToDynamicList<int>();
Check.That(result.Count).Equals(2);
Check.That(result[0]).Equals(6);
Check.That(result[1]).Equals(7);
}
[Fact]
public void CallMethodOnEnum()
{
// Arrange
var queryable = new[] { Status.Active, Status.ActiveOther, Status.Inactive }.AsQueryable();
// Act
var status = Status.Active;
var result = queryable.Where("@0.HasFlag(it)", status).ToDynamicArray<Status>();
// Assert
result.Should().HaveCount(2);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/DynamicLinqTypeTest.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,426
|
```smalltalk
using FluentAssertions;
using System.Collections.Generic;
using System.Globalization;
using System.Linq.Dynamic.Core.Parser;
using System.Linq.Expressions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser;
public class NumberParserTests
{
private readonly ParsingConfig _parsingConfig = new();
public static object?[][] Decimals()
{
return
[
["de-DE", "1", 1m],
["de-DE", "-42", -42m],
["de-DE", "3,215", 3.215m],
["de-DE", "3.215", 3215m],
[null, "1", 1m],
[null, "-42", -42m],
[null, "3,215", 3215m],
[null, "3.215", 3.215m]
];
}
[Theory]
[MemberData(nameof(Decimals))]
public void NumberParser_ParseNumber_Decimal(string? culture, string text, decimal expected)
{
// Arrange
if (culture != null)
{
_parsingConfig.NumberParseCulture = CultureInfo.CreateSpecificCulture(culture);
}
// Act
var result = new NumberParser(_parsingConfig).ParseNumber(text, typeof(decimal));
// Assert
result.Should().Be(expected);
}
public static IEnumerable<object?[]> Floats()
{
return new object?[][]
{
["de-DE", "1", 1f],
["de-DE", "-42", -42f],
["de-DE", "3,215", 3.215f],
["de-DE", "3.215", 3215f],
["de-DE", "1,2345E-4", 0.00012345f],
["de-DE", "1,2345e-4", 0.00012345f],
["de-DE", "1,2345E4", 12345d],
["de-DE", "1,2345e4", 12345d],
[null, "1", 1f],
[null, "-42", -42f],
[null, "3,215", 3215f],
[null, "3.215", 3.215f],
[null, "1.2345E-4", 0.00012345f],
[null, "1.2345e-4", 0.00012345f],
[null, "1.2345E4", 12345f],
[null, "1.2345e4", 12345f]
};
}
[Theory]
[MemberData(nameof(Floats))]
public void NumberParser_ParseNumber_Float(string? culture, string text, float expected)
{
// Arrange
if (culture != null)
{
_parsingConfig.NumberParseCulture = CultureInfo.CreateSpecificCulture(culture);
}
// Act
var result = new NumberParser(_parsingConfig).ParseNumber(text, typeof(float));
// Assert
result.Should().Be(expected);
}
public static IEnumerable<object?[]> Doubles()
{
return new object?[][]
{
["de-DE", "1", 1d],
["de-DE", "-42", -42d],
["de-DE", "3,215", 3.215d],
["de-DE", "3.215", 3215d],
["de-DE", "1,2345E-4", 0.00012345d],
["de-DE", "1,2345e-4", 0.00012345d],
["de-DE", "1,2345E4", 12345d],
["de-DE", "1,2345e4", 12345d],
[null, "1", 1d],
[null, "-42", -42d],
[null, "3,215", 3215d],
[null, "3.215", 3.215d],
[null, "1.2345E-4", 0.00012345d],
[null, "1.2345e-4", 0.00012345d],
[null, "1.2345E4", 12345d],
[null, "1.2345e4", 12345d]
};
}
[Theory]
[MemberData(nameof(Doubles))]
public void NumberParser_ParseNumber_Double(string? culture, string text, double expected)
{
// Arrange
if (culture != null)
{
_parsingConfig.NumberParseCulture = CultureInfo.CreateSpecificCulture(culture);
}
// Act
var result = new NumberParser(_parsingConfig).ParseNumber(text, typeof(double));
// Assert
result.Should().Be(expected);
}
[Theory]
[InlineData("42", 42)]
[InlineData("-42", -42)]
[InlineData("77u", 77)]
[InlineData("77l", 77)]
[InlineData("77ul", 77)]
[InlineData("0xff", 255)]
[InlineData("-0xff", -255)]
[InlineData("0b1100000011101", 6173)]
[InlineData("-0b1100000011101", -6173)]
[InlineData("123d", 123d)]
[InlineData("123f", 123f)]
[InlineData("123m", 123)]
[InlineData("-123d", -123d)]
[InlineData("-123f", -123f)]
[InlineData("-123m", -123)]
public void NumberParser_ParseIntegerLiteral(string text, double expected)
{
// Act
var result = new NumberParser(_parsingConfig).ParseIntegerLiteral(0, text) as ConstantExpression;
// Assert
result?.Value.Should().Be(expected);
}
[Theory]
[InlineData("42", 'm', 42)]
[InlineData("-42", 'm', -42)]
[InlineData("42m", 'm', 42)]
[InlineData("-42m", 'm', -42)]
public void NumberParser_ParseDecimalLiteral(string text, char qualifier, decimal expected)
{
// Act
var result = new NumberParser(_parsingConfig).ParseRealLiteral(text, qualifier, true) as ConstantExpression;
// Assert
result?.Value.Should().Be(expected);
}
[Theory]
[InlineData("42", 'd', 42)]
[InlineData("-42", 'd', -42)]
[InlineData("42d", 'd', 42)]
[InlineData("-42d", 'd', -42)]
public void NumberParser_ParseDoubleLiteral(string text, char qualifier, double expected)
{
// Arrange
// Act
var result = new NumberParser(_parsingConfig).ParseRealLiteral(text, qualifier, true) as ConstantExpression;
// Assert
result?.Value.Should().Be(expected);
}
[Theory]
[InlineData("42", 'f', 42)]
[InlineData("-42", 'f', -42)]
[InlineData("42f", 'f', 42)]
[InlineData("-42f", 'f', -42)]
public void NumberParser_ParseFloatLiteral(string text, char qualifier, float expected)
{
// Arrange
// Act
var result = new NumberParser(_parsingConfig).ParseRealLiteral(text, qualifier, true) as ConstantExpression;
// Assert
result?.Value.Should().Be(expected);
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/NumberParserTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,662
|
```smalltalk
using FluentAssertions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser
{
partial class ExpressionParserTests
{
[Fact]
public void ParseMemberAccess_DictionaryIndex_On_Dynamic()
{
// Arrange
var products = new ProductDynamic[0].AsQueryable();
// Act
var expression = products.Where("Properties.Name == @0", "First Product").Expression;
// Assert
#if NET461 || NET48
expression.ToString().Should().Be("System.Linq.Dynamic.Core.Tests.Parser.ProductDynamic[].Where(Param_0 => (GetMember Name(Param_0.Properties) == Convert(\"First Product\")))");
#else
expression.ToString().Should().Be("System.Linq.Dynamic.Core.Tests.Parser.ProductDynamic[].Where(Param_0 => ([Dynamic] == Convert(\"First Product\", Object)))");
#endif
}
}
public class ProductDynamic
{
public string ProductId { get; set; }
public dynamic Properties { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/ExpressionParserTests.MemberAccess.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 212
|
```smalltalk
using System.Linq.Dynamic.Core.Exceptions;
using System.Linq.Dynamic.Core.Parser;
using FluentAssertions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser;
public class StringParserTests
{
[Theory]
[InlineData("'s")]
[InlineData("\"s")]
public void your_sha256_hashg_ThrowsException(string input)
{
// Act
var exception = Assert.Throws<ParseException>(() => StringParser.ParseStringAndUnescape(input));
// Assert
Assert.Equal($"Unexpected end of string with unclosed string at position 2 near '{input}'.", exception.Message);
}
[Theory]
[InlineData("")]
[InlineData(null)]
[InlineData("x")]
public void your_sha256_hashowsException(string input)
{
// Act
Action action = () => StringParser.ParseStringAndUnescape(input);
// Assert
action.Should().Throw<ParseException>().WithMessage($"String '{input}' should have at least 2 characters.");
}
[Theory]
[InlineData("xx")]
[InlineData(" ")]
public void your_sha256_hashcter_ThrowsException(string input)
{
// Act
Action action = () => StringParser.ParseStringAndUnescape(input);
// Assert
action.Should().Throw<ParseException>().WithMessage("An escaped string should start with a double (\") or a single (') quote.");
}
[Fact]
public void your_sha256_hashscapeSequence_ThrowsException()
{
// Arrange
var input = new string(new[] { '"', '\\', 'u', '?', '"' });
// Act
Action action = () => StringParser.ParseStringAndUnescape(input);
// Assert
var parseException = action.Should().Throw<ParseException>();
parseException.Which.InnerException!.Message.Should().Contain("hexadecimal digits");
parseException.Which.StackTrace.Should().Contain("at System.Linq.Dynamic.Core.Parser.StringParser.ParseStringAndUnescape(String s, Int32 pos) in ").And.Contain("StringParser.cs:line ");
}
[Theory]
[InlineData("''", "")]
[InlineData("'s'", "s")]
[InlineData("'\\\\'", "\\")]
[InlineData("'\\n'", "\n")]
public void StringParser_ParseStringAndUnescape_SingleQuotedString(string input, string expectedResult)
{
// Act
var result = StringParser.ParseStringAndUnescape(input);
// Assert
result.Should().Be(expectedResult);
}
[Theory]
[InlineData("\"\"", "")]
[InlineData("\"\\\\\"", "\\")]
[InlineData("\"\\n\"", "\n")]
[InlineData("\"\\\\n\"", "\\n")]
[InlineData("\"\\\\new\"", "\\new")]
[InlineData("\"[]\"", "[]")]
[InlineData("\"()\"", "()")]
[InlineData("\"(\\\"\\\")\"", "(\"\")")]
[InlineData("\"/\"", "/")]
[InlineData("\"a\"", "a")]
[InlineData("\"This \\\"is\\\" a test.\"", "This \"is\" a test.")]
[InlineData(@"""This \""is\"" b test.""", @"This ""is"" b test.")]
[InlineData("\"ab\\\"cd\"", "ab\"cd")]
[InlineData("\"\\\"\"", "\"")]
[InlineData("\"\\\"\\\"\"", "\"\"")]
[InlineData("\"AB YZ 19 \uD800\udc05 \u00e4\"", "AB YZ 19 \uD800\udc05 \u00e4")]
[InlineData("\"\\\\\\\\192.168.1.1\\\\audio\\\\new\"", "\\\\192.168.1.1\\audio\\new")]
[InlineData("\"{\\\"PropertyA\\\":\\\"\\\"}\"", @"{""PropertyA"":""""}")] // #786
public void StringParser_ParseStringAndUnescape_DoubleQuotedString(string input, string expectedResult)
{
// Act
var result = StringParser.ParseStringAndUnescape(input);
// Assert
result.Should().Be(expectedResult);
}
[Fact]
public void StringParser_ParseStringAndUnescape()
{
// Arrange
var test = "\"x\\\"X\"";
// Act
var result = StringParser.ParseStringAndUnescape(test);
// Assert
result.Should().Be("x\"X");
}
[Fact]
public void your_sha256_hasheQuote()
{
// Arrange
var test = "\"x\"\"X\"";
// Act
var result = StringParser.ParseStringAndUnescapeTwoDoubleQuotesByASingleDoubleQuote(test);
// Assert
result.Should().Be("x\"X");
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/StringParserTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 990
|
```smalltalk
using Moq;
using System.Collections.Generic;
using System.Linq.Dynamic.Core.CustomTypeProviders;
using System.Linq.Dynamic.Core.Parser;
using System.Linq.Expressions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser
{
public class ExpressionPromoterTests
{
public class SampleDto
{
public Guid data { get; set; }
}
private readonly Mock<IExpressionPromoter> _expressionPromoterMock;
private readonly Mock<IDynamicLinkCustomTypeProvider> _dynamicLinkCustomTypeProviderMock;
public ExpressionPromoterTests()
{
_dynamicLinkCustomTypeProviderMock = new Mock<IDynamicLinkCustomTypeProvider>();
_dynamicLinkCustomTypeProviderMock.Setup(d => d.GetCustomTypes()).Returns(new HashSet<Type>());
_dynamicLinkCustomTypeProviderMock.Setup(d => d.ResolveType(It.IsAny<string>())).Returns(typeof(SampleDto));
_expressionPromoterMock = new Mock<IExpressionPromoter>();
_expressionPromoterMock.Setup(e => e.Promote(It.IsAny<Expression>(), It.IsAny<Type>(), It.IsAny<bool>(), It.IsAny<bool>())).Returns(Expression.Constant(Guid.NewGuid()));
}
[Fact]
public void your_sha256_hash()
{
// Assign
var parsingConfig = new ParsingConfig()
{
AllowNewToEvaluateAnyType = true,
CustomTypeProvider = _dynamicLinkCustomTypeProviderMock.Object,
ExpressionPromoter = _expressionPromoterMock.Object
};
// Act
string query = $"new {typeof(SampleDto).FullName}(@0 as data)";
LambdaExpression expression = DynamicExpressionParser.ParseLambda(parsingConfig, null, query, new object[] { Guid.NewGuid().ToString() });
Delegate del = expression.Compile();
SampleDto result = (SampleDto)del.DynamicInvoke();
// Assert
Assert.NotNull(result);
// Verify
_dynamicLinkCustomTypeProviderMock.Verify(d => d.GetCustomTypes(), Times.Once);
_dynamicLinkCustomTypeProviderMock.Verify(d => d.ResolveType($"{typeof(SampleDto).FullName}"), Times.Once);
_expressionPromoterMock.Verify(e => e.Promote(It.IsAny<ConstantExpression>(), typeof(Guid), true, true), Times.Once);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/ExpressionPromoterTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 462
|
```smalltalk
using Moq;
using NFluent;
using System.Linq.Dynamic.Core.CustomTypeProviders;
using System.Linq.Dynamic.Core.Parser;
using System.Linq.Dynamic.Core.Tests.Entities;
using System.Linq.Expressions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser
{
public class TypeFinderTests
{
private readonly ParsingConfig _parsingConfig = new ParsingConfig();
private readonly Mock<IKeywordsHelper> _keywordsHelperMock;
private readonly Mock<IDynamicLinkCustomTypeProvider> _dynamicTypeProviderMock;
private readonly TypeFinder _sut;
public TypeFinderTests()
{
_dynamicTypeProviderMock = new Mock<IDynamicLinkCustomTypeProvider>();
_dynamicTypeProviderMock.Setup(dt => dt.ResolveType(typeof(BaseEmployee).FullName)).Returns(typeof(BaseEmployee));
_dynamicTypeProviderMock.Setup(dt => dt.ResolveType(typeof(Boss).FullName)).Returns(typeof(Boss));
_dynamicTypeProviderMock.Setup(dt => dt.ResolveType(typeof(Worker).FullName)).Returns(typeof(Worker));
_dynamicTypeProviderMock.Setup(dt => dt.ResolveTypeBySimpleName("Boss")).Returns(typeof(Boss));
_parsingConfig = new ParsingConfig
{
CustomTypeProvider = _dynamicTypeProviderMock.Object
};
_keywordsHelperMock = new Mock<IKeywordsHelper>();
_sut = new TypeFinder(_parsingConfig, _keywordsHelperMock.Object);
}
[Fact]
public void your_sha256_hashProvider_equals_false()
{
// Assign
_parsingConfig.ResolveTypesBySimpleName = true;
// Act
Type result = _sut.FindTypeByName("Boss", null, forceUseCustomTypeProvider: false);
// Assert
Check.That(result).IsNull();
}
[Fact]
public void your_sha256_hashProvider_equals_true()
{
// Assign
_parsingConfig.ResolveTypesBySimpleName = true;
// Act
Type result = _sut.FindTypeByName("Boss", null, forceUseCustomTypeProvider: true);
// Assert
Check.That(result).Equals(typeof(Boss));
}
[Fact]
public void TypeFinder_FindTypeByName_With_SimpleTypeName_basedon_it()
{
// Assign
_parsingConfig.ResolveTypesBySimpleName = true;
var expressions = new[] { Expression.Parameter(typeof(BaseEmployee)) };
// Act
Type result = _sut.FindTypeByName("Boss", expressions, forceUseCustomTypeProvider: false);
// Assert
Check.That(result).Equals(typeof(Boss));
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/TypeFinderTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 530
|
```smalltalk
using NFluent;
using System.Linq.Dynamic.Core.Parser;
using System.Linq.Expressions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser
{
public class ConstantExpressionWrapperTests
{
private readonly IConstantExpressionWrapper _constantExpressionWrapper;
public ConstantExpressionWrapperTests()
{
_constantExpressionWrapper = new ConstantExpressionWrapper();
}
[Theory]
[InlineData(true)]
[InlineData((int)1)]
[InlineData((uint)2)]
[InlineData((short)3)]
[InlineData((ushort)4)]
[InlineData(5L)]
[InlineData(6UL)]
[InlineData(7.1f)]
[InlineData(8.1d)]
[InlineData('c')]
[InlineData((byte)10)]
[InlineData((sbyte)11)]
public void your_sha256_hash<T>(T test)
{
// Assign
var expression = Expression.Constant(test) as Expression;
// Act
_constantExpressionWrapper.Wrap(ref expression);
// Verify
Check.That(expression).IsNotNull();
ConstantExpression constantExpression = (expression as MemberExpression).Expression as ConstantExpression;
dynamic wrappedObj = constantExpression.Value;
T value = wrappedObj.Value;
Check.That(value).IsEqualTo(test);
}
[Fact]
public void ConstantExpressionWrapper_Wrap_ConstantExpression_String()
{
// Assign
string test = "abc";
var expression = Expression.Constant(test) as Expression;
// Act
_constantExpressionWrapper.Wrap(ref expression);
// Verify
Check.That(expression).IsNotNull();
ConstantExpression constantExpression = (expression as MemberExpression).Expression as ConstantExpression;
dynamic wrappedObj = constantExpression.Value;
string value = wrappedObj.Value;
Check.That(value).IsEqualTo(test);
}
[Fact]
public void ConstantExpressionWrapper_Wrap_ConstantExpression_ComplexTypes()
{
// Assign
var test = DateTime.Now;
var expression = Expression.Constant(test) as Expression;
// Act
_constantExpressionWrapper.Wrap(ref expression);
// Verify
Check.That(expression).IsNotNull();
var constantExpression = (expression as MemberExpression).Expression as ConstantExpression;
dynamic wrappedObj = constantExpression.Value;
DateTime value = wrappedObj.Value;
Check.That(value).IsEqualTo(test);
}
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/ConstantExpressionWrapperTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 495
|
```smalltalk
using FluentAssertions;
using NFluent;
using System.Collections;
using System.Linq.Dynamic.Core.Parser;
using System.Linq.Expressions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser;
public class ExpressionHelperTests
{
private readonly ExpressionHelper _sut;
public ExpressionHelperTests()
{
_sut = new ExpressionHelper(ParsingConfig.Default);
}
[Fact]
public void ExpressionHelper_WrapConstantExpression_false()
{
// Assign
var config = new ParsingConfig
{
UseParameterizedNamesInDynamicQuery = false
};
var expressionHelper = new ExpressionHelper(config);
string value = "test";
Expression expression = Expression.Constant(value);
// Act
expressionHelper.WrapConstantExpression(ref expression);
// Assert
Check.That(expression).IsInstanceOf<ConstantExpression>();
Check.That(expression.ToString()).Equals("\"test\"");
}
[Fact]
public void ExpressionHelper_WrapNullableConstantExpression_false()
{
// Assign
var config = new ParsingConfig
{
UseParameterizedNamesInDynamicQuery = false
};
var expressionHelper = new ExpressionHelper(config);
int? value = 42;
Expression expression = Expression.Constant(value);
// Act
expressionHelper.WrapConstantExpression(ref expression);
// Assert
Check.That(expression).IsInstanceOf<ConstantExpression>();
Check.That(expression.ToString()).Equals("42");
}
[Fact]
public void ExpressionHelper_WrapConstantExpression_true()
{
// Assign
var config = new ParsingConfig
{
UseParameterizedNamesInDynamicQuery = true
};
var expressionHelper = new ExpressionHelper(config);
string value = "test";
Expression expression = Expression.Constant(value);
// Act
expressionHelper.WrapConstantExpression(ref expression);
expressionHelper.WrapConstantExpression(ref expression);
// Assert
Check.That(expression.GetType().FullName).Equals("System.Linq.Expressions.PropertyExpression");
Check.That(expression.ToString()).Equals("value(System.Linq.Dynamic.Core.Parser.WrappedValue`1[System.String]).Value");
}
[Fact]
public void ExpressionHelper_WrapNullableConstantExpression_true()
{
// Assign
var config = new ParsingConfig
{
UseParameterizedNamesInDynamicQuery = true
};
var expressionHelper = new ExpressionHelper(config);
int? value = 42;
Expression expression = Expression.Constant(value);
// Act
expressionHelper.WrapConstantExpression(ref expression);
expressionHelper.WrapConstantExpression(ref expression);
// Assert
Check.That(expression.GetType().FullName).Equals("System.Linq.Expressions.PropertyExpression");
Check.That(expression.ToString()).Equals("value(System.Linq.Dynamic.Core.Parser.WrappedValue`1[System.Int32]).Value");
}
[Fact]
public void ExpressionHelper_OptimizeStringForEqualityIfPossible_Guid()
{
// Assign
string guidAsString = Guid.NewGuid().ToString();
// Act
Expression result = _sut.OptimizeStringForEqualityIfPossible(guidAsString, typeof(Guid));
// Assert
Check.That(result).IsInstanceOf<ConstantExpression>();
Check.That(result.ToString()).Equals(guidAsString);
}
[Fact]
public void your_sha256_hashd()
{
// Assign
string guidAsString = "x";
// Act
Expression result = _sut.OptimizeStringForEqualityIfPossible(guidAsString, typeof(Guid));
// Assert
Check.That(result).IsNull();
}
[Fact]
public void your_sha256_hashullable()
{
// Assign
Expression<Func<Item, int>> expression = x => x.Relation1.Relation2.Id;
// Act
bool result = _sut.TryGenerateAndAlsoNotNullExpression(expression, true, out Expression generatedExpression);
// Assert
Check.That(result).IsTrue();
Check.That(generatedExpression.ToString()).IsEqualTo("((((x != null) AndAlso (x.Relation1 != null)) AndAlso (x.Relation1.Relation2 != null)) AndAlso (x => x.Relation1.Relation2.Id != null))");
}
[Fact]
public void your_sha256_hashullable_Config_Has_UseDefault()
{
// Assign
var config = new ParsingConfig
{
NullPropagatingUseDefaultValueForNonNullableValueTypes = true
};
var expressionHelper = new ExpressionHelper(config);
Expression<Func<Item, int>> expression = x => x.Relation1.Relation2.Id;
// Act
bool result = expressionHelper.TryGenerateAndAlsoNotNullExpression(expression, true, out Expression generatedExpression);
// Assert
Check.That(result).IsTrue();
Check.That(generatedExpression.ToString()).IsEqualTo("((((x != null) AndAlso (x.Relation1 != null)) AndAlso (x.Relation1.Relation2 != null)) AndAlso (x => x.Relation1.Relation2.Id != null))");
}
[Fact]
public void your_sha256_hashableInt()
{
// Assign
Expression<Func<Relation2, int?>> expression = x => x.IdNullable;
// Act
bool result = _sut.TryGenerateAndAlsoNotNullExpression(expression, true, out Expression generatedExpression);
// Assert
Check.That(result).IsTrue();
Check.That(generatedExpression.ToString()).IsEqualTo("((x != null) AndAlso (x => x.IdNullable != null))");
}
[Fact]
public void your_sha256_hashableString()
{
// Assign
Expression<Func<Relation2, string>> expression = x => x.S;
// Act
bool result = _sut.TryGenerateAndAlsoNotNullExpression(expression, true, out Expression generatedExpression);
// Assert
Check.That(result).IsTrue();
Check.That(generatedExpression.ToString()).IsEqualTo("((x != null) AndAlso (x => x.S != null))");
}
[Fact]
public void your_sha256_hashable_AddSelfFalse()
{
// Assign
Expression<Func<Item, int?>> expression = x => x.Relation1.Relation2.IdNullable;
// Act
bool result = _sut.TryGenerateAndAlsoNotNullExpression(expression, false, out Expression generatedExpression);
// Assert
Check.That(result).IsTrue();
Check.That(generatedExpression.ToString()).IsEqualTo("(((x != null) AndAlso (x.Relation1 != null)) AndAlso (x.Relation1.Relation2 != null))");
}
[Fact]
public void your_sha256_hashable_AddSelfTrue()
{
// Assign
Expression<Func<Item, int?>> expression = x => x.Relation1.Relation2.IdNullable;
// Act
bool result = _sut.TryGenerateAndAlsoNotNullExpression(expression, true, out Expression generatedExpression);
// Assert
Check.That(result).IsTrue();
Check.That(generatedExpression.ToString()).IsEqualTo("((((x != null) AndAlso (x.Relation1 != null)) AndAlso (x.Relation1.Relation2 != null)) AndAlso (x => x.Relation1.Relation2.IdNullable != null))");
}
[Fact]
public void ExpressionHelper_TryGenerateAndAlsoNotNullExpression_Nullable()
{
// Assign
Expression<Func<Item, int?>> expression = x => x.Id;
// Act
bool result = _sut.TryGenerateAndAlsoNotNullExpression(expression, true, out Expression generatedExpression);
// Assert
result.Should().BeTrue();
generatedExpression.ToString().Should().StartWith("((x != null) AndAlso (x =>").And.EndWith("!= null))");
}
[Fact]
public void ConvertAnyArrayToObjectArray_ShouldConvertIntArrayToObjectArray()
{
// Arrange
var array = new[] { 1, 2, 3 };
var arrayExpression = Expression.Constant(array);
// Act
var expression = _sut.ConvertAnyArrayToObjectArray(arrayExpression);
// Assert
expression.Should().NotBeNull();
var lambdaExpressionCompiled = Expression.Lambda(expression).Compile();
var result = (object[]) lambdaExpressionCompiled.DynamicInvoke();
result.Should().HaveCount(array.Length).And.ContainInOrder((object) 1, (object) 2, (object) 3);
}
class Item
{
public int Id { get; set; }
public Relation1 Relation1 { get; set; }
}
class Relation1
{
public int Id { get; set; }
public Relation2 Relation2 { get; set; }
}
class Relation2
{
public int Id { get; set; }
public int? IdNullable { get; set; }
public string S { get; set; }
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/ExpressionHelperTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,836
|
```smalltalk
using System.Linq.Dynamic.Core.Parser;
using FluentAssertions;
using NFluent;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser;
public class TypeHelperTests
{
enum TestEnum
{
x = 1
}
[Fact]
public void TypeHelper_TryParseEnum_Valid()
{
// Assign + Act
var result = TypeHelper.TryParseEnum("x", typeof(TestEnum), out var enumValue);
// Assert
result.Should().BeTrue();
enumValue.Should().Be(TestEnum.x);
}
[Fact]
public void TypeHelper_TryParseEnum_Invalid()
{
// Assign + Act
var result = TypeHelper.TryParseEnum("test", typeof(TestEnum), out var enumValue);
// Assert
result.Should().BeFalse();
enumValue.Should().BeNull();
}
[Fact]
public void TypeHelper_IsCompatibleWith_SameTypes_True()
{
// Assign + Act
var result = TypeHelper.IsCompatibleWith(typeof(int), typeof(int));
// Assert
Check.That(result).IsTrue();
}
[Fact]
public void TypeHelper_IsCompatibleWith_True()
{
// Assign + Act
var result = TypeHelper.IsCompatibleWith(typeof(int), typeof(long));
// Assert
Check.That(result).IsTrue();
}
[Fact]
public void TypeHelper_IsCompatibleWith_False()
{
// Assign + Act
var result = TypeHelper.IsCompatibleWith(typeof(long), typeof(int));
// Assert
Check.That(result).IsFalse();
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/TypeHelperTests.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 338
|
```smalltalk
using System.Linq.Dynamic.Core.Parser;
using System.Linq.Expressions;
using Xunit;
using static System.Linq.Expressions.Expression;
namespace System.Linq.Dynamic.Core.Tests.Parser;
public class MethodFinderTest
{
[Fact]
public void MethodsOfDynamicLinqAndSystemLinqShouldBeEqual()
{
Expression<Func<int?, string?>> expr = x => x.ToString();
var selector = "ToString()";
var prm = Parameter(typeof(int?));
var parser = new ExpressionParser(new[] { prm }, selector, new object[] { }, ParsingConfig.Default);
var expr1 = parser.Parse(null);
Assert.Equal(((MethodCallExpression)expr.Body).Method.DeclaringType, ((MethodCallExpression)expr1).Method.DeclaringType);
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/MethodFinderTest.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 159
|
```xml
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net7.0</TargetFramework>
<AssemblyName>System.Linq.Dynamic.Core.Tests</AssemblyName>
<DebugType>full</DebugType>
<SignAssembly>True</SignAssembly>
<AssemblyOriginatorKeyFile>../../src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.snk</AssemblyOriginatorKeyFile>
<IsPackable>false</IsPackable>
<DefineConstants>$(DefineConstants);NETCOREAPP;EFCORE;EFCORE_3X;NETCOREAPP3_1;AspNetCoreIdentity</DefineConstants>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="coverlet.msbuild" Version="6.0.2">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
<PackageReference Include="xunit" Version="2.4.2" />
<PackageReference Include="xunit.runner.visualstudio" Version="2.4.5">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
<PackageReference Include="coverlet.collector" Version="6.0.2">
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
<PrivateAssets>all</PrivateAssets>
</PackageReference>
<PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
<PackageReference Include="Linq.PropertyTranslator.Core" Version="1.0.5" />
<PackageReference Include="QueryInterceptor.Core" Version="1.0.9" />
<PackageReference Include="NFluent" Version="2.8.0" />
<PackageReference Include="Moq" Version="4.18.2" />
<PackageReference Include="FluentAssertions" Version="6.8.0" />
<PackageReference Include="Microsoft.EntityFrameworkCore" Version="7.0.0" />
<PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="7.0.0" />
<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="7.0.0" />
<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="7.0.0" />
<PackageReference Include="LinqKit.Microsoft.EntityFrameworkCore" Version="7.1.3" />
<PackageReference Include="NodaTime" Version="3.1.5" />
<PackageReference Include="Testcontainers.MsSql" Version="3.9.0" />
<ProjectReference Include="..\..\src\Microsoft.EntityFrameworkCore.DynamicLinq.EFCore7\Microsoft.EntityFrameworkCore.DynamicLinq.EFCore7.csproj" />
</ItemGroup>
<ItemGroup>
<Compile Include="..\System.Linq.Dynamic.Core.Tests\*.cs" />
<Compile Include="..\System.Linq.Dynamic.Core.Tests\*\*.cs" />
<Compile Include="..\System.Linq.Dynamic.Core.Tests\*\*\*.cs" />
</ItemGroup>
<ItemGroup>
<Compile Remove="TestResults\**" />
<EmbeddedResource Remove="TestResults\**" />
<None Remove="TestResults\**" />
</ItemGroup>
</Project>
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests.Net7/System.Linq.Dynamic.Core.Tests.Net7.csproj
|
xml
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 760
|
```smalltalk
using System.Collections.Generic;
using System.Linq.Dynamic.Core.Exceptions;
using System.Linq.Dynamic.Core.Parser;
using System.Linq.Expressions;
using FluentAssertions;
using Xunit;
namespace System.Linq.Dynamic.Core.Tests.Parser;
partial class ExpressionParserTests
{
[Fact]
public void ParseTypeAccess_Via_Constructor_CharAndInt_To_String()
{
// Arrange
var parameter = Expression.Parameter(typeof(string));
// Act
var parser = new ExpressionParser(new[] { parameter }, "string('c', 3)", new object[] { }, ParsingConfig.Default);
var expression = parser.Parse(typeof(string));
// Assert
expression.ToString().Should().Be("new String(c, 3)");
}
[Theory]
[InlineData(123, "new DateTime(123)")]
[InlineData(633979008000000000, "new DateTime(633979008000000000)")]
public void ParseTypeAccess_Via_Constructor_Ticks_To_DateTime(object ticks, string result)
{
// Arrange
var parameter = Expression.Parameter(typeof(DateTime));
// Act
var parser = new ExpressionParser(new[] { parameter }, $"DateTime({ticks})", new object[] { }, ParsingConfig.Default);
var expression = parser.Parse(typeof(DateTime));
// Assert
expression.ToString().Should().Be(result);
}
[Fact]
public void ParseTypeAccess_Via_Constructor_String_To_DateTime_Valid()
{
// Arrange
string str = "\"2020-10-31 09:15:11\"";
var parameter = Expression.Parameter(typeof(DateTime));
// Act
var parser = new ExpressionParser(new[] { parameter }, $"DateTime({str})", new object[] { }, ParsingConfig.Default);
var expression = parser.Parse(typeof(DateTime));
// Assert
expression.ToString().Should().NotBeEmpty();
}
[Fact]
public void ParseTypeAccess_Via_Constructor_Arguments_To_DateTime_Valid()
{
// Arrange
var arguments = "2022, 10, 31, 9, 15, 11";
var parameter = Expression.Parameter(typeof(DateTime));
// Act
var parser = new ExpressionParser(new[] { parameter }, $"DateTime({arguments})", new object[] { }, ParsingConfig.Default);
var expression = parser.Parse(typeof(DateTime));
// Assert
expression.ToString().Should().NotBeEmpty();
}
[Theory]
[InlineData(null)]
[InlineData("\"abc\"")]
public void ParseTypeAccess_Via_Constructor_Any_To_DateTime_Invalid(object any)
{
// Arrange
var parameter = Expression.Parameter(typeof(DateTime));
// Act
var parser = new ExpressionParser(new[] { parameter }, $"DateTime({any})", new object[] { }, ParsingConfig.Default);
Action a = () => parser.Parse(typeof(DateTime));
// Assert
a.Should().Throw<Exception>();
}
#if NET6_0_OR_GREATER
[Fact]
public void ParseTypeAccess_Via_Constructor_String_To_DateOnly_Valid()
{
// Arrange
string str = "\"2020-10-31\"";
var parameter = Expression.Parameter(typeof(DateOnly));
// Act
var parser = new ExpressionParser(new[] { parameter }, $"DateOnly({str})", new object[] { }, ParsingConfig.Default);
var expression = parser.Parse(typeof(DateOnly));
// Assert
expression.ToString().Should().NotBeEmpty();
}
[Fact]
public void ParseTypeAccess_Via_Constructor_Arguments_To_DateOnly_Valid()
{
// Arrange
var arguments = "2022, 10, 31";
var parameter = Expression.Parameter(typeof(DateOnly));
// Act
var parser = new ExpressionParser(new[] { parameter }, $"DateOnly({arguments})", new object[] { }, ParsingConfig.Default);
var expression = parser.Parse(typeof(DateOnly));
// Assert
expression.ToString().Should().NotBeEmpty();
}
[Theory]
[InlineData(null)]
[InlineData("\"abc\"")]
public void ParseTypeAccess_Via_Constructor_Any_To_DateOnly_Invalid(object any)
{
// Arrange
var parameter = Expression.Parameter(typeof(DateOnly));
// Act
var parser = new ExpressionParser(new[] { parameter }, $"DateOnly({any})", new object[] { }, ParsingConfig.Default);
Action a = () => parser.Parse(typeof(DateOnly));
// Assert
a.Should().Throw<Exception>();
}
[Fact]
public void ParseTypeAccess_Via_Constructor_String_To_TimeOnly_Valid()
{
// Arrange
string str = "\"09:15:11\"";
var parameter = Expression.Parameter(typeof(TimeOnly));
// Act
var parser = new ExpressionParser(new[] { parameter }, $"TimeOnly({str})", new object[] { }, ParsingConfig.Default);
var expression = parser.Parse(typeof(TimeOnly));
// Assert
expression.ToString().Should().NotBeEmpty();
}
[Fact]
public void ParseTypeAccess_Via_Constructor_Arguments_To_TimeOnly_Valid()
{
// Arrange
var arguments = "9, 15, 11";
var parameter = Expression.Parameter(typeof(TimeOnly));
// Act
var parser = new ExpressionParser(new[] { parameter }, $"TimeOnly({arguments})", new object[] { }, ParsingConfig.Default);
var expression = parser.Parse(typeof(TimeOnly));
// Assert
expression.ToString().Should().NotBeEmpty();
}
[Theory]
[InlineData(null)]
[InlineData("\"abc\"")]
public void ParseTypeAccess_Via_Constructor_Any_To_TimeOnly_Invalid(object any)
{
// Arrange
var parameter = Expression.Parameter(typeof(TimeOnly));
// Act
var parser = new ExpressionParser(new[] { parameter }, $"TimeOnly({any})", new object[] { }, ParsingConfig.Default);
Action a = () => parser.Parse(typeof(TimeOnly));
// Assert
a.Should().Throw<Exception>();
}
#endif
[Fact]
public void ParseTypeAccess_Via_Constructor_String_To_Uri()
{
// Arrange
string selector = "Uri(\"path_to_url")";
var parameter = Expression.Parameter(typeof(Uri));
// Act
var parser = new ExpressionParser(new[] { parameter }, selector, new object[] { }, ParsingConfig.Default);
var expression = parser.Parse(typeof(Uri));
// Assert
expression.ToString().Should().Be("path_to_url");
}
[Fact]
public void ParseTypeAccess_Via_Constructor_String_And_UriKind_To_Uri()
{
// Arrange
string selector = "Uri(\"path_to_url", UriKind.Absolute)";
var parameter = Expression.Parameter(typeof(Uri));
// Act
var parser = new ExpressionParser(new[] { parameter }, selector, new object[] { }, ParsingConfig.Default);
var expression = parser.Parse(typeof(Uri));
// Assert
expression.ToString().Should().Be("new Uri(\"path_to_url", Absolute)");
}
[Theory]
[InlineData("new(1 as a, 2 as b)", "new*(a = 1, b = 2)")]
[InlineData("new(2 as b, 1 as a)", "new*(a = 1, b = 2)")]
public void ParseTypeAccess_Via_Constructor_DynamicType_To_String(string newExpression, string newExpression2)
{
// Arrange
var parameter = Expression.Parameter(typeof(int));
var parameter2 = Expression.Parameter(typeof(int));
var returnType = DynamicClassFactory.CreateType(new List<DynamicProperty>
{
new("a", typeof(int)),
new("b", typeof(int))
});
// Act
var parser = new ExpressionParser(new[] { parameter, parameter2 }, newExpression, new object[] { }, ParsingConfig.Default);
var expression = parser.Parse(returnType);
// Assert
expression.ToString().Should().Match(newExpression2);
}
[Fact]
public void your_sha256_hashxception()
{
// Arrange
var parameter = Expression.Parameter(typeof(int));
var returnType = DynamicClassFactory.CreateType(new List<DynamicProperty>
{
new("a", typeof(int))
});
var config = new ParsingConfig
{
DisallowNewKeyword = true
};
// Act
var parser = new ExpressionParser(new[] { parameter }, "new(1 as a)", new object[] { }, config);
Action action = () => parser.Parse(returnType);
// Assert
action.Should().Throw<ParseException>().Which.Message.Should().Be(Res.NewOperatorIsNotAllowed);
}
}
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests/Parser/ExpressionParserTests.TypeAccess.cs
|
smalltalk
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 1,815
|
```xml
<Project Sdk="Microsoft.NET.Sdk" ToolsVersion="15.0">
<PropertyGroup>
<Authors>Stef Heyenrath</Authors>
<TargetFramework>netcoreapp3.1</TargetFramework>
<AssemblyName>System.Linq.Dynamic.Core.Tests</AssemblyName>
<DebugType>full</DebugType>
<SignAssembly>True</SignAssembly>
<AssemblyOriginatorKeyFile>../../src/System.Linq.Dynamic.Core/System.Linq.Dynamic.Core.snk</AssemblyOriginatorKeyFile>
<ProjectGuid>{7AFC2836-0F6E-4B0D-8BB3-13317A3B6616}</ProjectGuid>
<DefineConstants>$(DefineConstants);EFCORE;EFCORE_3X;AspNetCoreIdentity</DefineConstants>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="coverlet.msbuild" Version="6.0.2">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
</PackageReference>
<PackageReference Include="FluentAssertions" Version="5.10.3" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.10.0" />
<PackageReference Include="Mono.Reflection" Version="2.0.0" />
<PackageReference Include="OpenCover" Version="4.7.1221" />
<PackageReference Include="ReportGenerator" Version="4.8.13" />
<PackageReference Include="System.Reflection.Emit" Version="4.7.0" />
<PackageReference Include="xunit.runner.console" Version="2.4.1">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
</PackageReference>
<PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
</PackageReference>
<PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
<PackageReference Include="Linq.PropertyTranslator.Core" Version="1.0.5" />
<PackageReference Include="QueryInterceptor.Core" Version="1.0.9" />
<PackageReference Include="xunit" Version="2.4.1" />
<PackageReference Include="NFluent" Version="2.8.0" />
<PackageReference Include="Moq" Version="4.13.1" />
<PackageReference Include="Testcontainers.MsSql" Version="3.9.0" />
<PackageReference Include="NodaTime" Version="2.4.7" />
<PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="3.1.0" />
<PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="3.1.0" />
<PackageReference Include="Microsoft.AspNetCore.Identity.EntityFrameworkCore" Version="3.1.0" />
<PackageReference Include="LinqKit.Microsoft.EntityFrameworkCore" Version="3.0.0" />
<ProjectReference Include="..\..\src\Microsoft.EntityFrameworkCore.DynamicLinq.EFCore3\Microsoft.EntityFrameworkCore.DynamicLinq.EFCore3.csproj" />
</ItemGroup>
<ItemGroup>
<Compile Include="..\System.Linq.Dynamic.Core.Tests\*.cs" />
<Compile Include="..\System.Linq.Dynamic.Core.Tests\*\*.cs" />
<Compile Include="..\System.Linq.Dynamic.Core.Tests\*\*\*.cs" />
</ItemGroup>
</Project>
```
|
/content/code_sandbox/test/System.Linq.Dynamic.Core.Tests.NetCoreApp31/System.Linq.Dynamic.Core.Tests.NetCoreApp31.csproj
|
xml
| 2016-04-08T16:41:51
| 2024-08-16T05:55:59
|
System.Linq.Dynamic.Core
|
zzzprojects/System.Linq.Dynamic.Core
| 1,537
| 796
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.