Skip to content

Commit 5a134b0

Browse files
alex-kulakovalex-kulakov
committed
Linq.OfTypeTest: order-independant checks
1 parent a9dc4eb commit 5a134b0

File tree

1 file changed

+77
-65
lines changed

1 file changed

+77
-65
lines changed

‎Orm/Xtensive.Orm.Tests/Linq/OfTypeTest.cs‎

Lines changed: 77 additions & 65 deletions
Original file line numberDiff line numberDiff line change
@@ -247,32 +247,34 @@ public class OfTypeTest : AutoBuildTest
247247
[Test]
248248
public void Test01()
249249
{
250+
var expectedStrings = new[] { "100000String1", "200000String2", "300000String3" };
251+
250252
using (var session = Domain.OpenSession())
251253
using (var tx = session.OpenTransaction()) {
252254
var result = session.Query.All<AClassTable>().OfType<IB1>()
253255
.Select(x => x.Field3.Value2.Value1 + x.Field4).ToArray();
254-
Assert.That(result[0], Is.EqualTo("100000String1"));
255-
Assert.That(result[1], Is.EqualTo("200000String2"));
256-
Assert.That(result[2], Is.EqualTo("300000String3"));
256+
foreach (var expectedString in expectedStrings) {
257+
Assert.That(result.Contains(expectedString), Is.True);
258+
}
257259
}
258260

259261
using (var session = Domain.OpenSession())
260262
using (var tx = session.OpenTransaction()) {
261263
var result = session.Query.All<AConcreteTable>().OfType<IB1>()
262264
.Select(x => x.Field3.Value2.Value1 + x.Field4).ToArray();
263-
Assert.That(result[0], Is.EqualTo("100000String1"));
264-
Assert.That(result[1], Is.EqualTo("200000String2"));
265-
Assert.That(result[2], Is.EqualTo("300000String3"));
265+
foreach (var expectedString in expectedStrings) {
266+
Assert.That(result.Contains(expectedString), Is.True);
267+
}
266268
}
267269

268270

269271
using (var session = Domain.OpenSession())
270272
using (var tx = session.OpenTransaction()) {
271273
var result = session.Query.All<ASingleTable>().OfType<IB1>()
272274
.Select(x => x.Field3.Value2.Value1 + x.Field4).ToArray();
273-
Assert.That(result[0], Is.EqualTo("100000String1"));
274-
Assert.That(result[1], Is.EqualTo("200000String2"));
275-
Assert.That(result[2], Is.EqualTo("300000String3"));
275+
foreach (var expectedString in expectedStrings) {
276+
Assert.That(result.Contains(expectedString), Is.True);
277+
}
276278
}
277279
}
278280

@@ -289,7 +291,8 @@ public void Test02()
289291
.Select(x => x.Field3.Value2.Value1 + x.Field4).ToArray();
290292

291293
Assert.That(result1, Is.Not.Empty);
292-
Assert.That(result1.SequenceEqual(result2));
294+
Assert.That(result1.Length, Is.EqualTo(result2.Length));
295+
Assert.That(result1.Intersect(result2).Count(), Is.EqualTo(result1.Length));
293296
}
294297

295298

@@ -303,7 +306,8 @@ public void Test02()
303306
.Select(x => x.Field3.Value2.Value1 + x.Field4).ToArray();
304307

305308
Assert.That(result1, Is.Not.Empty);
306-
Assert.That(result1.SequenceEqual(result2));
309+
Assert.That(result1.Length, Is.EqualTo(result2.Length));
310+
Assert.That(result1.Intersect(result2).Count(), Is.EqualTo(result1.Length));
307311
}
308312

309313

@@ -317,7 +321,8 @@ public void Test02()
317321
.Select(x => x.Field3.Value2.Value1 + x.Field4).ToArray();
318322

319323
Assert.That(result1, Is.Not.Empty);
320-
Assert.That(result1.SequenceEqual(result2));
324+
Assert.That(result1.Length, Is.EqualTo(result2.Length));
325+
Assert.That(result1.Intersect(result2).Count(), Is.EqualTo(result1.Length));
321326
}
322327
}
323328

