Exemplo n.º 1
0
        public void LiftedArithmeticPlusSerializeTest()
        {
            Expression <Func <SecurityDbContext, int?, bool> > criteria = (db, obj) => obj + 1 < 5;
            CriteriaSerializer criteriaSerializer = new CriteriaSerializer();
            XElement           serialized         = criteriaSerializer.SerializeAsXElement(criteria);

            string   objectType = "System.Nullable`1|System.Int32";
            XElement nominal    = SerializeTestHelper.CreateBaseCriteriaXElement(objectType);

            XElement left = SerializeTestHelper.GetBinaryExpression("Add",
                                                                    SerializeTestHelper.SetLifted(SerializeTestHelper.GetConstantConvertUnaryExpression(objectType, "System.Int32", "1"), true, true),
                                                                    SerializeTestHelper.GetParameterExpression(objectType, "obj"),
                                                                    objectType);
            XElement right = SerializeTestHelper.GetConstantConvertUnaryExpression(objectType, "System.Int32", "5");

            SerializeTestHelper.SetLifted(left, true, true);
            SerializeTestHelper.SetLifted(right, true, true);

            XElement body = SerializeTestHelper.GetBinaryExpression("LessThan", right, left);

            SerializeTestHelper.SetLifted(body, true, false);

            SerializeTestHelper.SetLambdaBody(nominal, body);
            SerializeTestHelper.CheckIfNominalAndSerializedAreEqual(nominal, serialized);
        }
Exemplo n.º 2
0
        public void TwoPropertiesWithImplicitConversionSerializeTest()
        {
            Expression <Func <SecurityDbContext, DbContextObject1, bool> > criteria = (db, obj) => obj.ItemCount < obj.DecimalItem;
            CriteriaSerializer criteriaSerializer = new CriteriaSerializer();
            XElement           serialized         = criteriaSerializer.SerializeAsXElement(criteria);

            string property1Type = "System.Int32";
            string property2Type = "System.Decimal";
            string property1Name = "ItemCount";
            string property2Name = "DecimalItem";
            string objectName    = "obj";
            string objectType    = "DevExpress.EntityFramework.SecurityDataStore.Tests.DbContexts.DbContextObject1";

            XElement nominal = SerializeTestHelper.CreateBaseCriteriaXElement(objectType);

            XElement implicitConversionMethod = SerializeTestHelper.GetSingleParameterMethod("op_Implicit", "System.Decimal", "System.Int32");
            XElement lessThanMethod           = SerializeTestHelper.GetMethod("op_LessThan", "System.Decimal", new string[] { "System.Decimal", "System.Decimal" });

            XElement right = SerializeTestHelper.GetMemberExpression(objectType, objectName, property2Type, property2Name);
            XElement left  = SerializeTestHelper.GetMemberConvertUnaryExpression(property2Type, objectType, objectName, property1Type, property1Name);

            SerializeTestHelper.SetMethodElement(left, implicitConversionMethod);

            XElement body = SerializeTestHelper.GetBinaryExpression("LessThan",
                                                                    right,
                                                                    left
                                                                    );

            SerializeTestHelper.SetMethodElement(body, lessThanMethod);

            SerializeTestHelper.SetLambdaBody(nominal, body);
            SerializeTestHelper.CheckIfNominalAndSerializedAreEqual(nominal, serialized);
        }
        public void ComplexDeserializeTest()
        {
            Expression <Func <DbContextMultiClass, DbContextObject1, bool> > criteria = (db, obj) => obj.ItemCount < db.dbContextDbSet1.Count();

            string propertyType         = "System.Int32";
            string objectType           = "DevExpress.EntityFramework.SecurityDataStore.Tests.DbContexts.DbContextObject1";
            string dbContextType        = "DevExpress.EntityFramework.SecurityDataStore.Tests.DbContexts.DbContextMultiClass";
            string methodCallResultType = "System.Int32";
            string methodObjectType     = "System.Linq.Queryable";
            string methodParameterType  = "System.Linq.IQueryable`1|DevExpress.EntityFramework.SecurityDataStore.Tests.DbContexts.DbContextObject1";
            string dbSetMemberType      = "Microsoft.EntityFrameworkCore.DbSet`1|DevExpress.EntityFramework.SecurityDataStore.Tests.DbContexts.DbContextObject1";
            string dbSetPropertyName    = "dbContextDbSet1";
            string dbSetType            = "DevExpress.EntityFramework.SecurityDataStore.Tests.DbContexts.DbContextMultiClass";

            XElement nominal = SerializeTestHelper.CreateBaseCriteriaXElement(objectType, dbContextType);

            XElement memberExpression = new XElement("MemberExpression",
                                                     new XAttribute("NodeType", "MemberAccess"),
                                                     new XAttribute("CanReduce", "false"),
                                                     SerializeTestHelper.GetTypeElement(dbSetMemberType),
                                                     new XElement("Member",
                                                                  new XAttribute("MemberType", "Property"),
                                                                  new XAttribute("PropertyName", dbSetPropertyName),
                                                                  new XElement("DeclaringType",
                                                                               new XElement("Type",
                                                                                            new XAttribute("Name", dbSetType)
                                                                                            )
                                                                               )
                                                                  ),
                                                     new XElement("Expression",
                                                                  SerializeTestHelper.GetParameterExpression(dbContextType, "db")
                                                                  )
                                                     );

            XElement right = new XElement("MethodCallExpression",
                                          new XAttribute("NodeType", "Call"),
                                          new XAttribute("CanReduce", "false"),
                                          SerializeTestHelper.GetTypeElement(methodCallResultType),
                                          SerializeTestHelper.GetSingleParameterMethod("Count", methodObjectType, methodParameterType, new string[] { objectType }),
                                          new XElement("Object"),
                                          new XElement("Arguments",
                                                       memberExpression
                                                       )
                                          );

            XElement body = SerializeTestHelper.GetBinaryExpression("LessThan",
                                                                    right,
                                                                    SerializeTestHelper.GetMemberExpression(objectType, "obj", propertyType, "ItemCount"));

            SerializeTestHelper.SetLambdaBody(nominal, body);

            CriteriaSerializer criteriaSerializer = new CriteriaSerializer();

            criteriaSerializer.RegisterAdditionalAssemblies(GetAdditionalAssemblies());
            Expression deserializedCriteria = criteriaSerializer.Deserialize(nominal);

            SerializeTestHelper.CheckIfExpressionsAreEqual(criteria, deserializedCriteria);
        }
