public VMDependencyManagment(DBItemType type_available, Meta current)
{
ManagedMeta = current;
ManagedItemType = DBItemType.Meta;
ListDependencies = Linq.DependenciesList(current, type_available);
Init(type_available);
}
public VMDependencyManagment(DBItemType type_available, LTG_Entity.Environment current)
{
ManagedEnvironment = current;
ManagedItemType = DBItemType.Environment;
ListDependencies = Linq.DependenciesList(current, type_available);
Init(type_available);
}
/// <summary>
/// A simple example of how to combine expressions (i.e., how to have one expression call another).
/// </summary>
static void TestExpressionCombiner()
{
var criteria1 = Linq.Predicate <Purchase>(p => p.Price > 1000);
var criteria2 = Linq.Predicate <Purchase>(p => criteria1.Invoke(p) || p.Description.Contains("a"));
//Expression<Func<Purchase, bool>> criteria1 = p => p.Price > 1000;
//Expression<Func<Purchase, bool>> criteria2 = p => criteria1.Invoke(p) || p.Description.Contains("a");
Console.WriteLine("Here's what criteria2 looks like, before calling Expand");
Console.WriteLine(criteria2.ToString());
Console.WriteLine();
Console.WriteLine("Here's what criteria2 looks like, after calling Expand");
Console.WriteLine(criteria2.Expand().ToString());
var data = new DemoData();
// We can use criteria2 in either of two ways: either call Expand on the expression before using it:
var query = data.Purchases.Where(criteria2.Expand());
Console.WriteLine("Count: " + query.Count());
// or call AsExpandable() on the Table:
query = data.Purchases.AsExpandable().Where(criteria2);
Console.WriteLine("Count: " + query.Count());
}
// Constructors
public VMDependencyManagment(DBItemType type_available, Template t)
{
ManagedTemplate = t;
ManagedItemType = DBItemType.Template;
ListDependencies = Linq.DependenciesList(t, type_available);
Init(type_available);
}
public void Round()
{
Assert.AreEqual(Filter.Serialize(Linq.Expr <Customer, bool>(t => Math.Round(t.FreightDecimal) == 32)), "round(FreightDecimal) eq 32m");
// ReSharper disable once CompareOfFloatsByEqualityOperator
Assert.AreEqual(Filter.Serialize(Linq.Expr <Customer, bool>(t => Math.Round(t.FreightDouble) == 32)), "round(FreightDouble) eq 32");
}
// [TestMethod]
public void Division()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Sbyte / t.Sbyte > 10), Filter.Deserialize <Customer>("Sbyte div Sbyte gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Sbyte / t.Sbyte == null), Filter.Deserialize <Customer>("Sbyte div Sbyte eq null")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableSbyte / t.NullableSbyte > 10), Filter.Deserialize <Customer>("NullableSbyte div NullableSbyte gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableSbyte / t.NullableSbyte == null), Filter.Deserialize <Customer>("NullableSbyte div NullableSbyte eq null")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableSbyte / t.Sbyte > 10), Filter.Deserialize <Customer>("NullableSbyte div Sbyte gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Sbyte / t.NullableSbyte > 10), Filter.Deserialize <Customer>("Sbyte div NullableSbyte gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableSbyte / t.Sbyte > null), Filter.Deserialize <Customer>("NullableSbyte div Sbyte gt null")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Sbyte / t.NullableSbyte > null), Filter.Deserialize <Customer>("Sbyte div NullableSbyte gt null")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.FreightDouble / t.NullableInt > 10), Filter.Deserialize <Customer>("FreightDouble div NullableInt gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableInt / t.FreightDouble > 10), Filter.Deserialize <Customer>("NullableInt div FreightDouble gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableInt / t.FreightDouble > t.NullableInt), Filter.Deserialize <Customer>("NullableInt div FreightDouble gt NullableInt")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableInt / t.NullableInt > 10), Filter.Deserialize <Customer>("NullableInt div NullableInt gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableInt / t.NullableInt > 10.0), Filter.Deserialize <Customer>("NullableInt div NullableInt gt 10.0")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableInt / t.NullableInt > t.NullableInt), Filter.Deserialize <Customer>("NullableInt div NullableInt gt NullableInt")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableInt / t.NullableInt != null), Filter.Deserialize <Customer>("NullableInt div NullableInt ne null")));
}
public Kaydol()
{
InitializeComponent();
bl = new BusinessLogic();
dal = new DataAccess();
linq = new Linq();
}
public void TopNRecords()
{
// Arrange
var subject = new Linq();
var expectedList = new List <int> {
24, 13, 9
};
// Act
var actual = subject.GetTopNRecords(3,
new List <int>
{
5,
7,
13,
24,
6,
9,
8,
7
});
// Assert
Assert.AreEqual(3, actual.Count());
foreach (var actualNumber in actual)
{
Assert.IsTrue(expectedList.Contains(actualNumber));
}
}
public void FloorNullable()
{
Assert.AreEqual(Filter.Serialize(Linq.Expr <Customer, bool>(t => Math.Floor(t.FreightDecimalNullable.Value) == 34)), "floor(FreightDecimalNullable/Value) eq 34m");
// ReSharper disable once CompareOfFloatsByEqualityOperator
Assert.AreEqual(Filter.Serialize(Linq.Expr <Customer, bool>(t => Math.Floor(t.FreightDoubleNullable.Value) == 34)), "floor(FreightDoubleNullable/Value) eq 34");
}
// [TestMethod]
public void Multiplication()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Sbyte + t.Sbyte > 10), Filter.Deserialize <Customer>("Sbyte add Sbyte gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Sbyte + t.Sbyte == null), Filter.Deserialize <Customer>("Sbyte add Sbyte eq null")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableSbyte + t.NullableSbyte > 10), Filter.Deserialize <Customer>("NullableSbyte add NullableSbyte gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableSbyte + t.NullableSbyte == null), Filter.Deserialize <Customer>("NullableSbyte add NullableSbyte eq null")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableSbyte + t.Sbyte > 10), Filter.Deserialize <Customer>("NullableSbyte add Sbyte gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Sbyte + t.NullableSbyte > 10), Filter.Deserialize <Customer>("Sbyte add NullableSbyte gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableSbyte + t.Sbyte > null), Filter.Deserialize <Customer>("NullableSbyte add Sbyte gt null")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Sbyte + t.NullableSbyte > null), Filter.Deserialize <Customer>("Sbyte add NullableSbyte gt null")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.FreightDouble + t.NullableInt > 10), Filter.Deserialize <Customer>("FreightDouble add NullableInt gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableInt + t.FreightDouble > 10), Filter.Deserialize <Customer>("NullableInt add FreightDouble gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableInt + t.FreightDouble > t.NullableInt), Filter.Deserialize <Customer>("NullableInt add FreightDouble gt NullableInt")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableInt + t.NullableInt > 10), Filter.Deserialize <Customer>("NullableInt add NullableInt gt 10")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableInt + t.NullableInt > 10.0), Filter.Deserialize <Customer>("NullableInt add NullableInt gt 10.0")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableInt + t.NullableInt > t.NullableInt), Filter.Deserialize <Customer>("NullableInt add NullableInt gt NullableInt")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableInt + t.NullableInt != null), Filter.Deserialize <Customer>("NullableInt add NullableInt ne null")));
}
public void FloorNullable()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => Math.Floor(t.FreightDecimalNullable.Value) == 34), Filter.Deserialize <Customer>("floor(FreightDecimalNullable) eq 34")));
// ReSharper disable once CompareOfFloatsByEqualityOperator
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => Math.Floor(t.FreightDoubleNullable.Value) == 34), Filter.Deserialize <Customer>("floor(FreightDoubleNullable) eq 34")));
}
public void Ceiling()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => Math.Ceiling(t.FreightDecimal) == 33), Filter.Deserialize <Customer>("ceiling(FreightDecimal) eq 33")));
// ReSharper disable once CompareOfFloatsByEqualityOperator
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => Math.Ceiling(t.FreightDouble) == 33), Filter.Deserialize <Customer>("ceiling(FreightDouble) eq 33")));
}
public void TestAtLeastPercent()
{
var ints = Linq.Range(1, 10).ToShuffledList(0);
Assert.True(ints.AtLeastPercent(0.5, x => x >= 5));
Assert.False(ints.AtLeastPercent(0.5, x => x > 5));
}
public void FileCountByExtension()
{
// Arrange
var subject = new Linq();
var expectedList = new Dictionary <string, int>
{
{ "frx", 1 },
{ "txt", 3 },
{ "dbf", 1 },
{ "pdf", 2 },
{ "frt", 1 },
{ "xml", 1 }
};
// Act
var actual = subject.GetFileCountByExtension(
new List <string>
{
"aaa.frx", "bbb.TXT", "xyz.dbf", "abc.pdf",
"aaaa.PDF", "xyz.frt", "abc.xml", "ccc.txt", "zzz.txt"
});
// Assert
Assert.AreEqual(6, actual.Count);
foreach (var actualFc in actual)
{
Assert.IsTrue(expectedList.Contains(actualFc));
}
}
// [TestMethod]
public void Equal()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => String.Compare(t.Name, t.LastName, StringComparison.Ordinal) > 0), Filter.Deserialize <Customer>("Name gt LastName")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Name != t.LastName), Filter.Deserialize <Customer>("Name ne LastName")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Id == 15), Filter.Deserialize <Customer>("Id eq 15")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.FreightDoubleNullable == t.FreightDouble), Filter.Deserialize <Customer>("FreightDoubleNullable eq FreightDouble")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Sbyte == 15), Filter.Deserialize <Customer>("Sbyte eq 15")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Char == 15), Filter.Deserialize <Customer>("Char eq 15")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableSbyte == 15), Filter.Deserialize <Customer>("NullableSbyte eq 15")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableChar == 15), Filter.Deserialize <Customer>("NullableChar eq 15")));
// ReSharper disable once ConditionIsAlwaysTrueOrFalse
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Id == null), Filter.Deserialize <Customer>("Id eq null")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => null > t.Id), Filter.Deserialize <Customer>("null gt Id")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => null == t.FreightDecimalNullable), Filter.Deserialize <Customer>("null eq FreightDecimalNullable")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.FreightDecimalNullable == null), Filter.Deserialize <Customer>("FreightDecimalNullable eq null")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Name == null), Filter.Deserialize <Customer>("Name eq null")));
//Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr<Customer, bool>(t => null == t.Name), Filter.Deserialize<Customer>("null eq Name")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableEnumData == null), Filter.Deserialize <Customer>("NullableEnumData eq null")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.NullableEnumData == (EnumData.TestData1 | EnumData.TestData2)), Filter.Deserialize <Customer>("NullableEnumData eq Sprint.Filter.OData.Test.Models.EnumData'TestData1,TestData2'")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.EnumData == (EnumData.TestData1 | EnumData.TestData2)), Filter.Deserialize <Customer>("EnumData eq Sprint.Filter.OData.Test.Models.EnumData'TestData1,TestData2'")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.EnumDataShort == (EnumDataShort.TestData1 | EnumDataShort.TestData2)), Filter.Deserialize <Customer>("EnumDataShort eq Sprint.Filter.OData.Test.Models.EnumDataShort'TestData1,TestData2'")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.EnumDataLong == (EnumDataLong.TestData1 | EnumDataLong.TestData2)), Filter.Deserialize <Customer>("EnumDataLong eq Sprint.Filter.OData.Test.Models.EnumDataLong'TestData1,TestData2'")));
}
public void GreaterThan80()
{
// Arrange
var subject = new Linq();
var expectedList = new List <int> {
200, 740, 230, 482, 95
};
// Act
var actual = subject.GetGreaterNumbers(80,
new List <int>
{
55,
200,
740,
76,
230,
482,
95
});
// Assert
Assert.AreEqual(5, actual.Count());
foreach (var actualNumber in actual)
{
Assert.IsTrue(expectedList.Contains(actualNumber));
}
}
//[TestMethod]
public void Negation()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => - t.Id > 0), Filter.Deserialize <Customer>("-Id gt 0")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => - t.FreightDoubleNullable > 0), Filter.Deserialize <Customer>("-FreightDoubleNullable gt 0")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => - t.FreightDoubleNullable > 0), Filter.Deserialize <Customer>("- FreightDoubleNullable gt 0")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => - t.FreightDoubleNullable > 0), Filter.Deserialize <Customer>("- FreightDoubleNullable gt 0")));
}
public override Linq.Translation.SqlGen.SqlStatement GetOrderByColumn(Linq.Translation.SqlGen.SqlStatement expression, bool descending)
{
string result = string.Format("{0} COLLATE NOCASE", expression);
if(descending)
result += " DESC";
return result;
}
public void CeilingNullable()
{
Assert.AreEqual(Filter.Serialize(Linq.Expr <Customer, bool>(t => Math.Ceiling(t.FreightDecimalNullable.Value) == 32)), "ceiling(FreightDecimalNullable/Value) eq 32m");
// ReSharper disable once CompareOfFloatsByEqualityOperator
Assert.AreEqual(Filter.Serialize(Linq.Expr <Customer, bool>(t => Math.Ceiling(t.FreightDoubleNullable.Value) == 32)), "ceiling(FreightDoubleNullable/Value) eq 32");
}
public void Isof()
{
// ReSharper disable once CSharpWarnings::CS0183
Assert.AreEqual(Filter.Serialize(Linq.Expr <Customer, bool>(t => t.Parent is Customer)), "isof(Parent, Sprint.Filter.OData.Test.Models.Customer)");
// ReSharper disable once CSharpWarnings::CS0183
Assert.AreEqual(Filter.Serialize(Linq.Expr <Customer, bool>(t => t is Customer)), "isof(Sprint.Filter.OData.Test.Models.Customer)");
}
public void SelectMany()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Customers.SelectMany(x => x.Items).Count() == 15),
Filter.Deserialize <Customer>("Customers/SelectMany(x: x/Items)/Count() eq 15")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Items.SelectMany(x => x.Customers).Count() == 15),
Filter.Deserialize <Customer>("Items/SelectMany(x: x/Customers)/Count() eq 15")));
}
public void Distinct()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Customers.Select(x => x.Id).Distinct().Count() == 15),
Filter.Deserialize <Customer>("Customers/Select(x: x/Id)/Distinct()/Count() eq 15")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Numbers.Distinct().Count() == 15),
Filter.Deserialize <Customer>("Numbers/Distinct()/Count() eq 15")));
}
public void Cast()
{
// ReSharper disable once RedundantCast
Assert.AreEqual(Filter.Serialize(Linq.Expr <Customer, bool>(t => t.Parent as Customer != null)), "cast(Parent, Sprint.Filter.OData.Test.Models.Customer) ne null");
// ReSharper disable once RedundantCast
Assert.AreEqual(Filter.Serialize(Linq.Expr <Customer, bool>(t => t as Customer != null)), "cast(Sprint.Filter.OData.Test.Models.Customer) ne null");
}
public AnaEkran(string username, int userid)
{
InitializeComponent();
bl = new BusinessLogic();
linq = new Linq();
Username = username;
Userid = userid;
}
public void SingleOrDefault()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Customers.SingleOrDefault().Id == 15),
Filter.Deserialize <Customer>("Customers/SingleOrDefault()/Id eq 15")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Customers.SingleOrDefault(c => c.Name == "test").Id == 15),
Filter.Deserialize <Customer>("Customers/SingleOrDefault(c: c/Name eq 'test')/Id eq 15")));
}
public void ThenByDescending()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Customers.OrderBy(x => x.Id).ThenByDescending(x => x.Name).Select(x => x.Id).First() == 15),
Filter.Deserialize <Customer>("Customers/OrderBy(x: x/Id)/ThenByDescending(x: x/Name)/Select(x: x/Id)/First() eq 15")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Numbers.Distinct().OrderBy(x => x).ThenByDescending(x => x).First() == 15),
Filter.Deserialize <Customer>("Numbers/Distinct()/OrderBy(x: x)/ThenByDescending(x: x)/First() eq 15")));
}
public void All()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Customers.All(x => true)), Filter.Deserialize <Customer>("Customers/All(x: true)")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.EnumerableCustomers.All(x => true)), Filter.Deserialize <Customer>("EnumerableCustomers/All(x: true)")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.ListCustomers.All(x => true)), Filter.Deserialize <Customer>("ListCustomers/All(x: true)")));
}
private static void ExecModuleByPartial()
{
var assembly = Assembly.Load("ModuleByPartial");
var type = Linq.Single(assembly.GetTypes(), t => t.Name == "ModuleByPartialCode");
var method = type.GetMethod("Run", BindingFlags.Public | BindingFlags.Static);
method.Invoke(null, new object[0]);
}
public void Sum()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Customers.Sum(x => x.Id) == 15),
Filter.Deserialize <Customer>("Customers/Sum(x: x/Id) eq 15")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Numbers.Sum() == 15),
Filter.Deserialize <Customer>("Numbers/Sum() eq 15")));
}
public void Select()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.IntArray.Select(x => x).Count() == 15),
Filter.Deserialize <Customer>("IntArray/Select(x: x)/Count() eq 15")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Customers.Select(x => x.Id).Count() == 15),
Filter.Deserialize <Customer>("Customers/Select(x: x/Id)/Count() eq 15")));
}
public void AnyNoArgsTest()
{
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.Customers.Any()), Filter.Deserialize <Customer>("Customers/Any()")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.EnumerableCustomers.Any()), Filter.Deserialize <Customer>("EnumerableCustomers/Any()")));
Assert.IsTrue(ExpressionEqualityComparer.Equals(Linq.Expr <Customer, bool>(t => t.ListCustomers.Any()), Filter.Deserialize <Customer>("ListCustomers/Any()")));
}
virtual public void VisitLinqExpression(Linq.LinqExpression x)
{
VisitQueryBody(x.Body);
}
public virtual object Visit (Linq.QueryStartClause queryExpression)
{
return null;
}
virtual public void VisitQueryBody(Linq.QueryBody x)
{
foreach (Linq.FromWhereClause item in x.FromWhere)
VisitElement(item);
}
public virtual object Visit (Linq.Let let)
{
return null;
}
public virtual object Visit (Linq.Select select)
{
return null;
}
public virtual object Visit (Linq.OrderByDescending orderByDescending)
{
return null;
}
public virtual object Visit (Linq.Join join)
{
return null;
}
virtual public void VisitFromClause(Linq.FromClause x)
{
foreach (Linq.Generator g in x.Generators)
VisitElement(g);
}
virtual public void VisitGenerator(Linq.Generator x)
{
VisitElement(x.Expression);
}
virtual internal void VisitLinqTuple(Linq.LinqTuple x)
{
VisitElement(x.LastItem);
foreach (Linq.OrderingClause item in x.OrderingItems)
VisitElement(item);
}
virtual internal void VisitLinqOpChain(Linq.LinqOpChain x)
{
VisitElement(x.Expression);
}
virtual internal void VisitLinqTupleItemAccess(Linq.LinqTupleItemAccess x)
{
// nothing
}
public virtual object Visit (Linq.QueryExpression queryExpression)
{
return null;
}
virtual public void VisitSelectClause(Linq.SelectClause x)
{
VisitElement(x.Expression);
}
public virtual object Visit (Linq.SelectMany selectMany)
{
return null;
}
virtual public void VisitGroupByClause(Linq.GroupByClause x)
{
VisitElement(x.GroupExpr);
VisitElement(x.ByExpr);
}
public virtual object Visit (Linq.GroupBy groupBy)
{
return null;
}
virtual public void VisitIntoClause(Linq.IntoClause x)
{
VisitElement(x.KeyVar);
VisitElement(x.ValueVar);
VisitQueryBody(x.NextQuery);
}
public virtual object Visit (Linq.Where where)
{
return null;
}
virtual public void VisitOrderByClause(Linq.OrderByClause x)
{
foreach (Linq.OrderingClause item in x.OrderingClauses)
VisitElement(item);
}
public virtual object Visit (Linq.GroupJoin groupJoin)
{
return null;
}
virtual public void VisitOrderingClause(Linq.OrderingClause x)
{
VisitElement(x.Expression);
}
public virtual object Visit (Linq.ThenByDescending thenByDescending)
{
return null;
}
virtual public void VisitWhereClause(Linq.WhereClause x)
{
VisitElement(x.Expression);
}
