public override void BuildTree(CodeDomProvider provider, CodeCompileUnit cu)
{
CodeNamespace nspace = new CodeNamespace("NSPC");
nspace.Imports.Add(new CodeNamespaceImport("System"));
cu.Namespaces.Add(nspace);
// declare class with fields
// GENERATES (C#):
// public class ClassWithFields {
// public int NonStaticPublicField = 6;
// private int PrivateField = 7;
// public int UsePrivateField(int i) {
// this.PrivateField = i;
// return this.PrivateField;
// }
// }
CodeTypeDeclaration cd = new CodeTypeDeclaration("ClassWithFields");
cd.IsClass = true;
nspace.Types.Add(cd);
CodeMemberField field = new CodeMemberField();
field.Name = "NonStaticPublicField";
field.Attributes = MemberAttributes.Public | MemberAttributes.Final;
field.Type = new CodeTypeReference(typeof(int));
field.InitExpression = new CodePrimitiveExpression(6);
cd.Members.Add(field);
field = new CodeMemberField();
field.Name = "PrivateField";
field.Attributes = MemberAttributes.Private | MemberAttributes.Final;
field.Type = new CodeTypeReference(typeof(int));
field.InitExpression = new CodePrimitiveExpression(7);
cd.Members.Add(field);
// create a method to test access to private field
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "UsePrivateField";
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeAssignStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "PrivateField"), new CodeArgumentReferenceExpression("i")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "PrivateField")));
cd.Members.Add(cmm);
// GENERATES (C#):
// public class TestFields {
// public int UseFields(int i) {
// ClassWithFields number = new ClassWithFields();
// int someSum;
// int privateField;
// someSum = number.NonStaticPublicField;
// privateField = number.UsePrivateField (i);
// return someSum + privateField;
// }
// }
cd = new CodeTypeDeclaration("TestFields");
cd.IsClass = true;
nspace.Types.Add(cd);
AddScenario("CheckTestFields");
cmm = new CodeMemberMethod();
cmm.Name = "UseFields";
cmm.Attributes = MemberAttributes.Public;
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(new CodeTypeReference(typeof(int)), "i"));
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("ClassWithFields"), "number",
new CodeObjectCreateExpression("ClassWithFields")));
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int),
"someSum"));
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int),
"privateField"));
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("someSum"),
CDHelper.CreateFieldRef("number", "NonStaticPublicField")));
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("privateField"),
CDHelper.CreateMethodInvoke(new CodeVariableReferenceExpression("number"),
"UsePrivateField", new CodeArgumentReferenceExpression("i"))));
cmm.Statements.Add(new CodeMethodReturnStatement(CDHelper.CreateBinaryOperatorExpression("someSum",
CodeBinaryOperatorType.Add, "privateField")));
cd.Members.Add(cmm);
}
public override void BuildTree(CodeDomProvider provider, CodeCompileUnit cu)
{
CodeNamespace nspace = new CodeNamespace("NSPC");
nspace.Imports.Add(new CodeNamespaceImport("System"));
cu.Namespaces.Add(nspace);
CodeTypeDeclaration cd = new CodeTypeDeclaration("TEST");
cd.IsClass = true;
nspace.Types.Add(cd);
// GENERATES (C#):
// public int CallingOverrideScenario(int i) {
// ClassWVirtualMethod t = new ClassWOverrideMethod();
// return t.VirtualMethod(i);
// }
AddScenario("Check1CallingOverrideScenario", "Check an overridden method.");
CodeMemberMethod cmm = new CodeMemberMethod();
cmm.Name = "CallingOverrideScenario";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeVariableDeclarationStatement("ClassWVirtualMethod", "t", new CodeCastExpression(new CodeTypeReference("ClassWVirtualMethod"), new CodeObjectCreateExpression("ClassWOverrideMethod"))));
CodeMethodInvokeExpression methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"), "VirtualMethod");
methodinvoke.Parameters.Add(new CodeArgumentReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(methodinvoke));
cd.Members.Add(cmm);
// declare a method without parameters
cmm = new CodeMemberMethod();
cmm.Name = "NoParamsMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodePrimitiveExpression(16)));
cd.Members.Add(cmm);
// declare a method with multiple parameters
cmm = new CodeMemberMethod();
cmm.Name = "MultipleParamsMethod";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "b"));
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Final;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(new
CodeArgumentReferenceExpression("a"), CodeBinaryOperatorType.Add,
new CodeArgumentReferenceExpression("b"))));
cd.Members.Add(cmm);
// call method with no parameters, call a method with multiple parameters,
// and call a method from a method call
// public virtual int CallParamsMethods() {
// TEST t = new TEST();
// int val;
// val = t.NoParamsMethod ();
// return t.MultipleParamsMethod(78, val);
// }
AddScenario("CheckCallParamsMethod", "Check CheckCallParamsMethod.");
cmm = new CodeMemberMethod();
cmm.Name = "CallParamsMethods";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeVariableDeclarationStatement(new CodeTypeReference("TEST"), "t", new CodeObjectCreateExpression("TEST")));
CodeVariableReferenceExpression cvre = new CodeVariableReferenceExpression(); //To increase code coverage
cvre.VariableName = "t";
CodeVariableReferenceExpression valCVRE = new CodeVariableReferenceExpression();
valCVRE.VariableName = "val";
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "val"));
cmm.Statements.Add(new CodeAssignStatement(valCVRE,
CDHelper.CreateMethodInvoke(new CodeVariableReferenceExpression("t"), "NoParamsMethod")));
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeMethodInvokeExpression(cvre,
"MultipleParamsMethod", new CodePrimitiveExpression(78), valCVRE)));
cd.Members.Add(cmm);
// method to test the 'new' scenario by calling the 'new' method
// GENERATES (C#):
// public int CallingNewScenario(int i) {
// ClassWVirtualMethod t = new ClassWNewMethod();
// int x1;
// int x2;
// x1 = ((ClassWNewMethod)(t)).VirtualMethod(i);
// x2 = t.VirtualMethod(i);
// return (x1 - x2);
// }
AddScenario("CheckCallingNewScenario", "Check CheckCallingNewScenario.");
cmm = new CodeMemberMethod();
cmm.Name = "CallingNewScenario";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeVariableDeclarationStatement("ClassWVirtualMethod", "t", new CodeCastExpression(new CodeTypeReference("ClassWVirtualMethod"), new CodeObjectCreateExpression("ClassWNewMethod"))));
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "x1"));
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "x2"));
methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"), "VirtualMethod");
methodinvoke.Parameters.Add(new CodeArgumentReferenceExpression("i"));
CodeMethodInvokeExpression methodinvoke2 = new CodeMethodInvokeExpression(new CodeCastExpression("ClassWNewMethod", new
CodeVariableReferenceExpression("t")), "VirtualMethod");
methodinvoke2.Parameters.Add(new CodeArgumentReferenceExpression("i"));
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("x1"),
methodinvoke2));
cmm.Statements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression("x2"),
methodinvoke));
cmm.Statements.Add(new CodeMethodReturnStatement(
CDHelper.CreateBinaryOperatorExpression("x1", CodeBinaryOperatorType.Subtract, "x2")));
cd.Members.Add(cmm);
// ***************** declare method using new ******************
// first declare a class with a virtual method in it
// GENERATES (C#):
// public class ClassWVirtualMethod {
// public virtual int VirtualMethod(int a) {
// return a;
// }
// }
cd = new CodeTypeDeclaration("ClassWVirtualMethod");
cd.IsClass = true;
nspace.Types.Add(cd);
cmm = new CodeMemberMethod();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeArgumentReferenceExpression("a")));
cd.Members.Add(cmm);
// now declare a class that inherits from the previous class and has a 'new' method with the
// name VirtualMethod
// GENERATES (C#):
// public class ClassWNewMethod : ClassWVirtualMethod {
// public new virtual int VirtualMethod(int a) {
// return (2 * a);
// }
// }
cd = new CodeTypeDeclaration("ClassWNewMethod");
cd.BaseTypes.Add(new CodeTypeReference("ClassWVirtualMethod"));
cd.IsClass = true;
nspace.Types.Add(cd);
cmm = new CodeMemberMethod();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.New;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(2), CodeBinaryOperatorType.Multiply
, new CodeArgumentReferenceExpression("a"))));
cd.Members.Add(cmm);
// now declare a class that inherits from the previous class and has a 'new' method with the
// name VirtualMethod
// GENERATES (C#):
// public class ClassWOverrideMethod : ClassWVirtualMethod {
// public override int VirtualMethod(int a) {
// return (2 * a);
// }
// }
cd = new CodeTypeDeclaration("ClassWOverrideMethod");
cd.BaseTypes.Add(new CodeTypeReference("ClassWVirtualMethod"));
cd.IsClass = true;
nspace.Types.Add(cd);
cmm = new CodeMemberMethod();
cmm.Name = "VirtualMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public | MemberAttributes.Override;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
new CodePrimitiveExpression(2), CodeBinaryOperatorType.Multiply
, new CodeArgumentReferenceExpression("a"))));
cd.Members.Add(cmm);
//*************** overload member function ****************
// new class which will include both functions
// GENERATES (C#):
// public class TEST7 {
// public int OverloadedMethod(int a) {
// return a;
// }
// public int OverloadedMethod(int a, int b) {
// return (b + a);
// }
// public int CallingOverloadedMethods(int i) {
// int one = OverloadedMethod(i, i);
// int two = OverloadedMethod(i);
// return (one - two);
// }
// }
AddScenario("CheckTEST7.CallingOverloadedMethods", "Check CallingOverloadedMethods()");
cd = new CodeTypeDeclaration("TEST7");
cd.IsClass = true;
nspace.Types.Add(cd);
cmm = new CodeMemberMethod();
cmm.Name = "OverloadedMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeArgumentReferenceExpression("a")));
cd.Members.Add(cmm);
cmm = new CodeMemberMethod();
cmm.Name = "OverloadedMethod";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "a"));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "b"));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeMethodReturnStatement(new CodeBinaryOperatorExpression(
new CodeArgumentReferenceExpression("b"), CodeBinaryOperatorType.Add,
new CodeArgumentReferenceExpression("a"))));
cd.Members.Add(cmm);
// declare a method that will call both OverloadedMethod functions
cmm = new CodeMemberMethod();
cmm.Name = "CallingOverloadedMethods";
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.Attributes = MemberAttributes.Public;
CodeMethodReferenceExpression methodref = new CodeMethodReferenceExpression();
methodref.MethodName = "OverloadedMethod";
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "one",
new CodeMethodInvokeExpression(methodref, new
CodeArgumentReferenceExpression("i"), new CodeArgumentReferenceExpression("i"))));
cmm.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "two",
new CodeMethodInvokeExpression(methodref, new
CodeArgumentReferenceExpression("i"))));
cmm.Statements.Add(new CodeMethodReturnStatement(
CDHelper.CreateBinaryOperatorExpression("one", CodeBinaryOperatorType.Subtract, "two")));
cd.Members.Add(cmm);
// GENERATES (C#):
//
// namespace NSPC2 {
//
//
// public class TEST {
//
// public virtual int CallingOverrideScenario(int i) {
// NSPC.ClassWVirtualMethod t = new NSPC.ClassWOverrideMethod();
// return t.VirtualMethod(i);
// }
// }
// }
nspace = new CodeNamespace("NSPC2");
cu.Namespaces.Add(nspace);
cd = new CodeTypeDeclaration("TEST");
cd.IsClass = true;
nspace.Types.Add(cd);
AddScenario("Check2CallingOverrideScenario", "Check CallingOverrideScenario()");
cmm = new CodeMemberMethod();
cmm.Name = "CallingOverrideScenario";
cmm.Parameters.Add(new CodeParameterDeclarationExpression(typeof(int), "i"));
cmm.ReturnType = new CodeTypeReference(typeof(int));
cmm.Attributes = MemberAttributes.Public;
cmm.Statements.Add(new CodeVariableDeclarationStatement("NSPC.ClassWVirtualMethod", "t", new CodeCastExpression(new CodeTypeReference("NSPC.ClassWVirtualMethod"), new CodeObjectCreateExpression("NSPC.ClassWOverrideMethod"))));
methodinvoke = new CodeMethodInvokeExpression(new CodeVariableReferenceExpression("t"), "VirtualMethod");
methodinvoke.Parameters.Add(new CodeArgumentReferenceExpression("i"));
cmm.Statements.Add(new CodeMethodReturnStatement(methodinvoke));
cd.Members.Add(cmm);
}
