using System.Reflection;
using System.Linq;
-namespace System.Linq {
+namespace System.Linq
+{
- public static class Queryable {
+ public static class Queryable
+ {
static MethodInfo MakeGeneric (MethodBase method, params Type [] parameters)
{
{
Check.Source1AndSource2 (source1, source2);
- return source1.Provider.Execute<IQueryable<TSource>> (
+ return source1.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source1.Expression,
#region DefaultIfEmpty
- public static TSource DefaultIfEmpty<TSource> (this IQueryable<TSource> source)
+ public static IQueryable<TSource> DefaultIfEmpty<TSource> (this IQueryable<TSource> source)
{
Check.Source (source);
- return source.Provider.Execute<TSource> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression));
}
- public static TSource DefaultIfEmpty<TSource> (this IQueryable<TSource> source, TSource defaultValue)
+ public static IQueryable<TSource> DefaultIfEmpty<TSource> (this IQueryable<TSource> source, TSource defaultValue)
{
Check.Source (source);
- return source.Provider.Execute<TSource> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression,
#region Distinct
- public static bool Distinct<TSource> (this IQueryable<TSource> source)
+ public static IQueryable<TSource> Distinct<TSource> (this IQueryable<TSource> source)
{
Check.Source (source);
- return source.Provider.Execute<bool> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression));
}
- public static bool Distinct<TSource> (this IQueryable<TSource> source, IEqualityComparer<TSource> comparer)
+ public static IQueryable<TSource> Distinct<TSource> (this IQueryable<TSource> source, IEqualityComparer<TSource> comparer)
{
Check.Source (source);
- return source.Provider.Execute<bool> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression,
{
Check.Source1AndSource2 (source1, source2);
- return source1.Provider.Execute<IQueryable<TSource>> (
+ return source1.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source1.Expression,
{
Check.Source1AndSource2 (source1, source2);
- return source1.Provider.Execute<IQueryable<TSource>> (
+ return source1.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source1.Expression,
{
Check.SourceAndKeySelector (source, keySelector);
- return source.Provider.Execute<IQueryable<IGrouping<TKey, TSource>>> (
+ return source.Provider.CreateQuery<IGrouping<TKey, TSource>> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
source.Expression,
{
Check.SourceAndKeySelector (source, keySelector);
- return source.Provider.Execute<IQueryable<IGrouping<TKey, TSource>>> (
+ return source.Provider.CreateQuery<IGrouping<TKey, TSource>> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
source.Expression,
{
Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
- return source.Provider.Execute<IQueryable<IGrouping<TKey, TSource>>> (
+ return source.Provider.CreateQuery<IGrouping<TKey, TSource>> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TElement)),
source.Expression,
{
Check.SourceAndKeyResultSelectors (source, keySelector, resultSelector);
- return source.Provider.Execute<IQueryable<TResult>> (
+ return source.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TResult)),
source.Expression,
{
Check.SourceAndKeyElementSelectors (source, keySelector, elementSelector);
- return source.Provider.Execute<IQueryable<IGrouping<TKey, TElement>>> (
+ return source.Provider.CreateQuery<IGrouping<TKey, TElement>> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TElement)),
source.Expression,
{
Check.GroupBySelectors (source, keySelector, elementSelector, resultSelector);
- return source.Provider.Execute<IQueryable<TResult>> (
+ return source.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TElement), typeof (TResult)),
source.Expression,
{
Check.SourceAndKeyResultSelectors (source, keySelector, resultSelector);
- return source.Provider.Execute<IQueryable<TResult>> (
+ return source.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TResult)),
source.Expression,
{
Check.GroupBySelectors (source, keySelector, elementSelector, resultSelector);
- return source.Provider.Execute<IQueryable<TResult>> (
+ return source.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey), typeof (TElement), typeof (TResult)),
source.Expression,
if (resultSelector == null)
throw new ArgumentNullException ("resultSelector");
- return outer.Provider.Execute<IQueryable<TResult>> (
+ return outer.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TOuter), typeof (TInner), typeof (TKey), typeof (TResult)),
outer.Expression,
if (resultSelector == null)
throw new ArgumentNullException ("resultSelector");
- return outer.Provider.Execute<IQueryable<TResult>> (
+ return outer.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TOuter), typeof (TInner), typeof (TKey), typeof (TResult)),
outer.Expression,
{
Check.Source1AndSource2 (source1, source2);
- return source1.Provider.Execute<IQueryable<TSource>> (
+ return source1.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source1.Expression,
{
Check.Source1AndSource2 (source1, source2);
- return source1.Provider.Execute<IQueryable<TSource>> (
+ return source1.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source1.Expression,
{
Check.JoinSelectors (outer, inner, outerKeySelector, innerKeySelector, resultSelector);
- return outer.Provider.Execute<IQueryable<TResult>> (
+ return outer.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TOuter), typeof (TInner), typeof (TKey), typeof (TResult)),
outer.Expression,
{
Check.JoinSelectors (outer, inner, outerKeySelector, innerKeySelector, resultSelector);
- return outer.Provider.Execute<IQueryable<TResult>> (
+ return outer.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TOuter), typeof (TInner), typeof (TKey), typeof (TResult)),
outer.Expression,
{
Check.SourceAndKeySelector (source, keySelector);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
source.Expression,
{
Check.SourceAndKeySelector (source, keySelector);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
source.Expression,
{
Check.SourceAndKeySelector (source, keySelector);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
source.Expression,
{
Check.SourceAndKeySelector (source, keySelector);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
source.Expression,
{
Check.Source (source);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression));
{
Check.SourceAndSelector (source, selector);
- return source.Provider.Execute<IQueryable<TResult>> (
+ return source.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
source.Expression,
{
Check.SourceAndSelector (source, selector);
- return source.Provider.Execute<IQueryable<TResult>> (
+ return source.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
source.Expression,
{
Check.SourceAndSelector (source, selector);
- return source.Provider.Execute<IQueryable<TResult>> (
+ return source.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
source.Expression,
{
Check.SourceAndSelector (source, selector);
- return source.Provider.Execute<IQueryable<TResult>> (
+ return source.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TResult)),
source.Expression,
{
Check.SourceAndCollectionSelectorAndResultSelector (source, collectionSelector, resultSelector);
- return source.Provider.Execute<IQueryable<TResult>> (
+ return source.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TCollection), typeof (TResult)),
source.Expression,
{
Check.SourceAndCollectionSelectorAndResultSelector (source, collectionSelector, resultSelector);
- return source.Provider.Execute<IQueryable<TResult>> (
+ return source.Provider.CreateQuery<TResult> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TCollection), typeof (TResult)),
source.Expression,
{
Check.Source (source);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression,
{
Check.SourceAndPredicate (source, predicate);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression,
{
Check.SourceAndPredicate (source, predicate);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression,
{
Check.Source (source);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression,
{
Check.SourceAndPredicate (source, predicate);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression,
{
Check.SourceAndPredicate (source, predicate);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression,
{
Check.SourceAndKeySelector (source, keySelector);
- return source.Provider.Execute<IOrderedQueryable<TSource>> (
+ return (IOrderedQueryable<TSource>) source.Provider.CreateQuery (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
source.Expression,
{
Check.SourceAndKeySelector (source, keySelector);
- return source.Provider.Execute<IOrderedQueryable<TSource>> (
+ return (IOrderedQueryable<TSource>) source.Provider.CreateQuery (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
source.Expression,
{
Check.SourceAndKeySelector (source, keySelector);
- return source.Provider.Execute<IOrderedQueryable<TSource>> (
+ return (IOrderedQueryable<TSource>) source.Provider.CreateQuery (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
source.Expression,
{
Check.SourceAndKeySelector (source, keySelector);
- return source.Provider.Execute<IOrderedQueryable<TSource>> (
+ return (IOrderedQueryable<TSource>) source.Provider.CreateQuery (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource), typeof (TKey)),
source.Expression,
{
Check.Source1AndSource2 (source1, source2);
- return source1.Provider.Execute<IOrderedQueryable<TSource>> (
+ return source1.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source1.Expression,
{
Check.Source1AndSource2 (source1, source2);
- return source1.Provider.Execute<IOrderedQueryable<TSource>> (
+ return source1.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source1.Expression,
{
Check.SourceAndPredicate (source, predicate);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression,
{
Check.SourceAndPredicate (source, predicate);
- return source.Provider.Execute<IQueryable<TSource>> (
+ return source.Provider.CreateQuery<TSource> (
StaticCall (
MakeGeneric (MethodBase.GetCurrentMethod (), typeof (TSource)),
source.Expression,
--- /dev/null
+using System;\r
+using System.Text;\r
+using System.Collections;\r
+using System.Collections.Generic;\r
+using System.Linq;\r
+using System.Linq.Expressions;\r
+using System.Reflection;\r
+using NUnit.Framework;\r
+\r
+\r
+namespace MonoTests.System.Linq\r
+{\r
+\r
+ [TestFixture]\r
+ public class QueryableProviderTest\r
+ {\r
+ QueryProvider _provider;\r
+\r
+ Query<int> _src;\r
+\r
+ int [] _array = { 1, 2, 3 };\r
+ int [] _otherArray = { 0, 2 };\r
+\r
+ public QueryableProviderTest ()\r
+ {\r
+ _provider = new QueryProvider ();\r
+ _src = new Query<int> (_provider, _array);\r
+\r
+ }\r
+\r
+ [SetUp]\r
+ public void MyTestCleanup ()\r
+ {\r
+ _provider.Init ();\r
+ }\r
+\r
+ [Test]\r
+ public void TestAggregate ()\r
+ {\r
+ _src.Aggregate<int> ((n, m) => n + m);\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+\r
+ }\r
+\r
+ [Test]\r
+ public void TestAll ()\r
+ {\r
+ _src.All<int> ((n) => true);\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestAny ()\r
+ {\r
+ _src.Any<int> ();\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestAverage ()\r
+ {\r
+ _src.Average<int> ((n) => n);\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestCast ()\r
+ {\r
+ _src.Cast<int> ();\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestConcat ()\r
+ {\r
+ _src.Concat<int> (_otherArray);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestContains ()\r
+ {\r
+ _src.Contains<int> (3);\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void TestCount ()\r
+ {\r
+ _src.Count<int> ();\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestDefaultIfEmpty ()\r
+ {\r
+ _src.DefaultIfEmpty<int> (0);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestDistinct ()\r
+ {\r
+ _src.Distinct<int> ();\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestElementAt ()\r
+ {\r
+ _src.ElementAt<int> (1);\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestElementAtOrDefault ()\r
+ {\r
+ _src.ElementAtOrDefault<int> (1);\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestExcept ()\r
+ {\r
+ _src.Except<int> (_otherArray);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestFirst ()\r
+ {\r
+ _src.First<int> ();\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestFirstOrDefault ()\r
+ {\r
+ _src.FirstOrDefault<int> ((n) => n > 1);\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestGroupBy ()\r
+ {\r
+ _src.GroupBy<int, bool> ((n) => n > 2);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestGroupJoin ()\r
+ {\r
+ _src.GroupJoin<int, int, bool, int> (_otherArray, (n) => n > 1, (n) => n > 1, (n, col) => n);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestIntersect ()\r
+ {\r
+ _src.Intersect<int> (_otherArray);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestJoin ()\r
+ {\r
+ _src.Join<int, int, int, int> (_otherArray, (n) => n, (n => n), (n, m) => n + m);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestLast ()\r
+ {\r
+ _src.Last<int> ((n) => n > 1);\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestLastOrDefault ()\r
+ {\r
+ _src.LastOrDefault<int> ();\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestLongCount ()\r
+ {\r
+ _src.LongCount<int> ();\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestMax ()\r
+ {\r
+ _src.Max<int> ();\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestMin ()\r
+ {\r
+ _src.Min<int> ();\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestOfType ()\r
+ {\r
+ _src.OfType<int> ();\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestOrderBy ()\r
+ {\r
+ _src.OrderBy<int, bool> ((n) => n > 1);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestOrderByDescending ()\r
+ {\r
+ _src.OrderByDescending<int, bool> ((n) => n > 1);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestReverse ()\r
+ {\r
+ _src.Reverse<int> ();\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestSelect ()\r
+ {\r
+ _src.Select<int, int> ((n) => n);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestSelectMany ()\r
+ {\r
+ _src.SelectMany<int, int> ((n) => new int [] { n });\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestSequenceEqual ()\r
+ {\r
+ _src.SequenceEqual<int> (_otherArray);\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestSingle ()\r
+ {\r
+ (new Query<int> (_provider, new int [] { 1 })).Single<int> ();\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestSingleOrDefault ()\r
+ {\r
+ (new Query<int> (_provider, new int [] { 1 })).SingleOrDefault<int> ();\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestSkip ()\r
+ {\r
+ _src.Skip<int> (1);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestSkipWhile ()\r
+ {\r
+ _src.SkipWhile<int> ((n) => n > 1);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestSum ()\r
+ {\r
+ _src.Sum<int> ((n) => n);\r
+ Assert.AreEqual (StatusEnum.Execute, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestTake ()\r
+ {\r
+ _src.Take<int> (3);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+\r
+ [Test]\r
+ public void TestTakeWhile ()\r
+ {\r
+ _src.TakeWhile<int> ((n) => n < 2);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestThenBy ()\r
+ {\r
+ _src.ThenBy<int, bool> ((n) => n < 2);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestThenByDescending ()\r
+ {\r
+ _src.ThenByDescending<int, bool> ((n) => n < 2);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestUnion ()\r
+ {\r
+ _src.Union<int> (_otherArray);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ [Test]\r
+ public void TestWhere ()\r
+ {\r
+ _src.Where<int> ((n) => true);\r
+ Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);\r
+ }\r
+\r
+ public class Query<T> : IQueryable<T>, IQueryable, IEnumerable<T>, IEnumerable, IOrderedQueryable<T>, IOrderedQueryable\r
+ {\r
+ IQueryProvider provider;\r
+\r
+ Expression expression;\r
+\r
+ IEnumerable<T> _context;\r
+\r
+ public Query (IQueryProvider provider, IEnumerable<T> context)\r
+ {\r
+ _context = context;\r
+ this.provider = provider;\r
+ this.expression = Expression.Constant (this);\r
+ }\r
+\r
+ Expression IQueryable.Expression\r
+ {\r
+\r
+ get { return this.expression; }\r
+\r
+ }\r
+\r
+\r
+\r
+ Type IQueryable.ElementType\r
+ {\r
+\r
+ get { return typeof (T); }\r
+\r
+ }\r
+\r
+\r
+ IQueryProvider IQueryable.Provider\r
+ {\r
+\r
+ get { return this.provider; }\r
+\r
+ }\r
+\r
+\r
+ public IEnumerator<T> GetEnumerator ()\r
+ {\r
+ throw new NotImplementedException ();\r
+ }\r
+\r
+ IEnumerator IEnumerable.GetEnumerator ()\r
+ {\r
+ throw new NotImplementedException ();\r
+ }\r
+\r
+ }\r
+\r
+ public enum StatusEnum { NotInitilized, Execute, CreateQuery }\r
+\r
+ public class QueryProvider : IQueryProvider\r
+ {\r
+\r
+ private StatusEnum _status = StatusEnum.NotInitilized;\r
+\r
+ public StatusEnum Status\r
+ {\r
+ get { return _status; }\r
+ set { _status = value; }\r
+ }\r
+\r
+ public void Init ()\r
+ {\r
+ _status = StatusEnum.NotInitilized;\r
+ }\r
+\r
+ public QueryProvider ()\r
+ {\r
+ Init ();\r
+ }\r
+\r
+ #region IQueryProvider Members\r
+\r
+ IQueryable<S> IQueryProvider.CreateQuery<S> (Expression expression)\r
+ {\r
+ Status = StatusEnum.CreateQuery;\r
+ return null;\r
+ }\r
+\r
+ IQueryable IQueryProvider.CreateQuery (Expression expression)\r
+ {\r
+ Status = StatusEnum.CreateQuery;\r
+ return null;\r
+\r
+ }\r
+\r
+ S IQueryProvider.Execute<S> (Expression expression)\r
+ {\r
+ Status = StatusEnum.Execute;\r
+ return default (S);\r
+ }\r
+\r
+\r
+\r
+ object IQueryProvider.Execute (Expression expression)\r
+ {\r
+ Status = StatusEnum.Execute;\r
+ return null;\r
+\r
+ }\r
+\r
+ #endregion\r
+ }\r
+ }\r
+}\r
projects / mono.git / commitdiff