Exemplo n.º 1
0
        public void LessThanFunctionCallSerializeTest()
        {
            Expression <Func <SecurityDbContext, int, bool> > criteria = (db, obj) => obj < getSomeValue();
            CriteriaSerializer criteriaSerializer = new CriteriaSerializer();
            XElement           serialized         = criteriaSerializer.SerializeAsXElement(criteria);
            XElement           nominal            = SerializeTestHelper.CreateBaseCriteriaXElementWithIntObj();

            XElement body = new XElement("BinaryExpression",
                                         new XAttribute("NodeType", "LessThan"),
                                         new XAttribute("CanReduce", "false"),
                                         new XAttribute("IsLifted", "false"),
                                         new XAttribute("IsLiftedToNull", "false"),
                                         SerializeTestHelper.GetTypeElement("System.Boolean"),
                                         new XElement("Right",
                                                      SerializeTestHelper.GetConstantExpression("System.Int32", "5")
                                                      ),
                                         new XElement("Left",
                                                      SerializeTestHelper.GetParameterExpression("System.Int32", "obj")
                                                      ),
                                         new XElement("Method"),
                                         new XElement("Conversion")
                                         );

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

            string propertyType        = "System.String";
            string methodResultType    = "System.Boolean";
            string methodObjectType    = "System.String";
            string methodParameterType = "System.String";
            string objectType          = "DevExpress.EntityFramework.SecurityDataStore.Tests.DbContexts.DbContextObject1";

            XElement nominal = SerializeTestHelper.CreateBaseCriteriaXElement(objectType);

            XElement body = new XElement("MethodCallExpression",
                                         new XAttribute("NodeType", "Call"),
                                         new XAttribute("CanReduce", "false"),
                                         SerializeTestHelper.GetTypeElement(methodResultType),
                                         SerializeTestHelper.GetSingleParameterMethod("StartsWith", methodObjectType, methodParameterType),
                                         new XElement("Object",
                                                      SerializeTestHelper.GetMemberExpression(objectType, "obj", propertyType, "Description")
                                                      ),
                                         new XElement("Arguments",
                                                      SerializeTestHelper.GetConstantExpression(methodParameterType, "hello")
                                                      )
                                         );

            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);
        }