@@ -328,8 +333,9 @@ public void Test03()
328333
using (var tx = session.OpenTransaction()) {
329334
var result1 = session.Query.All<B1ClassTable>().OfType<IB1>()
330335
.Select(x => x.Field3.Value2.Value1 + x.Field4).ToArray();
331-
Assert.That(result1.First(), Is.EqualTo("100000String1"));
332-
Assert.That(result1.Last(), Is.EqualTo("200000String2"));
336+
Assert.That(result1.Length, Is.EqualTo(2));
337+
new[] { "100000String1", "200000String2" }
338+
.ForEach(s => Assert.That(result1.Contains(s), Is.True));
333339

334340
var result2 = session.Query.All<B2ClassTable>().OfType<IB1>()
335341
.Select(x => x.Field3.Value2.Value1 + x.Field4).ToArray();
@@ -341,8 +347,9 @@ public void Test03()
341347
using (var tx = session.OpenTransaction()) {
342348
var result1 = session.Query.All<B1ConcreteTable>().OfType<IB1>()
343349
.Select(x => x.Field3.Value2.Value1 + x.Field4).ToArray();
344-
Assert.That(result1.First(), Is.EqualTo("100000String1"));
345-
Assert.That(result1.Last(), Is.EqualTo("200000String2"));
350+
Assert.That(result1.Length, Is.EqualTo(2));
351+
new[] { "100000String1", "200000String2" }
352+
.ForEach(s => Assert.That(result1.Contains(s), Is.True));
346353

347354
var result2 = session.Query.All<B2ConcreteTable>().OfType<IB1>()
348355
.Select(x => x.Field3.Value2.Value1 + x.Field4).ToArray();
@@ -354,8 +361,9 @@ public void Test03()
354361
using (var tx = session.OpenTransaction()) {
355362
var result1 = session.Query.All<B1SingleTable>().OfType<IB1>()
356363
.Select(x => x.Field3.Value2.Value1 + x.Field4).ToArray();
357-
Assert.That(result1.First(), Is.EqualTo("100000String1"));
358-
Assert.That(result1.Last(), Is.EqualTo("200000String2"));
364+
Assert.That(result1.Length, Is.EqualTo(2));
365+
new[] { "100000String1", "200000String2" }
366+
.ForEach(s => Assert.That(result1.Contains(s), Is.True));
359367

360368
var result2 = session.Query.All<B2SingleTable>().OfType<IB1>()
361369
.Select(x => x.Field3.Value2.Value1 + x.Field4).ToArray();
@@ -370,6 +378,9 @@ public void Test04()
370378
using (var tx = session.OpenTransaction()) {
371379
var result1 = session.Query.All<B1ClassTable>().OfType<AClassTable>()
372380
.Select(x => x.Field2).ToArray();
381+
Assert.That(result1.Length, Is.EqualTo(2));
382+
new[] { 1000, 2000 }
383+
.ForEach(i => Assert.That(result1.Contains(i), Is.True));
373384
Assert.That(result1.First(), Is.EqualTo(1000));
374385
Assert.That(result1.Last(), Is.EqualTo(2000));
375386

@@ -383,8 +394,9 @@ public void Test04()
383394
using (var tx = session.OpenTransaction()) {
384395
var result1 = session.Query.All<B1ConcreteTable>().OfType<AConcreteTable>()
385396
.Select(x => x.Field2).ToArray();
386-
Assert.That(result1.First(), Is.EqualTo(1000));
387-
Assert.That(result1.Last(), Is.EqualTo(2000));
397+
Assert.That(result1.Length, Is.EqualTo(2));
398+
new[] { 1000, 2000 }
399+
.ForEach(i => Assert.That(result1.Contains(i), Is.True));
388400

389401
var result2 = session.Query.All<B2ConcreteTable>().OfType<AConcreteTable>()
390402
.Select(x => x.Field2).ToArray();
@@ -396,8 +408,9 @@ public void Test04()
396408
using (var tx = session.OpenTransaction()) {
397409
var result1 = session.Query.All<B1SingleTable>().OfType<ASingleTable>()
398410
.Select(x => x.Field2).ToArray();
399-
Assert.That(result1.First(), Is.EqualTo(1000));
400-
Assert.That(result1.Last(), Is.EqualTo(2000));
411+
Assert.That(result1.Length, Is.EqualTo(2));
412+
new[] { 1000, 2000 }
413+
.ForEach(i => Assert.That(result1.Contains(i), Is.True));
401414

402415
var result2 = session.Query.All<B2SingleTable>().OfType<ASingleTable>()
403416
.Select(x => x.Field2).ToArray();
@@ -463,10 +476,9 @@ public void Test07()
463476
var source = session.Query.All<AClassTable>().OfType<IB1>();
464477

465478
var result1 = source.Select(x => x.Field3.Value1).ToArray();
466-
Assert.That(result1[0], Is.EqualTo(10000));
467-
Assert.That(result1[1], Is.EqualTo(20000));
468-
Assert.That(result1[2], Is.EqualTo(30000));
469479
Assert.That(result1.Length, Is.EqualTo(3));
480+
new[] { 10000, 20000, 30000 }
481+
.ForEach(i => Assert.That(result1.Contains(i)));
470482

471483
var result2 = source.OfType<B3ClassTable>().Select(x => x.Field3.Value1).ToArray();
472484
Assert.That(result2, Is.Empty);
@@ -477,10 +489,9 @@ public void Test07()
477489
var source = session.Query.All<AConcreteTable>().OfType<IB1>();
478490

479491
var result1 = source.Select(x => x.Field3.Value1).ToArray();
480-
Assert.That(result1[0], Is.EqualTo(10000));
481-
Assert.That(result1[1], Is.EqualTo(20000));
482-
Assert.That(result1[2], Is.EqualTo(30000));
483492
Assert.That(result1.Length, Is.EqualTo(3));
493+
new[] { 10000, 20000, 30000 }
494+
.ForEach(i => Assert.That(result1.Contains(i)));
484495

485496
var result2 = source.OfType<B3ConcreteTable>().Select(x => x.Field3.Value1).ToArray();
486497
Assert.That(result2, Is.Empty);
@@ -490,10 +501,9 @@ public void Test07()
490501
using (var tx = session.OpenTransaction()) {
491502
var source = session.Query.All<ASingleTable>().OfType<IB1>();
492503
var result1 = source.Select(x => x.Field3.Value1).ToArray();
493-
Assert.That(result1[0], Is.EqualTo(10000));
494-
Assert.That(result1[1], Is.EqualTo(20000));
495-
Assert.That(result1[2], Is.EqualTo(30000));
496504
Assert.That(result1.Length, Is.EqualTo(3));
505+
new[] { 10000, 20000, 30000 }
506+
.ForEach(i => Assert.That(result1.Contains(i)));
497507

498508
var result2 = source.OfType<B3SingleTable>().Select(x => x.Field3.Value1).ToArray();
499509
Assert.That(result2, Is.Empty);
@@ -509,7 +519,8 @@ public void Test08()
509519
var result1 = source.ToArray().OfType<IC>().Select(x => x.Field5).ToArray();
510520
var result2 = source.OfType<IC>().Select(x => x.Field5).ToArray();
511521
Assert.That(result1, Is.Not.Empty);
512-
Assert.That(result1.SequenceEqual(result2));
522+
Assert.That(result1.Length, Is.EqualTo(result2.Length));
523+
Assert.That(result1.Intersect(result2).Count(), Is.EqualTo(result1.Length));
513524
}
514525

515526
using (var session = Domain.OpenSession())
@@ -518,7 +529,8 @@ public void Test08()
518529
var result1 = source.ToArray().OfType<IC>().Select(x => x.Field5).ToArray();
519530
var result2 = source.OfType<IC>().Select(x => x.Field5).ToArray();
520531
Assert.That(result1, Is.Not.Empty);
521-
Assert.That(result1.SequenceEqual(result2));
532+
Assert.That(result1.Length, Is.EqualTo(result2.Length));
533+
Assert.That(result1.Intersect(result2).Count(), Is.EqualTo(result1.Length));
522534
}
523535

524536
using (var session = Domain.OpenSession())
@@ -527,7 +539,8 @@ public void Test08()
527539
var result1 = source.ToArray().OfType<IC>().Select(x => x.Field5).ToArray();
528540
var result2 = source.OfType<IC>().Select(x => x.Field5).ToArray();
529541
Assert.That(result1, Is.Not.Empty);
530-
Assert.That(result1.SequenceEqual(result2));
542+
Assert.That(result1.Length, Is.EqualTo(result2.Length));
543+
Assert.That(result1.Intersect(result2).Count(), Is.EqualTo(result1.Length));
531544
}
532545
}
533546

@@ -540,7 +553,8 @@ public void Test09()
540553
var result1 = source.ToArray().OfType<IBaseInterface>().Select(x => x.BaseField).ToArray();
541554
var result2 = source.OfType<IBaseInterface>().Select(x => x.BaseField).ToArray();
542555
Assert.That(result1, Is.Not.Empty);
543-
Assert.That(result1.SequenceEqual(result2));
556+
Assert.That(result1.Length, Is.EqualTo(result2.Length));
557+
Assert.That(result1.Intersect(result2).Count(), Is.EqualTo(result1.Length));
544558
}
545559

546560
using (var session = Domain.OpenSession())
@@ -549,7 +563,8 @@ public void Test09()
549563
var result1 = source.ToArray().OfType<IBaseInterface>().Select(x => x.BaseField).ToArray();
550564
var result2 = source.OfType<IBaseInterface>().Select(x => x.BaseField).ToArray();
551565
Assert.That(result1, Is.Not.Empty);
552-
Assert.That(result1.SequenceEqual(result2));
566+
Assert.That(result1.Length, Is.EqualTo(result2.Length));
567+
Assert.That(result1.Intersect(result2).Count(), Is.EqualTo(result1.Length));
553568
}
554569

555570
using (var session = Domain.OpenSession())
@@ -558,7 +573,8 @@ public void Test09()
558573
var result1 = source.ToArray().OfType<IBaseInterface>().Select(x => x.BaseField).ToArray();
559574
var result2 = source.OfType<IBaseInterface>().Select(x => x.BaseField).ToArray();
560575
Assert.That(result1, Is.Not.Empty);
561-
Assert.That(result1.SequenceEqual(result2));
576+
Assert.That(result1.Length, Is.EqualTo(result2.Length));
577+
Assert.That(result1.Intersect(result2).Count(), Is.EqualTo(result1.Length));
562578
}
563579
}
564580

