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);
}
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)
{
// create a namespace
CodeNamespace ns = new CodeNamespace("NS");
ns.Imports.Add(new CodeNamespaceImport("System"));
ns.Imports.Add(new CodeNamespaceImport("System.Windows.Forms"));
cu.ReferencedAssemblies.Add("System.Windows.Forms.dll");
cu.Namespaces.Add(ns);
// create a class
CodeTypeDeclaration class1 = new CodeTypeDeclaration();
class1.Name = "Test";
class1.IsClass = true;
ns.Types.Add(class1);
// create method to test casting enum -> int
// GENERATE (C#):
// public int EnumToInt(System.Windows.Forms.AnchorStyles enum1) {
// return ((int)(enum1));
// }
AddScenario("CheckEnumToInt1", "Check the return value of EnumToInt() with a single flag");
AddScenario("CheckEnumToInt2", "Check the return value of EnumToInt() with multiple flags");
CodeMemberMethod enumToInt = new CodeMemberMethod();
enumToInt.Name = "EnumToInt";
enumToInt.ReturnType = new CodeTypeReference(typeof(int));
enumToInt.Attributes = MemberAttributes.Public;
CodeParameterDeclarationExpression param = new CodeParameterDeclarationExpression(typeof(System.Windows.Forms.AnchorStyles), "enum1");
enumToInt.Parameters.Add(param);
enumToInt.Statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(typeof(int), new CodeArgumentReferenceExpression("enum1"))));
class1.Members.Add(enumToInt);
// create method to test casting enum -> int
// GENERATE (C#):
// public virtual int CastReturnValue(string value) {
// float val = System.Single.Parse(value, System.Globalization.CultureInfo.InvariantCulture);
// return ((int) val);
// }
AddScenario("CheckCastReturnValue", "Check the return value of CastReturnValue()");
CodeMemberMethod castReturnValue = new CodeMemberMethod();
castReturnValue.Name = "CastReturnValue";
castReturnValue.ReturnType = new CodeTypeReference(typeof(int));
castReturnValue.Attributes = MemberAttributes.Public;
CodeParameterDeclarationExpression strParam = new CodeParameterDeclarationExpression(typeof(string), "value");
castReturnValue.Parameters.Add(strParam);
castReturnValue.Statements.Add(new CodeVariableDeclarationStatement(typeof(int), "val",
CDHelper.CreateMethodInvoke(new CodeTypeReferenceExpression(new CodeTypeReference("System.Int32")), // F#: Type conversion "int -> float" is not a type-cast!
"Parse", new CodeArgumentReferenceExpression("value"),
new CodePropertyReferenceExpression(new CodeTypeReferenceExpression("System.Globalization.CultureInfo"),
"InvariantCulture"))));
castReturnValue.Statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(typeof(int), new CodeVariableReferenceExpression("val"))));
class1.Members.Add(castReturnValue);
// create method to test casting interface -> class
// GENERATE (C#):
// public string CastInterface(System.ICloneable value) {
// return ((string)(value));
// }
AddScenario("CheckCastInterface", "Check the return value of CastInterface()");
CodeMemberMethod castInterface = new CodeMemberMethod();
castInterface.Name = "CastInterface";
castInterface.ReturnType = new CodeTypeReference(typeof(string));
castInterface.Attributes = MemberAttributes.Public;
CodeParameterDeclarationExpression interfaceParam = new CodeParameterDeclarationExpression(typeof(System.ICloneable), "value");
castInterface.Parameters.Add(interfaceParam);
castInterface.Statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(typeof(string), new CodeArgumentReferenceExpression("value"))));
class1.Members.Add(castInterface);
// create method to test casting value type -> reference type
// GENERATE (C#):
// public object ValueToReference(int value) {
// return ((object)(value));
// }
AddScenario("CheckValueToReference", "Check the return value of ValueToReference()");
CodeMemberMethod valueToReference = new CodeMemberMethod();
valueToReference.Name = "ValueToReference";
valueToReference.ReturnType = new CodeTypeReference(typeof(System.Object));
valueToReference.Attributes = MemberAttributes.Public;
CodeParameterDeclarationExpression valueParam = new CodeParameterDeclarationExpression(typeof(int), "value");
valueToReference.Parameters.Add(valueParam);
valueToReference.Statements.Add(new CodeMethodReturnStatement(new CodeCastExpression(typeof(System.Object), new CodeArgumentReferenceExpression("value"))));
class1.Members.Add(valueToReference);
}