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 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 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 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));
}
/// <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 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 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 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));
}
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 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 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 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 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));
}
private static List<Function> GetFunctionsInFileWithAttribute(string file, string attributeName)
{
List<Function> functions = new List<Function>();
string code = Slyce.Common.Utility.ReadTextFile(file);
CSharpParser csf = new CSharpParser();
csf.FormatSettings.CommentLinesAsCommentBlock = true;
csf.ParseCode(code);
if (csf.ErrorOccurred)
{
// TODO: what do we do here?
throw new Exception("Parser error. Please contact [email protected]");
}
CodeRoot root = (CodeRoot)csf.CreatedCodeRoot;
foreach (Namespace ns in root.Namespaces)
{
foreach (Class c in ns.Classes)
{
functions.AddRange(GetFunctionsInClassWithAttribute(c, attributeName));
}
}
foreach (Class c in root.Classes)
{
functions.AddRange(GetFunctionsInClassWithAttribute(c, attributeName));
}
return functions;
}
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 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;"));
}
internal static ICodeRoot GetCodeRoot(string fileName)
{
CSharpParser formatter = new CSharpParser();
formatter.ParseCode(File.ReadAllText(fileName));
return formatter.CreatedCodeRoot;
}
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 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("{ }"));
}
public void PrimitiveTypes_ShortNames()
{
const string code = @"public class Class1
{
public int a = 0;
public string b = """";
public short c = 0;
public long d = 0;
public float 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 = 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("int"));
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("short"));
con = (Field) clazz.WalkChildren()[3];
Assert.That(con.Name, Is.EqualTo("d"));
Assert.That(con.DataType.Name, Is.EqualTo("long"));
con = (Field) clazz.WalkChildren()[4];
Assert.That(con.Name, Is.EqualTo("e"));
Assert.That(con.DataType.Name, Is.EqualTo("float"));
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 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"));
}
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 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"));
}
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 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"));
}