@@ -599,22 +615,20 @@ public void Test11()
599615
.OfType<IBaseEntity>();
600616

601617
var result1 = query.Select(x => x.Field1).ToArray();
602-
Assert.That(result1[0], Is.EqualTo(10));
603-
Assert.That(result1[1], Is.EqualTo(20));
604-
Assert.That(result1[2], Is.EqualTo(30));
605618
Assert.That(result1.Length, Is.EqualTo(3));
619+
new[] { 10, 20, 30 }
620+
.ForEach(i => Assert.That(result1.Contains(i)));
606621

607622
var result2 = query.OfType<AClassTable>().Select(x => x.Field1).ToArray();
608-
Assert.That(result2[0], Is.EqualTo(10));
609-
Assert.That(result2[1], Is.EqualTo(20));
610-
Assert.That(result2[2], Is.EqualTo(30));
611623
Assert.That(result2.Length, Is.EqualTo(3));
624+
new[] { 10, 20, 30 }
625+
.ForEach(i => Assert.That(result2.Contains(i)));
612626

613627
var result3 = query.OfType<AClassTable>().OfType<IBaseEntity>()
614628
.OfType<C1ClassTable>().Select(x => x.Field1).ToArray();
615-
Assert.That(result3[0], Is.EqualTo(10));
616-
Assert.That(result3[1], Is.EqualTo(20));
617629
Assert.That(result3.Length, Is.EqualTo(2));
630+
new[] { 10, 20 }
631+
.ForEach(i => Assert.That(result3.Contains(i)));
618632
}
619633

