public void Namespaces()
{
string code = @"namespace n1 { }";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Namespace n1 = (Namespace)codeRoot.WalkChildren()[0];
Assert.That(n1.Name, Is.EqualTo("n1"));
code = @"namespace n1 { namespace n2 { } }";
parser = new CSharpParser();
parser.ParseCode(code);
codeRoot = parser.CreatedCodeRoot;
n1 = (Namespace)codeRoot.WalkChildren()[0];
Namespace n2 = n1.InnerNamespaces[0];
Assert.That(n2.Name, Is.EqualTo("n2"));
Assert.That(n2.FullyQualifiedName, Is.EqualTo("n1.n2"));
}
public void Comments()
{
const string code = @"
/// <summary>
/// Xml Comment line\r\n
/// break.
///</summary>
public class Class1 // Class Trailing Comment
{
// Comment1-1
// Comment1-2
public int i = 0; // Trailing Comment
// Comment2-1
public int j = 0;
}";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Assert.That(codeRoot, Is.InstanceOfType(typeof(CodeRoot)));
Assert.That(codeRoot.WalkChildren(), Has.Count(1));
Class clazz = (Class)codeRoot.WalkChildren()[0];
Assert.That(clazz, Is.Not.Null);
Assert.That(clazz.Name, Is.EqualTo("Class1"));
Assert.That(clazz.XmlComments, Has.Count(4));
Assert.That(clazz.XmlComments[0].Trim(), Is.EqualTo(@"<summary>"));
Assert.That(clazz.XmlComments[1].Trim(), Is.EqualTo(@"Xml Comment line\r\n"));
Assert.That(clazz.XmlComments[2].Trim(), Is.EqualTo(@"break."));
Assert.That(clazz.XmlComments[3].Trim(), Is.EqualTo(@"</summary>"));
Assert.That(clazz.Comments.TrailingComment, Is.EqualTo("// Class Trailing Comment"));
Assert.That(clazz.WalkChildren(), Has.Count(2));
Field field = (Field)clazz.WalkChildren()[0];
Assert.That(field.Name, Is.EqualTo("i"));
Assert.That(field.Comments.PreceedingComments, Has.Count(2));
Assert.That(field.Comments.PreceedingComments[0], Is.EqualTo("// Comment1-1"));
Assert.That(field.Comments.PreceedingComments[1], Is.EqualTo("// Comment1-2"));
Assert.That(field.Comments.TrailingComment, Is.EqualTo("// Trailing Comment"));
field = (Field)clazz.WalkChildren()[1];
Assert.That(field.Name, Is.EqualTo("j"));
Assert.That(field.Comments.PreceedingComments, Has.Count(1));
Assert.That(field.Comments.PreceedingComments[0], Is.EqualTo("// Comment2-1"));
}
public void Constructors()
{
const string code = @"
public class Class1
{
public Class1(string param1)
{
}
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Constructor con = (Constructor)clazz.WalkChildren()[0];
Assert.That(con.Name, Is.EqualTo("Class1"));
Assert.That(con.Modifiers, Has.Count(1));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
Assert.That(con.Parameters, Has.Count(1));
Assert.That(con.Parameters[0].Name, Is.EqualTo("param1"));
Assert.That(con.Parameters[0].DataType, Is.EqualTo("string"));
Assert.That(con.BodyText, Is.EqualTo("{\r\n}\r\n"));
}
public void Interface_Methods()
{
const string code = @"
public interface Interface1
{
string Method1(int param, Interface1 i);
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Interface clazz = (Interface)codeRoot.WalkChildren()[0];
InterfaceMethod inter = (InterfaceMethod)clazz.WalkChildren()[0];
Assert.That(inter.Name, Is.EqualTo("Method1"));
Assert.That(inter.ReturnType.ToString(), Is.EqualTo("string"));
Assert.That(inter.Parameters, Has.Count(2));
Assert.That(inter.Parameters[0].Name, Is.EqualTo("param"));
Assert.That(inter.Parameters[0].DataType, Is.EqualTo("int"));
Assert.That(inter.Parameters[1].Name, Is.EqualTo("i"));
Assert.That(inter.Parameters[1].DataType, Is.EqualTo("Interface1"));
}
public void GenericInterfaceMethod_WithConstraints()
{
const string code = @"
public interface Interface1
{
string Method1<T>(int param, T i) where T : class;
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
if (parser.ErrorOccurred)
{
Assert.Fail(parser.GetFormattedErrors());
}
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Interface clazz = (Interface)codeRoot.WalkChildren()[0];
InterfaceMethod inter = (InterfaceMethod)clazz.WalkChildren()[0];
Assert.That(inter.Name, Is.EqualTo("Method1"));
Assert.That(inter.GenericParameters.Count, Is.EqualTo(1));
Assert.That(inter.GenericParameters[0], Is.EqualTo("T"));
Assert.That(inter.GenericConstraintClause, Is.EqualTo("where T : class"));
Assert.That(inter.ReturnType.ToString(), Is.EqualTo("string"));
Assert.That(inter.Parameters, Has.Count(2));
Assert.That(inter.Parameters[0].Name, Is.EqualTo("param"));
Assert.That(inter.Parameters[0].DataType, Is.EqualTo("int"));
Assert.That(inter.Parameters[1].Name, Is.EqualTo("i"));
Assert.That(inter.Parameters[1].DataType, Is.EqualTo("T"));
}
public void Interface_Indexer()
{
const string code = @"
public interface Interface1
{
string this[int i] { get; set; }
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Interface clazz = (Interface)codeRoot.WalkChildren()[0];
InterfaceIndexer inter = (InterfaceIndexer)clazz.WalkChildren()[0];
Assert.That(inter.DataType.ToString(), Is.EqualTo("string"));
Assert.That(inter.GetAccessor, Is.Not.Null);
Assert.That(inter.SetAccessor, Is.Not.Null);
Assert.That(inter.Parameters, Has.Count(1));
Assert.That(inter.Parameters[0].Name, Is.EqualTo("i"));
Assert.That(inter.Parameters[0].DataType, Is.EqualTo("int"));
}
public void Regions()
{
const string code = @"
namespace N1
{
#region Region Name
public class Class1
{
}
#endregion
}";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Namespace ns = (Namespace)codeRoot.WalkChildren()[0];
Assert.That(ns.WalkChildren(), Has.Count(1));
Region region = ns.SortedConstructs[0] as Region;
Assert.IsNotNull(region);
Assert.That(region.Name, Is.EqualTo("Region Name"));
Assert.That(region.WalkChildren(), Has.Count(1));
Assert.That(region.SortedConstructs[0], Is.InstanceOfType(typeof(Class)));
}
public void Methods()
{
const string code = @"
public class Class1
{
public void Class1(string param1)
{
int i = 0;
}
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Function con = (Function)clazz.WalkChildren()[0];
Assert.That(con.Name, Is.EqualTo("Class1"));
Assert.That(con.ReturnType.ToString(), Is.EqualTo("void"));
Assert.That(con.Modifiers, Has.Count(1));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
Assert.That(con.Parameters, Has.Count(1));
Assert.That(con.Parameters[0].Name, Is.EqualTo("param1"));
Assert.That(con.Parameters[0].DataType, Is.EqualTo("string"));
Assert.That(con.BodyText, Is.EqualTo("{\r\n\tint i = 0;\r\n}\r\n"));
}
public void Indexers()
{
const string code = @"
public class Class1
{
public static int this[int i]
{
get { return i; }
set { }
}
}";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Indexer con = (Indexer)clazz.WalkChildren()[0];
Assert.That(con.Name, Is.Empty);
Assert.That(con.DataType.ToString(), Is.EqualTo("int"));
Assert.That(con.Parameters, Has.Count(1));
Assert.That(con.Parameters[0].Name, Is.EqualTo("i"));
Assert.That(con.Parameters[0].DataType, Is.EqualTo("int"));
Assert.That(con.GetAccessor, Is.Not.Null);
Assert.That(con.GetAccessor.AccessorType, Is.EqualTo(PropertyAccessor.AccessorTypes.Get));
Assert.That(con.GetAccessor.BodyText, Is.EqualTo("{ return i; }"));
Assert.That(con.SetAccessor, Is.Not.Null);
Assert.That(con.SetAccessor.AccessorType, Is.EqualTo(PropertyAccessor.AccessorTypes.Set));
Assert.That(con.SetAccessor.BodyText, Is.EqualTo("{ }"));
}
public void GenericMethod_WithConstraints()
{
const string code = @"
public class Class1
{
public void Method1<T>(T param) where T : struct
{
}
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
if (parser.ErrorOccurred)
{
Assert.Fail(parser.GetFormattedErrors());
}
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Function function = (Function)clazz.WalkChildren()[0];
Assert.That(function.Name, Is.EqualTo("Method1"));
Assert.That(function.GenericParameters.Count, Is.EqualTo(1));
Assert.That(function.GenericParameters[0], Is.EqualTo("T"));
Assert.That(function.GenericConstraintClause, Is.EqualTo("where T : struct"));
Assert.That(function.ReturnType.ToString(), Is.EqualTo("void"));
Assert.That(function.Parameters, Has.Count(1));
Assert.That(function.Parameters[0].Name, Is.EqualTo("param"));
Assert.That(function.Parameters[0].DataType, Is.EqualTo("T"));
}
public void Operators()
{
const string code = @"
public class Class1
{
public static int operator +(Class1 self, string param1)
{
int i = 0;
return i;
}
}";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Operator con = (Operator)clazz.WalkChildren()[0];
Assert.That(con.Name, Is.EqualTo("+"));
Assert.That(con.DataType.ToString(), Is.EqualTo("int"));
Assert.That(con.Modifiers, Has.Count(2));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
Assert.That(con.Modifiers[1], Is.EqualTo("static"));
Assert.That(con.Parameters, Has.Count(2));
Assert.That(con.Parameters[0].Name, Is.EqualTo("self"));
Assert.That(con.Parameters[0].DataType, Is.EqualTo("Class1"));
Assert.That(con.Parameters[1].Name, Is.EqualTo("param1"));
Assert.That(con.Parameters[1].DataType, Is.EqualTo("string"));
Assert.That(con.BodyText, Is.EqualTo("{\r\n\tint i = 0;\r\n\treturn i;\r\n}\r\n"));
}
public void Delegates()
{
const string code = @"
public class Class1
{
public delegate int Delegate1(string param1, Class1 p2);
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Delegate con = (Delegate)clazz.WalkChildren()[0];
Assert.That(con.Name, Is.EqualTo("Delegate1"));
Assert.That(con.Modifiers, Has.Count(1));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
Assert.That(con.ReturnType.Name, Is.EqualTo("int"));
Assert.That(con.Parameters, Has.Count(2));
Assert.That(con.Parameters[0].Name, Is.EqualTo("param1"));
Assert.That(con.Parameters[0].DataType, Is.EqualTo("string"));
Assert.That(con.Parameters[1].Name, Is.EqualTo("p2"));
Assert.That(con.Parameters[1].DataType, Is.EqualTo("Class1"));
}
public void Properties()
{
const string code = @"
public class Class1
{
public static int SomeValue
{
get { return i; }
set { }
}
}";
CSharpParser parser = new CSharpParser();
parser.FormatSettings.InlineSingleLineGettersAndSetters = true;
parser.FormatSettings.PutBracesOnNewLines = false;
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Property con = (Property)clazz.WalkChildren()[0];
Assert.That(con.Name, Is.EqualTo("SomeValue"));
Assert.That(con.DataType.ToString(), Is.EqualTo("int"));
Assert.That(con.Modifiers, Has.Count(2));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
Assert.That(con.Modifiers[1], Is.EqualTo("static"));
Assert.That(con.GetAccessor, Is.Not.Null);
Assert.That(con.GetAccessor.AccessorType, Is.EqualTo(PropertyAccessor.AccessorTypes.Get));
Assert.That(con.GetAccessor.BodyText, Is.EqualTo("{ return i; }"));
Assert.That(con.SetAccessor, Is.Not.Null);
Assert.That(con.SetAccessor.AccessorType, Is.EqualTo(PropertyAccessor.AccessorTypes.Set));
Assert.That(con.SetAccessor.BodyText, Is.EqualTo("{ }"));
}
/// <summary>
/// Adds a CodeRoot to the tree.
/// </summary>
/// <param name="codeRoot">The CodeRoot to add.</param>
/// <param name="type">The Version of the CodeRoot to add.</param>
public void AddCodeRoot(ICodeRoot codeRoot, Version type)
{
coderoots.SetObject(codeRoot, type);
foreach (IBaseConstruct bc in codeRoot.WalkChildren())
{
AddBaseConstructAsChild(bc, type);
}
}
public void MultiLineComments()
{
const string code = @"
/* adfjlaskdjflkasdjflkjdf */
public class Class1
{
/* Comment1-1
* Comment1-2 */
public int i = 0; /* Trailing Comment
* Comment2-1 */
public int j = 0;
}";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Assert.That(codeRoot, Is.InstanceOfType(typeof(CodeRoot)));
Assert.That(codeRoot.WalkChildren(), Has.Count(1));
Class clazz = (Class)codeRoot.WalkChildren()[0];
Assert.That(clazz, Is.Not.Null);
Assert.That(clazz.Name, Is.EqualTo("Class1"));
Assert.That(clazz.Comments.PreceedingComments, Has.Count(1));
Assert.That(clazz.Comments.PreceedingComments[0].Trim(), Is.EqualTo("/* adfjlaskdjflkasdjflkjdf */"));
Assert.That(clazz.WalkChildren(), Has.Count(2));
Field field = (Field)clazz.WalkChildren()[0];
Assert.That(field.Name, Is.EqualTo("i"));
Assert.That(field.Comments.PreceedingComments, Has.Count(1));
Assert.That(field.Comments.PreceedingComments[0], Is.EqualTo(@"/* Comment1-1
* Comment1-2 */"));
Assert.That(field.Comments.TrailingComment, Is.EqualTo(@"/* Trailing Comment
* Comment2-1 */"));
field = (Field)clazz.WalkChildren()[1];
Assert.That(field.Name, Is.EqualTo("j"));
Assert.That(field.Comments.PreceedingComments, Has.Count(0));
}
public void UsingStatements()
{
string code = @"using System;
namespace n1 { }";
CSharpParser parser = new CSharpParser();
parser.FormatSettings.ReorderBaseConstructs = false;
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Assert.That(((CodeRoot)codeRoot).UsingStatements[0].ToString(), Is.EqualTo("using System;"));
Namespace n1 = (Namespace)codeRoot.WalkChildren()[0];
Assert.That(n1.Name, Is.EqualTo("n1"));
Assert.That(n1.UsingStatements, Is.Empty);
code = @"using System;
namespace n1
{
using System.Web;
namespace n2
{
using Slyce.Common;
}
}";
parser = new CSharpParser();
parser.ParseCode(code);
codeRoot = parser.CreatedCodeRoot;
Assert.That(((CodeRoot)codeRoot).UsingStatements[0].ToString(), Is.EqualTo("using System;"));
n1 = (Namespace)codeRoot.WalkChildren()[0];
Assert.That(n1.UsingStatements[0].ToString(), Is.EqualTo("using System.Web;"));
Namespace n2 = n1.InnerNamespaces[0];
Assert.That(n2.Name, Is.EqualTo("n2"));
Assert.That(n2.FullyQualifiedName, Is.EqualTo("n1.n2"));
Assert.That(n2.UsingStatements[0].ToString(), Is.EqualTo("using Slyce.Common;"));
}
/// <summary>
/// Returns the IBaseConstruct for Class1
/// </summary>
/// <param name="cr"></param>
/// <returns></returns>
private static void AssertBasicConstructsExist(ICodeRoot cr)
{
Assert.That(cr.WalkChildren(), Has.Count(1));
IBaseConstruct namespaceBC = cr.WalkChildren()[0];
Assert.That(namespaceBC.FullyQualifiedIdentifer, Is.EqualTo("Slyce.IntelliMerge.UnitTesting.Resources.CSharp"));
Assert.That(namespaceBC.WalkChildren(), Has.Count(1));
IBaseConstruct classBC = namespaceBC.WalkChildren()[0];
Assert.That(classBC.FullyQualifiedIdentifer,
Is.EqualTo(string.Format("Slyce.IntelliMerge.UnitTesting.Resources.CSharp{0}Class1", BaseConstructConstants.FullyQualifiedIdentifierSeparator)));
Assert.That(classBC.WalkChildren(), Has.Count(1));
IBaseConstruct methodBC = classBC.WalkChildren()[0];
Assert.That(methodBC.FullyQualifiedIdentifer,
Is.EqualTo(string.Format("Slyce.IntelliMerge.UnitTesting.Resources.CSharp{0}Class1{0}Method ()", BaseConstructConstants.FullyQualifiedIdentifierSeparator)));
return;
}
public void GenericClasses()
{
const string code =
@"
public class Class1<T> : IComparer<T>
{
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Assert.That(clazz.Name, Is.EqualTo("Class1<T>"));
Assert.That(clazz.BaseNames[0], Is.EqualTo("IComparer<T>"));
}
public void Interface_Events()
{
const string code = @"
public interface Interface1
{
event Delegate1 Event1;
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Interface clazz = (Interface)codeRoot.WalkChildren()[0];
InterfaceEvent enu = (InterfaceEvent)clazz.WalkChildren()[0];
Assert.That(enu.Name, Is.EqualTo("Event1"));
Assert.That(enu.DataType.ToString(), Is.EqualTo("Delegate1"));
}
public static void SetupBaseConstructs(MockRepository mocks, IBaseConstruct bc1, IBaseConstruct bc2, ICodeRoot coderoot)
{
using (mocks.Record())
{
Expect.Call(bc1.ShortName).Repeat.Any().Return("bc1");
Expect.Call(bc2.ShortName).Repeat.Any().Return("bc2");
Expect.Call(bc1.IsTheSame(bc1)).Repeat.Any().Return(true);
Expect.Call(bc2.IsTheSame(bc2)).Repeat.Any().Return(true);
Expect.Call(bc2.WalkChildren()).Repeat.AtLeastOnce().Return(new List <IBaseConstruct>().AsReadOnly());
List <IBaseConstruct> bc1Children = new List <IBaseConstruct>();
bc1Children.Add(bc2);
Expect.Call(bc1.WalkChildren()).Repeat.AtLeastOnce().Return(bc1Children.AsReadOnly());
List <IBaseConstruct> rootChildren = new List <IBaseConstruct>();
rootChildren.Add(bc1);
Expect.On(coderoot).Call(coderoot.WalkChildren()).Repeat.AtLeastOnce().Return(rootChildren.AsReadOnly());
}
}
public void Structures_MultipleFields()
{
const string code = @"
public class Class1
{
public struct Structure1
{
public int i;
public int j;
}
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Struct con = (Struct)clazz.WalkChildren()[0];
Assert.That(con.Name, Is.EqualTo("Structure1"));
Assert.That(con.Modifiers, Has.Count(1));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
Field f1 = con.Fields[0];
Assert.That(f1.Name, Is.EqualTo("i"));
Assert.That(f1.Modifiers, Has.Count(1));
Assert.That(f1.Modifiers[0], Is.EqualTo("public"));
Assert.That(f1.DataType.Name, Is.EqualTo("int"));
Field f2 = con.Fields[1];
Assert.That(f2.Name, Is.EqualTo("j"));
Assert.That(f2.Modifiers, Has.Count(1));
Assert.That(f2.Modifiers[0], Is.EqualTo("public"));
Assert.That(f2.DataType.Name, Is.EqualTo("int"));
}
public static void TestBodyText(string methodBody, string expectedText, CSharpFormatSettings formatSettings)
{
string code =
string.Format("public class Class1\r\n{0}\r\npublic void Method1(string param1)\r\n{0}\r\n{2}\r\n{1}\r\n{1}", '{',
'}', methodBody);
CSharpParser parser = new CSharpParser();
parser.FormatSettings.SetFrom(formatSettings);
parser.ParseCode(code);
Assert.That(parser.ErrorOccurred, Is.False, "Parser errors occurred:\n" + GetSyntaxErrors(parser));
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Function con = (Function)clazz.WalkChildren()[0];
Assert.That(con.Name, Is.EqualTo("Method1"));
Assert.That(con.BodyText, Is.EqualTo(expectedText));
}
public void Fields()
{
const string code = @"
public class Class1
{
public static int i = 0;
public const float PI = 3.14159265358979323846;
}
";
CSharpParser parser = new CSharpParser();
parser.FormatSettings.ReorderBaseConstructs = false;
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Field con = (Field)clazz.WalkChildren()[0];
Assert.That(con.Name, Is.EqualTo("i"));
Assert.That(con.Modifiers, Has.Count(2));
Assert.That(con.DataType.Name, Is.EqualTo("int"));
Assert.That(con.InitialValue, Is.EqualTo("0"));
// Modifiers should be kept in order.
Assert.That(con.Modifiers, Has.Count(2));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
Assert.That(con.Modifiers[1], Is.EqualTo("static"));
con = (Field)clazz.WalkChildren()[1];
Assert.That(con.Name, Is.EqualTo("PI"));
Assert.That(con.Modifiers, Has.Count(2));
Assert.That(con.DataType.Name, Is.EqualTo("float"));
Assert.That(con.InitialValue, Is.EqualTo("3.14159265358979323846"));
// Modifiers should be kept in order.
Assert.That(con.Modifiers, Has.Count(2));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
Assert.That(con.Modifiers[1], Is.EqualTo("const"));
}
public void Structures()
{
const string code = @"
public class Class1
{
public struct Structure1 { }
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Struct con = (Struct)clazz.WalkChildren()[0];
Assert.That(con.Name, Is.EqualTo("Structure1"));
Assert.That(con.Modifiers, Has.Count(1));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
}
public void Interfaces()
{
const string code = @"
public class Class1
{
public interface MarkerInterface { }
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Interface con = (Interface)clazz.WalkChildren()[0];
Assert.That(con.Name, Is.EqualTo("MarkerInterface"));
Assert.That(con.Modifiers, Has.Count(1));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
}
public void Interface_Properties()
{
const string code = @"
public interface Interface1
{
string Property1 { get; set; }
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Interface clazz = (Interface)codeRoot.WalkChildren()[0];
InterfaceProperty inter = (InterfaceProperty)clazz.WalkChildren()[0];
Assert.That(inter.Name, Is.EqualTo("Property1"));
Assert.That(inter.DataType.ToString(), Is.EqualTo("string"));
Assert.That(inter.GetAccessor, Is.Not.Null);
Assert.That(inter.SetAccessor, Is.Not.Null);
}
public void Events()
{
const string code = @"
public class Class1
{
public event Delegate1 Event1;
}
";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Event enu = (Event)clazz.WalkChildren()[0];
Assert.That(enu.Name, Is.EqualTo("Event1"));
Assert.That(enu.Modifiers, Has.Count(1));
Assert.That(enu.Modifiers[0], Is.EqualTo("public"));
Assert.That(enu.DataType.ToString(), Is.EqualTo("Delegate1"));
}
public void Attributes()
{
const string code = @"
namespace n1
{
[Serializable]
[SomeAttribute(NamedParam = ""Nothing"")]
public class Class1
{
}
[Positional(1, ""string"")]
public class Class2
{
}
}";
CSharpParser parser = new CSharpParser();
parser.FormatSettings.ReorderBaseConstructs = false;
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Namespace n1 = (Namespace)codeRoot.WalkChildren()[0];
Class clazz = n1.Classes[0];
Assert.That(clazz.Attributes, Has.Count(2));
Assert.That(clazz.Attributes[0].ToString(), Is.EqualTo("Serializable"));
Assert.That(clazz.Attributes[1].ToString(), Is.EqualTo("SomeAttribute(NamedParam = \"Nothing\")"));
clazz = n1.Classes[1];
Assert.That(clazz.Attributes, Has.Count(1));
Assert.That(clazz.Attributes[0].ToString(), Is.EqualTo("Positional(1, \"string\")"));
}
public void Enums()
{
const string code = @"
public class Class1
{
public enum Enumeration1
{
One = 1, Two = 2
}
}";
CSharpParser parser = new CSharpParser();
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Enumeration enu = (Enumeration)clazz.WalkChildren()[0];
Assert.That(enu.Name, Is.EqualTo("Enumeration1"));
Assert.That(enu.Modifiers, Has.Count(1));
Assert.That(enu.Modifiers[0], Is.EqualTo("public"));
}
/// <summary>
/// Returns the IBaseConstruct for Class1
/// </summary>
/// <param name="cr"></param>
/// <returns></returns>
private static void AssertBasicConstructsExist(ICodeRoot cr)
{
Assert.That(cr.WalkChildren(), Has.Count(1));
IBaseConstruct namespaceBC = cr.WalkChildren()[0];
Assert.That(namespaceBC.FullyQualifiedIdentifer, Is.EqualTo("Slyce.IntelliMerge.UnitTesting.Resources.CSharp"));
Assert.That(namespaceBC.WalkChildren(), Has.Count(1));
IBaseConstruct classBC = namespaceBC.WalkChildren()[0];
Assert.That(classBC.FullyQualifiedIdentifer,
Is.EqualTo(string.Format("Slyce.IntelliMerge.UnitTesting.Resources.CSharp{0}Class1", BaseConstructConstants.FullyQualifiedIdentifierSeparator)));
Assert.That(classBC.WalkChildren(), Has.Count(1));
IBaseConstruct methodBC = classBC.WalkChildren()[0];
Assert.That(methodBC.FullyQualifiedIdentifer,
Is.EqualTo(string.Format("Slyce.IntelliMerge.UnitTesting.Resources.CSharp{0}Class1{0}Method ()", BaseConstructConstants.FullyQualifiedIdentifierSeparator)));
return;
}
public void PrimitiveTypes_LongNames()
{
const string code = @"public class Class1
{
public Int32 a = 0;
public String b = """";
public Int16 c = 0;
public Int64 d = 0;
public Single e = 0;
public Double f = 0;
public Bool g = false;
public Char h = 'c';
public Byte i = 0;
public Object j = null;
public Decimal k = 0.0m;
}";
CSharpParser parser = new CSharpParser();
parser.FormatSettings.ReorderBaseConstructs = false;
parser.ParseCode(code);
ICodeRoot codeRoot = parser.CreatedCodeRoot;
Class clazz = (Class)codeRoot.WalkChildren()[0];
Field con = (Field)clazz.WalkChildren()[0];
Assert.That(con.Name, Is.EqualTo("a"));
Assert.That(con.DataType.Name, Is.EqualTo("Int32"));
con = (Field)clazz.WalkChildren()[1];
Assert.That(con.Name, Is.EqualTo("b"));
Assert.That(con.DataType.Name, Is.EqualTo("String"));
con = (Field)clazz.WalkChildren()[2];
Assert.That(con.Name, Is.EqualTo("c"));
Assert.That(con.DataType.Name, Is.EqualTo("Int16"));
con = (Field)clazz.WalkChildren()[3];
Assert.That(con.Name, Is.EqualTo("d"));
Assert.That(con.DataType.Name, Is.EqualTo("Int64"));
con = (Field)clazz.WalkChildren()[4];
Assert.That(con.Name, Is.EqualTo("e"));
Assert.That(con.DataType.Name, Is.EqualTo("Single"));
con = (Field)clazz.WalkChildren()[5];
Assert.That(con.Name, Is.EqualTo("f"));
Assert.That(con.DataType.Name, Is.EqualTo("Double"));
con = (Field)clazz.WalkChildren()[6];
Assert.That(con.Name, Is.EqualTo("g"));
Assert.That(con.DataType.Name, Is.EqualTo("Bool"));
con = (Field)clazz.WalkChildren()[7];
Assert.That(con.Name, Is.EqualTo("h"));
Assert.That(con.DataType.Name, Is.EqualTo("Char"));
con = (Field)clazz.WalkChildren()[8];
Assert.That(con.Name, Is.EqualTo("i"));
Assert.That(con.DataType.Name, Is.EqualTo("Byte"));
con = (Field)clazz.WalkChildren()[9];
Assert.That(con.Name, Is.EqualTo("j"));
Assert.That(con.DataType.Name, Is.EqualTo("Object"));
con = (Field)clazz.WalkChildren()[10];
Assert.That(con.Name, Is.EqualTo("k"));
Assert.That(con.DataType.Name, Is.EqualTo("Decimal"));
}
public static void SetupBaseConstructs(MockRepository mocks, IBaseConstruct bc1, IBaseConstruct bc2, ICodeRoot coderoot)
{
using(mocks.Record())
{
Expect.Call(bc1.ShortName).Repeat.Any().Return("bc1");
Expect.Call(bc2.ShortName).Repeat.Any().Return("bc2");
Expect.Call(bc1.IsTheSame(bc1)).Repeat.Any().Return(true);
Expect.Call(bc2.IsTheSame(bc2)).Repeat.Any().Return(true);
Expect.Call(bc2.WalkChildren()).Repeat.AtLeastOnce().Return(new List<IBaseConstruct>().AsReadOnly());
List<IBaseConstruct> bc1Children = new List<IBaseConstruct>();
bc1Children.Add(bc2);
Expect.Call(bc1.WalkChildren()).Repeat.AtLeastOnce().Return(bc1Children.AsReadOnly());
List<IBaseConstruct> rootChildren = new List<IBaseConstruct>();
rootChildren.Add(bc1);
Expect.On(coderoot).Call(coderoot.WalkChildren()).Repeat.AtLeastOnce().Return(rootChildren.AsReadOnly());
}
}
