public void TestChangeScopeSpecificNextLevel() { GeneratedCode target = new GeneratedCode(); target.Add(new StatementInlineBlock()); IStatement s = new StatementInlineBlock(); var deepestStatementLevel = TestUtils.GetDeepestStatementLevel(target); var deepestDeclarLevel = TestUtils.GetDeepestBookingLevel(target); var currentS = target.CurrentScope; var curVars = deepestDeclarLevel.DeclaredVariables.Count(); var curStatements = deepestStatementLevel.Statements.Count(); var v1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); target.Add(v1); target.Add(s); target.CurrentScope = currentS; var v2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); target.Add(v2); s.Parent = null; target.Add(s); Assert.AreEqual(curStatements + 2, deepestStatementLevel.Statements.Count(), "Scope reset, should always be two extra statements here!"); Assert.AreEqual(curVars + 2, deepestDeclarLevel.DeclaredVariables.Count(), "Scope reset should have also reset where the variable was pointing"); }
public void TestForFunctionNumber() { CPPTranslator target = new CPPTranslator(); var vInt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); vInt.SetInitialValue("2"); GeneratedCode code = new GeneratedCode(); code.SetResult(vInt); var innerBlock = new StatementInlineBlock(); var vInt2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); vInt2.SetInitialValue("5"); innerBlock.Add(vInt2); code.Add(innerBlock); var r = TranslateGeneratedCode(target, code); Assert.IsTrue(r.ContainsKey("NumberOfQueryFunctions"), "Number of functions isn't here"); Assert.IsInstanceOfType(r["NumberOfQueryFunctions"], typeof(int), "# function type"); Assert.AreEqual(1, r["NumberOfQueryFunctions"], "# of functions"); Assert.IsTrue(r.ContainsKey("QueryFunctionBlocks"), "Missing query function blocks"); Assert.IsInstanceOfType(r["QueryFunctionBlocks"], typeof(IEnumerable <IEnumerable <string> >), "Type is incorrect"); var codeBlocks = r["QueryFunctionBlocks"] as IEnumerable <IEnumerable <string> >; Assert.AreEqual(1, codeBlocks.Count(), "Wrong number of code blocks"); }
public void TestObjectInitalizerInInnerBlock() { CPPTranslator target = new CPPTranslator(); var vInt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); vInt.SetInitialValue("2"); GeneratedCode code = new GeneratedCode(); code.SetResult(vInt); var innerBlock = new StatementInlineBlock(); var vInt2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); vInt2.SetInitialValue("5"); innerBlock.Add(vInt2); innerBlock.Add(new StatementSimpleStatement("fork = dork")); code.Add(innerBlock); var r = TranslateGeneratedCode(target, code); var st = (r["QueryFunctionBlocks"] as IEnumerable <IEnumerable <string> >).First().ToArray(); Assert.AreEqual(6, st.Length, "incorrect number of statements"); Assert.AreEqual("int " + vInt2.RawValue + " = 5;", st[2].Trim(), "incorrect initialization"); }
public void TestResultScopeCurrentScope() { var gc = new GeneratedCode(); var b1 = new StatementInlineBlock(); gc.Add(b1); gc.SetCurrentScopeAsResultScope(); var outterScope = gc.CurrentScope; var b2 = new StatementInlineBlock(); gc.Add(b2); gc.SetCurrentScopeAsResultScope(); gc.AddAtResultScope(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int))); Assert.AreEqual(0, b1.DeclaredVariables.Count(), "variables at outside loop after 0 add"); Assert.AreEqual(1, b2.DeclaredVariables.Count(), "variables at inner loop after 1 add"); gc.CurrentScope = outterScope; gc.AddAtResultScope(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int))); Assert.AreEqual(1, b1.DeclaredVariables.Count(), "variables at outside loop after 1 add"); Assert.AreEqual(1, b2.DeclaredVariables.Count(), "variables at inner loop after 2 add"); }
public void TestForFunctionNumber() { CPPTranslator target = new CPPTranslator(); var vInt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); vInt.SetInitialValue("2"); GeneratedCode code = new GeneratedCode(); code.SetResult(vInt); var innerBlock = new StatementInlineBlock(); var vInt2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); vInt2.SetInitialValue("5"); innerBlock.Add(vInt2); code.Add(innerBlock); var r = TranslateGeneratedCode(target, code); Assert.IsTrue(r.ContainsKey("NumberOfQueryFunctions"), "Number of functions isn't here"); Assert.IsInstanceOfType(r["NumberOfQueryFunctions"], typeof(int), "# function type"); Assert.AreEqual(1, r["NumberOfQueryFunctions"], "# of functions"); Assert.IsTrue(r.ContainsKey("QueryFunctionBlocks"), "Missing query function blocks"); Assert.IsInstanceOfType(r["QueryFunctionBlocks"], typeof(IEnumerable<IEnumerable<string>>), "Type is incorrect"); var codeBlocks = r["QueryFunctionBlocks"] as IEnumerable<IEnumerable<string>>; Assert.AreEqual(1, codeBlocks.Count(), "Wrong number of code blocks"); }
public void AddQMFunc() { var gc = new GeneratedCode(); Assert.AreEqual(0, gc.QMFunctions.Count(), "# of functions before add"); gc.Add(new QMFuncSource()); Assert.AreEqual(1, gc.QMFunctions.Count(), "# of functions before add"); }
public void CombineOneTwoLevelAndOneOneLevelFunctions2() { var q1 = new GeneratedCode(); var q2 = new GeneratedCode(); var f1 = QMFuncUtils.GenerateFunction(); var r1 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s1 = new Statements.StatementAssign(r1, new Variables.ValSimple(f1.Name + "()", typeof(int))); var f2 = GenerateFunction2(); var r2 = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var s2 = new Statements.StatementAssign(r2, new Variables.ValSimple(f2[1].Name + "()", typeof(int))); q1.Add(f1); q1.Add(s1); q1.SetResult(r1); q2.Add(f2[0]); q2.Add(f2[1]); q2.Add(s2); q2.SetResult(r2); var target = new CombinedGeneratedCode(); target.AddGeneratedCode(q1); target.AddGeneratedCode(q2); target.DumpCodeToConsole(); Assert.AreEqual(2, target.Functions.Count(), "# of functions should be combined to 2"); Assert.AreEqual(1, target.QueryCode().Count(), "# of query code blocks"); Assert.AreEqual(2, target.QueryCode().First().Statements.Count(), "# of statements in the combined block."); Assert.IsFalse(target.DumpCode().Where(l => l.Contains(f2[0].Name)).Any(), "The new function was still in there"); }
public void TestPopUpOneLevelLoopInline() { GeneratedCode gc = new GeneratedCode(); gc.Add(new StatementInlineBlock()); gc.Pop(true); }
public void TestFirstBookingBad() { var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var gc = new GeneratedCode(); Assert.IsNull(gc.FirstAllInScopeFromNow(new IDeclaredParameter[] { i })); }
public void TestAddOutsideLoopWithJustInlineBLock() { var target = new GeneratedCode(); target.Add(new Statements.StatementInlineBlock()); target.AddOutsideLoop(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int))); }
public void TestResultScopeNull() { var gc = new GeneratedCode(); var b = new StatementInlineBlock(); gc.Add(b); gc.AddAtResultScope(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int))); }
public void TestInScopeDownOneOK() { var gc = new GeneratedCode(); var sc = gc.CurrentScope; gc.Add(new StatementFilter(new ValSimple("true", typeof(bool)))); Assert.IsTrue(gc.InScopeNow(sc), "current scope should be in scope now."); }
public void TestAddOneLevelUpSingleLevel() { GeneratedCode gc = new GeneratedCode(); gc.Add(new Statements.StatementInlineBlock()); gc.AddOneLevelUp(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int))); Assert.AreEqual(1, gc.CodeBody.DeclaredVariables.Count(), "Expected top level declaration"); }
public void RemoveMissingStatement() { var fixture = new GeneratedCode(); fixture.Add(new StatementInlineBlock()); var s1 = new SimpleStatement(); fixture.Remove(s1); }
public void TestFirstBookingThisLevel() { var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var gc = new GeneratedCode(); gc.Add(i); var r = gc.FirstAllInScopeFromNow(new IDeclaredParameter[] { i }); Assert.AreEqual(r, gc.CodeBody, "Same code body."); }
public void TestRememberExprSimpleByVal() { var gc = new GeneratedCode(); var expr = Expression.Constant(10); var r = new LINQToTTreeLib.Variables.ValSimple("10", typeof(int)); gc.RememberSubexpression(expr, r); Assert.AreEqual(r, gc.LookupSubexpression(Expression.Constant(10)), "Could not find expression"); }
public void TestRememberConstantObject() { var gc = new GeneratedCode(); var expr = Expression.Constant(new ROOTNET.NTH1F()); var r1 = new LINQToTTreeLib.Variables.ValSimple("10", typeof(int)); gc.RememberSubexpression(expr, r1); Assert.AreEqual(r1, gc.LookupSubexpression(expr), "Constant Expressions of arbitrary objects can't be looked up"); }
public void TestNameCombo() { GeneratedCode gc = new GeneratedCode(); var obj = new ROOTNET.NTH1F("hi", "there", 10, 0.0, 10.0); var n1 = gc.QueueForTransfer(obj); var n2 = gc.QueueForTransfer(obj); Assert.AreEqual(n1, n2, "Names should be identical"); Assert.AreEqual(1, gc.VariablesToTransfer.Count(), "# of variables to move over wire"); }
public void TestAddOutsideLoopWithOnStatement() { var target = new GeneratedCode(); var blk = new Statements.StatementInlineBlock(); target.Add(blk); target.Add(new LINQToTTreeLib.Tests.TestUtils.SimpleLoop()); target.AddOutsideLoop(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int))); Assert.AreEqual(1, blk.DeclaredVariables.Count(), "# of loop declared variables"); }
public void TestFirstBookingNextLevel() { var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var gc = new GeneratedCode(); gc.Add(i); gc.Add(new StatementFilter(new ValSimple("dude", typeof(bool)))); var r = gc.FirstAllInScopeFromNow(new IDeclaredParameter[] { i }); Assert.AreEqual(r, gc.CodeBody, "Same code body."); }
public void TestPopUpOneLevelLoopWithLoop() { GeneratedCode gc = new GeneratedCode(); var loopV = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); gc.Add(new StatementForLoop(loopV, new Variables.ValSimple("5", typeof(int)))); gc.Pop(true); Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements present now"); gc.Add(new StatementAssign(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)), new Variables.ValSimple("ih", typeof(int)))); Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements present now"); }
public void CheckDepthAndPopWorkTogether() { var target = new GeneratedCode(); var s1 = new StatementInlineBlock(); target.Add(s1); var s2 = new StatementInlineBlock(); target.Add(s2); Assert.AreEqual(3, target.Depth); target.Pop(); Assert.AreEqual(2, target.Depth); }
public void TestTranslateForIncludeFiles() { CPPTranslator target = new CPPTranslator(); var obj = DeclarableParameter.CreateDeclarableParameterExpression(typeof(ROOTNET.NTH1F)); GeneratedCode code = new GeneratedCode(); code.SetResult(obj); var r = TranslateGeneratedCode(target, code); Assert.AreEqual(1, code.IncludeFiles.Count(), "# of include files"); Assert.AreEqual("TH1F.h", code.IncludeFiles.First(), "include file name is incorrect"); }
internal void CheckAddIncludeFiles([PexAssumeNotNull] string[] incnames) { var cc = new CombinedGeneratedCode(); foreach (var item in incnames) { var gc = new GeneratedCode(); gc.AddIncludeFile(item); cc.AddGeneratedCode(gc); } HashSet<string> unique = new HashSet<string>(incnames); Assert.AreEqual(unique.Count, cc.IncludeFiles.Count(), "wrong # of unqiue names"); }
public void RemoveStatement() { var fixture = new GeneratedCode(); fixture.Add(new StatementInlineBlock()); var s1 = new SimpleStatement(); fixture.Add(s1); Assert.AreEqual(1, (fixture.CodeBody.Statements.First() as IBookingStatementBlock).Statements.Count(), "before removal"); fixture.Remove(s1); Assert.AreEqual(0, (fixture.CodeBody.Statements.First() as IBookingStatementBlock).Statements.Count(), "after removal"); }
public void TestRememberTwoSameConstantObjects() { var gc = new GeneratedCode(); var expr1 = Expression.Constant(new ROOTNET.NTH1F()); var expr2 = Expression.Constant(new ROOTNET.NTH1F()); var r1 = new LINQToTTreeLib.Variables.ValSimple("10", typeof(int)); var r2 = new LINQToTTreeLib.Variables.ValSimple("11", typeof(int)); gc.RememberSubexpression(expr1, r1); gc.RememberSubexpression(expr2, r2); Assert.AreEqual(r1, gc.LookupSubexpression(expr1), "expr1 failure"); Assert.AreEqual(r2, gc.LookupSubexpression(expr2), "expr2 failure"); }
internal void CheckAddSameVariableNamesToTransfer([PexAssumeNotNull] ROOTNET.NTObject[] varnames) { var cc = new CombinedGeneratedCode(); HashSet<string> unique = new HashSet<string>(); foreach (var item in varnames) { var gc = new GeneratedCode(); var name = gc.QueueForTransfer(item); unique.Add(name); cc.AddGeneratedCode(gc); } Assert.AreEqual(unique.Count, varnames.Length, "there are non-unique names and there are no errors!"); Assert.AreEqual(varnames.Length, cc.VariablesToTransfer.Count(), "bad number added"); }
public void TestCompoundPostInsert() { var gc = new GeneratedCode(); gc.Add(new Statements.StatementSimpleStatement("dir")); var block = new Statements.StatementInlineBlock(); gc.Add(block); gc.Add(new Statements.StatementSimpleStatement("dir")); gc.Add(new Statements.StatementSimpleStatement("fork")); gc.Pop(); gc.Add(new Statements.StatementSimpleStatement("dir")); Assert.AreEqual(3, gc.CodeBody.Statements.Count(), "# of statements"); }
public void TestRememberExprPop() { var gc = new GeneratedCode(); var initialScope = gc.CurrentScope; gc.Add(new StatementInlineBlock()); var expr = Expression.Constant(10); var r = new LINQToTTreeLib.Variables.ValSimple("10", typeof(int)); gc.RememberSubexpression(expr, r); gc.CurrentScope = initialScope; Assert.IsNull(gc.LookupSubexpression(Expression.Constant(10)), "Expression after popping"); }
internal Expression ProcessResultOperator( [PexAssumeUnderTest]ROCount target, CountResultOperator resultOperator, QueryModel queryModel, GeneratedCode codeEnv ) { int origCount = 0; if (codeEnv != null) origCount = codeEnv.CodeBody.Statements.Count(); CodeContext c = new CodeContext(); Expression result = target.ProcessResultOperator(resultOperator, queryModel, codeEnv, c, null); Assert.AreEqual(origCount + 1, codeEnv.CodeBody.Statements.Count(), "Expected an added statement!"); Assert.IsInstanceOfType(codeEnv.CodeBody.Statements.Last(), typeof(StatementAggregate), "Statement to inc the integer must have been done!"); Assert.AreEqual(result.Type, typeof(int), "Expected to be calculating an integer"); return result; }
public void TestTranslateWithInitialValue() { CPPTranslator target = new CPPTranslator(); var vInt = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); vInt.SetInitialValue("2"); GeneratedCode code = new GeneratedCode(); code.SetResult(vInt); var r = TranslateGeneratedCode(target, code); Assert.IsTrue(r.ContainsKey("ResultVariables"), "Result variable is missing"); Assert.IsInstanceOfType(r["ResultVariables"], typeof(IEnumerable<CPPTranslator.VarInfo>), "bad type for the result variable"); var rList = r["ResultVariables"] as IEnumerable<CPPTranslator.VarInfo>; Assert.AreEqual(1, rList.Count(), "incorrect # of result variables"); var rv = rList.First(); Assert.AreEqual("2", rv.InitialValue, "initial value"); }
public void Pop(IStatement s, bool popPastLoop) { var gc = new GeneratedCode(); int depth = gc.Depth; gc.Add(s); bool good = s is IBookingStatementBlock; try { gc.Pop(popPastLoop); Assert.AreEqual(depth, gc.Depth, "Depth isn't set correctly"); Assert.IsTrue(good, "booking statement"); } catch (InvalidOperationException) { Assert.IsFalse(good, "a booking statement"); } }
public void TestRememberEmbededConstExpr() { var gc = new GeneratedCode(); var c1 = Expression.Constant(new ROOTNET.NTH1F("hi", "there", 100, 0.0, 10.0)); var c2 = Expression.Constant(new ROOTNET.NTH1F("no", "way", 100, 0.0, 10.0)); var n1 = Expression.Call(c1, typeof(ROOTNET.NTH1F).GetMethod("GetNbinsX")); var n2 = Expression.Call(c2, typeof(ROOTNET.NTH1F).GetMethod("GetNbinsX")); var r1 = new ValSimple("1", typeof(int)); var r2 = new ValSimple("2", typeof(int)); gc.RememberSubexpression(n1, r1); gc.RememberSubexpression(n2, r2); Assert.AreEqual(r1, gc.LookupSubexpression(n1), "lookup n1"); Assert.AreEqual(r2, gc.LookupSubexpression(n2), "lookup n2"); }
public void TestResultScopePop() { var gc = new GeneratedCode(); var b1 = new StatementInlineBlock(); gc.Add(b1); var b2 = new StatementInlineBlock(); gc.Add(b2); gc.SetCurrentScopeAsResultScope(); gc.AddAtResultScope(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int))); // This pop should remove the result scope, and it should be back to "null" now, which // should cause an exception. gc.Pop(); gc.AddAtResultScope(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int))); }
public void TestRememberExprHideAndSeek() { var gc = new GeneratedCode(); var expr = Expression.Constant(5); var r1 = new LINQToTTreeLib.Variables.ValSimple("10", typeof(int)); gc.RememberSubexpression(expr, r1); var initialScope = gc.CurrentScope; gc.Add(new StatementInlineBlock()); var r2 = new LINQToTTreeLib.Variables.ValSimple("11", typeof(int)); gc.RememberSubexpression(expr, r2); Assert.AreEqual(r2, gc.LookupSubexpression(expr), "Is hidden one done right?"); gc.Pop(); Assert.AreEqual(r1, gc.LookupSubexpression(expr), "Is revealed one done right?"); }
public void TestAddOutsideLoopWithJustIn2Loops() { var target = new GeneratedCode(); target.Add(new Statements.StatementInlineBlock()); var loop = new LINQToTTreeLib.Tests.TestUtils.SimpleLoop(); target.Add(loop); target.Add(new LINQToTTreeLib.Tests.TestUtils.SimpleLoop()); target.AddOutsideLoop(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int))); Assert.AreEqual(1, loop.DeclaredVariables.Count(), "# of loop declared variables"); }
public void TestFirstBookingNextLevelIt() { var i = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); var gc = new GeneratedCode(); var ifs = new StatementFilter(new ValSimple("dude", typeof(bool))); gc.Add(ifs); gc.Add(i); var r = gc.FirstAllInScopeFromNow(new IDeclaredParameter[] { i }); Assert.AreEqual(r, ifs, "Same code body."); }
public void TestPopUpOneLevelLoopWithLoopDeeper() { GeneratedCode gc = new GeneratedCode(); var loopV = DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)); gc.Add(new StatementForLoop(loopV, new Variables.ValSimple("5", typeof(int)))); gc.Add(new StatementInlineBlock()); gc.Add(new StatementAssign(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)), new Variables.ValSimple("ih", typeof(int)))); gc.Pop(true); Assert.AreEqual(1, gc.CodeBody.Statements.Count(), "# of statements present now"); gc.Add(new StatementAssign(DeclarableParameter.CreateDeclarableParameterExpression(typeof(int)), new Variables.ValSimple("ih", typeof(int)))); Assert.AreEqual(2, gc.CodeBody.Statements.Count(), "# of statements present now"); }
public void TestRememberEmbededConstExpr() { var gc = new GeneratedCode(); var c1 = Expression.Constant(new ROOTNET.NTH1F("hi", "there", 100, 0.0, 10.0)); var c2 = Expression.Constant(new ROOTNET.NTH1F("no", "way", 100, 0.0, 10.0)); var n1 = Expression.Call(c1, typeof(ROOTNET.NTH1F).GetMethod("GetNbinsX")); var n2 = Expression.Call(c2, typeof(ROOTNET.NTH1F).GetMethod("GetNbinsX")); var r1 = new ValSimple("1", typeof(int)); var r2 = new ValSimple("2", typeof(int)); gc.RememberSubExpression(n1, r1); gc.RememberSubExpression(n2, r2); Assert.AreEqual(r1, gc.LookupSubExpression(n1), "lookup n1"); Assert.AreEqual(r2, gc.LookupSubExpression(n2), "lookup n2"); }
public void TestRememberConstantObject() { var gc = new GeneratedCode(); var expr = Expression.Constant(new ROOTNET.NTH1F()); var r1 = new LINQToTTreeLib.Variables.ValSimple("10", typeof(int)); gc.RememberSubExpression(expr, r1); Assert.AreEqual(r1, gc.LookupSubExpression(expr), "Constant Expressions of arbitrary objects can't be looked up"); }
public void TestRememberTwoSameConstantObjects() { var gc = new GeneratedCode(); var expr1 = Expression.Constant(new ROOTNET.NTH1F()); var expr2 = Expression.Constant(new ROOTNET.NTH1F()); var r1 = new LINQToTTreeLib.Variables.ValSimple("10", typeof(int)); var r2 = new LINQToTTreeLib.Variables.ValSimple("11", typeof(int)); gc.RememberSubExpression(expr1, r1); gc.RememberSubExpression(expr2, r2); Assert.AreEqual(r1, gc.LookupSubExpression(expr1), "expr1 failure"); Assert.AreEqual(r2, gc.LookupSubExpression(expr2), "expr2 failure"); }
public void TestInScopeNoChangeInScope() { var gc = new GeneratedCode(); Assert.IsTrue(gc.InScopeNow(gc.CurrentScope), "current scope should be in scope now."); }
public void TestInScopeUpOneNotOK() { var gc = new GeneratedCode(); gc.Add(new StatementFilter(new ValSimple("true", typeof(bool)))); var sc = gc.CurrentScope; gc.Pop(); Assert.IsFalse(gc.InScopeNow(sc), "current scope should be in scope now."); }
public void TestPopUpOneLevelLoopEmpty() { GeneratedCode gc = new GeneratedCode(); gc.Pop(true); }
public void TestRememberExprHideAndSeek() { var gc = new GeneratedCode(); var expr = Expression.Constant(5); var r1 = new LINQToTTreeLib.Variables.ValSimple("10", typeof(int)); gc.RememberSubExpression(expr, r1); var initialScope = gc.CurrentScope; gc.Add(new StatementInlineBlock()); var r2 = new LINQToTTreeLib.Variables.ValSimple("11", typeof(int)); gc.RememberSubExpression(expr, r2); Assert.AreEqual(r2, gc.LookupSubExpression(expr), "Is hidden one done right?"); gc.Pop(); Assert.AreEqual(r1, gc.LookupSubExpression(expr), "Is revealed one done right?"); }
public void TestRememberExprPop() { var gc = new GeneratedCode(); var initialScope = gc.CurrentScope; gc.Add(new StatementInlineBlock()); var expr = Expression.Constant(10); var r = new LINQToTTreeLib.Variables.ValSimple("10", typeof(int)); gc.RememberSubExpression(expr, r); gc.CurrentScope = initialScope; Assert.IsNull(gc.LookupSubExpression(Expression.Constant(10)), "Expression after popping"); }
public void TestPopUpOneLevel() { GeneratedCode gc = new GeneratedCode(); gc.Pop(); }
public void TestRememberExprSimpleByVal() { var gc = new GeneratedCode(); var expr = Expression.Constant(10); var r = new LINQToTTreeLib.Variables.ValSimple("10", typeof(int)); gc.RememberSubExpression(expr, r); Assert.AreEqual(r, gc.LookupSubExpression(Expression.Constant(10)), "Could not find expression"); }