public void Invocation_SimpleComposition() { CompleteInCSharpFile(@" namespace N { public class H { public int Get() { return 1; } } public class C { public void A(H h) { var i = 1 + h.Get(); $ } } } "); var mA = NewMethodDeclaration(Fix.Void, "A", "[N.H, TestProject] h"); mA.Body.Add(SSTUtil.Declare("i", Fix.Int)); mA.Body.Add(SSTUtil.Declare("$0", Fix.Int)); mA.Body.Add( SSTUtil.AssignmentToLocal( "$0", SSTUtil.InvocationExpression( "h", Names.Method("[{0}] [N.H, TestProject].Get()", Fix.Int)))); mA.Body.Add(SSTUtil.AssignmentToLocal("i", SSTUtil.ComposedExpression("$0"))); AssertAllMethods(mA); }
public void SwitchBlock_NoDefaultBlock() { var sst = new SwitchBlock { Reference = SSTUtil.VariableReference("a"), Sections = { new CaseBlock { Label = new ConstantValueExpression{ Value = "1" }, Body = { new BreakStatement(), new BreakStatement() } }, new CaseBlock { Label = new ConstantValueExpression{ Value = "2" }, Body = { new BreakStatement() } } } }; AssertPrint( sst, "switch (a)", "{", " case 1:", " break;", " break;", " case 2:", " break;", "}"); }
public void CombinedInlineIfElse() { CompleteInClass(@" public void A() { var i = (true ? 1 : 2) + 3; $ } "); var mA = NewMethodDeclaration(Fix.Void, "A"); mA.Body.Add(SSTUtil.Declare("i", Fix.Int)); mA.Body.Add(SSTUtil.Declare("$0", Fix.Int)); mA.Body.Add( SSTUtil.AssignmentToLocal( "$0", new IfElseExpression { Condition = new ConstantValueExpression(), ThenExpression = new ConstantValueExpression(), ElseExpression = new ConstantValueExpression() })); mA.Body.Add(SSTUtil.AssignmentToLocal("i", SSTUtil.ComposedExpression("$0"))); AssertAllMethods(mA); }
public void ReferenceExpression() { var sst = new ReferenceExpression { Reference = SSTUtil.VariableReference("variable") }; AssertPrint(sst, "variable"); }
public void InvocationExpression_Static() { var a = SSTUtil.InvocationExpression(GetStaticMethod("B2"), Refs("c2")); Assert.AreEqual(new VariableReference(), a.Reference); Assert.AreEqual(GetStaticMethod("B2"), a.MethodName); Assert.AreEqual(Refs("c2"), a.Parameters); }
public void Assignment() { var sst = SSTUtil.AssignmentToLocal("var", new ConstantValueExpression { Value = "true" }); AssertPrint(sst, "var = true;"); }
public void InvocationExpression_NonStatic() { var a = SSTUtil.InvocationExpression("a1", GetMethod("B1"), Refs("c1")); Assert.AreEqual(SSTUtil.VariableReference("a1"), a.Reference); Assert.AreEqual(GetMethod("B1"), a.MethodName); Assert.AreEqual(Refs("c1"), a.Parameters); }
public void ComposedExpression() { var actual = SSTUtil.ComposedExpression("a", "b"); var expected = new ComposedExpression { References = Lists.NewList(Ref("a"), Ref("b")) }; Assert.AreEqual(expected, actual); }
public void Return() { var actual = SSTUtil.Return(new ConstantValueExpression()); var expected = new ReturnStatement { Expression = new ConstantValueExpression() }; Assert.AreEqual(expected, actual); }
public void Equality_DifferentReference() { var a = new VariableDeclaration { Reference = SSTUtil.VariableReference("a") }; var b = new VariableDeclaration(); Assert.AreNotEqual(a, b); Assert.AreNotEqual(a.GetHashCode(), b.GetHashCode()); }
public void SettingValues() { var a = SSTUtil.InvocationExpression("a1", GetMethod("A2"), Refs("a3")); Assert.AreEqual(new VariableReference { Identifier = "a1" }, a.Reference); Assert.AreEqual(GetMethod("A2"), a.MethodName); Assert.AreEqual(Refs("a3"), a.Parameters); }
public void EventReference() { var sst = new EventReference { EventName = Names.Event("[EventType,P] [DeclaringType,P].E"), Reference = SSTUtil.VariableReference("o") }; AssertPrint(sst, "o.E"); }
public void FieldReference() { var sst = new FieldReference { FieldName = Names.Field("[FieldType,P] [DeclaringType,P].F"), Reference = SSTUtil.VariableReference("o") }; AssertPrint(sst, "o.F"); }
public void Equality_ReallyTheSame() { Assert.AreEqual(GetMethod("a"), GetMethod("a")); var a = SSTUtil.InvocationExpression("o", GetMethod("A"), RefExprs("a", "b", "c")); var b = SSTUtil.InvocationExpression("o", GetMethod("A"), RefExprs("a", "b", "c")); Assert.AreEqual(a, b); Assert.AreEqual(a.GetHashCode(), b.GetHashCode()); }
public void MethodReference() { var sst = new MethodReference { MethodName = Names.Method("[ReturnType,P] [DeclaringType,P].M([ParameterType,P] p)"), Reference = SSTUtil.VariableReference("o") }; AssertPrint(sst, "o.M"); }
public void PropertyReference() { var sst = new PropertyReference { PropertyName = Names.Property("get set [PropertyType,P] [DeclaringType,P].P()"), Reference = SSTUtil.VariableReference("o") }; AssertPrint(sst, "o.P"); }
public void Declare() { var actual = SSTUtil.Declare("a", Names.UnknownType); var expected = new VariableDeclaration { Reference = Ref("a"), Type = Names.UnknownType }; Assert.AreEqual(expected, actual); }
public void InvocationExpression_NullValue() { var sst = new InvocationExpression { Reference = SSTUtil.VariableReference("this"), MethodName = Names.Method("[R,P] [D,P].M([T,P] p)"), Parameters = { Null() } }; AssertPrint(sst, "this.M(null)"); }
public void ReferenceExprToVariable() { var actual = SSTUtil.ReferenceExprToVariable("a"); var expected = new ReferenceExpression { Reference = new VariableReference { Identifier = "a" } }; Assert.AreEqual(expected, actual); }
public void LockBlock() { var actual = SSTUtil.LockBlock("a"); var expected = new LockBlock { Reference = new VariableReference { Identifier = "a" } }; Assert.AreEqual(expected, actual); }
public void SettingValues() { var sut = new VariableDeclaration { Reference = SSTUtil.VariableReference("a"), Type = Names.Type("T,P") }; Assert.False(sut.IsMissing); Assert.AreEqual(SSTUtil.VariableReference("a"), sut.Reference); Assert.AreEqual(Names.Type("T,P"), sut.Type); }
public void Equality_ReallyEquals() { var a = new VariableDeclaration { Reference = SSTUtil.VariableReference("a"), Type = Names.Type("T1,P1") }; var b = new VariableDeclaration { Reference = SSTUtil.VariableReference("a"), Type = Names.Type("T1,P1") }; Assert.AreEqual(a, b); Assert.AreEqual(a.GetHashCode(), b.GetHashCode()); }
public void ComposedExpression() { var sst = new ComposedExpression { References = { SSTUtil.VariableReference("a"), SSTUtil.VariableReference("b"), SSTUtil.VariableReference("c") } }; AssertPrint(sst, "composed(a, b, c)"); }
public void InvocationStatement_Static() { var actual = SSTUtil.InvocationStatement(GetStaticMethod("B2"), Refs("c2")); var expected = new ExpressionStatement { Expression = new InvocationExpression { MethodName = GetStaticMethod("B2"), Parameters = { VarRefExpr("c2") } } }; Assert.AreEqual(expected, actual); }
public void UsingBlock() { var sst = new UsingBlock { Reference = SSTUtil.VariableReference("variable"), Body = { new BreakStatement() } }; AssertPrint( sst, "using (variable)", "{", " break;", "}"); }
public void LockBlock() { var sst = new LockBlock { Reference = SSTUtil.VariableReference("variable"), Body = { new ContinueStatement() } }; AssertPrint( sst, "lock (variable)", "{", " continue;", "}"); }
public void CompositionOfTypeOf() { CompleteInClass(@" public void A() { var t = typeof(int) == typeof(string); $ } "); var mA = NewMethodDeclaration(SSTAnalysisFixture.Void, "A"); mA.Body.Add(SSTUtil.Declare("t", SSTAnalysisFixture.Bool)); mA.Body.Add(SSTUtil.AssignmentToLocal("t", new ConstantValueExpression())); AssertAllMethods(mA); }
public void ExpressionStatement() { var invocation = new InvocationExpression { Reference = SSTUtil.VariableReference("this"), MethodName = Names.Method("[ReturnType,P] [DeclaringType,P].M([ParameterType,P] p)"), Parameters = { new ConstantValueExpression { Value = "1" } } }; var sst = new ExpressionStatement { Expression = invocation }; AssertPrint(sst, "this.M(1);"); }
public void ArrayInit_Constant() { CompleteInClass(@" public void A() { var arr = new[] {1,2,3}; $ } "); var mA = NewMethodDeclaration(Fix.Void, "A"); mA.Body.Add(SSTUtil.Declare("arr", Fix.IntArray)); mA.Body.Add(SSTUtil.AssignmentToLocal("arr", new ConstantValueExpression())); AssertAllMethods(mA); }
public void Is_Const() { CompleteInClass(@" public void A() { var isInstanceOf = 1 is double; $ } "); var mA = NewMethodDeclaration(SSTAnalysisFixture.Void, "A"); mA.Body.Add(SSTUtil.Declare("isInstanceOf", SSTAnalysisFixture.Bool)); mA.Body.Add(SSTUtil.AssignmentToLocal("isInstanceOf", new ConstantValueExpression())); AssertAllMethods(mA); }