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")); }
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()); } }