620634
using (var session = Domain.OpenSession())
@@ -623,22 +637,20 @@ public void Test11()
623637
.OfType<IBaseEntity>();
624638

625639
var result1 = query.Select(x => x.Field1).ToArray();
626-
Assert.That(result1[0], Is.EqualTo(10));
627-
Assert.That(result1[1], Is.EqualTo(20));
628-
Assert.That(result1[2], Is.EqualTo(30));
629640
Assert.That(result1.Length, Is.EqualTo(3));
641+
new[] { 10, 20, 30 }
642+
.ForEach(i => Assert.That(result1.Contains(i)));
630643

631644
var result2 = query.OfType<AConcreteTable>().Select(x => x.Field1).ToArray();
632-
Assert.That(result2[0], Is.EqualTo(10));
633-
Assert.That(result2[1], Is.EqualTo(20));
634-
Assert.That(result2[2], Is.EqualTo(30));
635645
Assert.That(result2.Length, Is.EqualTo(3));
646+
new[] { 10, 20, 30 }
647+
.ForEach(i => Assert.That(result2.Contains(i)));
636648

637649
var result3 = query.OfType<AConcreteTable>().OfType<IBaseEntity>()
638650
.OfType<C1ConcreteTable>().Select(x => x.Field1).ToArray();
639-
Assert.That(result3[0], Is.EqualTo(10));
640-
Assert.That(result3[1], Is.EqualTo(20));
641651
Assert.That(result3.Length, Is.EqualTo(2));
652+
new[] { 10, 20 }
653+
.ForEach(i => Assert.That(result3.Contains(i)));
642654
}
643655

