示例#1
0
        public void TestEmptListThrowsExceptionOk()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP

                //ATTEMPT
                Assert.Throws <ArgumentException>(() => env.CompareAndLogList(new String[] { }, new String[] {}));

                //VERIFY
            }
        }
示例#2
0
        public void TestSupportedSingleOk()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP

                //ATTEMPT
                env.CompareAndLogSingleton(1, 1);

                //VERIFY
                classEnv.GetLastMethodLog().State.ShouldEqual(LogStates.Supported);
            }
        }
示例#3
0
        public void TestNoSupportedListResultsWrongOk()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP

                //ATTEMPT
                Assert.Throws <AssertionException>(() => env.CompareAndLogList(new String[] { "fred" }, new String[] { }));

                //VERIFY
                classEnv.GetLastMethodLog().State.ShouldEqual(LogStates.NotSupported);
            }
        }
示例#4
0
        public void TestSupportedListOk()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP

                //ATTEMPT
                env.CompareAndLogList(new String[] { "fred" }, new String[] { "fred" });

                //VERIFY
                classEnv.GetLastMethodLog().State.ShouldEqual(LogStates.Supported);
            }
        }
示例#5
0
        public void TestNotSupportedSingleResultsWrongOk()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP

                //ATTEMPT
                Assert.Throws <AssertionException>(() => env.CompareAndLogSingleton(1, 2));

                //VERIFY
                classEnv.GetLastMethodLog().State.ShouldEqual(LogStates.NotSupported);
            }
        }
示例#6
0
        public static CSTMethod Translate(MethodEnvironment methEnv, JST.NameSupply nameSupply, CSTWriter trace)
        {
            // Infer machine states for each control point
            var machineStateInference = new MachineStateInference(methEnv, trace);

            machineStateInference.Infer();

            if (trace != null)
            {
                trace.Trace
                    ("After machine state inference",
                    w =>
                {
                    methEnv.Method.AppendDefinition(w);
                    w.EndLine();
                });
            }

            // Translate to basic-blocks which use structural control flow where possible
            var controlFlowRecovery = new ControlFlowRecovery(methEnv, nameSupply.GenSym, -1, trace);
            var root = controlFlowRecovery.Root();

            if (trace != null)
            {
                trace.Trace
                    ("After control flow recovery",
                    w =>
                {
                    root.AppendAll(w);
                    w.EndLine();
                });
            }

            var initState = root.Targets[0].Block.BeforeState;
            var compEnv   = methEnv.AddVariables(nameSupply, i => initState.ArgLocalIsAlive(ArgLocal.Local, i));

            // Translate to intermediate statements/expressions/cells language
            var translator = new Translator
                                 (compEnv, nameSupply, controlFlowRecovery.NextInstructionId, trace);
            var body = translator.Translate(root);

            var res = new CSTMethod(compEnv, body);

            if (trace != null)
            {
                trace.Trace("After translation to intermediate representation", res.Append);
            }

            return(res);
        }
示例#7
0
        public async Task TestAsync()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = await env.Db.EfParents.ToListAsync();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = await env.Db.EfParents.DecompileAsync().ToListAsync();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#8
0
        public void TestAllFilterOnChildrenInt()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.EfParents.Select(x => x.Children.All(y => y.ChildInt == 123)).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.Select(x => x.AllFilterOnChildrenInt).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
        public void TestSelectMethodWithoutComputedAttribute()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.EfPersons.Select(x => x.FirstName + " " + x.MiddleName + " " + x.LastName).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfPersons.Select(x => x.GetFullNameNoAttibute()).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
        public void TestSelectMultipleLevelsOfAbstractMembersOverTphHierarchy()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.LivingBeeing.OfType <Animal>().ToList().Select(p => p.Species + " : " + p.IsPet).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.LivingBeeing.OfType <Animal>().Select(p => p.Species + " : " + p.IsPet).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
        public void TestSelectAbstractMemberOverTphHierarchyAfterRestrictingToSubtype()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.LivingBeeing.OfType <Animal>().ToList().Select(p => p.Species).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.LivingBeeing.OfType <Animal>().Select(p => p.Species).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#12