Exemplo n.º 4
0
        public void LogicalOrSerializeTest()
        {
            Expression <Func <SecurityDbContext, int, bool> > criteria = (db, obj) => obj < 5 || obj > 1;
            CriteriaSerializer criteriaSerializer = new CriteriaSerializer();
            XElement           serialized         = criteriaSerializer.SerializeAsXElement(criteria);
            XElement           nominal            = SerializeTestHelper.CreateBaseCriteriaXElementWithIntObj();

            XElement left  = SerializeTestHelper.GetIntegerBinaryExpression("LessThan", "5");
            XElement right = SerializeTestHelper.GetIntegerBinaryExpression("GreaterThan", "1");

            XElement body = SerializeTestHelper.GetBinaryExpression("OrElse", right, left);

            SerializeTestHelper.SetLambdaBody(nominal, body);
            SerializeTestHelper.CheckIfNominalAndSerializedAreEqual(nominal, serialized);
        }
Exemplo n.º 5
0
        public void ConvertToDoubleSerializeTest()
        {
            Expression <Func <SecurityDbContext, int, bool> > criteria = (db, obj) => obj / 2.0 < 5.2;
            CriteriaSerializer criteriaSerializer = new CriteriaSerializer();
            XElement           serialized         = criteriaSerializer.SerializeAsXElement(criteria);
            XElement           nominal            = SerializeTestHelper.CreateBaseCriteriaXElementWithIntObj();

            XElement left = SerializeTestHelper.GetBinaryExpression("Divide",
                                                                    SerializeTestHelper.GetConstantExpression("System.Double", "2"),
                                                                    SerializeTestHelper.GetParameterConvertUnaryExpression("System.Double", "System.Int32", "obj"),
                                                                    "System.Double");
            XElement right = SerializeTestHelper.GetConstantExpression("System.Double", "5.2");
            XElement body  = SerializeTestHelper.GetBinaryExpression("LessThan", right, left);

            SerializeTestHelper.SetLambdaBody(nominal, body);
            SerializeTestHelper.CheckIfNominalAndSerializedAreEqual(nominal, serialized);
        }
