Files
mono/mcs/class/System.Core/Test/System.Linq/QueryableProviderTest.cs
T
Jb Evain 401fb04309 properties
svn path=/trunk/mcs/; revision=102267
2008-05-01 10:15:12 +00:00

443 lines
8.4 KiB
C#

using System;
using System.Text;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using NUnit.Framework;
namespace MonoTests.System.Linq
{
[TestFixture]
public class QueryableProviderTest
{
QueryProvider _provider;
Query<int> _src;
int [] _array = { 1, 2, 3 };
int [] _otherArray = { 0, 2 };
public QueryableProviderTest ()
{
_provider = new QueryProvider ();
_src = new Query<int> (_provider, _array);
}
[SetUp]
public void MyTestCleanup ()
{
_provider.Init ();
}
[Test]
public void TestAggregate ()
{
_src.Aggregate<int> ((n, m) => n + m);
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestAll ()
{
_src.All<int> ((n) => true);
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestAny ()
{
_src.Any<int> ();
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestAverage ()
{
_src.Average<int> ((n) => n);
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestCast ()
{
_src.Cast<int> ();
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestConcat ()
{
_src.Concat<int> (_otherArray);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestContains ()
{
_src.Contains<int> (3);
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestCount ()
{
_src.Count<int> ();
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestDefaultIfEmpty ()
{
_src.DefaultIfEmpty<int> (0);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestDistinct ()
{
_src.Distinct<int> ();
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestElementAt ()
{
_src.ElementAt<int> (1);
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestElementAtOrDefault ()
{
_src.ElementAtOrDefault<int> (1);
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestExcept ()
{
_src.Except<int> (_otherArray);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestFirst ()
{
_src.First<int> ();
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestFirstOrDefault ()
{
_src.FirstOrDefault<int> ((n) => n > 1);
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestGroupBy ()
{
_src.GroupBy<int, bool> ((n) => n > 2);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestGroupJoin ()
{
_src.GroupJoin<int, int, bool, int> (_otherArray, (n) => n > 1, (n) => n > 1, (n, col) => n);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestIntersect ()
{
_src.Intersect<int> (_otherArray);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestJoin ()
{
_src.Join<int, int, int, int> (_otherArray, (n) => n, (n => n), (n, m) => n + m);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestLast ()
{
_src.Last<int> ((n) => n > 1);
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestLastOrDefault ()
{
_src.LastOrDefault<int> ();
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestLongCount ()
{
_src.LongCount<int> ();
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestMax ()
{
_src.Max<int> ();
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestMin ()
{
_src.Min<int> ();
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestOfType ()
{
_src.OfType<int> ();
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestOrderBy ()
{
_src.OrderBy<int, bool> ((n) => n > 1);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestOrderByDescending ()
{
_src.OrderByDescending<int, bool> ((n) => n > 1);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestReverse ()
{
_src.Reverse<int> ();
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestSelect ()
{
_src.Select<int, int> ((n) => n);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestSelectMany ()
{
_src.SelectMany<int, int> ((n) => new int [] { n });
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestSequenceEqual ()
{
_src.SequenceEqual<int> (_otherArray);
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestSingle ()
{
(new Query<int> (_provider, new int [] { 1 })).Single<int> ();
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestSingleOrDefault ()
{
(new Query<int> (_provider, new int [] { 1 })).SingleOrDefault<int> ();
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestSkip ()
{
_src.Skip<int> (1);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestSkipWhile ()
{
_src.SkipWhile<int> ((n) => n > 1);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestSum ()
{
_src.Sum<int> ((n) => n);
Assert.AreEqual (StatusEnum.Execute, _provider.Status);
}
[Test]
public void TestTake ()
{
_src.Take<int> (3);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestTakeWhile ()
{
_src.TakeWhile<int> ((n) => n < 2);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestThenBy ()
{
_src.ThenBy<int, bool> ((n) => n < 2);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestThenByDescending ()
{
_src.ThenByDescending<int, bool> ((n) => n < 2);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestUnion ()
{
_src.Union<int> (_otherArray);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
[Test]
public void TestWhere ()
{
_src.Where<int> ((n) => true);
Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
}
public class Query<T> : IQueryable<T>, IQueryable, IEnumerable<T>, IEnumerable, IOrderedQueryable<T>, IOrderedQueryable
{
IQueryProvider provider;
Expression expression;
IEnumerable<T> _context;
public Query (IQueryProvider provider, IEnumerable<T> context)
{
_context = context;
this.provider = provider;
this.expression = Expression.Constant (this);
}
Expression IQueryable.Expression
{
get { return this.expression; }
}
Type IQueryable.ElementType
{
get { return typeof (T); }
}
IQueryProvider IQueryable.Provider
{
get { return this.provider; }
}
public IEnumerator<T> GetEnumerator ()
{
throw new NotImplementedException ();
}
IEnumerator IEnumerable.GetEnumerator ()
{
throw new NotImplementedException ();
}
}
public enum StatusEnum { NotInitilized, Execute, CreateQuery }
public class QueryProvider : IQueryProvider
{
private StatusEnum _status = StatusEnum.NotInitilized;
public StatusEnum Status
{
get { return _status; }
set { _status = value; }
}
public void Init ()
{
_status = StatusEnum.NotInitilized;
}
public QueryProvider ()
{
Init ();
}
#region IQueryProvider Members
IQueryable<S> IQueryProvider.CreateQuery<S> (Expression expression)
{
Status = StatusEnum.CreateQuery;
return null;
}
IQueryable IQueryProvider.CreateQuery (Expression expression)
{
Status = StatusEnum.CreateQuery;
return null;
}
S IQueryProvider.Execute<S> (Expression expression)
{
Status = StatusEnum.Execute;
return default (S);
}
object IQueryProvider.Execute (Expression expression)
{
Status = StatusEnum.Execute;
return null;
}
#endregion
}
}
}