0
        public void TestWhereFiltersOnMultipleLevelsOfAbstractMembersOverTphHierarchy()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.LivingBeeing.OfType <Animal>().ToList().Where(p => string.Concat(p.Species, " : ", p.IsPet) == "Apis mellifera : False").Select(x => x.Id).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.LivingBeeing.OfType <Animal>().Where(p => string.Concat(p.Species, " : ", p.IsPet) == "Apis mellifera : False").Select(x => x.Id).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#13
0
        public void TestWhereFiltersOnAbstractMembersOverTphHierarchy()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.LivingBeeing.ToList().Where(x => x.Species == "Human").Select(x => x.Id).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.LivingBeeing.Where(x => x.Species == "Human").Select(x => x.Id).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#14
0
        public async Task TestDecompileUpfrontBoolEqualsConstantAsync()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = await env.Db.EfParents.Select(x => x.ParentBool == true).ToListAsync();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = await env.Db.EfParents.DecompileAsync().Select(x => x.BoolEqualsConstant).ToListAsync();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#15
0
        public void TestDateTimeWhereCompareWithStaticVariable()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.EfParents.Where(x => x.StartDate > dateConst).Select(x => x.StartDate).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.Where(x => x.StartDateGreaterThanStaticVar).Select(x => x.StartDate).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
        public void TestIntEqualsConstant()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.EfParents.Select(x => x.ParentNullableInt == 123).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.Select(x => x.ParentNullableIntEqualsConstant).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
        public void TestNullableAdd()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.EfParents.Select(x => x.ParentNullableDecimal1 + x.ParentNullableDecimal2).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.Select(x => x.ParentNullableDecimalAdd).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#18
0
        public void TestWhereBoolEqualsStaticVariable()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.EfParents.Where(x => x.ParentBool == staticBool).Select(x => x.EfParentId).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.Where(x => x.BoolEqualsStaticVariable).Select(x => x.EfParentId).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#19
0
        public void TestSingletonAllFilter()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.EfParents.All(x => x.ParentInt == 123);

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.Decompile().All(x => x.IntEqualsConstant);

                //VERIFY
                env.CompareAndLogSingleton(linq, dd);
            }
        }
        public void TestConcatenatePersonHandleNull()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.EfPersons.Select(x => x.FirstName + (x.MiddleName == null ? "" : " ") + x.MiddleName + " " + x.LastName).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfPersons.Select(x => x.FullNameHandleNull).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#21
0
        public void TestIntNotEqualsStringLength()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = env.Db.EfParents.Select(x => x.ParentInt != x.ParentString.Length).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.Select(x => x.IntNotEqualsStringLength).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
        public async Task TestBoolEqualsStaticVariableToArrayAsync()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq = await env.Db.EfParents.Select(x => x.ParentBool == staticBool).ToListAsync();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = await env.Db.EfParents.Select(x => x.BoolEqualsStaticVariable).DecompileAsync().ToListAsync();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#23
0
        public void TestCountChildrenWithFilterByClosure()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP

                var linq = env.Db.EfParents.Select(x => x.Children.Count(y => y.ChildInt == x.EfParentId)).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.Select(x => x.CountChildrenWithFilterByClosure).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#24
0
        public void TestSingletonCountChildrenWithFilter()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP

                var linq = env.Db.EfParents.Count(x => x.Children.Count() == 2);

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.Decompile().Count(x => x.CountChildren == 2);

                //VERIFY
                env.CompareAndLogSingleton(linq, dd);
            }
        }
示例#25
0
        public void TestStringContainsConstantStringWithFilter()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP
                var linq =
                    env.Db.EfParents.Where(x => x.ParentString.Contains("2")).Select(x => x.ParentString).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.Where(x => x.StringContainsConstantString).Select(x => x.ParentString).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
        public async Task TestCountChildrenWithFilterAsync()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP

                var linq = await env.Db.EfParents.Select(x => x.Children.Count(y => y.ChildInt == 123)).ToListAsync();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = await env.Db.EfParents.Select(x => x.CountChildrenWithFilter).DecompileAsync().ToListAsync();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#27
