mcs/class/System.Core/Test/System.Linq/QueryableProviderTest.cs

   1 using System;
   2 using System.Text;
   3 using System.Collections;
   4 using System.Collections.Generic;
   5 using System.Linq;
   6 using System.Linq.Expressions;
   7 using System.Reflection;
   8 using NUnit.Framework;
   9
  10
  11 namespace MonoTests.System.Linq
  12 {
  13
  14         [TestFixture]
  15         public class QueryableProviderTest
  16         {
  17                 QueryProvider _provider;
  18
  19                 Query<int> _src;
  20
  21                 int [] _array = { 1, 2, 3 };
  22                 int [] _otherArray = { 0, 2 };
  23
  24                 public QueryableProviderTest ()
  25                 {
  26                         _provider = new QueryProvider ();
  27                         _src = new Query<int> (_provider, _array);
  28
  29                 }
  30
  31                 [SetUp]
  32                 public void MyTestCleanup ()
  33                 {
  34                         _provider.Init ();
  35                 }
  36
  37                 [Test]
  38                 public void TestAggregate ()
  39                 {
  40                         _src.Aggregate<int> ((n, m) => n + m);
  41                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
  42
  43                 }
  44
  45                 [Test]
  46                 public void TestAll ()
  47                 {
  48                         _src.All<int> ((n) => true);
  49                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
  50                 }
  51
  52                 [Test]
  53                 public void TestAny ()
  54                 {
  55                         _src.Any<int> ();
  56                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
  57                 }
  58
  59                 [Test]
  60                 public void TestAverage ()
  61                 {
  62                         _src.Average<int> ((n) => n);
  63                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
  64                 }
  65
  66                 [Test]
  67                 public void TestCast ()
  68                 {
  69                         _src.Cast<int> ();
  70                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
  71                 }
  72
  73                 [Test]
  74                 public void TestConcat ()
  75                 {
  76                         _src.Concat<int> (_otherArray);
  77                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
  78                 }
  79
  80                 [Test]
  81                 public void TestContains ()
  82                 {
  83                         _src.Contains<int> (3);
  84                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
  85                 }
  86
  87
  88                 [Test]
  89                 public void TestCount ()
  90                 {
  91                         _src.Count<int> ();
  92                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
  93                 }
  94
  95                 [Test]
  96                 public void TestDefaultIfEmpty ()
  97                 {
  98                         _src.DefaultIfEmpty<int> (0);
  99                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 100                 }
 101
 102                 [Test]
 103                 public void TestDistinct ()
 104                 {
 105                         _src.Distinct<int> ();
 106                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 107                 }
 108
 109                 [Test]
 110                 public void TestElementAt ()
 111                 {
 112                         _src.ElementAt<int> (1);
 113                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 114                 }
 115
 116                 [Test]
 117                 public void TestElementAtOrDefault ()
 118                 {
 119                         _src.ElementAtOrDefault<int> (1);
 120                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 121                 }
 122
 123                 [Test]
 124                 public void TestExcept ()
 125                 {
 126                         _src.Except<int> (_otherArray);
 127                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 128                 }
 129
 130                 [Test]
 131                 public void TestFirst ()
 132                 {
 133                         _src.First<int> ();
 134                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 135                 }
 136
 137                 [Test]
 138                 public void TestFirstOrDefault ()
 139                 {
 140                         _src.FirstOrDefault<int> ((n) => n > 1);
 141                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 142                 }
 143
 144                 [Test]
 145                 public void TestGroupBy ()
 146                 {
 147                         _src.GroupBy<int, bool> ((n) => n > 2);
 148                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 149                 }
 150
 151                 [Test]
 152                 public void TestGroupJoin ()
 153                 {
 154                         _src.GroupJoin<int, int, bool, int> (_otherArray, (n) => n > 1, (n) => n > 1, (n, col) => n);
 155                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 156                 }
 157
 158                 [Test]
 159                 public void TestIntersect ()
 160                 {
 161                         _src.Intersect<int> (_otherArray);
 162                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 163                 }
 164
 165                 [Test]
 166                 public void TestJoin ()
 167                 {
 168                         _src.Join<int, int, int, int> (_otherArray, (n) => n, (n => n), (n, m) => n + m);
 169                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 170                 }
 171
 172                 [Test]
 173                 public void TestLast ()
 174                 {
 175                         _src.Last<int> ((n) => n > 1);
 176                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 177                 }
 178
 179                 [Test]
 180                 public void TestLastOrDefault ()
 181                 {
 182                         _src.LastOrDefault<int> ();
 183                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 184                 }
 185
 186                 [Test]
 187                 public void TestLongCount ()
 188                 {
 189                         _src.LongCount<int> ();
 190                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 191                 }
 192
 193                 [Test]
 194                 public void TestMax ()
 195                 {
 196                         _src.Max<int> ();
 197                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 198                 }
 199
 200                 [Test]
 201                 public void TestMin ()
 202                 {
 203                         _src.Min<int> ();
 204                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 205                 }
 206
 207                 [Test]
 208                 public void TestOfType ()
 209                 {
 210                         _src.OfType<int> ();
 211                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 212                 }
 213
 214                 [Test]
 215                 public void TestOrderBy ()
 216                 {
 217                         _src.OrderBy<int, bool> ((n) => n > 1);
 218                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 219                 }
 220
 221                 [Test]
 222                 public void TestOrderByDescending ()
 223                 {
 224                         _src.OrderByDescending<int, bool> ((n) => n > 1);
 225                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 226                 }
 227
 228                 [Test]
 229                 public void TestReverse ()
 230                 {
 231                         _src.Reverse<int> ();
 232                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 233                 }
 234
 235                 [Test]
 236                 public void TestSelect ()
 237                 {
 238                         _src.Select<int, int> ((n) => n);
 239                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 240                 }
 241
 242                 [Test]
 243                 public void TestSelectMany ()
 244                 {
 245                         _src.SelectMany<int, int> ((n) => new int [] { n });
 246                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 247                 }
 248
 249                 [Test]
 250                 public void TestSequenceEqual ()
 251                 {
 252                         _src.SequenceEqual<int> (_otherArray);
 253                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 254                 }
 255
 256                 [Test]
 257                 public void TestSingle ()
 258                 {
 259                         (new Query<int> (_provider, new int [] { 1 })).Single<int> ();
 260                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 261                 }
 262
 263                 [Test]
 264                 public void TestSingleOrDefault ()
 265                 {
 266                         (new Query<int> (_provider, new int [] { 1 })).SingleOrDefault<int> ();
 267                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 268                 }
 269
 270                 [Test]
 271                 public void TestSkip ()
 272                 {
 273                         _src.Skip<int> (1);
 274                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 275                 }
 276
 277                 [Test]
 278                 public void TestSkipWhile ()
 279                 {
 280                         _src.SkipWhile<int> ((n) => n > 1);
 281                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 282                 }
 283
 284                 [Test]
 285                 public void TestSum ()
 286                 {
 287                         _src.Sum<int> ((n) => n);
 288                         Assert.AreEqual (StatusEnum.Execute, _provider.Status);
 289                 }
 290
 291                 [Test]
 292                 public void TestTake ()
 293                 {
 294                         _src.Take<int> (3);
 295                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 296                 }
 297
 298
 299                 [Test]
 300                 public void TestTakeWhile ()
 301                 {
 302                         _src.TakeWhile<int> ((n) => n < 2);
 303                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 304                 }
 305
 306                 [Test]
 307                 public void TestThenBy ()
 308                 {
 309                         _src.ThenBy<int, bool> ((n) => n < 2);
 310                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 311                 }
 312
 313                 [Test]
 314                 public void TestThenByDescending ()
 315                 {
 316                         _src.ThenByDescending<int, bool> ((n) => n < 2);
 317                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 318                 }
 319
 320                 [Test]
 321                 public void TestUnion ()
 322                 {
 323                         _src.Union<int> (_otherArray);
 324                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 325                 }
 326
 327                 [Test]
 328                 public void TestWhere ()
 329                 {
 330                         _src.Where<int> ((n) => true);
 331                         Assert.AreEqual (StatusEnum.CreateQuery, _provider.Status);
 332                 }
 333
 334                 public class Query<T> : IQueryable<T>, IQueryable, IEnumerable<T>, IEnumerable, IOrderedQueryable<T>, IOrderedQueryable
 335                 {
 336                         IQueryProvider provider;
 337
 338                         Expression expression;
 339
 340                         IEnumerable<T> _context;
 341
 342                         public Query (IQueryProvider provider, IEnumerable<T> context)
 343                         {
 344                                 _context = context;
 345                                 this.provider = provider;
 346                                 this.expression = Expression.Constant (this);
 347                         }
 348
 349                         Expression IQueryable.Expression
 350                         {
 351
 352                                 get { return this.expression; }
 353
 354                         }
 355
 356
 357
 358                         Type IQueryable.ElementType
 359                         {
 360
 361                                 get { return typeof (T); }
 362
 363                         }
 364
 365
 366                         IQueryProvider IQueryable.Provider
 367                         {
 368
 369                                 get { return this.provider; }
 370
 371                         }
 372
 373
 374                         public IEnumerator<T> GetEnumerator ()
 375                         {
 376                                 throw new NotImplementedException ();
 377                         }
 378
 379                         IEnumerator IEnumerable.GetEnumerator ()
 380                         {
 381                                 throw new NotImplementedException ();
 382                         }
 383
 384                 }
 385
 386                 public enum StatusEnum { NotInitilized, Execute, CreateQuery }
 387
 388                 public class QueryProvider : IQueryProvider
 389                 {
 390
 391                         private StatusEnum _status = StatusEnum.NotInitilized;
 392
 393                         public StatusEnum Status
 394                         {
 395                                 get { return _status; }
 396                                 set { _status = value; }
 397                         }
 398
 399                         public void Init ()
 400                         {
 401                                 _status = StatusEnum.NotInitilized;
 402                         }
 403
 404                         public QueryProvider ()
 405                         {
 406                                 Init ();
 407                         }
 408
 409                         #region IQueryProvider Members
 410
 411                         IQueryable<S> IQueryProvider.CreateQuery<S> (Expression expression)
 412                         {
 413                                 Status = StatusEnum.CreateQuery;
 414                                 return null;
 415                         }
 416
 417                         IQueryable IQueryProvider.CreateQuery (Expression expression)
 418                         {
 419                                 Status = StatusEnum.CreateQuery;
 420                                 return null;
 421
 422                         }
 423
 424                         S IQueryProvider.Execute<S> (Expression expression)
 425                         {
 426                                 Status = StatusEnum.Execute;
 427                                 return default (S);
 428                         }
 429
 430
 431
 432                         object IQueryProvider.Execute (Expression expression)
 433                         {
 434                                 Status = StatusEnum.Execute;
 435                                 return null;
 436
 437                         }
 438
 439                         #endregion
 440                 }
 441         }
 442 }