private Constructor(Constructor iiToCopyFrom)
: base(null)
{
iiToCopyFrom.CloneInto(this);
InitializerType = iiToCopyFrom.InitializerType;
InitializerArguments = new List<string>(iiToCopyFrom.InitializerArguments);
Modifiers = new List<string>(iiToCopyFrom.Modifiers);
CloneParameters(iiToCopyFrom);
}
public void Constructor()
{
Constructor con = new Constructor(controller, "Class1");
con.Parameters.Add(new Parameter(controller, "int", "i"));
con.Parameters.Add(new Parameter(controller, "string", "j"));
Assert.That(con.FullyQualifiedDisplayName, Is.EqualTo("Class1 (int, string)"));
Class cl = new Class(controller, "Class1");
cl.AddChild(con);
Assert.That(con.FullyQualifiedDisplayName, Is.EqualTo("Class1.Class1 (int, string)"));
}
public void Constructor()
{
Constructor inter = new Constructor(controller);
inter.Modifiers.Add("public");
inter.Name = "Class1";
Parameter param = new Parameter(controller);
param.Name = "i";
param.DataType = "int";
inter.Parameters.Add(param);
Assert.That(inter.IsTheSame(inter.Clone(), ComparisonDepth.Outer), Is.True);
}
public void Constructor_Renamed_Parameter()
{
const string className = "MyClassName1";
const string parameterName1 = "MyParameterName1";
const string parameterName2 = "MyParameterName2";
string expectedResult = String.Format("{0} {1}({2} {3})", Modifier1, className, DataType1, parameterName2);
Constructor merged1 = new Constructor(controller);
Constructor merged2 = new Constructor(controller);
Constructor merged3 = new Constructor(controller);
Constructor changing = new Constructor(controller, className);
changing.Parameters.Add(new Parameter(controller, DataType1, parameterName2));
changing.Modifiers.Add(Modifier1);
Constructor unchanging = new Constructor(controller, className);
unchanging.Parameters.Add(new Parameter(controller, DataType1, parameterName1));
unchanging.Modifiers.Add(Modifier1);
Merge_And_Assert(merged1, merged2, merged3, changing, unchanging, expectedResult);
}
public void Constructor_Added_Initialiser()
{
const string className = "MyClassName1";
const string initName = "MyInitializerName1";
const string initArgs1 = "MyInitializerArgs1";
const string initArgs2 = "MyInitializerArgs2";
string expectedResult = String.Format("{0}() : {1}({2}, {3})\n{{ }}".Replace("\n",Environment.NewLine), className, initName, initArgs1, initArgs2);
Constructor merged1 = new Constructor(controller);
Constructor merged2 = new Constructor(controller);
Constructor merged3 = new Constructor(controller);
Constructor changing = new Constructor(controller, className);
changing.InitializerType = initName;
changing.InitializerArguments.Add(initArgs1);
changing.InitializerArguments.Add(initArgs2);
Constructor unchanging = new Constructor(controller, className);
Merge_And_Assert(merged1, merged2, merged3, changing, unchanging, expectedResult);
}
private bool IsTheSame(Constructor comparisonConstructor, ComparisonDepth depth)
{
if (comparisonConstructor == null)
return false;
if (Name == comparisonConstructor.Name)
{
if (ParametersAreTheSame(comparisonConstructor, depth) == false) return false;
// Function names are the same, so now compare the class names
if (depth == ComparisonDepth.Signature)
{
return true;
}
if (!base.IsTheSame(comparisonConstructor, depth))
{
return false;
}
if (!Utility.StringCollectionsAreTheSame(Modifiers, comparisonConstructor.Modifiers))
{
ComparisonDifference += GetType().Name + ".Modifiers";
return false;
}
if (depth == ComparisonDepth.Outer)
{
return true;
}
if (BodyText != comparisonConstructor.BodyText)
{
ComparisonDifference += GetType().Name + ".Body";
return false;
}
if (!ParentObject.IsTheSame(comparisonConstructor.ParentObject))
{
ComparisonDifference += GetType().Name + ".Parent";
return false;
}
if (!ArchAngel.Providers.CodeProvider.CSharp.Utility.BaseContructCollectionsAreTheSame(Attributes.ToArray(), comparisonConstructor.Attributes.ToArray()))
{
ComparisonDifference += GetType().Name + ".Attributes";
return false;
}
return true;
}
return false;
}
private bool IsTheSame(Constructor comparisonConstructor)
{
return IsTheSame(comparisonConstructor, ComparisonDepth.Signature);
}
public VBConstructorPrinter(Constructor obj)
{
this.obj = obj;
}
private void Process_Constructor_Declaration(ConstructorDeclaration node)
{
if (node == null) throw new ArgumentNullException("node");
Constructor constructor = new Constructor(controller);
constructor.Name = "New";// VB.Net constructors are always named 'New' // node.Name.Text;
constructor.Modifiers.AddRange(FormatterUtility.GetModifiersFromEnum(node.Modifiers));
foreach (IAstNode param in node.Parameters)
{
Parameter p = GetParameterFromParameterDeclaration(document, controller, param as ParameterDeclaration);
constructor.Parameters.Add(p);
p.ParentObject = constructor;
}
ProcessBodyText(node, constructor, node.Statements, node.Comments);
SetupBaseConstruct(node, constructor);
}
public void Constructor()
{
Constructor constructor = new Constructor(controller);
constructor.Modifiers.Add("public");
constructor.Name = "Class1";
constructor.BodyText = "{ }";
Parameter param = new Parameter(controller);
param.Name = "i";
param.DataType = "int";
constructor.Parameters.Add(param);
CodeRoot root = CreateClassAndNamespace(constructor);
CodeRootMap map = new CodeRootMap();
map.AddCodeRoot(root, Version.User);
map.AddCodeRoot(root, Version.NewGen);
map.AddCodeRoot(root, Version.PrevGen);
string result = map.GetMergedCodeRoot().ToString();
Assert.That(result, Is.EqualTo(root.ToString()));
Assertions.StringContains(result, "class Class1");
Assertions.StringContains(result, "[Serializable(true)]");
Assertions.StringContains(result, "namespace ArchAngel.Tests");
Assertions.StringContains(result, "public Class1");
Assertions.StringContains(result, "{ }");
}