0
        public void TestSumCountInChildrenWhereChildrenCanBeNone()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP

                var linq = env.Db.EfParents.Select(x => x.Children.Sum(y => (int?)y.ChildInt) ?? 0).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.Select(x => x.SumIntInChildrenWhereChildrenCanBeNone).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#28
0
        public void TestOrderByChildrenCountThenByStringLength()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP

                var linq = env.Db.EfParents.OrderBy(x => x.Children.Count).ThenBy(x => x.ParentString.Length).Select(x => x.EfParentId).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.OrderBy(x => x.CountChildren).ThenBy(x => x.GetStringLength).Select(x => x.EfParentId).Decompile().ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
        public void TestWhereAnyChildrenThenOrderByThenSkipTake()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP

                var linq = env.Db.EfParents.Where(x => x.Children.Any()).OrderBy(x => x.Children.Count).Select(x => x.EfParentId).Skip(1).Take(1).ToList();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = env.Db.EfParents.Where(x => x.AnyChildren).OrderBy(x => x.CountChildren).Select(x => x.EfParentId).Decompile().Skip(1).Take(1).ToList();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
        public async Task TestCountChildrenWithFilterByExternalClosure2Async()
        {
            using (var env = new MethodEnvironment(classEnv))
            {
                //SETUP

                var i    = 123;
                var j    = 456;
                var linq = await env.Db.EfParents.Select(x => x.Children.Count(y => y.ChildInt == i && y.EfParentId == j)).ToListAsync();

                //ATTEMPT
                env.AboutToUseDelegateDecompiler();
                var dd = await env.Db.EfParents.Select(x => x.GetCountChildrenWithFilterByExternalClosure(i, j)).DecompileAsync().ToListAsync();

                //VERIFY
                env.CompareAndLogList(linq, dd);
            }
        }
示例#31
0
        public static CSTMethod Translate(MethodEnvironment methEnv, JST.NameSupply nameSupply, CSTWriter trace)
        {
            // Infer machine states for each control point
            var machineStateInference = new MachineStateInference(methEnv, trace);
            machineStateInference.Infer();

            if (trace != null)
                trace.Trace
                    ("After machine state inference",
                     w =>
                         {
                             methEnv.Method.AppendDefinition(w);
                             w.EndLine();
                         });

            // Translate to basic-blocks which use structural control flow where possible
            var controlFlowRecovery = new ControlFlowRecovery(methEnv, nameSupply.GenSym, -1, trace);
            var root = controlFlowRecovery.Root();

            if (trace != null)
                trace.Trace
                    ("After control flow recovery",
                     w =>
                         {
                             root.AppendAll(w);
                             w.EndLine();
                         });

            var initState = root.Targets[0].Block.BeforeState;
            var compEnv = methEnv.AddVariables(nameSupply, i => initState.ArgLocalIsAlive(ArgLocal.Local, i));

            // Translate to intermediate statements/expressions/cells language
            var translator = new Translator
                (compEnv, nameSupply, controlFlowRecovery.NextInstructionId, trace);
            var body = translator.Translate(root);

            var res = new CSTMethod(compEnv, body);

            if (trace != null)
                trace.Trace("After translation to intermediate representation", res.Append);

            return res;
        }
示例#32
0
 public MachineStateInference(MethodEnvironment methEnv, CSTWriter tracer)
 {
     this.methEnv = methEnv;
     global = methEnv.Global;
     method = methEnv.Method;
     this.tracer = tracer;
     offsetToBeforeState = new Map<int, MachineState>();
     offsetToAfterState = new Map<int, MachineState>();
 }
示例#33
0
        public ControlFlowRecovery(MethodEnvironment methEnv, Func<JST.Identifier> gensym, int nextInstructionId, CSTWriter tracer)
        {
            this.methEnv = methEnv;
            method = methEnv.Method;
            this.gensym = gensym;
            this.tracer = tracer;

            targets = new Set<int>();
            nextBlockId = 0;
            NextInstructionId = nextInstructionId;
        }