Beispiel #1
0
        public void Test(string context)
        {
            var ms = new MappingSchema();

            ms.SetConvertExpression <bool, DataParameter>(_ => DataParameter.Char(null, _ ? 'Y' : 'N'));
            ms.SetConvertExpression <char, bool>(_ => _ == 'Y');
            ms.SetConvertExpression <string, bool>(_ => _.Trim() == "Y");

            ms.SetConvertExpression <Guid?, DataParameter>(_ => DataParameter.VarChar(null, _.ToString()));
            ms.SetConvertExpression <string, Guid?>(_ => Guid.Parse(_));

            using (var db = GetDataContext(context, ms))
                using (new LocalTable <TypeConvertTable>(db))
                {
                    var notVerified = new TypeConvertTable
                    {
                        Name      = "NotVerified",
                        BoolValue = false,
                        GuidValue = Guid.NewGuid()
                    };

                    var verified = new TypeConvertTable
                    {
                        Name      = "Verified",
                        BoolValue = true,
                        GuidValue = Guid.NewGuid()
                    };

                    db.Insert(notVerified);
                    db.Insert(verified);


                    Assert.AreEqual(1, db.GetTable <TypeConvertTableRaw>().Count(_ => _.BoolValue == 'N'));
                    Assert.AreEqual(1, db.GetTable <TypeConvertTableRaw>().Count(_ => _.BoolValue == 'Y'));
                    Assert.AreEqual(1, db.GetTable <TypeConvertTableRaw>().Count(_ => _.GuidValue == verified.GuidValue.ToString()));

                    Assert.AreEqual(notVerified, db.GetTable <TypeConvertTable>().First(_ => _.BoolValue == false));
                    Assert.AreEqual(verified, db.GetTable <TypeConvertTable>().First(_ => _.BoolValue == true));

                    Assert.AreEqual(notVerified, db.GetTable <TypeConvertTable>().First(_ => _.BoolValue != true));
                    Assert.AreEqual(verified, db.GetTable <TypeConvertTable>().First(_ => _.BoolValue != false));

                    Assert.AreEqual(notVerified, db.GetTable <TypeConvertTable>().First(_ => !_.BoolValue));
                    Assert.AreEqual(verified, db.GetTable <TypeConvertTable>().First(_ => _.BoolValue));

                    Assert.AreEqual(notVerified, db.GetTable <TypeConvertTable>().First(_ => _.BoolValue.Equals(false)));
                    Assert.AreEqual(verified, db.GetTable <TypeConvertTable>().First(_ => _.BoolValue.Equals(true)));

                    Assert.AreEqual(notVerified, db.GetTable <TypeConvertTable>().First(_ => !_.BoolValue.Equals(true)));
                    Assert.AreEqual(verified, db.GetTable <TypeConvertTable>().First(_ => !_.BoolValue.Equals(false)));

                    Assert.AreEqual(notVerified, db.GetTable <TypeConvertTable>().First(_ => _.GuidValue == notVerified.GuidValue));
                    Assert.AreEqual(verified, db.GetTable <TypeConvertTable>().First(_ => _.GuidValue == verified.GuidValue));
                }
        }
Beispiel #2
0
        public void Test([DataSources(ProviderName.SQLiteMS)] string context)
        {
            var ms = new MappingSchema();

            ms.SetConvertExpression <bool, DataParameter>(_ => DataParameter.Char(null, _ ? 'Y' : 'N'));
            ms.SetConvertExpression <char, bool>(_ => _ == 'Y');
            ms.SetConvertExpression <string, bool>(_ => _.Trim() == "Y");

            ms.SetConvertExpression <Guid?, DataParameter>(_ => DataParameter.VarChar(null, _.ToString()));
            ms.SetConvertExpression <string, Guid?>(_ => Guid.Parse(_));

            using (var db = GetDataContext(context, ms))
                using (var tbl = db.CreateLocalTable <TypeConvertTable>())
                {
                    var notVerified = new TypeConvertTable
                    {
                        Name      = "NotVerified",
                        BoolValue = false,
                        GuidValue = TestData.Guid1
                    };

                    var verified = new TypeConvertTable
                    {
                        Name      = "Verified",
                        BoolValue = true,
                        GuidValue = TestData.Guid2
                    };

                    db.Insert(notVerified, tbl.TableName);
                    db.Insert(verified, tbl.TableName);


                    Assert.AreEqual(1, db.GetTable <TypeConvertTableRaw>().TableName(tbl.TableName).Count(_ => _.BoolValue == 'N'));
                    Assert.AreEqual(1, db.GetTable <TypeConvertTableRaw>().TableName(tbl.TableName).Count(_ => _.BoolValue == 'Y'));
                    Assert.AreEqual(1, db.GetTable <TypeConvertTableRaw>().TableName(tbl.TableName).Count(_ => _.GuidValue == verified.GuidValue.ToString()));

                    Assert.AreEqual(notVerified, tbl.First(_ => _.BoolValue == false));
                    Assert.AreEqual(verified, tbl.First(_ => _.BoolValue == true));

                    Assert.AreEqual(notVerified, tbl.First(_ => _.BoolValue != true));
                    Assert.AreEqual(verified, tbl.First(_ => _.BoolValue != false));

                    Assert.AreEqual(notVerified, tbl.First(_ => !_.BoolValue));
                    Assert.AreEqual(verified, tbl.First(_ => _.BoolValue));

                    Assert.AreEqual(notVerified, tbl.First(_ => _.BoolValue.Equals(false)));
                    Assert.AreEqual(verified, tbl.First(_ => _.BoolValue.Equals(true)));

                    Assert.AreEqual(notVerified, tbl.First(_ => !_.BoolValue.Equals(true)));
                    Assert.AreEqual(verified, tbl.First(_ => !_.BoolValue.Equals(false)));

                    Assert.AreEqual(notVerified, tbl.First(_ => _.GuidValue == notVerified.GuidValue));
                    Assert.AreEqual(verified, tbl.First(_ => _.GuidValue == verified.GuidValue));
                }
        }