Exemplo n.º 6
0
        public void ArithmeticXorSerializeTest()
        {
            Expression <Func <SecurityDbContext, int, bool> > criteria = (db, obj) => (obj ^ 2) < 5;
            CriteriaSerializer criteriaSerializer = new CriteriaSerializer();
            XElement           serialized         = criteriaSerializer.SerializeAsXElement(criteria);
            XElement           nominal            = SerializeTestHelper.CreateBaseCriteriaXElementWithIntObj();

            XElement left = SerializeTestHelper.GetBinaryExpression("ExclusiveOr",
                                                                    SerializeTestHelper.GetConstantExpression("System.Int32", "2"),
                                                                    SerializeTestHelper.GetParameterExpression("System.Int32", "obj"),
                                                                    "System.Int32");
            XElement right = SerializeTestHelper.GetConstantExpression("System.Int32", "5");
            XElement body  = SerializeTestHelper.GetBinaryExpression("LessThan", right, left);

            SerializeTestHelper.SetLambdaBody(nominal, body);
            SerializeTestHelper.CheckIfNominalAndSerializedAreEqual(nominal, serialized);
        }
        public void LogicalAndDeserializeTest()
        {
            Expression <Func <SecurityDbContext, int, bool> > criteria = (db, obj) => obj < 5 && obj > 1;

            XElement nominal = SerializeTestHelper.CreateBaseCriteriaXElementWithIntObj();
            XElement left    = SerializeTestHelper.GetIntegerBinaryExpression("LessThan", "5");
            XElement right   = SerializeTestHelper.GetIntegerBinaryExpression("GreaterThan", "1");

            XElement body = SerializeTestHelper.GetBinaryExpression("AndAlso", right, left);

            SerializeTestHelper.SetLambdaBody(nominal, body);

            CriteriaSerializer criteriaSerializer   = new CriteriaSerializer();
            Expression         deserializedCriteria = criteriaSerializer.Deserialize(nominal);

            SerializeTestHelper.CheckIfExpressionsAreEqual(criteria, deserializedCriteria);
        }
Exemplo n.º 8
0
        public void ObjectPropertyLessThanConstantSerializeTest()
        {
            Expression <Func <SecurityDbContext, DbContextObject1, bool> > criteria = (db, obj) => obj.ItemCount < 3;
            CriteriaSerializer criteriaSerializer = new CriteriaSerializer();
            XElement           serialized         = criteriaSerializer.SerializeAsXElement(criteria);

            string propertyType = "System.Int32";
            string objectType   = "DevExpress.EntityFramework.SecurityDataStore.Tests.DbContexts.DbContextObject1";

            XElement nominal = SerializeTestHelper.CreateBaseCriteriaXElement(objectType);

            XElement body = SerializeTestHelper.GetBinaryExpression("LessThan",
                                                                    SerializeTestHelper.GetConstantExpression("System.Int32", "3"),
                                                                    SerializeTestHelper.GetMemberExpression(objectType, "obj", propertyType, "ItemCount"));

            SerializeTestHelper.SetLambdaBody(nominal, body);
            SerializeTestHelper.CheckIfNominalAndSerializedAreEqual(nominal, serialized);
        }
Exemplo n.º 9
0
        public void NotEqualNullSerializeTest()
        {
            Expression <Func <SecurityDbContext, DbContextObject1, bool> > criteria = (db, obj) => obj != null;

            CriteriaSerializer criteriaSerializer = new CriteriaSerializer();
            XElement           serialized         = criteriaSerializer.SerializeAsXElement(criteria);

            string objectType = "DevExpress.EntityFramework.SecurityDataStore.Tests.DbContexts.DbContextObject1";

            XElement nominal = SerializeTestHelper.CreateBaseCriteriaXElement(objectType);

            XElement body = SerializeTestHelper.GetBinaryExpression("NotEqual",
                                                                    SerializeTestHelper.GetConstantExpression("System.Object", ""),
                                                                    SerializeTestHelper.GetParameterExpression(objectType, "obj"));

            SerializeTestHelper.SetLambdaBody(nominal, body);
            SerializeTestHelper.CheckIfNominalAndSerializedAreEqual(nominal, serialized);
        }
        public void ArithmeticOrDeserializeTest()
        {
            Expression <Func <SecurityDbContext, int, bool> > criteria = (db, obj) => (obj | 2) < 5;

            XElement nominal = SerializeTestHelper.CreateBaseCriteriaXElementWithIntObj();
            XElement left    = SerializeTestHelper.GetBinaryExpression("Or",
                                                                       SerializeTestHelper.GetConstantExpression("System.Int32", "2"),
                                                                       SerializeTestHelper.GetParameterExpression("System.Int32", "obj"),
                                                                       "System.Int32");
            XElement right = SerializeTestHelper.GetConstantExpression("System.Int32", "5");
            XElement body  = SerializeTestHelper.GetBinaryExpression("LessThan", right, left);

            SerializeTestHelper.SetLambdaBody(nominal, body);

            CriteriaSerializer criteriaSerializer   = new CriteriaSerializer();
            Expression         deserializedCriteria = criteriaSerializer.Deserialize(nominal);

            SerializeTestHelper.CheckIfExpressionsAreEqual(criteria, deserializedCriteria);
        }