644656
using (var session = Domain.OpenSession())
@@ -647,22 +659,20 @@ public void Test11()
647659
.OfType<IBaseEntity>();
648660

649661
var result1 = query.Select(x => x.Field1).ToArray();
650-
Assert.That(result1[0], Is.EqualTo(10));
651-
Assert.That(result1[1], Is.EqualTo(20));
652-
Assert.That(result1[2], Is.EqualTo(30));
653662
Assert.That(result1.Length, Is.EqualTo(3));
663+
new[] { 10, 20, 30 }
664+
.ForEach(i => Assert.That(result1.Contains(i)));
654665

655666
var result2 = query.OfType<ASingleTable>().Select(x => x.Field1).ToArray();
656-
Assert.That(result2[0], Is.EqualTo(10));
657-
Assert.That(result2[1], Is.EqualTo(20));
658-
Assert.That(result2[2], Is.EqualTo(30));
659667
Assert.That(result2.Length, Is.EqualTo(3));
668+
new[] { 10, 20, 30 }
669+
.ForEach(i => Assert.That(result2.Contains(i)));
660670

661671
var result3 = query.OfType<ASingleTable>().OfType<IBaseEntity>()
662672
.OfType<C1SingleTable>().Select(x => x.Field1).ToArray();
663-
Assert.That(result3[0], Is.EqualTo(10));
664-
Assert.That(result3[1], Is.EqualTo(20));
665673
Assert.That(result3.Length, Is.EqualTo(2));
674+
new[] { 10, 20 }
675+
.ForEach(i => Assert.That(result3.Contains(i)));
666676
}
667677
}
668678

@@ -735,7 +745,8 @@ public void Test13()
735745
var resultB = result1B.Union(result2B).Select(x => x.Field1).ToArray();
736746

737747
Assert.That(resultA, Is.Not.Empty);
738-
Assert.That(resultA.SequenceEqual(resultB));
748+
Assert.That(resultA.Length, Is.EqualTo(resultB.Length));
749+
Assert.That(resultA.Intersect(resultB).Count(), Is.EqualTo(resultA.Length));
739750
}
740751

741752
using (var session = Domain.OpenSession())
@@ -752,7 +763,8 @@ public void Test13()
752763
var resultB = result1B.Union(result2B).Select(x => x.Field1).ToArray();
753764

754765
Assert.That(resultA, Is.Not.Empty);
755-
Assert.That(resultA.SequenceEqual(resultB));
766+
Assert.That(resultA.Length, Is.EqualTo(resultB.Length));
767+
Assert.That(resultA.Intersect(resultB).Count(), Is.EqualTo(resultA.Length));
756768
}
757769

758770
using (var session = Domain.OpenSession())
@@ -769,7 +781,8 @@ public void Test13()
769781
var resultB = result1B.Union(result2B).Select(x => x.Field1).ToArray();
770782

771783
Assert.That(resultA, Is.Not.Empty);
772-
Assert.That(resultA.SequenceEqual(resultB));
784+
Assert.That(resultA.Length, Is.EqualTo(resultB.Length));
785+
Assert.That(resultA.Intersect(resultB).Count(), Is.EqualTo(resultA.Length));
773786
}
774787
}
775788

@@ -863,7 +876,6 @@ public void Test14()
863876
Assert.That(result1A.Contains(item));
864877
}
865878

866-
867879
var result2A = source1B.Union(source2B).ToArray().OfType<B3SingleTable>().Select(x => x.Field4)
868880
.ToArray();
869881
var result2B = source1B.Union(source2B).OfType<B3SingleTable>().Select(x => x.Field4).ToArray();

0 commit comments

Comments
 (0)