Mercurial > pub > bltoolkit

comparison UnitTests/Linq/EnumMapping.cs @ 0:f990fcb411a9

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Копия текущей версии из github
author cin
date Thu, 27 Mar 2014 21:46:09 +0400
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:f990fcb411a9
1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Linq.Expressions;
5 using BLToolkit.Data.DataProvider;
6 using BLToolkit.Data.Linq;
7 using BLToolkit.DataAccess;
8 using BLToolkit.Mapping;
9 using NUnit.Framework;
10
11 namespace Data.Linq
12 {
13 [TestFixture, Category("MapValue")]
14 public class EnumMapping : TestBase
15 {
16 enum TestEnum1
17 {
18 [MapValue(11L)] Value1 = 3,
19 [MapValue(12L)] Value2,
20 }
21 enum TestEnum2
22 {
23 Value1 = 3,
24 Value2,
25 }
26 enum TestEnum3
27 {
28 Value1 = 3,
29 Value2,
30 }
31
32 [TableName("LinqDataTypes")]
33 class TestTable1
34 {
35 [PrimaryKey, MapField("ID")] public int Id;
36 [MapField("BigIntValue")] public TestEnum1 TestField;
37 }
38
39 [MapValue(TestEnum2.Value2, 12L)]
40 [TableName("LinqDataTypes")]
41 class TestTable2
42 {
43 [PrimaryKey, MapField("ID")]
44 public int Id;
45
46 [MapValue(TestEnum2.Value1, 11L)]
47 [MapField("BigIntValue")]
48 public TestEnum2 TestField;
49
50 [MapField("IntValue")]
51 public TestEnum3 Int32Field;
52 }
53
54 [TableName("LinqDataTypes")]
55 class NullableTestTable1
56 {
57 [PrimaryKey, MapField("ID")]
58 public int? Id;
59
60 [MapField("BigIntValue")]
61 public TestEnum1? TestField;
62 }
63
64 [MapValue(TestEnum2.Value2, 12L)]
65 [TableName("LinqDataTypes")]
66 class NullableTestTable2
67 {
68 [PrimaryKey, MapField("ID")]
69 public int? Id;
70
71 [MapValue(TestEnum2.Value1, 11L)]
72 [MapField("BigIntValue")]
73 public TestEnum2? TestField;
74
75 [MapField("IntValue")]
76 public TestEnum3? Int32Field;
77 }
78
79 [TableName("LinqDataTypes")]
80 class RawTable
81 {
82 [PrimaryKey, MapField("ID")]
83 public int Id;
84
85 [MapField("BigIntValue")]
86 public long TestField;
87
88 [MapField("IntValue")]
89 public int Int32Field;
90 }
91
92 class Cleaner : IDisposable
93 {
94 readonly ITestDataContext _db;
95
96 public Cleaner(ITestDataContext db)
97 {
98 _db = db;
99 Clean();
100 }
101
102 private void Clean()
103 {
104 _db.GetTable<RawTable>().Where(r => r.Id == RID).Delete();
105 }
106
107 public void Dispose()
108 {
109 try
110 {
111 // rollback emulation for WCF
112 Clean();
113 }
114 catch (Exception)
115 {
116 }
117 }
118 }
119
120 const long VAL2 = 12;
121 const long VAL1 = 11;
122 const int RID = 101;
123
124 [Test]
125 public void EnumMapInsert1()
126 {
127 ForEachProvider(db =>
128 {
129 using (new Cleaner(db))
130 {
131 db.GetTable<TestTable1>().Insert(() => new TestTable1
132 {
133 Id = RID,
134 TestField = TestEnum1.Value2
135 });
136
137 Assert.AreEqual(1, db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL2).Count());
138 }
139 });
140 }
141
142 [Test]
143 public void EnumMapInsert2()
144 {
145 ForEachProvider(db =>
146 {
147 using (new Cleaner(db))
148 {
149 db.GetTable<TestTable2>().Insert(() => new TestTable2
150 {
151 Id = RID,
152 TestField = TestEnum2.Value2
153 });
154
155 Assert.AreEqual(1, db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL2).Count());
156 }
157 });
158 }
159
160 [Test]
161 public void EnumMapInsert3()
162 {
163 ForEachProvider(db =>
164 {
165 using (new Cleaner(db))
166 {
167 db.GetTable<NullableTestTable1>().Insert(() => new NullableTestTable1
168 {
169 Id = RID,
170 TestField = TestEnum1.Value2
171 });
172
173 Assert.AreEqual(1, db.GetTable<RawTable>()
174 .Where(r => r.Id == RID && r.TestField == VAL2).Count());
175 }
176 });
177 }
178
179 [Test]
180 public void EnumMapInsert4()
181 {
182 ForEachProvider(db =>
183 {
184 using (new Cleaner(db))
185 {
186 db.GetTable<NullableTestTable2>().Insert(() => new NullableTestTable2
187 {
188 Id = RID,
189 TestField = TestEnum2.Value2
190 });
191
192 Assert.AreEqual(1, db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL2).Count());
193 }
194 });
195 }
196
197 [Test]
198 public void EnumMapWhere1()
199 {
200 ForEachProvider(db =>
201 {
202 using (new Cleaner(db))
203 {
204 db.GetTable<RawTable>().Insert(() => new RawTable
205 {
206 Id = RID,
207 TestField = VAL2
208 });
209
210 var result = db.GetTable<TestTable1>().Where(r => r.Id == RID && r.TestField == TestEnum1.Value2).Select(r => r.TestField).FirstOrDefault();
211 Assert.True(result == TestEnum1.Value2);
212 }
213 });
214 }
215
216 [Test]
217 public void EnumMapWhere2()
218 {
219 ForEachProvider(db =>
220 {
221 using (new Cleaner(db))
222 {
223 db.GetTable<RawTable>().Insert(() => new RawTable
224 {
225 Id = RID,
226 TestField = VAL2
227 });
228
229 var result = db.GetTable<TestTable2>().Where(r => r.Id == RID && r.TestField == TestEnum2.Value2).Select(r => r.TestField).FirstOrDefault();
230 Assert.True(result == TestEnum2.Value2);
231 }
232 });
233 }
234
235 [Test]
236 public void EnumMapWhere3()
237 {
238 ForEachProvider(db =>
239 {
240 using (new Cleaner(db))
241 {
242 db.GetTable<RawTable>().Insert(() => new RawTable
243 {
244 Id = RID,
245 TestField = VAL2
246 });
247
248 var result = db.GetTable<NullableTestTable1>()
249 .Where(r => r.Id == RID && r.TestField == TestEnum1.Value2)
250 .Select(r => r.TestField).FirstOrDefault();
251 Assert.True(result == TestEnum1.Value2);
252 }
253 });
254 }
255
256 [Test]
257 public void EnumMapWhere4()
258 {
259 ForEachProvider(db =>
260 {
261 using (new Cleaner(db))
262 {
263 db.GetTable<RawTable>().Insert(() => new RawTable
264 {
265 Id = RID,
266 TestField = VAL2
267 });
268
269 var result = db.GetTable<NullableTestTable2>()
270 .Where(r => r.Id == RID && r.TestField == TestEnum2.Value2)
271 .Select(r => r.TestField).FirstOrDefault();
272 Assert.True(result == TestEnum2.Value2);
273 }
274 });
275 }
276
277 [Test]
278 public void EnumMapUpdate1()
279 {
280 ForEachProvider(db =>
281 {
282 using (new Cleaner(db))
283 {
284 db.GetTable<RawTable>().Insert(() => new RawTable
285 {
286 Id = RID,
287 TestField = VAL1
288 });
289
290 db.GetTable<TestTable1>()
291 .Where(r => r.Id == RID && r.TestField == TestEnum1.Value1)
292 .Update(r => new TestTable1 { TestField = TestEnum1.Value2 });
293
294 var result = db.GetTable<RawTable>()
295 .Where(r => r.Id == RID && r.TestField == VAL2)
296 .Select(r => r.TestField)
297 .FirstOrDefault();
298
299 Assert.True(result == VAL2);
300 }
301 });
302 }
303
304 [Test]
305 public void EnumMapUpdate2()
306 {
307 ForEachProvider(db =>
308 {
309 using (new Cleaner(db))
310 {
311 db.GetTable<RawTable>().Insert(() => new RawTable
312 {
313 Id = RID,
314 TestField = VAL1
315 });
316
317 db.GetTable<TestTable2>()
318 .Where(r => r.Id == RID && r.TestField == TestEnum2.Value1)
319 .Update(r => new TestTable2 { TestField = TestEnum2.Value2 });
320
321 var result = db.GetTable<RawTable>()
322 .Where(r => r.Id == RID && r.TestField == VAL2)
323 .Select(r => r.TestField)
324 .FirstOrDefault();
325
326 Assert.True(result == VAL2);
327 }
328 });
329 }
330
331 [Test]
332 public void EnumMapUpdate3()
333 {
334 ForEachProvider(db =>
335 {
336 using (new Cleaner(db))
337 {
338 db.GetTable<RawTable>().Insert(() => new RawTable
339 {
340 Id = RID,
341 TestField = VAL1
342 });
343
344 db.GetTable<NullableTestTable1>()
345 .Where(r => r.Id == RID && r.TestField == TestEnum1.Value1)
346 .Update(r => new NullableTestTable1 { TestField = TestEnum1.Value2 });
347
348 var result = db.GetTable<RawTable>()
349 .Where(r => r.Id == RID && r.TestField == VAL2)
350 .Select(r => r.TestField)
351 .FirstOrDefault();
352
353 Assert.True(result == VAL2);
354 }
355 });
356 }
357
358 [Test]
359 public void EnumMapUpdate4()
360 {
361 ForEachProvider(db =>
362 {
363 using (new Cleaner(db))
364 {
365 db.GetTable<RawTable>().Insert(() => new RawTable
366 {
367 Id = RID,
368 TestField = VAL1
369 });
370
371 db.GetTable<NullableTestTable2>()
372 .Where(r => r.Id == RID && r.TestField == TestEnum2.Value1)
373 .Update(r => new NullableTestTable2 { TestField = TestEnum2.Value2 });
374
375 var result = db.GetTable<RawTable>()
376 .Where(r => r.Id == RID && r.TestField == VAL2)
377 .Select(r => r.TestField)
378 .FirstOrDefault();
379
380 Assert.True(result == VAL2);
381 }
382 });
383 }
384
385 [Test]
386 public void EnumMapSelectAnon1([DataContexts] string context)
387 {
388 using (var db = GetDataContext(context))
389 {
390 using (new Cleaner(db))
391 {
392 db.GetTable<RawTable>().Insert(() => new RawTable
393 {
394 Id = RID,
395 TestField = VAL2
396 });
397
398 var result = db.GetTable<TestTable1>()
399 .Where(r => r.Id == RID && r.TestField == TestEnum1.Value2)
400 .Select(r => new { r.TestField })
401 .FirstOrDefault();
402
403 Assert.NotNull(result);
404 Assert.That(result.TestField, Is.EqualTo(TestEnum1.Value2));
405 }
406 }
407 }
408
409 [Test]
410 public void EnumMapSelectAnon2()
411 {
412 ForEachProvider(db =>
413 {
414 using (new Cleaner(db))
415 {
416 db.GetTable<RawTable>().Insert(() => new RawTable
417 {
418 Id = RID,
419 TestField = VAL2
420 });
421
422 var result = db.GetTable<TestTable2>()
423 .Where(r => r.Id == RID && r.TestField == TestEnum2.Value2)
424 .Select(r => new { r.TestField })
425 .FirstOrDefault();
426
427 Assert.NotNull(result);
428 Assert.True(result.TestField == TestEnum2.Value2);
429 }
430 });
431 }
432
433 [Test]
434 public void EnumMapSelectAnon3()
435 {
436 ForEachProvider(db =>
437 {
438 using (new Cleaner(db))
439 {
440 db.GetTable<RawTable>().Insert(() => new RawTable
441 {
442 Id = RID,
443 TestField = VAL2
444 });
445
446 var result = db.GetTable<NullableTestTable1>()
447 .Where(r => r.Id == RID && r.TestField == TestEnum1.Value2)
448 .Select(r => new { r.TestField })
449 .FirstOrDefault();
450
451 Assert.NotNull(result);
452 Assert.True(result.TestField == TestEnum1.Value2);
453 }
454 });
455 }
456
457 [Test]
458 public void EnumMapSelectAnon4()
459 {
460 ForEachProvider(db =>
461 {
462 using (new Cleaner(db))
463 {
464 db.GetTable<RawTable>().Insert(() => new RawTable
465 {
466 Id = RID,
467 TestField = VAL2
468 });
469
470 var result = db.GetTable<NullableTestTable2>()
471 .Where(r => r.Id == RID && r.TestField == TestEnum2.Value2)
472 .Select(r => new { r.TestField })
473 .FirstOrDefault();
474
475 Assert.NotNull(result);
476 Assert.True(result.TestField == TestEnum2.Value2);
477 }
478 });
479 }
480
481 [Test]
482 public void EnumMapDelete1()
483 {
484 ForEachProvider(db =>
485 {
486 using (new Cleaner(db))
487 {
488 db.GetTable<RawTable>().Insert(() => new RawTable
489 {
490 Id = RID,
491 TestField = VAL2
492 });
493
494 Assert.True(1 == db.GetTable<TestTable1>().Delete(r => r.Id == RID && r.TestField == TestEnum1.Value2));
495 }
496 });
497 }
498
499 [Test]
500 public void EnumMapDelete2()
501 {
502 ForEachProvider(db =>
503 {
504 using (new Cleaner(db))
505 {
506 db.GetTable<RawTable>().Insert(() => new RawTable
507 {
508 Id = RID,
509 TestField = VAL2
510 });
511
512 Assert.True(1 == db.GetTable<TestTable2>().Delete(r => r.Id == RID && r.TestField == TestEnum2.Value2));
513 }
514 });
515 }
516
517 [Test]
518 public void EnumMapDelete3()
519 {
520 ForEachProvider(db =>
521 {
522 using (new Cleaner(db))
523 {
524 db.GetTable<RawTable>().Insert(() => new RawTable
525 {
526 Id = RID,
527 TestField = VAL2
528 });
529
530 Assert.True(1 == db.GetTable<NullableTestTable1>()
531 .Delete(r => r.Id == RID && r.TestField == TestEnum1.Value2));
532 }
533 });
534 }
535
536 [Test]
537 public void EnumMapDelete4()
538 {
539 ForEachProvider(db =>
540 {
541 using (new Cleaner(db))
542 {
543 db.GetTable<RawTable>().Insert(() => new RawTable
544 {
545 Id = RID,
546 TestField = VAL2
547 });
548
549 Assert.True(1 == db.GetTable<NullableTestTable2>()
550 .Delete(r => r.Id == RID && r.TestField == TestEnum2.Value2));
551 }
552 });
553 }
554
555 [Test]
556 public void EnumMapSet1()
557 {
558 ForEachProvider(db =>
559 {
560 using (new Cleaner(db))
561 {
562 db.GetTable<RawTable>().Insert(() => new RawTable
563 {
564 Id = RID,
565 TestField = VAL1
566 });
567
568 db.GetTable<TestTable1>()
569 .Where(r => r.Id == RID && r.TestField == TestEnum1.Value1)
570 .Set(r => r.TestField, TestEnum1.Value2).Update();
571 var result = db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL2).Select(r => r.TestField).FirstOrDefault();
572 Assert.True(result == VAL2);
573 }
574 });
575 }
576
577 [Test]
578 public void EnumMapSet2()
579 {
580 ForEachProvider(db =>
581 {
582 using (new Cleaner(db))
583 {
584 db.GetTable<RawTable>().Insert(() => new RawTable
585 {
586 Id = RID,
587 TestField = VAL1
588 });
589
590 db.GetTable<TestTable2>()
591 .Where(r => r.Id == RID && r.TestField == TestEnum2.Value1)
592 .Set(r => r.TestField, TestEnum2.Value2).Update();
593 var result = db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL2).Select(r => r.TestField).FirstOrDefault();
594 Assert.True(result == VAL2);
595 }
596 });
597 }
598
599 [Test]
600 public void EnumMapSet3()
601 {
602 ForEachProvider(db =>
603 {
604 using (new Cleaner(db))
605 {
606 db.GetTable<RawTable>().Insert(() => new RawTable
607 {
608 Id = RID,
609 Int32Field = 3
610 });
611
612 db.GetTable<TestTable2>()
613 .Where(r => r.Id == RID && r.Int32Field == TestEnum3.Value1)
614 .Set(r => r.Int32Field, () => TestEnum3.Value2).Update();
615 Assert.True(1 == db.GetTable<RawTable>().Where(r => r.Id == RID && r.Int32Field == 4).Count());
616 }
617 });
618 }
619
620 [Test]
621 public void EnumMapSet4()
622 {
623 ForEachProvider(db =>
624 {
625 using (new Cleaner(db))
626 {
627 db.GetTable<RawTable>().Insert(() => new RawTable
628 {
629 Id = RID,
630 TestField = VAL1
631 });
632
633 db.GetTable<NullableTestTable1>()
634 .Where(r => r.Id == RID && r.TestField == TestEnum1.Value1)
635 .Set(r => r.TestField, TestEnum1.Value2).Update();
636 var result = db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL2).Select(r => r.TestField).FirstOrDefault();
637 Assert.True(result == VAL2);
638 }
639 });
640 }
641
642 [Test]
643 public void EnumMapSet5()
644 {
645 ForEachProvider(db =>
646 {
647 using (new Cleaner(db))
648 {
649 db.GetTable<RawTable>().Insert(() => new RawTable
650 {
651 Id = RID,
652 TestField = VAL1
653 });
654
655 db.GetTable<NullableTestTable2>()
656 .Where(r => r.Id == RID && r.TestField == TestEnum2.Value1)
657 .Set(r => r.TestField, TestEnum2.Value2).Update();
658 var result = db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL2).Select(r => r.TestField).FirstOrDefault();
659 Assert.True(result == VAL2);
660 }
661 });
662 }
663
664 [Test]
665 public void EnumMapSet6()
666 {
667 ForEachProvider(db =>
668 {
669 using (new Cleaner(db))
670 {
671 db.GetTable<RawTable>().Insert(() => new RawTable
672 {
673 Id = RID,
674 Int32Field = 3
675 });
676
677 db.GetTable<NullableTestTable2>()
678 .Where(r => r.Id == RID && r.Int32Field == TestEnum3.Value1)
679 .Set(r => r.Int32Field, () => TestEnum3.Value2).Update();
680 Assert.True(1 == db.GetTable<RawTable>().Where(r => r.Id == RID && r.Int32Field == 4).Count());
681 }
682 });
683 }
684
685 [Test]
686 public void EnumMapContains1([DataContexts] string context)
687 {
688 using (var db = GetDataContext(context))
689 {
690 using (new Cleaner(db))
691 {
692 db.GetTable<RawTable>().Insert(() => new RawTable
693 {
694 Id = RID,
695 TestField = VAL2
696 });
697
698 Assert.True(1 == db.GetTable<TestTable1>()
699 .Where(r => r.Id == RID && new[] { TestEnum1.Value2 }.Contains(r.TestField)).Count());
700 }
701 }
702 }
703
704 [Test]
705 public void EnumMapContains2()
706 {
707 ForEachProvider(db =>
708 {
709 using (new Cleaner(db))
710 {
711 db.GetTable<RawTable>().Insert(() => new RawTable
712 {
713 Id = RID,
714 TestField = VAL2
715 });
716
717 Assert.That(db.GetTable<TestTable2>().Where(r => r.Id == RID && new[] { TestEnum2.Value2 }.Contains(r.TestField)).Count(), Is.EqualTo(1));
718 }
719 });
720 }
721
722 [Test]
723 public void EnumMapContains3()
724 {
725 ForEachProvider(db =>
726 {
727 using (new Cleaner(db))
728 {
729 db.GetTable<RawTable>().Insert(() => new RawTable
730 {
731 Id = RID,
732 TestField = VAL2
733 });
734
735 Assert.True(1 == db.GetTable<NullableTestTable1>()
736 .Where(r => r.Id == RID && new[] { (TestEnum1?)TestEnum1.Value2 }.Contains(r.TestField)).Count());
737 }
738 });
739 }
740
741 [Test]
742 public void EnumMapContains4()
743 {
744 ForEachProvider(db =>
745 {
746 using (new Cleaner(db))
747 {
748 db.GetTable<RawTable>().Insert(() => new RawTable
749 {
750 Id = RID,
751 TestField = VAL2
752 });
753
754 Assert.True(1 == db.GetTable<NullableTestTable2>()
755 .Where(r => r.Id == RID && new[] { (TestEnum2?)TestEnum2.Value2 }.Contains(r.TestField)).Count());
756 }
757 });
758 }
759
760 [Test]
761 public void EnumMapSelectNull1()
762 {
763 ForEachProvider(db =>
764 {
765 using (new Cleaner(db))
766 {
767 db.GetTable<RawTable>().Insert(() => new RawTable
768 {
769 Id = RID
770 });
771
772 var result = db.GetTable<NullableTestTable1>()
773 .Where(r => r.Id == RID)
774 .Select(r => new { r.TestField })
775 .FirstOrDefault();
776
777 Assert.NotNull(result);
778 Assert.True(result.TestField == null);
779 }
780 });
781 }
782
783 [Test]
784 public void EnumMapSelectNull2()
785 {
786 ForEachProvider(db =>
787 {
788 using (new Cleaner(db))
789 {
790 db.GetTable<RawTable>().Insert(() => new RawTable
791 {
792 Id = RID
793 });
794
795 var result = db.GetTable<NullableTestTable2>()
796 .Where(r => r.Id == RID)
797 .Select(r => new { r.TestField })
798 .FirstOrDefault();
799
800 Assert.NotNull(result);
801 Assert.True(result.TestField == null);
802 }
803 });
804 }
805
806 [Test]
807 public void EnumMapWhereNull1()
808 {
809 ForEachProvider(db =>
810 {
811 using (new Cleaner(db))
812 {
813 db.GetTable<RawTable>().Insert(() => new RawTable
814 {
815 Id = RID
816 });
817
818 var result = db.GetTable<NullableTestTable1>()
819 .Where(r => r.Id == RID && r.TestField == null)
820 .Select(r => new { r.TestField }).FirstOrDefault();
821 Assert.NotNull(result);
822 Assert.Null(result.TestField);
823 }
824 });
825 }
826
827 [Test]
828 public void EnumMapWhereNull2()
829 {
830 ForEachProvider(db =>
831 {
832 using (new Cleaner(db))
833 {
834 db.GetTable<RawTable>().Insert(() => new RawTable
835 {
836 Id = RID
837 });
838
839 var result = db.GetTable<NullableTestTable2>()
840 .Where(r => r.Id == RID && r.TestField == null)
841 .Select(r => new { r.TestField }).FirstOrDefault();
842 Assert.NotNull(result);
843 Assert.Null(result.TestField);
844 }
845 });
846 }
847
848 [Test]
849 public void EnumMapInsertObject1()
850 {
851 ForEachProvider(db =>
852 {
853 using (new Cleaner(db))
854 {
855 db.Insert(new TestTable1
856 {
857 Id = RID,
858 TestField = TestEnum1.Value2
859 });
860
861 Assert.AreEqual(1, db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL2).Count());
862 }
863 });
864 }
865
866 [Test]
867 public void EnumMapInsertObject2()
868 {
869 ForEachProvider(db =>
870 {
871 using (new Cleaner(db))
872 {
873 db.Insert(new TestTable2
874 {
875 Id = RID,
876 TestField = TestEnum2.Value2
877 });
878
879 Assert.AreEqual(1, db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL2).Count());
880 }
881 });
882 }
883
884 [Test]
885 public void EnumMapInsertObject3()
886 {
887 ForEachProvider(db =>
888 {
889 using (new Cleaner(db))
890 {
891 db.Insert(new NullableTestTable1
892 {
893 Id = RID,
894 TestField = TestEnum1.Value2
895 });
896
897 Assert.AreEqual(1, db.GetTable<RawTable>()
898 .Where(r => r.Id == RID && r.TestField == VAL2).Count());
899 }
900 });
901 }
902
903 [Test]
904 public void EnumMapInsertObject4()
905 {
906 ForEachProvider(db =>
907 {
908 using (new Cleaner(db))
909 {
910 db.Insert(new NullableTestTable2
911 {
912 Id = RID,
913 TestField = TestEnum2.Value2
914 });
915
916 Assert.AreEqual(1, db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL2).Count());
917 }
918 });
919 }
920
921 [Test]
922 public void EnumMapInsertFromSelectWithParam1()
923 {
924 ForEachProvider(db =>
925 {
926 using (new Cleaner(db))
927 {
928 db.GetTable<RawTable>().Insert(() => new RawTable
929 {
930 Id = RID,
931 TestField = VAL2
932 });
933
934 var param = TestEnum1.Value1;
935
936 var result = db.GetTable<TestTable1>()
937 .Where(r => r.Id == RID && r.TestField == TestEnum1.Value2)
938 .Select(r => new TestTable1
939 {
940 Id = r.Id,
941 TestField = param
942 })
943 .Insert(db.GetTable<TestTable1>(), r => r);
944
945 Assert.AreEqual(1, result);
946 Assert.AreEqual(1, db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL1).Count());
947 }
948 });
949 }
950
951 [Test]
952 public void EnumMapInsertFromSelectWithParam2()
953 {
954 ForEachProvider(db =>
955 {
956 using (new Cleaner(db))
957 {
958 db.GetTable<RawTable>().Insert(() => new RawTable
959 {
960 Id = RID,
961 TestField = VAL2
962 });
963
964 var param = TestEnum2.Value1;
965
966 var result = db.GetTable<TestTable2>()
967 .Where(r => r.Id == RID && r.TestField == TestEnum2.Value2)
968 .Select(r => new TestTable2
969 {
970 Id = r.Id,
971 TestField = param
972 })
973 .Insert(db.GetTable<TestTable2>(), r => r);
974
975 Assert.AreEqual(1, result);
976 Assert.AreEqual(1, db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL1).Count());
977 }
978 });
979 }
980
981 [Test]
982 public void EnumMapInsertFromSelectWithParam3()
983 {
984 ForEachProvider(db =>
985 {
986 using (new Cleaner(db))
987 {
988 db.GetTable<RawTable>().Insert(() => new RawTable
989 {
990 Id = RID,
991 TestField = VAL2
992 });
993
994 var param = TestEnum1.Value1;
995
996 var result = db.GetTable<NullableTestTable1>()
997 .Where(r => r.Id == RID && r.TestField == TestEnum1.Value2)
998 .Select(r => new NullableTestTable1
999 {
1000 Id = r.Id,
1001 TestField = param
1002 })
1003 .Insert(db.GetTable<NullableTestTable1>(), r => r);
1004
1005 Assert.AreEqual(1, result);
1006 Assert.AreEqual(1, db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL1).Count());
1007 }
1008 });
1009 }
1010
1011 [Test]
1012 public void EnumMapInsertFromSelectWithParam4()
1013 {
1014 ForEachProvider(db =>
1015 {
1016 using (new Cleaner(db))
1017 {
1018 db.GetTable<RawTable>().Insert(() => new RawTable
1019 {
1020 Id = RID,
1021 TestField = VAL2
1022 });
1023
1024 var param = TestEnum2.Value1;
1025
1026 var result = db.GetTable<NullableTestTable2>()
1027 .Where(r => r.Id == RID && r.TestField == TestEnum2.Value2)
1028 .Select(r => new NullableTestTable2
1029 {
1030 Id = r.Id,
1031 TestField = param
1032 })
1033 .Insert(db.GetTable<NullableTestTable2>(), r => r);
1034
1035 Assert.AreEqual(1, result);
1036 Assert.AreEqual(1, db.GetTable<RawTable>().Where(r => r.Id == RID && r.TestField == VAL1).Count());
1037 }
1038 });
1039 }
1040
1041 [Test]
1042 public void EnumMapDeleteEquals1()
1043 {
1044 ForEachProvider(db =>
1045 {
1046 using (new Cleaner(db))
1047 {
1048 db.GetTable<RawTable>().Insert(() => new RawTable
1049 {
1050 Id = RID,
1051 TestField = VAL2
1052 });
1053
1054 Assert.True(1 == db.GetTable<TestTable1>().Delete(r => r.Id == RID && r.TestField.Equals(TestEnum1.Value2)));
1055 }
1056 });
1057 }
1058
1059 [Test]
1060 public void EnumMapDeleteEquals2()
1061 {
1062 ForEachProvider(db =>
1063 {
1064 using (new Cleaner(db))
1065 {
1066 db.GetTable<RawTable>().Insert(() => new RawTable
1067 {
1068 Id = RID,
1069 TestField = VAL2
1070 });
1071
1072 Assert.True(1 == db.GetTable<TestTable2>().Delete(r => r.Id == RID && r.TestField.Equals(TestEnum2.Value2)));
1073 }
1074 });
1075 }
1076
1077 [Test]
1078 public void EnumMapDeleteEquals3()
1079 {
1080 ForEachProvider(db =>
1081 {
1082 using (new Cleaner(db))
1083 {
1084 db.GetTable<RawTable>().Insert(() => new RawTable
1085 {
1086 Id = RID,
1087 TestField = VAL2
1088 });
1089
1090 Assert.True(1 == db.GetTable<NullableTestTable1>()
1091 .Delete(r => r.Id == RID && r.TestField.Equals(TestEnum1.Value2)));
1092 }
1093 });
1094 }
1095
1096 [Test]
1097 public void EnumMapDeleteEquals4()
1098 {
1099 ForEachProvider(db =>
1100 {
1101 using (new Cleaner(db))
1102 {
1103 db.GetTable<RawTable>().Insert(() => new RawTable
1104 {
1105 Id = RID,
1106 TestField = VAL2
1107 });
1108
1109 Assert.True(1 == db.GetTable<NullableTestTable2>()
1110 .Delete(r => r.Id == RID && r.TestField.Equals(TestEnum2.Value2)));
1111 }
1112 });
1113 }
1114
1115 [Test]
1116 public void EnumMapCustomPredicate1([DataContexts] string context)
1117 {
1118 using (var db = GetDataContext(context))
1119 {
1120 using (new Cleaner(db))
1121 {
1122 db.GetTable<RawTable>().Insert(() => new RawTable
1123 {
1124 Id = RID,
1125 TestField = VAL2
1126 });
1127
1128 var entityParameter = Expression.Parameter(typeof(TestTable1), "entity"); // parameter name required for BLToolkit
1129 var filterExpression = Expression.Equal(Expression.Field(entityParameter, "TestField"), Expression.Constant(TestEnum1.Value2));
1130 var filterPredicate = Expression.Lambda<Func<TestTable1, bool>>(filterExpression, entityParameter);
1131 var result = db.GetTable<TestTable1>().Where(filterPredicate).ToList();
1132
1133 Assert.AreEqual(1, result.Count);
1134 }
1135 }
1136 }
1137
1138 [Test]
1139 public void EnumMapCustomPredicate2([DataContexts] string context)
1140 {
1141 using (var db = GetDataContext(context))
1142 {
1143 using (new Cleaner(db))
1144 {
1145 db.GetTable<RawTable>().Insert(() => new RawTable
1146 {
1147 Id = RID,
1148 TestField = VAL2
1149 });
1150
1151 var entityParameter = Expression.Parameter(typeof(TestTable2), "entity"); // parameter name required for BLToolkit
1152 var filterExpression = Expression.Equal(Expression.Field(entityParameter, "TestField"), Expression.Constant(TestEnum2.Value2));
1153 var filterPredicate = Expression.Lambda<Func<TestTable2, bool>>(filterExpression, entityParameter);
1154 var result = db.GetTable<TestTable2>().Where(filterPredicate).ToList();
1155
1156 Assert.AreEqual(1, result.Count);
1157 }
1158 }
1159 }
1160
1161 [TableName("LinqDataTypes")]
1162 class TestTable3
1163 {
1164 [PrimaryKey]
1165 public int ID;
1166
1167 [MapField("BigIntValue")]
1168 public TestEnum1? TargetType;
1169
1170 [MapField("IntValue")]
1171 public int? TargetID;
1172 }
1173
1174 struct ObjectReference
1175 {
1176 public TestEnum1 TargetType;
1177 public int TargetID;
1178 public ObjectReference(TestEnum1 targetType, int tagetId)
1179 {
1180 TargetType = targetType;
1181 TargetID = tagetId;
1182 }
1183 }
1184
1185 [Test]
1186 public void Test_4_1_18_Regression1()
1187 {
1188 ForEachProvider(db =>
1189 {
1190 using (new Cleaner(db))
1191 {
1192 db.GetTable<RawTable>().Insert(() => new RawTable()
1193 {
1194 Id = RID,
1195 TestField = VAL2,
1196 Int32Field = 10
1197 });
1198
1199 var result = db.GetTable<TestTable3>().Where(r => r.ID == RID).Select(_ => new
1200 {
1201 Target = _.TargetType != null && _.TargetID != null
1202 ? new ObjectReference(_.TargetType.Value, _.TargetID.Value)
1203 : default(ObjectReference?)
1204 })
1205 .ToArray();
1206
1207 Assert.AreEqual(1, result.Length);
1208 Assert.NotNull(result[0].Target);
1209 Assert.AreEqual(10, result[0].Target.Value.TargetID);
1210 Assert.AreEqual(TestEnum1.Value2, result[0].Target.Value.TargetType);
1211 }
1212 });
1213 }
1214
1215 [TableName("LinqDataTypes")]
1216 class TestTable4
1217 {
1218 [PrimaryKey]
1219 public int ID;
1220
1221 [MapField("BigIntValue")]
1222 public TestEnum2? TargetType;
1223
1224 [MapField("IntValue")]
1225 public int? TargetID;
1226 }
1227
1228 struct ObjectReference2
1229 {
1230 public TestEnum2 TargetType;
1231 public int TargetID;
1232 public ObjectReference2(TestEnum2 targetType, int tagetId)
1233 {
1234 TargetType = targetType;
1235 TargetID = tagetId;
1236 }
1237 }
1238
1239 [Test]
1240 public void Test_4_1_18_Regression2()
1241 {
1242 ForEachProvider(db =>
1243 {
1244 using (new Cleaner(db))
1245 {
1246 db.GetTable<RawTable>().Insert(() => new RawTable()
1247 {
1248 Id = RID,
1249 TestField = (long)TestEnum2.Value2,
1250 Int32Field = 10
1251 });
1252
1253 var result = db.GetTable<TestTable4>().Where(r => r.ID == RID).Select(_ => new
1254 {
1255 Target = _.TargetType != null && _.TargetID != null
1256 ? new ObjectReference2(_.TargetType.Value, _.TargetID.Value)
1257 : default(ObjectReference2?)
1258 })
1259 .ToArray();
1260
1261 Assert.AreEqual(1, result.Length);
1262 Assert.NotNull(result[0].Target);
1263 Assert.AreEqual(10, result[0].Target.Value.TargetID);
1264 Assert.AreEqual(TestEnum2.Value2, result[0].Target.Value.TargetType);
1265 }
1266 });
1267 }
1268
1269 class NullableResult
1270 {
1271 public TestEnum1? Value;
1272 }
1273
1274 [Test]
1275 public void EnumMapSelectNull([DataContexts] string context)
1276 {
1277 using (var db = GetDataContext(context))
1278 {
1279 using (new Cleaner(db))
1280 {
1281 db.GetTable<RawTable>().Insert(() => new RawTable
1282 {
1283 Id = RID
1284 });
1285
1286 var result = db.GetTable<TestTable1>()
1287 .Where(r => r.Id == RID)
1288 .Select(r => new NullableResult {Value = r.TestField })
1289 .FirstOrDefault();
1290
1291 Assert.NotNull(result);
1292 Assert.Null(result.Value);
1293 }
1294 }
1295 }
1296
1297 private TestEnum1 Convert(TestEnum1 val)
1298 {
1299 return val;
1300 }
1301
1302 [Test]
1303 public void EnumMapSelectNull_Regression([DataContexts] string context)
1304 {
1305 using (var db = GetDataContext(context))
1306 {
1307 using (new Cleaner(db))
1308 {
1309 db.GetTable<RawTable>().Insert(() => new RawTable
1310 {
1311 Id = RID,
1312 TestField = VAL2
1313 });
1314
1315 var result = db.GetTable<TestTable1>()
1316 .Where(r => r.Id == RID)
1317 .Select(r => new NullableResult { Value = Convert(r.TestField) })
1318 .FirstOrDefault();
1319
1320 Assert.NotNull(result);
1321 Assert.That(result.Value, Is.EqualTo(TestEnum1.Value2));
1322 }
1323 }
1324 }
1325
1326 [Flags]
1327 enum TestFlag
1328 {
1329 Value1 = 0x1,
1330 Value2 = 0x2
1331 }
1332
1333 [TableName("LinqDataTypes")]
1334 class TestTable5
1335 {
1336 public int ID;
1337 public TestFlag IntValue;
1338 }
1339
1340 [Test]
1341 public void TestFlagEnum([DataContexts(ProviderName.Access)] string context)
1342 {
1343 using (var db = GetDataContext(context))
1344 {
1345 var result =
1346 from t in db.GetTable<TestTable5>()
1347 where (t.IntValue & TestFlag.Value1) != 0
1348 select t;
1349
1350 var sql = result.ToString();
1351
1352 Assert.That(sql, Is.Not.Contains("Convert"));
1353 }
1354 }
1355
1356 [Test]
1357 public void EnumMapContainsList1()
1358 {
1359 ForEachProvider(db =>
1360 {
1361 using (new Cleaner(db))
1362 {
1363 db.GetTable<RawTable>().Insert(() => new RawTable
1364 {
1365 Id = RID,
1366 TestField = VAL2
1367 });
1368
1369 var set = new HashSet<TestEnum1>();
1370 set.Add(TestEnum1.Value2);
1371
1372 Assert.That(db.GetTable<TestTable1>()
1373 .Where(r => r.Id == RID && set.Contains(r.TestField)).Count(), Is.EqualTo(1));
1374 Assert.That(db.GetTable<TestTable1>()
1375 .Where(r => r.Id == RID && !set.Contains(r.TestField)).Count(), Is.EqualTo(0));
1376 }
1377 });
1378 }
1379
1380 [Test]
1381 public void EnumMapContainsList2()
1382 {
1383 ForEachProvider(db =>
1384 {
1385 using (new Cleaner(db))
1386 {
1387 db.GetTable<RawTable>().Insert(() => new RawTable
1388 {
1389 Id = RID,
1390 TestField = VAL2
1391 });
1392
1393 var set = new HashSet<TestEnum2>();
1394 set.Add(TestEnum2.Value2);
1395
1396 Assert.That(db.GetTable<TestTable2>().Where(r => r.Id == RID && set.Contains(r.TestField)).Count(), Is.EqualTo(1));
1397 Assert.That(db.GetTable<TestTable2>().Where(r => r.Id == RID && !set.Contains(r.TestField)).Count(), Is.EqualTo(0));
1398 }
1399 });
1400 }
1401
1402 [Test]
1403 public void EnumMapContainsList3()
1404 {
1405 ForEachProvider(db =>
1406 {
1407 using (new Cleaner(db))
1408 {
1409 db.GetTable<RawTable>().Insert(() => new RawTable
1410 {
1411 Id = RID,
1412 TestField = VAL2
1413 });
1414
1415 var set = new HashSet<TestEnum1?>();
1416 set.Add(TestEnum1.Value2);
1417
1418 Assert.That(db.GetTable<NullableTestTable1>()
1419 .Where(r => r.Id == RID && set.Contains(r.TestField)).Count(), Is.EqualTo(1));
1420 Assert.That(db.GetTable<NullableTestTable1>()
1421 .Where(r => r.Id == RID && !set.Contains(r.TestField)).Count(), Is.EqualTo(0));
1422 }
1423 });
1424 }
1425
1426 [Test]
1427 public void EnumMapContainsList4()
1428 {
1429 ForEachProvider(db =>
1430 {
1431 using (new Cleaner(db))
1432 {
1433 db.GetTable<RawTable>().Insert(() => new RawTable
1434 {
1435 Id = RID,
1436 TestField = VAL2
1437 });
1438
1439 var set = new HashSet<TestEnum2?>();
1440 set.Add(TestEnum2.Value2);
1441
1442 Assert.That(db.GetTable<NullableTestTable2>()
1443 .Where(r => r.Id == RID && set.Contains(r.TestField)).Count(), Is.EqualTo(1));
1444 Assert.That(db.GetTable<NullableTestTable2>()
1445 .Where(r => r.Id == RID && !set.Contains(r.TestField)).Count(), Is.EqualTo(0));
1446 }
1447 });
1448 }
1449
1450 [Test]
1451 public void EnumMapIntermediateObject1()
1452 {
1453 ForEachProvider(db =>
1454 {
1455 using (new Cleaner(db))
1456 {
1457 db.GetTable<RawTable>().Insert(() => new RawTable
1458 {
1459 Id = RID,
1460 TestField = VAL2
1461 });
1462
1463 Assert.That(
1464 db.GetTable<TestTable1>()
1465 .Select(r => new {r.Id, r.TestField})
1466 .Where(r => r.Id == RID && r.TestField == TestEnum1.Value2).Count(), Is.EqualTo(1));
1467 }
1468 });
1469 }
1470
1471 //////[Test]
1472 public void EnumMapIntermediateObject2()
1473 {
1474 ForEachProvider(db =>
1475 {
1476 using (new Cleaner(db))
1477 {
1478 db.GetTable<RawTable>().Insert(() => new RawTable
1479 {
1480 Id = RID,
1481 TestField = VAL2
1482 });
1483
1484 Assert.That(
1485 db.GetTable<TestTable2>()
1486 .Select(r => new { r.Id, r.TestField })
1487 .Where(r => r.Id == RID && r.TestField == TestEnum2.Value2).Count(), Is.EqualTo(1));
1488 }
1489 });
1490 }
1491
1492 [Test]
1493 public void EnumMapIntermediateObject3()
1494 {
1495 ForEachProvider(db =>
1496 {
1497 using (new Cleaner(db))
1498 {
1499 db.GetTable<RawTable>().Insert(() => new RawTable
1500 {
1501 Id = RID,
1502 TestField = VAL2
1503 });
1504
1505 Assert.That(
1506 db.GetTable<NullableTestTable1>()
1507 .Select(r => new { r.Id, r.TestField })
1508 .Where(r => r.Id == RID && r.TestField == TestEnum1.Value2).Count(), Is.EqualTo(1));
1509 }
1510 });
1511 }
1512
1513 //////[Test]
1514 public void EnumMapIntermediateObject4()
1515 {
1516 ForEachProvider(db =>
1517 {
1518 using (new Cleaner(db))
1519 {
1520 db.GetTable<RawTable>().Insert(() => new RawTable
1521 {
1522 Id = RID,
1523 TestField = VAL2
1524 });
1525
1526 Assert.That(
1527 db.GetTable<NullableTestTable2>()
1528 .Select(r => new { r.Id, r.TestField })
1529 .Where(r => r.Id == RID && r.TestField == TestEnum2.Value2).Count(), Is.EqualTo(1));
1530 }
1531 });
1532 }
1533 }
1534 }