Exemplo n.º 11
0
        public void ObjectNullablleIsNotNullSerializeTest()
        {
            Expression <Func <SecurityDbContext, DbContextObject1, bool> > criteria = (db, obj) => obj.ItemCountNull != null;

            CriteriaSerializer criteriaSerializer = new CriteriaSerializer();
            XElement           serialized         = criteriaSerializer.SerializeAsXElement(criteria);

            string   objectType   = "DevExpress.EntityFramework.SecurityDataStore.Tests.DbContexts.DbContextObject1";
            string   propertyType = "System.Nullable`1|System.Int32";
            XElement nominal      = SerializeTestHelper.CreateBaseCriteriaXElement(objectType);

            XElement left  = SerializeTestHelper.GetMemberExpression(objectType, "obj", propertyType, "ItemCountNull");
            XElement right = SerializeTestHelper.GetConstantExpression(propertyType, "");

            XElement body = SerializeTestHelper.GetBinaryExpression("NotEqual", right, left);

            SerializeTestHelper.SetLifted(body, true, false);

            SerializeTestHelper.SetLambdaBody(nominal, body);
            SerializeTestHelper.CheckIfNominalAndSerializedAreEqual(nominal, serialized);
        }
        public void NotEqualNullDeserializeTest()
        {
            Expression <Func <SecurityDbContext, DbContextObject1, bool> > criteria = (db, obj) => obj != null;

            string objectType = "DevExpress.EntityFramework.SecurityDataStore.Tests.DbContexts.DbContextObject1";

            XElement nominal = SerializeTestHelper.CreateBaseCriteriaXElement(objectType);

            XElement body = SerializeTestHelper.GetBinaryExpression("NotEqual",
                                                                    SerializeTestHelper.GetConstantExpression("System.Object", ""),
                                                                    SerializeTestHelper.GetParameterExpression(objectType, "obj"));

            SerializeTestHelper.SetLambdaBody(nominal, body);

            CriteriaSerializer criteriaSerializer = new CriteriaSerializer();

            criteriaSerializer.RegisterAdditionalAssemblies(GetAdditionalAssemblies());
            Expression deserializedCriteria = criteriaSerializer.Deserialize(nominal);

            SerializeTestHelper.CheckIfExpressionsAreEqual(criteria, deserializedCriteria);
        }
        public void MultipleDeserializeTest()
        {
            Expression <Func <SecurityDbContext, int, bool> > criteria = (db, obj) => obj < 5;
            XElement nominal = SerializeTestHelper.CreateBaseCriteriaXElementWithIntObj();

            XElement body = SerializeTestHelper.GetIntegerBinaryExpression("LessThan", "5");

            SerializeTestHelper.SetLambdaBody(nominal, body);

            CriteriaSerializer criteriaSerializer = new CriteriaSerializer();

            criteriaSerializer.RegisterAdditionalAssemblies(GetAdditionalAssemblies());

            Expression deserializedCriteria = criteriaSerializer.Deserialize(nominal);

            SerializeTestHelper.CheckIfExpressionsAreEqual(criteria, deserializedCriteria);

            Expression <Func <SecurityDbContext, DbContextObject1, bool> > criteria2 = (db, obj) => obj.ItemCount < 3;

            string propertyType = "System.Int32";
            string objectType   = "DevExpress.EntityFramework.SecurityDataStore.Tests.DbContexts.DbContextObject1";

            XElement nominal2 = SerializeTestHelper.CreateBaseCriteriaXElement(objectType);

            XElement body2 = SerializeTestHelper.GetBinaryExpression("LessThan",
                                                                     SerializeTestHelper.GetConstantExpression("System.Int32", "3"),
                                                                     SerializeTestHelper.GetMemberExpression(objectType, "obj", propertyType, "ItemCount"));

            SerializeTestHelper.SetLambdaBody(nominal2, body2);

            Expression deserializedCriteria2 = criteriaSerializer.Deserialize(nominal2);

            SerializeTestHelper.CheckIfExpressionsAreEqual(criteria2, deserializedCriteria2);

            SerializeTestHelper.CheckIfExpressionsAreEqual(criteria, deserializedCriteria);
        }