public void Test()
{
string codeText = File.ReadAllText("Resources\\BasicClass.txt");
var parser = new CSharpParser();
parser.ParseCode(codeText);
var codeRoot = (CodeRoot)parser.CreatedCodeRoot;
//Actions actions = Test2(codeRoot);//Test1(codeRoot);
Actions actions = new Actions();
Entity entity = new EntityImpl("BasicClass");
entity.AddProperty(new PropertyImpl { Name = "Property5", Type = "Entity" });
Entity entity1 = new EntityImpl("Class1");
entity1.AddProperty(new PropertyImpl { Name = "Property5", Type = "Entity" });
entity.MappedClass = codeRoot.Namespaces[0].Classes[0];
entity1.MappedClass = codeRoot.Namespaces[0].Classes[1];
CheckEntity(entity, actions);
codeText = actions.RunActions(codeText, codeRoot, true);
actions = new Actions();
actions.AddAction(new AddAttributeToPropertyAction(entity.MappedClass.Properties[0], new Attribute(codeRoot.Controller){Name = "Attr"}));
CheckEntity(entity1, actions);
var output = actions.RunActions(codeText, codeRoot, false);
}
public void TestPosition()
{
CSharpParser parser = new CSharpParser();
parser.ParseCode(@"using System;
using NUnit.Framework;
class Hahaha
{
");
Assert.That(parser.ErrorOccurred, Is.True);
Assert.That(parser.SyntaxErrors, Has.Count(1));
Assert.That(parser.SyntaxErrors[0].LineNumber, Is.EqualTo(3));
parser = new CSharpParser();
parser.ParseCode(@"using System;
using NUnit.Framework;
class Hahaha
{
public TestMethod(){ }");
Assert.That(parser.ErrorOccurred, Is.True);
Assert.That(parser.SyntaxErrors, Has.Count(1));
Assert.That(parser.SyntaxErrors[0].LineNumber, Is.EqualTo(4));
parser = new CSharpParser();
parser.ParseCode(@"using System");
Assert.That(parser.ErrorOccurred, Is.True);
Assert.That(parser.SyntaxErrors, Has.Count(1));
Assert.That(parser.SyntaxErrors[0].LineNumber, Is.EqualTo(0));
}
public void testMultipleErrors()
{
CSharpParser parser = new CSharpParser();
parser.ParseCode(@"using System
using NUnit.Framework;
class Hahaha
{
publi TestMethod()
{
}
}");
Assert.That(parser.ErrorOccurred, Is.True);
Assert.That(parser.SyntaxErrors, Has.Count(2));
Assert.That(parser.SyntaxErrors[0].LineNumber, Is.EqualTo(0));
Assert.That(parser.SyntaxErrors[1].LineNumber, Is.EqualTo(4));
parser = new CSharpParser();
parser.ParseCode(@"using System
using NUnit.Framework;
class Hahaha
{
publi TestMethod()
{
}
public testOtherMethod(
{
}
}");
Assert.That(parser.ErrorOccurred, Is.True);
Assert.That(parser.SyntaxErrors, Has.Count(3));
Assert.That(parser.SyntaxErrors[0].LineNumber, Is.EqualTo(0));
Assert.That(parser.SyntaxErrors[1].LineNumber, Is.EqualTo(4));
Assert.That(parser.SyntaxErrors[2].LineNumber, Is.EqualTo(8));
}
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\")"));
}
/// <summary>
/// Parses the source-code in the csharpFileText.
/// </summary>
/// <param name="vbFileText"></param>
/// <returns></returns>
public static CodeRoot ParseVbCode(string vbFileText)
{
var parser = new CSharpParser();
var parseResults = new ParseResults();
parser.Reset();
parser.ParseCode(vbFileText);
return (CodeRoot)parser.CreatedCodeRoot;
}
public void Reparse()
{
ClearErrors();
CSharpParser formatter = new CSharpParser();
formatter.ParseCode(editor.Text);
if(formatter.ErrorOccurred)
{
AddAllErrors(formatter.SyntaxErrors);
}
DisplayErrors();
}
public void TestBasicSyntaxError()
{
CSharpParser parser = new CSharpParser();
parser.ParseCode("using System;");
Assert.That(parser.ErrorOccurred, Is.False);
parser = new CSharpParser();
parser.ParseCode("lkjakjlawel;rfjaolkjnawlekmfpijsdpv;je;kf23-54-9845emadvlz");
Assert.That(parser.ErrorOccurred, Is.True);
Assert.That(parser.SyntaxErrors, Has.Count(1));
}
public void An_InterfaceEvent_Is_Created()
{
const string code = "event Delegate1 Event1;";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.InterfaceEventDeclaration);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(InterfaceEvent)));
InterfaceEvent con = (InterfaceEvent)bc;
Assert.That(con.Name, Is.EqualTo("Event1"));
Assert.That(con.DataType.Name, Is.EqualTo("Delegate1"));
}
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 Diff_Result_Is_Exact_Copy()
{
string original = Path.Combine(ResourcePath, "Class1.cs");
CodeRootMap codeRootMap = new CodeRootMap();
CSharpParser formatter = new CSharpParser();
formatter.ParseCode(File.ReadAllText(original));
ICodeRoot codeRoot = formatter.CreatedCodeRoot;
codeRootMap.AddCodeRoot(codeRoot, Version.User);
codeRootMap.AddCodeRoot(codeRoot, Version.NewGen);
codeRootMap.AddCodeRoot(codeRoot, Version.PrevGen);
Assert.That(codeRootMap.Diff(), Is.EqualTo(TypeOfDiff.ExactCopy));
}
public void An_Event_Is_Created()
{
const string code = "public event Delegate1 Event1;";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.EventDeclaration);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(Event)));
Event con = (Event)bc;
Assert.That(con.Name, Is.EqualTo("Event1"));
Assert.That(con.Modifiers.Count, Is.EqualTo(1));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
Assert.That(con.DataType.Name, Is.EqualTo("Delegate1"));
}
public static ParseResults ParseCSharpFiles(IEnumerable<string> csharpFiles)
{
var parser = new CSharpParser();
var parseResults = new ParseResults();
foreach (var file in csharpFiles)
{
if (File.Exists(file) == false)
continue;
parser.Reset();
parser.ParseCode(file, File.ReadAllText(file));
parseResults.AddParsedFile(file, parser.CreatedCodeRoot as CodeRoot);
}
return parseResults;
}
private void TestFiles()
{
foreach(string file in _Files)
{
try
{
GC.Collect();
CSharpParser parser = new CSharpParser();
parser.ParseCode(file, File.ReadAllText(file));
if (parser.ErrorOccurred == false) continue;
Assert.IsNull(parser.ExceptionThrown, parser.ExceptionThrown == null ? "" : parser.ExceptionThrown.ToString());
Assert.That(parser.SyntaxErrors.Count, Is.EqualTo(0), "There were syntax errors in file " + file);
}
catch(Exception e)
{
Assert.Fail(e.ToString());
}
}
}
public void Parser_Exception_Thrown()
{
CSharpParser parser = new CSharpParser();
try
{
const string code = "Nonsense, and more nonsense.";
parser.ParseSingleConstruct(code, BaseConstructType.ConstructorDeclaration);
Assert.Fail("Parser exception not thrown");
}
catch(ParserException)
{
// Everything went according to plan
}
Assert.That(parser.ErrorOccurred);
Assert.That(parser.SyntaxErrors.Count, Is.GreaterThan(0));
}
public void TestFile(string filename, bool stripText, CSharpFormatSettings settings)
{
string fileText = File.ReadAllText(filename);
CSharpParser formatter = new CSharpParser();
formatter.FormatSettings.SetFrom(settings);
formatter.ParseCode(fileText);
Assert.IsFalse(formatter.ErrorOccurred);
string formattedText = formatter.CreatedCodeRoot.ToString();
formattedText =
Slyce.Common.Utility.StandardizeLineBreaks(formattedText, Slyce.Common.Utility.LineBreaks.Windows);
string strippedFileText = Diff.StripWhitespace(new[] {fileText}, stripText)[0].Replace("\t", " ");
string strippedFormattedText = Diff.StripWhitespace(new[] { formattedText }, stripText)[0].Replace("\t", " ");
Assert.That(strippedFormattedText, Is.EqualTo(strippedFileText));
}
public void They_Are_Added_Correctly()
{
var parser = new CSharpParser();
parser.ParseCode(Code.Class1Text);
var codeRoot = (CodeRoot)parser.CreatedCodeRoot;
var basicClass = codeRoot.Namespaces[0].Classes[0];
var property2 = new Property(codeRoot.Controller, "Property1", new DataType(codeRoot.Controller, "string"), "public");
var property3 = new Property(codeRoot.Controller, "Property2", new DataType(codeRoot.Controller, "Class1"), "private");
var action1 = new AddPropertyToClassAction(property2, AdditionPoint.EndOfParent, basicClass);
var action2 = new AddPropertyToClassAction(property3, AdditionPoint.EndOfParent, basicClass);
Actions actions = new Actions();
actions.AddAction(action1);
actions.AddAction(action2);
string output = actions.RunActions(parser);
output = Slyce.Common.Utility.StandardizeLineBreaks(output, Environment.NewLine);
Assert.That(output, Is.EqualTo(Code.Class1Plus2PropertiesText));
}
internal static ICodeRoot GetCodeRoot(string fileName)
{
CSharpParser formatter = new CSharpParser();
formatter.ParseCode(File.ReadAllText(fileName));
return formatter.CreatedCodeRoot;
}
internal static void AssertFilesAreSame(string original, string changed)
{
CodeRootMap codeRootMap = new CodeRootMap();
CSharpParser formatter = new CSharpParser();
formatter.FormatSettings.ReorderBaseConstructs = true;
formatter.ParseCode(File.ReadAllText(original));
ICodeRoot codeRoot = formatter.CreatedCodeRoot;
codeRootMap.AddCodeRoot(codeRoot, Version.NewGen);
codeRootMap.AddCodeRoot(codeRoot, Version.PrevGen);
formatter = new CSharpParser();
formatter.FormatSettings.ReorderBaseConstructs = true;
formatter.ParseCode(File.ReadAllText(changed));
codeRoot = formatter.CreatedCodeRoot;
codeRootMap.AddCodeRoot(codeRoot, Version.User);
Assert.That(codeRootMap.Diff(), Is.EqualTo(TypeOfDiff.ExactCopy));
}
public static FunctionInfo CreateFunctionInfoFrom(ApiExtensionMethod extMethod)
{
MethodInfo method = extMethod.ExtendedMethod;
string formattedCode = extMethod.OverridingFunctionBody;
if (extMethod.HasOverride == false && string.IsNullOrEmpty(extMethod.DefaultCode) == false)
{
CSharpParser parser = new CSharpParser();
parser.FormatSettings.MaintainWhitespace = false;
string methodText = string.Format("public void {0} () {{ {1} }}", method.Name, extMethod.DefaultCode);
var bc = parser.ParseSingleConstruct(methodText, BaseConstructType.MethodDeclaration);
// Remove the start and end braces
formattedCode = Utility.StandardizeLineBreaks(bc.ToString(), "\n");
// + 1 to get past the {, +1 to remove the first line break.
formattedCode = formattedCode.Substring(formattedCode.IndexOf('{')+2);
formattedCode = formattedCode.Substring(0, formattedCode.LastIndexOf('}')-1);
formattedCode = RemoveTabs(formattedCode);
}
FunctionInfo fi = new FunctionInfo(
method.Name,
method.ReturnType,
formattedCode,
true,
SyntaxEditorHelper.ScriptLanguageTypes.CSharp,
extMethod.Description,
"C#",
"Extension Methods");
return fi;
}
public void A_Structure_Is_Created()
{
const string code = "public struct Structure1 { }";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.StructureDeclaration);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(Struct)));
Struct con = (Struct)bc;
Assert.That(con.Name, Is.EqualTo("Structure1"));
}
public void A_Destructor_Is_Created()
{
// This should not be the name of the class
const string code = "public ~MadeUpClassName() { }";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.DestructorDeclaration);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(Destructor)));
Destructor con = (Destructor)bc;
Assert.That(con.Name, Is.EqualTo("MadeUpClassName"));
Assert.That(con.BodyText, Is.EqualTo("{\n}\n".Replace("\n", Environment.NewLine)));
}
public void An_InterfaceMethod_Is_Created()
{
const string code = "void Method1();";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.InterfaceMethodDeclaration);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(InterfaceMethod)));
InterfaceMethod con = (InterfaceMethod)bc;
Assert.That(con.Name, Is.EqualTo("Method1"));
Assert.That(con.ReturnType.Name, Is.EqualTo("void"));
}
public void A_Field_Is_Created()
{
const string code = "public string Key = \"12345\";";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.FieldDeclaration);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(Field)));
Field con = (Field)bc;
Assert.That(con.Name, Is.EqualTo("Key"));
Assert.That(con.Modifiers.Count, Is.EqualTo(1));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
Assert.That(con.DataType.Name, Is.EqualTo("string"));
Assert.That(con.InitialValue, Is.EqualTo("\"12345\""));
}
public void A_Method_Is_Created()
{
const string code = "public static SomeDataType Method1(int i) { }";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.MethodDeclaration);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(Function)));
Function con = (Function)bc;
Assert.That(con.Name, Is.EqualTo("Method1"));
Assert.That(con.Modifiers.Count, Is.EqualTo(2));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
Assert.That(con.Modifiers[1], Is.EqualTo("static"));
Assert.That(con.ReturnType.Name, Is.EqualTo("SomeDataType"));
Assert.That(con.Parameters.Count, Is.EqualTo(1));
Assert.That(con.Parameters[0].DataType, Is.EqualTo("int"));
Assert.That(con.Parameters[0].Name, Is.EqualTo("i"));
}
public void A_Namespace_Is_Created()
{
const string code = "namespace Namespace1 { }";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.NamespaceDeclaration);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(Namespace)));
Namespace con = (Namespace)bc;
Assert.That(con.Name, Is.EqualTo("Namespace1"));
}
public void A_UsingStatement_Is_Created()
{
const string code = "using System;";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.UsingDirective);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(UsingStatement)));
UsingStatement con = (UsingStatement)bc;
Assert.That(con.Value, Is.EqualTo("System"));
}
public string GetFormattedDefaultCode()
{
bool isMethod = false;
MethodInfo method = null;
bool hasApiExt = false;
string defaultCode = "";
foreach (MethodInfo meth in ObjectType.GetMethods())
{
if (meth.Name == PropertyName)
{
ParameterInfo[] realParams = meth.GetParameters();
if (realParams.Length == ParameterTypes.Count)
{
bool paramsMatch = true;
for (int paramCounter = 0; paramCounter < realParams.Length; paramCounter++)
{
if (realParams[paramCounter].ParameterType.FullName != ParameterTypes[paramCounter].DataType.FullName)
{
paramsMatch = false;
break;
}
}
if (paramsMatch)
{
object[] allAttributes = meth.GetCustomAttributes(false);
foreach (object att in allAttributes)
{
Type attType = att.GetType();
if (Utility.StringsAreEqual(attType.Name, "ApiExtensionAttribute", true))
{
hasApiExt = true;
method = meth;
defaultCode = (string)attType.InvokeMember("DefaultCode", BindingFlags.GetProperty, null, att, null);
}
}
break;
}
}
}
}
Type returnType = null;
if (method != null)
{
isMethod = true;
returnType = method.ReturnType;
}
else
{
PropertyInfo property = ObjectType.GetProperty(PropertyName);
object[] allAttributes = property.GetCustomAttributes(false);
foreach (object att in allAttributes)
{
Type attType = att.GetType();
if (Utility.StringsAreEqual(attType.Name, "ApiExtensionAttribute", true))
{
hasApiExt = true;
defaultCode = (string)attType.InvokeMember("DefaultCode", BindingFlags.GetProperty, null, att, null);
break;
}
}
returnType = property.PropertyType;
}
if (!hasApiExt)// attributes != null && attributes.Length == 0)
{
throw new NotImplementedException(String.Format("DefaultCodeAttribute not implemented for {0}.{1} yet.", ObjectType.FullName, PropertyName));
}
string code = defaultCode;// attributes[0].DefaultCode;
CSharpParser csf = new CSharpParser();
if (isMethod)
{
Function f = (Function)csf.ParseSingleConstruct("public void Method1(){ " + code + " }", BaseConstructType.MethodDeclaration);
code = f.BodyText;
}
else
{
Property p = (Property)csf.ParseSingleConstruct("public int Property1 { " + code + " }", BaseConstructType.PropertyDeclaration);
if (p.GetAccessor != null)
code = p.GetAccessor.BodyText;
else
code = p.SetAccessor.BodyText;
}
int secondLineBreak = code.IndexOf("\r\n", code.IndexOf("{")) + 2;
int lastLineBreak = code.LastIndexOf("\r\n", code.LastIndexOf("}"));
if (lastLineBreak > secondLineBreak)
{
code = code.Substring(secondLineBreak, lastLineBreak - secondLineBreak);
}
else
{
code = "";
}
string[] lines = Utility.StandardizeLineBreaks(code, Utility.LineBreaks.Unix).Split('\n');
StringBuilder sb = new StringBuilder(lines.Length * 100);
for (int i = 0; i < lines.Length; i++)
{
if (lines[i].Length > 1)
{
sb.AppendLine(lines[i].Substring(1));
}
else
{
sb.AppendLine(lines[i]);
}
}
return sb.ToString();
}
public void A_Delegate_Is_Created()
{
const string code = "public delegate int Delegate1();";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.DelegateDeclaration);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(Delegate)));
Delegate con = (Delegate)bc;
Assert.That(con.Name, Is.EqualTo("Delegate1"));
Assert.That(con.Parameters.Count, Is.EqualTo(0));
Assert.That(con.ReturnType.Name, Is.EqualTo("int"));
Assert.That(con.Modifiers.Count, Is.EqualTo(1));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
}
private void CallFunction()
{
try
{
SetUserOptionValues();
string fileName = System.IO.Path.Combine(System.IO.Path.GetTempPath(), "temp.aal");
string str = (string)Loader.Instance.CallTemplateFunction(TheFunction.Name, ref ParametersToPass);
if (TheFunction.IsTemplateFunction)
{
//SetSyntaxLanguage(Slyce.Common.SyntaxEditorHelper.LanguageEnumFromName(TheFunction.ReturnType.Name));
}
else
{
//SetSyntaxLanguage(Project.OutputLanguageTypes.PlainText);
}
syntaxEditor1.Text = str;
if (Project.Instance.TextLanguage == TemplateContentLanguage.CSharp)
{
CSharpParser formatter = new CSharpParser();
formatter.ParseCode(str);
if(formatter.ErrorOccurred)
{
StringBuilder errorMsg = new StringBuilder();
foreach(ParserSyntaxError error in formatter.SyntaxErrors)
{
errorMsg.AppendFormat("An error occurred on line {1}:\n\n{0}", error.ErrorMessage, error.LineNumber);
errorMsg.AppendLine();
}
MessageBox.Show(this, errorMsg.ToString(), "Formatting Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
str = formatter.CreatedCodeRoot.ToString();
syntaxEditorFormatted.Text = Utility.StandardizeLineBreaks(str, Utility.LineBreaks.Windows);
}
}
}
catch (Exception ex)
{
Controller.ReportError(ex);
}
}
public void A_Property_Is_Created()
{
const string code = "public int Property1 { get {return 1; } }";
CSharpParser parser = new CSharpParser();
IBaseConstruct bc = parser.ParseSingleConstruct(code, BaseConstructType.PropertyDeclaration);
Assert.That(bc, Is.Not.Null);
Assert.That(bc, Is.InstanceOfType(typeof(Property)));
Property con = (Property)bc;
Assert.That(con.Name, Is.EqualTo("Property1"));
Assert.That(con.Modifiers.Count, Is.EqualTo(1));
Assert.That(con.Modifiers[0], Is.EqualTo("public"));
Assert.That(con.DataType.Name, Is.EqualTo("int"));
Assert.That(con.GetAccessor, Is.Not.Null);
Assert.That(con.SetAccessor, Is.Null);
Assert.That(con.GetAccessor.BodyText, Is.EqualTo("{ return 1; }"));
}
