public virtual async Task Correlated_collections_on_select_many()
{
await AssertQuery <Gear, Squad>(
(gs, ss) =>
from g in gs
from s in ss
where g.HasSoulPatch
orderby g.Nickname, s.Id descending
select new
{
GearNickname = g.Nickname,
SquadName = s.Name,
Collection1 = from w in g.Weapons
where w.IsAutomatic || w.Name != "foo"
select w,
Collection2 = from m in s.Members
where !m.HasSoulPatch
select m
},
assertOrder : true,
elementAsserter : (e, a) =>
{
Assert.Equal(e.GearNickname, e.GearNickname);
Assert.Equal(e.SquadName, e.SquadName);
CollectionAsserter <Weapon>(ee => ee.Id, (ee, aa) => Assert.Equal(ee.Id, aa.Id))(e.Collection1, a.Collection1);
CollectionAsserter <Gear>(ee => ee.Nickname, (ee, aa) => Assert.Equal(ee.Nickname, aa.Nickname))(e.Collection2, a.Collection2);
});
}
public virtual async Task Correlated_collections_complex_scenario1()
{
await AssertQuery <Gear>(
gs =>
from r in gs
select new
{
r.FullName,
OuterCollection = (from w in r.Weapons
select new
{
w.Id,
InnerCollection = w.Owner.Squad.Members.OrderBy(mm => mm.Nickname).Select(mm => new { mm.Nickname, mm.HasSoulPatch }).ToList()
}).ToList()
},
elementSorter : e => e.FullName,
elementAsserter : (e, a) =>
{
Assert.Equal(e.FullName, a.FullName);
CollectionAsserter <dynamic>(
ee => ee.Id,
(ee, aa) =>
{
Assert.Equal(ee.Id, aa.Id);
CollectionAsserter <dynamic>(eee => eee.Nickname)(ee.InnerCollection, aa.InnerCollection);
})(e.OuterCollection, a.OuterCollection);
});
}
public virtual void GroupJoin_outer_projection3()
{
AssertQuery <Customer, Order>(
(cs, os) => cs.GroupJoin(os, c => c.CustomerID, o => o.CustomerID, (c, g) => new { g = g.Select(o => o.CustomerID) }),
e => CollectionSorter <string>()(e.g),
elementAsserter: (e, a) => CollectionAsserter <string>(s => s)(e.g, a.g));
}
public virtual async Task Correlated_collections_nested_with_custom_ordering()
{
await AssertQuery <Gear>(
gs => gs
.OfType <Officer>()
.OrderByDescending(o => o.HasSoulPatch)
.Select(o => new
{
o.FullName,
OuterCollection = o.Reports
.Where(r => r.FullName != "Foo")
.OrderBy(r => r.Rank)
.Select(g => new
{
g.FullName,
InnerCollection = g.Weapons
.Where(w => w.Name != "Bar")
.OrderBy(w => w.IsAutomatic).ToList()
}).ToList()
}),
elementSorter : e => e.FullName,
elementAsserter : (e, a) =>
{
Assert.Equal(e.FullName, a.FullName);
CollectionAsserter <dynamic>(
ee => ee.FullName,
(ee, aa) =>
{
Assert.Equal(ee.FullName, aa.FullName);
CollectionAsserter <dynamic>(
eee => eee.Name,
(eee, aaa) => Assert.Equal(eee.Name, aaa.Name))(ee.InnerCollection, aa.InnerCollection);
})(e.OuterCollection, a.OuterCollection);
});
}
public virtual async Task Correlated_collections_nested_inner_subquery_references_outer_qsre_two_levels_up()
{
await AssertQuery <Gear>(
gs =>
from o in gs.OfType <Officer>()
select new
{
o.FullName,
OuterCollection = from r in o.Reports
where r.FullName != "Foo"
select new
{
r.FullName,
InnerCollection = from w in r.Weapons
where w.Name != "Bar"
select new
{
w.Name,
o.Nickname
}
},
},
elementSorter : e => e.FullName,
elementAsserter : (e, a) =>
{
Assert.Equal(e.FullName, a.FullName);
CollectionAsserter <dynamic>(
ee => ee.FullName,
(ee, aa) =>
{
Assert.Equal(ee.FullName, aa.FullName);
CollectionAsserter <dynamic>(eee => eee.Name)(ee.InnerCollection, aa.InnerCollection);
})(e.OuterCollection, a.OuterCollection);
});
}
public virtual Task Filter_owned_entity_chained_with_regular_entity_followed_by_projecting_owned_collection(bool isAsync)
{
return(AssertQuery <OwnedPerson>(
isAsync,
ops => ops.Where(p => p.PersonAddress.Country.Planet.Id != 42).OrderBy(p => p.Id).Select(p => new { p.Orders }),
assertOrder: true,
elementAsserter: (e, a) => CollectionAsserter <Order>(ee => ee.Id, (ee, aa) => Assert.Equal(ee.Id, aa.Id))(e.Orders, a.Orders)));
}
public static Action <dynamic, dynamic> GroupingAsserter <TKey, TElement>(Func <TElement, object> elementSorter = null, Action <TElement, TElement> elementAsserter = null)
{
return((e, a) =>
{
Assert.Equal(((IGrouping <TKey, TElement>)e).Key, ((IGrouping <TKey, TElement>)a).Key);
CollectionAsserter(elementSorter, elementAsserter)(e, a);
});
}
public virtual Task GroupJoin_outer_projection3(bool isAsync)
{
return(AssertQuery <Customer, Order>(
isAsync,
(cs, os) => cs.GroupJoin(
os, c => c.CustomerID, o => o.CustomerID, (c, g) => new { g = g.Select(o => o.CustomerID) }),
e => CollectionSorter <string>()(e.g),
elementAsserter: (e, a) => CollectionAsserter <string>(s => s)(e.g, a.g)));
}
public virtual async Task Correlated_collections_with_Distinct()
{
await AssertQuery <Squad>(
ss => ss.OrderBy(s => s.Name).Select(s => s.Members.OrderBy(m => m.Nickname).Distinct()),
assertOrder : true,
elementAsserter : (e, a) =>
{
CollectionAsserter <Gear>(elementAsserter: (ee, aa) => Assert.Equal(ee.Nickname, aa.Nickname))(e, a);
});
}
public virtual async Task Correlated_collections_multiple_nested_complex_collections()
{
await AssertQuery <Gear>(
gs =>
from o in gs.OfType <Officer>()
orderby o.HasSoulPatch descending, o.Tag.Note
where o.Reports.Any()
select new
{
o.FullName,
OuterCollection = (from r in o.Reports
where r.FullName != "Foo"
orderby r.Rank
select new
{
r.FullName,
InnerCollection = (from w in r.Weapons
where w.Name != "Bar"
orderby w.IsAutomatic
select new
{
w.Id,
InnerFirst = w.Owner.Weapons.Select(ww => new { ww.Name, ww.IsAutomatic }).ToList(),
InnerSecond = w.Owner.Squad.Members.OrderBy(mm => mm.Nickname).Select(mm => new { mm.Nickname, mm.HasSoulPatch }).ToList()
}).ToList()
}).ToList(),
OuterCollection2 = (from www in o.Tag.Gear.Weapons
orderby www.IsAutomatic, www.Owner.Nickname descending
select www).ToList()
},
elementSorter : e => e.FullName,
elementAsserter : (e, a) =>
{
Assert.Equal(e.FullName, a.FullName);
CollectionAsserter <dynamic>(
ee => ee.FullName,
(ee, aa) =>
{
Assert.Equal(ee.FullName, aa.FullName);
CollectionAsserter <dynamic>(
eee => eee.Id,
(eee, aaa) =>
{
Assert.Equal(eee.Id, aaa.Id);
CollectionAsserter <dynamic>(eeee => eeee.Name)(eee.InnerFirst, aaa.InnerFirst);
CollectionAsserter <dynamic>()(eee.InnerSecond, aaa.InnerSecond);
})(ee.InnerCollection, aa.InnerCollection);
})(e.OuterCollection, a.OuterCollection);
CollectionAsserter <dynamic>(
ee => ee.Id,
(ee, aa) => Assert.Equal(ee.Id, aa.Id))(e.OuterCollection2, a.OuterCollection2);
});
}
public virtual void GroupJoin_outer_projection_reverse2()
{
AssertQuery <Customer, Order>(
(cs, os) => os.GroupJoin(cs, o => o.CustomerID, c => c.CustomerID, (o, g) => new { o.CustomerID, g = g.Select(c => c.City) }),
elementSorter: e => e.CustomerID,
elementAsserter: (e, a) =>
{
Assert.Equal(e.CustomerID, a.CustomerID);
CollectionAsserter <string>(s => s)(e.g, a.g);
});
}
public virtual void GroupJoin_outer_projection2()
{
AssertQuery <Customer, Order>(
(cs, os) => cs.GroupJoin(os, c => c.CustomerID, o => o.CustomerID, (c, g) => new { c.City, g = g.Select(o => o.CustomerID) }),
e => e.City + " " + CollectionSorter <string>()(e.g),
elementAsserter: (e, a) =>
{
Assert.Equal(e.City, a.City);
CollectionAsserter <string>(s => s)(e.g, a.g);
});
}
public override async Task Correlated_collection_order_by_constant()
{
await AssertQuery <Gear>(
gs => gs.OrderByDescending(s => 1).Select(g => new { g.Nickname, Weapons = g.Weapons.Select(w => w.Name).ToList() }),
elementSorter : e => e.Nickname,
elementAsserter : (e, a) =>
{
Assert.Equal(e.Nickname, a.Nickname);
CollectionAsserter <string>(ee => ee)(e.Weapons, a.Weapons);
});
}
public virtual void GroupJoin_outer_projection()
{
AssertQuery <Customer, Order>(
(cs, os) => cs.GroupJoin(os, c => c.CustomerID, o => o.CustomerID, (c, o) => new { c.City, o }),
e => e.City + " " + CollectionSorter <Order>()(e.o),
elementAsserter: (e, a) =>
{
Assert.Equal(e.City, a.City);
CollectionAsserter <Order>(o => o.OrderID)(e.o, a.o);
},
entryCount: 830);
}
public virtual void GroupJoin_outer_projection_reverse()
{
AssertQuery <Customer, Order>(
(cs, os) => os.GroupJoin(cs, o => o.CustomerID, c => c.CustomerID, (o, c) => new { o.CustomerID, c }),
e => e.CustomerID,
elementAsserter: (e, a) =>
{
Assert.Equal(e.CustomerID, a.CustomerID);
CollectionAsserter <Customer>(c => c.CustomerID)(e.c, a.c);
},
entryCount: 89);
}
public virtual void Select_collection_navigation_multi_part()
{
AssertQuery <Order>(
os => from o in os
where o.CustomerID == "ALFKI"
select new { o.OrderID, o.Customer.Orders },
elementSorter: e => e.OrderID,
elementAsserter: (e, a) =>
{
Assert.Equal(e.OrderID, a.OrderID);
CollectionAsserter <Order>(o => o.OrderID, (ee, aa) => Assert.Equal(ee.OrderID, aa.OrderID))(e.Orders, a.Orders);
},
entryCount: 6);
}
public virtual Task GroupJoin_outer_projection(bool isAsync)
{
return(AssertQuery <Customer, Order>(
isAsync,
(cs, os) => cs.GroupJoin(
os, c => c.CustomerID, o => o.CustomerID, (c, o) => new { c.City, o }),
e => (e.City, CollectionSorter <Order>()(e.o)),
elementAsserter: (e, a) =>
{
Assert.Equal(e.City, a.City);
CollectionAsserter <Order>(o => o.OrderID)(e.o, a.o);
},
entryCount: 830));
}
public virtual Task GroupJoin_outer_projection_reverse(bool isAsync)
{
return(AssertQuery <Customer, Order>(
isAsync,
(cs, os) => os.GroupJoin(
cs, o => o.CustomerID, c => c.CustomerID, (o, c) => new { o.CustomerID, c }),
e => e.CustomerID,
elementAsserter: (e, a) =>
{
Assert.Equal(e.CustomerID, a.CustomerID);
CollectionAsserter <Customer>(c => c.CustomerID)(e.c, a.c);
},
entryCount: 89));
}
public virtual Task Project_multiple_owned_navigations(bool isAsync)
{
return(AssertQuery <OwnedPerson>(
isAsync,
ops => ops.OrderBy(p => p.Id).Select(p => new { p.Orders, p.PersonAddress, p.PersonAddress.Country.Planet }),
assertOrder: true,
elementAsserter: (e, a) =>
{
CollectionAsserter <Order>(ee => ee.Id, (ee, aa) => Assert.Equal(ee.Id, aa.Id))(e.Orders, a.Orders);
AssertAddress(e.PersonAddress, a.PersonAddress);
Assert.Equal(e.Planet.Id, a.Planet.Id);
Assert.Equal(e.Planet.StarId, a.Planet.StarId);
}));
}
public override async Task GroupJoin_customers_orders()
{
await AssertQuery <Customer, Order>(
(cs, os) =>
from c in cs
join o in os.OrderBy(o => o.OrderID) on c.CustomerID equals o.CustomerID into orders
select new { customer = c, orders = orders.ToList() },
e => e.customer.CustomerID,
elementAsserter : (e, a) =>
{
Assert.Equal(e.customer.CustomerID, a.customer.CustomerID);
CollectionAsserter <Order>(o => o.OrderID)(e.orders, a.orders);
},
entryCount : 921);
}
public virtual void Select_collection_navigation_simple()
{
AssertQuery <Customer>(
cs => from c in cs
where c.CustomerID.StartsWith("A")
orderby c.CustomerID
select new { c.CustomerID, c.Orders },
elementSorter: e => e.CustomerID,
elementAsserter: (e, a) =>
{
Assert.Equal(e.CustomerID, a.CustomerID);
CollectionAsserter <Order>(o => o.OrderID, (ee, aa) => Assert.Equal(ee.OrderID, aa.OrderID))(e.Orders, a.Orders);
},
entryCount: 30);
}
public virtual void GroupJoin_tracking_groups2()
{
AssertQuery <Customer, Order>(
(cs, os) =>
from c in cs
join o in os on c.CustomerID equals o.CustomerID into orders
select new { c, orders },
elementSorter: e => e.c.CustomerID,
elementAsserter: (e, a) =>
{
Assert.Equal(e.c.CustomerID, a.c.CustomerID);
CollectionAsserter <Order>(o => o.OrderID)(e.orders, a.orders);
},
entryCount: 921);
}
public virtual Task GroupJoin_customers_orders(bool isAsync)
{
return(AssertQuery <Customer, Order>(
isAsync,
(cs, os) =>
from c in cs
join o in os.OrderBy(o => o.OrderID) on c.CustomerID equals o.CustomerID into orders
select new { customer = c, orders = orders.ToList() },
e => e.customer.CustomerID,
elementAsserter: (e, a) =>
{
Assert.Equal(e.customer.CustomerID, a.customer.CustomerID);
CollectionAsserter <Order>(o => o.OrderID)(e.orders, a.orders);
},
entryCount: 91));
}
AreEnumerablesEqualComparer_ExpectedAndActualHaveSameObjectsInSameOrder_ShouldNotThrowAssertFailedExceptionIfEqualsOverride()
{
var comparer =
new GenericComparer <EqualityTestObject, EqualityTestObject>(
(expected, actual) => expected.Equals(actual));
var expected = new List <EqualityTestObject>
{
new EqualityTestObject(), new EqualityTestObject {
BooleanPropertyTest = true
}
};
var actual = new List <EqualityTestObject>
{
new EqualityTestObject(), new EqualityTestObject {
BooleanPropertyTest = true
}
};
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
CollectionAsserter.AreEnumerablesEqual <EqualityTestObject>(expected, actual, comparer);
});
}
public void FileAndFolderNamesInShouldGetFileAndFolderNames()
{
var filesAndFolders = _fileSystemManager.FileAndFolderNamesIn(TestFolderPath);
CollectionAsserter <string> .AssertThat(filesAndFolders)
.Contains(TestSubFolderName)
.Contains(TestFileName);
}
public virtual async Task Correlated_collections_project_anonymous_collection_result()
{
await AssertQuery <Squad>(
ss => from s in ss
where s.Id < 20
select new
{
s.Name,
Collection = (from m in s.Members
select new { m.FullName, m.Rank }).ToList()
},
elementSorter : e => e.Name,
elementAsserter : (e, a) =>
{
Assert.Equal(e.Name, a.Name);
CollectionAsserter <dynamic>(ee => ee.FullName + " " + ee.Rank)(e.Collection, a.Collection);
});
}
public virtual async Task Correlated_collections_inner_subquery_selector_references_outer_qsre()
{
await AssertQuery <Gear>(
gs =>
from o in gs.OfType <Officer>()
select new
{
o.FullName,
Collection = from r in o.Reports
select new { ReportName = r.FullName, OfficerName = o.FullName }
},
elementSorter : e => e.FullName,
elementAsserter : (e, a) =>
{
Assert.Equal(e.FullName, a.FullName);
CollectionAsserter <dynamic>(ee => ee.ReportName)(e.Collection, a.Collection);
});
}
public void AreEnumerablesEqual_ExpectedIsSetAndActualIsNull_ShouldThrowAssertFailedException()
{
var expected = new List <NoEqualityTestObject>();
Assert.ThrowsException <AssertFailedException>(
() =>
{
CollectionAsserter.AreEnumerablesEqual <NoEqualityTestObject>(expected, default(IEnumerable <NoEqualityTestObject>));
});
}
public void AreEnumerablesEqual_ExpectedAndActualAreNull_ShouldNotThrowAssertFailedException()
{
ExceptionAsserter.DoesNotThrowException <AssertFailedException>(
() =>
{
CollectionAsserter.AreEnumerablesEqual <NoEqualityTestObject>(
default(IEnumerable <NoEqualityTestObject>),
default(IEnumerable <NoEqualityTestObject>));
});
}
public virtual async Task Correlated_collections_basic_projection_composite_key()
{
await AssertQuery <Gear>(gs =>
from o in gs.OfType <Officer>()
where o.Nickname != "Foo"
select new
{
o.Nickname,
Collection = (from r in o.Reports
where !r.HasSoulPatch
select new { r.Nickname, r.FullName }).ToArray()
},
elementSorter : e => e.Nickname,
elementAsserter : (e, a) =>
{
Assert.Equal(e.Nickname, a.Nickname);
CollectionAsserter <dynamic>(elementSorter: ee => ee.FullName)(e.Collection, a.Collection);
});
}
