public void TestPropertyTypes()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
public Test123 Property1 { get; set; }
public Test.Test.Test1 Property2 { get; set; }
}
}
" ;
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(2, classObject.PropertyList.Count);
Assert.AreEqual("Property1", classObject.PropertyList[0].PropertyName);
Assert.AreEqual("Test123", classObject.PropertyList[0].TypeName);
Assert.IsNullOrEmpty(classObject.PropertyList[0].TypeNamespace);
Assert.AreEqual("Test123", classObject.PropertyList[0].TypeFullName);
Assert.AreEqual("Property2", classObject.PropertyList[1].PropertyName);
Assert.AreEqual("Test1", classObject.PropertyList[1].TypeName);
Assert.AreEqual("Test.Test", classObject.PropertyList[1].TypeNamespace);
Assert.AreEqual("Test.Test.Test1", classObject.PropertyList[1].TypeFullName);
}
public void TestCompoundClassAttributes()
{
string data =
@"
using System;
namespace Test.Namespace
{
[TestAttribute1, Test1.Test2.TestAttribute2]
[TestAttribute3]
public class TestClass
{
}
}
" ;
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(3, classObject.AttributeList.Count);
Assert.AreEqual("TestAttribute1", classObject.AttributeList[0].TypeName);
Assert.IsNullOrEmpty(classObject.AttributeList[0].TypeNamespace);
Assert.AreEqual("TestAttribute1", classObject.AttributeList[0].TypeFullName);
Assert.AreEqual("TestAttribute2", classObject.AttributeList[1].TypeName);
Assert.AreEqual("Test1.Test2", classObject.AttributeList[1].TypeNamespace);
Assert.AreEqual("Test1.Test2.TestAttribute2", classObject.AttributeList[1].TypeFullName);
Assert.AreEqual("TestAttribute3", classObject.AttributeList[2].TypeName);
Assert.IsNullOrEmpty(classObject.AttributeList[2].TypeNamespace);
Assert.AreEqual("TestAttribute3", classObject.AttributeList[2].TypeFullName);
}
public void Output()
{
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
foreach (var f in Directory.GetFiles(outputDir))
{
File.Delete(f);
}
foreach (var doc in project.Documents.Where(doc => doc.Folders.Any()))
{
if (doc.Folders.First().Equals("Controller") && doc.Name.EndsWith("Controller.cs"))
{
var sm = doc.GetSemanticModelAsync().GetAwaiter().GetResult();
var models = new ClassParser(sm).Parse();
foreach (var model in models)
{
var poatmanModel = new PostmanFileModel()
{
Name = model.Description,
ClassName = model.Name.Replace("Controller", string.Empty),
ReqTemplate = reqTemplate,
Items = model.Methods
};
using (var writer = new StreamWriter(Path.Combine(outputDir, (doc.Name[0].ToString().ToLower() + doc.Name.Substring(1)).Replace("Controller.cs", ".json")), true, Encoding.UTF8))
{
writer.Write(JsonConvert.SerializeObject(poatmanModel.GetPostmanObject()));
}
}
}
}
}
public override Verb CreateVerb(string[] tokens)
{
Color(position, tokens[1].Length, IDEColor.EntityType.Whitespace);
string visibility = tokens[2];
Color(visibility.Length, IDEColor.EntityType.Verb);
string scope = tokens[3];
Color(scope.Length, IDEColor.EntityType.Verb);
ClassParser.SetScopeAndVisibility(scope, visibility, this);
string messageName = tokens[4];
Color(messageName.Length, IDEColor.EntityType.Variable);
Color(tokens[5].Length, IDEColor.EntityType.Structure);
var compiler = new OrangeCompiler(source, position + length);
Block parameterBlock = compiler.Compile();
int index = compiler.Position;
List <Parameter> parameterList = ParameterParser.GetParameterList(parameterBlock);
var parameters = new Parameters(parameterList);
if (functionBodyParser.Scan(source, index))
{
return(createMethod(messageName, functionBodyParser, parameters, false));
}
return(equalBlockParser.Scan(source, index) ? createMethod(messageName, equalBlockParser, parameters, true) : null);
}
public void SingleClass_Fail_NoStructureType()
{
var target = new ClassParser();
var result = target.Parse("public MyClass { }");
result.Should().BeNull();
}
public override Verb CreateVerb(string[] tokens)
{
Color(position, tokens[1].Length, IDEColor.EntityType.Whitespace);
string visibility = tokens[2];
Color(visibility.Length, IDEColor.EntityType.Verb);
string scope = tokens[3];
Color(scope.Length, IDEColor.EntityType.Verb);
ClassParser.SetScopeAndVisibility(scope, visibility, this);
string message = tokens[4];
Color(message.Length, IDEColor.EntityType.Variable);
Color(tokens[5].Length, IDEColor.EntityType.Verb);
string super = tokens[6];
int superLength = super.Length;
if (superLength > 0)
{
Color(superLength - 1, IDEColor.EntityType.Variable);
Color(1, IDEColor.EntityType.Verb);
}
string messageDelegatedTo = tokens[7];
Color(messageDelegatedTo.Length, IDEColor.EntityType.Variable);
Builder.AddDelegate(message, super + messageDelegatedTo, this);
return(new NullOp());
}
public void SingleClass_Fail_AccessModifierSecond()
{
var target = new ClassParser();
var result = target.Parse("class public MyClass { }");
result.Should().BeNull();
}
private void ReadJar()
{
using var ms = new MemoryStream(RawContents);
var archive = new ZipArchive(ms);
foreach (var javaClass in archive.Entries
.Where(c => Path.GetExtension(c.Name).ToLower() == ".class")
.Select(e =>
{
//Let NBCEL parse the class file
var reader = new ClassParser(e.Open().ReadFully(), e.Name);
var result = reader.Parse();
var ownJavaClass = new JavaClass(result);
//Store the class for future use from NBCEL.
SyntheticRepository.GetInstance().StoreClass(result);
LoadedClassRepository.Instance.StoreClass(ownJavaClass);
return(ownJavaClass);
}
))
{
Classes.Add(javaClass.FullClassName, javaClass);
}
}
public void NestedClasses_Success()
{
var target = new ClassParser();
var c1 = target.Parse(@"
public class MyClass1 {
private struct MyClass2 {
internal interface MyClass3 {
}
}
}");
c1.Should().NotBeNull();
c1.AccessModifier.Should().Be("public");
c1.StructureType.Should().Be("class");
c1.Name.Should().Be("MyClass1");
c1.Children.Count.Should().Be(1);
var c2 = c1.Children[0];
c2.Should().NotBeNull();
c2.AccessModifier.Should().Be("private");
c2.StructureType.Should().Be("struct");
c2.Name.Should().Be("MyClass2");
c2.Children.Count.Should().Be(1);
var c3 = c2.Children[0];
c3.Should().NotBeNull();
c3.AccessModifier.Should().Be("internal");
c3.StructureType.Should().Be("interface");
c3.Name.Should().Be("MyClass3");
c3.Children.Count.Should().Be(0);
}
public UmlToolWindowViewModel()
{
ThreadHelper.ThrowIfNotOnUIThread();
try
{
var fileCode = GetFileContent();
if (fileCode.Equals(string.Empty))
{
return;
}
var classCode = ClassParser.Parse(fileCode);
var plantCode = UmlRenderer.Render(classCode);
var renderFactory = new PlantUml.Net.RendererFactory();
var plantUmlRenderer = renderFactory.CreateRenderer();
using (var mStream = new MemoryStream(plantUmlRenderer.Render(plantCode, OutputFormat.Png)))
{
UmlOutput = BitmapFrame.Create(mStream, BitmapCreateOptions.None, BitmapCacheOption.OnLoad);
}
}
catch (HttpRequestException e)
{
Console.WriteLine(e);
}
}
// [DebuggerStepThrough]
public void Parse(string s)
{
// replace disturbing chars
string src = s.Replace("\n", "");
src = src.Replace("\t", "");
src = Regex.Replace(src, "~.+~", ""); // remove comments
// transform source
string[] cmdss = src.Split(Convert.ToChar("{"));
src = src.Remove(0, cmdss[0].Length + 1);
src = src.Remove(src.Length - 2, 2);
src = src.Replace("}", "\n");
UseStatementParser.Parse(cmdss[0], this);
//parsing commands
foreach (string cm in src.Split(Convert.ToChar("\n")))
{
var sh = BlockHeaderParser.Parse(cm.Split(Convert.ToChar("{"))[0]);
var cmd = new Section {
Header = { Name = sh.Name }
};
VarDefParser.Parse(DataTypes, cm, cmd);
FunctionCallParser.Parse(cm, cmd, this);
VarSetParser.Parse(DataTypes, cm, cmd);
ClassParser.Parse(cm, this);
Sections.Add(cmd);
}
}
public static void pitch(string _ip)
{
Client.Client cl = new Client.Client(_ip, 5255, "jak", "kaj");
cl.Connect();
TestClass tcl1 = new TestClass(true);
tcl1.b = new double[] { 666.66, 777.777 };
tcl1.inrr = new Innerer(true);
tcl1.a = 871;
tcl1.dsa._asd = "merge";
List <ClassElement> al = new List <ClassElement> ();
ClassParser cp = new ClassParser();
cp.Traverse(tcl1, "gigel");
al = cp.ListOfFields;
cl.List = al;
bool b = cl.Send();
if (!b)
{
Console.WriteLine("Nope");
}
}
public FunctionsCSharpFile(string file, HostJson hostData)
{
Name = Path.GetFileNameWithoutExtension(file);
FileName = file;
var fileText = Helpers.SafelyReadFromFile(file);
Syntax = CSharpSyntaxTree.ParseText(fileText, new CSharpParseOptions(LanguageVersion.Latest, DocumentationMode.None, SourceCodeKind.Regular));
Context = new GenerationContext();
Root = Syntax.GetRoot() as CompilationUnitSyntax;
var usingStatements = Root.DescendantNodes().OfType <UsingDirectiveSyntax>().ToList();
Regex allowedUsings;
Regex unallowedUsings;
if (Settings.AllowedNamespaces?.Any() ?? false)
{
allowedUsings = new Regex($"({string.Join("|", Settings.AllowedNamespaces)})");
}
else
{
allowedUsings = new Regex($"(.+)");
}
if (Settings.ExcludedNamespaces?.Any() ?? false)
{
unallowedUsings = new Regex($"({string.Join("|", Settings.ExcludedNamespaces)})");
}
else
{
unallowedUsings = new Regex($"(^[.]+)");
}
Context.UsingStatements = usingStatements.Select(x => x.WithoutLeadingTrivia().WithoutTrailingTrivia().ToFullString())
.Where(x => allowedUsings.IsMatch(x) &&
!unallowedUsings.IsMatch(x))
.ToList();
var namespaceDeclarations = Root.DescendantNodes().OfType <NamespaceDeclarationSyntax>().ToList();
foreach (var nsd in namespaceDeclarations)
{
var classDeclarations = nsd.DescendantNodes().OfType <ClassDeclarationSyntax>().ToList();
foreach (var cd in classDeclarations)
{
var methods = cd.DescendantNodes().OfType <MethodDeclarationSyntax>()
.Where(x => x.Modifiers.Any(y => y.Text == "public") && x.Modifiers.Any(y => y.Text == "static"))
.ToList();
foreach (var method in methods)
{
Context.Functions.Add(ClassParser.ReadMethodAsFunction(method, hostData));
}
}
}
}
/// <summary>
/// Modify this to suit your needs
/// </summary>
public void Test()
{
long then = DateTime.Now.Ticks;
asd ass = new asd();
ass._asd = "123";
#if DEBUG
System.Console.WriteLine(ass is ISerializable);
#endif
TestClass tcls = new TestClass(true);
tcls.a = 999;
tcls.b = new double[] { 999.123, 999e-4 };
tcls.dsa._asd = "better show";
oldInst = tcls;
ClassParser cprs = new ClassParser();
cprs.Traverse(tcls);
al = cprs.ListOfFields;
Console.WriteLine("Done. Phase 1 too {0}00ns", DateTime.Now.Ticks - then);
// ArrayList testArrayList = new ArrayList ();
// testArrayList.Add ("asd");
// testArrayList.Add (2.0);
// //testArrayList.Add (testArrayList);
// ArrayList dsa = new ArrayList ();
// dsa.Add ("blabla");
// dsa.Add (false);
// testArrayList.Add (dsa);
// cprs.Traverse (testArrayList);
// al = cprs.ListOfFields;
// oldInst = testArrayList;
DataSource = al.ToArray();
Panel bottom = new Panel();
bottom.Height = 25;
bottom.Dock = DockStyle.Bottom;
Button btnSave = new Button();
// btnSave.Dock = DockStyle.Left;
btnSave.Click += (o, e) => save(o, e);
btnSave.Text = "S&ave";
btnSave.UseMnemonic = true;
btnSave.Left = this.Size.Width / 2 - 10 - btnSave.Width;
bottom.Controls.Add(btnSave);
Button btn = new Button();
// btn.Dock = DockStyle.Right;
btn.Click += (o, e) => secondPhase(o, e);
btn.Text = "&Next";
btn.UseMnemonic = true;
btn.Left = this.Size.Width / 2 + 10;
bottom.Controls.Add(btn);
this.Controls.Add(bottom);
}
public override Verb CreateVerb(string[] tokens)
{
Color(position, tokens[1].Length, IDEColor.EntityType.Whitespace);
string visibility = tokens[2];
Color(visibility.Length, IDEColor.EntityType.Verb);
string scope = tokens[3];
Color(scope.Length, IDEColor.EntityType.Verb);
ClassParser.SetScopeAndVisibility(scope, visibility, this);
string messageName = tokens[4];
Color(messageName.Length, IDEColor.EntityType.Variable);
Color(tokens[5].Length, IDEColor.EntityType.Verb);
if (closureParser.Scan(source, position + length))
{
var closure = (Closure)closureParser.Result.Value;
int parserPosition = closureParser.Result.Position;
var multiMethodParser = new MultiMethodParser();
if (multiMethodParser.Scan(source, parserPosition))
{
var block = (Block)multiMethodParser.Result.Value;
Builder.AddMultiMethod(messageName, closure, block, this);
overridePosition = multiMethodParser.Result.Position;
}
else
{
Builder.AddMethod(messageName, closure, this);
overridePosition = parserPosition;
}
return(new NullOp());
}
if (parameterParser.Scan(source, position + length))
{
var closure = parameterParser.Result.Value as Closure;
if (closure == null)
{
return(null);
}
var multiMethodParser = new MultiMethodParser();
int parserPosition = parameterParser.Result.Position;
if (multiMethodParser.Scan(source, parserPosition))
{
var block = (Block)multiMethodParser.Result.Value;
Builder.AddMultiMethod(messageName, closure, block, this);
overridePosition = multiMethodParser.Result.Position;
}
else
{
Builder.AddMethod(messageName, closure, this);
overridePosition = parserPosition;
}
return(new NullOp());
}
return(null);
}
public override Verb CreateVerb(string[] tokens)
{
Color(position, tokens[1].Length, IDEColor.EntityType.Whitespace);
string visibility = tokens[2];
Color(visibility.Length, IDEColor.EntityType.Verb);
string scope = tokens[3];
Color(scope.Length, IDEColor.EntityType.Verb);
ClassParser.SetScopeAndVisibility(scope, visibility, this);
string messageName = tokens[4];
Color(messageName.Length, IDEColor.EntityType.Variable);
Color(tokens[5].Length, IDEColor.EntityType.Verb);
int index = position + length;
var classParser = new ClassParser();
parsers.Insert(0, classParser);
foreach (Parser parser in parsers.Where(p => p.Scan(source, index)))
{
if (parser is ClassParser)
{
index = parser.Result.Position;
if (matcher.IsMatch(source.Substring(index), @"^\.new\b"))
{
Color(1, IDEColor.EntityType.Structure);
int matchedLength = matcher[0].Length;
Color(matchedLength - 1, IDEColor.EntityType.Message);
var builderValue = (ClassBuilderValue)parser.Result.Value;
ClassBuilder builder = builderValue.Builder;
builder.AutoInstantiate = true;
index += matchedLength;
}
else
{
index = parser.Result.Position;
}
}
else
{
index = parser.Result.Position;
}
Value value = parser.Result.Value;
Block block = null;
if (multiMethodParser.Scan(source, index))
{
ParserResult innerResult = multiMethodParser.Result;
block = (Block)innerResult.Value;
index = innerResult.Position;
}
Builder.AddInitializedVariable(messageName, value, this, block);
overridePosition = index;
return(new NullOp());
}
return(null);
}
public void TestFields()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
public int TestField1 = 1;
private string TestField2 = ""abc"";
internal Test1.Test2.TestType TestField3;
protected int TestField4;
}
}
" ;
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.IsEmpty(classObject.PropertyList);
Assert.AreEqual(4, classObject.FieldList.Count);
Assert.AreEqual("TestField1", classObject.FieldList[0].FieldName);
Assert.AreEqual("int", classObject.FieldList[0].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[0].TypeNamespace);
Assert.AreEqual("int", classObject.FieldList[0].TypeFullName);
Assert.AreEqual(EnumProtectionLevel.Public, classObject.FieldList[0].ProtectionLevel);
Assert.AreEqual("TestField2", classObject.FieldList[1].FieldName);
Assert.AreEqual("string", classObject.FieldList[1].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[1].TypeNamespace);
Assert.AreEqual("string", classObject.FieldList[1].TypeFullName);
Assert.AreEqual(EnumProtectionLevel.Private, classObject.FieldList[1].ProtectionLevel);
Assert.AreEqual("TestField3", classObject.FieldList[2].FieldName);
Assert.AreEqual("TestType", classObject.FieldList[2].TypeName);
Assert.AreEqual("Test1.Test2", classObject.FieldList[2].TypeNamespace);
Assert.AreEqual("Test1.Test2.TestType", classObject.FieldList[2].TypeFullName);
Assert.AreEqual(EnumProtectionLevel.Internal, classObject.FieldList[2].ProtectionLevel);
Assert.AreEqual("TestField4", classObject.FieldList[3].FieldName);
Assert.AreEqual("int", classObject.FieldList[3].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[3].TypeNamespace);
Assert.AreEqual("int", classObject.FieldList[3].TypeFullName);
Assert.AreEqual(EnumProtectionLevel.Protected, classObject.FieldList[3].ProtectionLevel);
Assert.AreEqual("TestField2", classObject.FieldList[1].FieldName);
Assert.AreEqual("string", classObject.FieldList[1].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[1].TypeNamespace);
Assert.AreEqual("string", classObject.FieldList[1].TypeFullName);
Assert.AreEqual(EnumProtectionLevel.Private, classObject.FieldList[1].ProtectionLevel);
}
public void SingleClass_Success()
{
var target = new ClassParser();
var result = target.Parse("public class MyClass { }");
result.Should().NotBeNull();
result.AccessModifier.Should().Be("public");
result.StructureType.Should().Be("class");
result.Name.Should().Be("MyClass");
result.Children.Count.Should().Be(0);
}
public void InterfacesMayNotContainChildren()
{
var target = new ClassParser();
var c1 = target.Parse(@"
public interface Interface1 {
private class MyClass2 {
}
}");
c1.Should().BeNull();
}
public void SingleClass_Fail_NoAccessModifier()
{
// Unfortunately there is no good way, that I am aware of, for the parser to
// determine that a certain prefix is mandatory. Unfortuately this test will have to
// just stay as a reminder.
var target = new ClassParser();
var result = target.Parse("class MyClass { }");
result.Should().NotBeNull();
result.AccessModifier.Should().BeNull();
// result.Should().BeNull();
}
public void TestPropertyAttributes()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
public string Property1 { get; set; }
[TestAttribute1]
public int Property2 { get; set; }
[TestAttribute2]
[TestAttribute3, Test.Test.TestAttribute4]
public float Property3 { get; set; }
}
}
" ;
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(3, classObject.PropertyList.Count);
Assert.AreEqual("Property1", classObject.PropertyList[0].PropertyName);
Assert.IsEmpty(classObject.PropertyList[0].AttributeList);
Assert.AreEqual("Property2", classObject.PropertyList[1].PropertyName);
Assert.AreEqual(1, classObject.PropertyList[1].AttributeList.Count);
Assert.AreEqual("TestAttribute1", classObject.PropertyList[1].AttributeList[0].TypeName);
Assert.IsNullOrEmpty(classObject.PropertyList[1].AttributeList[0].TypeNamespace);
Assert.AreEqual("TestAttribute1", classObject.PropertyList[1].AttributeList[0].TypeFullName);
Assert.AreEqual("Property3", classObject.PropertyList[2].PropertyName);
Assert.AreEqual(3, classObject.PropertyList[2].AttributeList.Count);
Assert.AreEqual("TestAttribute2", classObject.PropertyList[2].AttributeList[0].TypeName);
Assert.IsNullOrEmpty(classObject.PropertyList[2].AttributeList[0].TypeNamespace);
Assert.AreEqual("TestAttribute2", classObject.PropertyList[2].AttributeList[0].TypeFullName);
Assert.AreEqual("TestAttribute3", classObject.PropertyList[2].AttributeList[1].TypeName);
Assert.IsNullOrEmpty(classObject.PropertyList[2].AttributeList[1].TypeNamespace);
Assert.AreEqual("TestAttribute3", classObject.PropertyList[2].AttributeList[1].TypeFullName);
Assert.AreEqual("TestAttribute4", classObject.PropertyList[2].AttributeList[2].TypeName);
Assert.AreEqual("Test.Test", classObject.PropertyList[2].AttributeList[2].TypeNamespace);
Assert.AreEqual("Test.Test.TestAttribute4", classObject.PropertyList[2].AttributeList[2].TypeFullName);
}
public void TestFieldAttributes()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
public string Field1;
[TestAttribute1]
public int Field2;
[TestAttribute2]
[TestAttribute3, Test.Test.TestAttribute4]
public float Field3;
}
}
" ;
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(3, classObject.FieldList.Count);
Assert.AreEqual("Field1", classObject.FieldList[0].FieldName);
Assert.IsEmpty(classObject.FieldList[0].AttributeList);
Assert.AreEqual("Field2", classObject.FieldList[1].FieldName);
Assert.AreEqual(1, classObject.FieldList[1].AttributeList.Count);
Assert.AreEqual("TestAttribute1", classObject.FieldList[1].AttributeList[0].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[1].AttributeList[0].TypeNamespace);
Assert.AreEqual("TestAttribute1", classObject.FieldList[1].AttributeList[0].TypeFullName);
Assert.AreEqual("Field3", classObject.FieldList[2].FieldName);
Assert.AreEqual(3, classObject.FieldList[2].AttributeList.Count);
Assert.AreEqual("TestAttribute2", classObject.FieldList[2].AttributeList[0].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[2].AttributeList[0].TypeNamespace);
Assert.AreEqual("TestAttribute2", classObject.FieldList[2].AttributeList[0].TypeFullName);
Assert.AreEqual("TestAttribute3", classObject.FieldList[2].AttributeList[1].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[2].AttributeList[1].TypeNamespace);
Assert.AreEqual("TestAttribute3", classObject.FieldList[2].AttributeList[1].TypeFullName);
Assert.AreEqual("TestAttribute4", classObject.FieldList[2].AttributeList[2].TypeName);
Assert.AreEqual("Test.Test", classObject.FieldList[2].AttributeList[2].TypeNamespace);
Assert.AreEqual("Test.Test.TestAttribute4", classObject.FieldList[2].AttributeList[2].TypeFullName);
}
public override Verb CreateVerb(string[] tokens)
{
Color(position, tokens[1].Length, IDEColor.EntityType.Whitespace);
string visibility = tokens[2];
Color(visibility.Length, IDEColor.EntityType.Verb);
string scope = tokens[3];
ClassParser.SetScopeAndVisibility(scope, visibility, this);
Color(scope.Length, IDEColor.EntityType.Verb);
string messageName = tokens[4];
Color(messageName.Length, IDEColor.EntityType.Variable);
Color(tokens[5].Length, IDEColor.EntityType.Verb);
Builder.AddAbstractMessage(messageName, this);
return(new NullOp());
}
private void Clustering(IClustering clusterAlgorithm)
{
DialogResult dialogResult = openClassMethodsFile.ShowDialog();
if (dialogResult == DialogResult.OK)
{
string inputfile = openClassMethodsFile.FileName;
Dictionary <string, List <string> > rawClasses = ClassParser.ReadClassEntities(inputfile);
List <INode> clusters = initializeClusters(rawClasses);
List <INode> clustered = clusterAlgorithm.Clusterize(clusters);
ReloadTree(clustered[0]);
}
}
static void Main(string[] args)
{
var options = new CommandLineOptions();
if (CommandLine.Parser.Default.ParseArguments(args, options))
{
DirectoryInfo directory = new DirectoryInfo(options.InputDirectory);
if (directory.Exists)
{
ClassParser parser = new ClassParser();
parser.ParseDirectory(directory);
Console.WriteLine("Generating {0} classes.", parser.ClassInformationList.Count);
ClassGenerator generator = new ClassGenerator(options.OutputDirectory, options.BaseNamespace);
generator.GenerateFiles(parser.ClassInformationList);
}
}
}
public void TestPropertyProtectionLevel()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
private int PrivateProperty1 { get; set; }
int PrivateProperty2 { get; set; }
public int PublicProperty1 { get; set; }
protected int ProtectedProperty1 { get; set; }
internal int InternalProperty1 { get; set; }
}
}
" ;
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(5, classObject.PropertyList.Count);
Assert.AreEqual("PrivateProperty1", classObject.PropertyList[0].PropertyName);
Assert.AreEqual(EnumProtectionLevel.Private, classObject.PropertyList[0].ProtectionLevel);
Assert.AreEqual("PrivateProperty2", classObject.PropertyList[1].PropertyName);
Assert.AreEqual(EnumProtectionLevel.Private, classObject.PropertyList[1].ProtectionLevel);
Assert.AreEqual("PublicProperty1", classObject.PropertyList[2].PropertyName);
Assert.AreEqual(EnumProtectionLevel.Public, classObject.PropertyList[2].ProtectionLevel);
Assert.AreEqual("ProtectedProperty1", classObject.PropertyList[3].PropertyName);
Assert.AreEqual(EnumProtectionLevel.Protected, classObject.PropertyList[3].ProtectionLevel);
Assert.AreEqual("InternalProperty1", classObject.PropertyList[4].PropertyName);
Assert.AreEqual(EnumProtectionLevel.Internal, classObject.PropertyList[4].ProtectionLevel);
}
public void TestClassProtectionLevel()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class PublicClass
{
}
private class PrivateClass
{
}
internal class InternalClass
{
}
protected class ProtectedClass
{
}
}
" ;
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(4, classList.Count);
Assert.AreEqual("PublicClass", classList[0].ClassName);
Assert.AreEqual(EnumProtectionLevel.Public, classList[0].ProtectionLevel);
Assert.AreEqual("PrivateClass", classList[1].ClassName);
Assert.AreEqual(EnumProtectionLevel.Private, classList[1].ProtectionLevel);
Assert.AreEqual("InternalClass", classList[2].ClassName);
Assert.AreEqual(EnumProtectionLevel.Internal, classList[2].ProtectionLevel);
Assert.AreEqual("ProtectedClass", classList[3].ClassName);
Assert.AreEqual(EnumProtectionLevel.Protected, classList[3].ProtectionLevel);
}
public Class ClassFromScript(string script)
{
var results = new List <Class>();
MsSqlParser msSqlParser = new MsSqlParser();
results.Add(msSqlParser.ClassFromScript(script));
OracleParser oracleParser = new OracleParser();
results.Add(oracleParser.ClassFromScript(script));
ClassParser classParser = new ClassParser();
results.Add(classParser.ClassFromScript(script));
return(results
.Where(c => !string.IsNullOrEmpty(c.Name))
.OrderByDescending(c => c.Properties?.Count())
.FirstOrDefault());
}
public void TestBasicClass()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
}
}
";
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual("Test.Namespace", classObject.NamespaceName);
Assert.AreEqual("TestClass", classObject.ClassName);
Assert.AreEqual("Test.Namespace.TestClass", classObject.ClassFullName);
}
public void TestCompoundFields()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
public string Field1 = ""abc"";
public int Field2, Field3=4;
public double Field5;
}
}
" ;
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(4, classObject.FieldList.Count);
Assert.AreEqual("Field1", classObject.FieldList[0].FieldName);
Assert.AreEqual("string", classObject.FieldList[0].TypeFullName);
Assert.AreEqual("abc", classObject.FieldList[0].FieldValue);
Assert.AreEqual("Field2", classObject.FieldList[1].FieldName);
Assert.AreEqual("int", classObject.FieldList[1].TypeFullName);
Assert.IsNull(classObject.FieldList[1].FieldValue);
Assert.AreEqual("Field3", classObject.FieldList[2].FieldName);
Assert.AreEqual("int", classObject.FieldList[2].TypeFullName);
Assert.AreEqual(4, classObject.FieldList[2].FieldValue);
Assert.AreEqual("Field5", classObject.FieldList[3].FieldName);
Assert.AreEqual("double", classObject.FieldList[3].TypeFullName);
Assert.IsNull(classObject.FieldList[3].FieldValue);
}
/// <summary>
/// Disassemble o and serialize it to the database server
/// </summary>
/// <param name="o">
/// A <see cref="System.Object"/>
/// </param>
/// <param name="_nameOfO">
/// A <see cref="System.String"/>
/// </param>
/// <param name="_forceListFlush">
/// Forces flushing the List. By default, the list contents, if any, are left intact.
/// A <see cref="System.Boolean"/>
/// </param>
/// <returns>
/// A <see cref="System.Boolean"/>
/// </returns>
public bool Send(object o, string _nameOfO, bool _forceListFlush)
{
if (tcpclnt_ == null || !(tcpclnt_.Connected))
{
#if DEBUG
Console.WriteLine("tcpclnt connected? {0}",
(tcpclnt_ != null) ? tcpclnt_.Connected : false);
#endif
return(false);
}
using (ClassParser cprs = new ClassParser())
{
cprs.Traverse(o, _nameOfO);
if (_forceListFlush)
{
List = null;
}
List = cprs.ListOfFields;
}
return(Send());
}
public void TestBasicClass()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
}
}
" ;
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual("Test.Namespace", classObject.NamespaceName);
Assert.AreEqual("TestClass", classObject.ClassName);
Assert.AreEqual("Test.Namespace.TestClass", classObject.ClassFullName);
}
public void TestCompoundFields()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
public string Field1 = ""abc"";
public int Field2, Field3=4;
public double Field5;
}
}
";
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(4, classObject.FieldList.Count);
Assert.AreEqual("Field1", classObject.FieldList[0].FieldName);
Assert.AreEqual("string", classObject.FieldList[0].TypeFullName);
Assert.AreEqual("abc", classObject.FieldList[0].FieldValue);
Assert.AreEqual("Field2", classObject.FieldList[1].FieldName);
Assert.AreEqual("int", classObject.FieldList[1].TypeFullName);
Assert.IsNull(classObject.FieldList[1].FieldValue);
Assert.AreEqual("Field3", classObject.FieldList[2].FieldName);
Assert.AreEqual("int", classObject.FieldList[2].TypeFullName);
Assert.AreEqual(4, classObject.FieldList[2].FieldValue);
Assert.AreEqual("Field5", classObject.FieldList[3].FieldName);
Assert.AreEqual("double", classObject.FieldList[3].TypeFullName);
Assert.IsNull(classObject.FieldList[3].FieldValue);
}
public void TestPropertyTypes()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
public Test123 Property1 { get; set; }
public Test.Test.Test1 Property2 { get; set; }
}
}
";
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(2, classObject.PropertyList.Count);
Assert.AreEqual("Property1", classObject.PropertyList[0].PropertyName);
Assert.AreEqual("Test123", classObject.PropertyList[0].TypeName);
Assert.IsNullOrEmpty(classObject.PropertyList[0].TypeNamespace);
Assert.AreEqual("Test123", classObject.PropertyList[0].TypeFullName);
Assert.AreEqual("Property2", classObject.PropertyList[1].PropertyName);
Assert.AreEqual("Test1", classObject.PropertyList[1].TypeName);
Assert.AreEqual("Test.Test", classObject.PropertyList[1].TypeNamespace);
Assert.AreEqual("Test.Test.Test1", classObject.PropertyList[1].TypeFullName);
}
public void TestCompoundClassAttributes()
{
string data =
@"
using System;
namespace Test.Namespace
{
[TestAttribute1, Test1.Test2.TestAttribute2]
[TestAttribute3]
public class TestClass
{
}
}
";
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(3, classObject.AttributeList.Count);
Assert.AreEqual("TestAttribute1", classObject.AttributeList[0].TypeName);
Assert.IsNullOrEmpty(classObject.AttributeList[0].TypeNamespace);
Assert.AreEqual("TestAttribute1", classObject.AttributeList[0].TypeFullName);
Assert.AreEqual("TestAttribute2", classObject.AttributeList[1].TypeName);
Assert.AreEqual("Test1.Test2", classObject.AttributeList[1].TypeNamespace);
Assert.AreEqual("Test1.Test2.TestAttribute2", classObject.AttributeList[1].TypeFullName);
Assert.AreEqual("TestAttribute3", classObject.AttributeList[2].TypeName);
Assert.IsNullOrEmpty(classObject.AttributeList[2].TypeNamespace);
Assert.AreEqual("TestAttribute3", classObject.AttributeList[2].TypeFullName);
}
public void TestClassAttributeParameters()
{
string data =
@"
using System;
namespace Test.Namespace
{
[TestAttribute1]
[TestAttribute2(123, 234)]
[TestAttribute3(123, ""abc"")]
[TestAttribute4(Parameter1=123,Parameter2=234)]
[TestAttribute5(123, Parameter2=234)]
[TestAttribute6(TestSomething=TestSomthing.Else)]
public class TestClass
{
}
}
";
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(6, classObject.AttributeList.Count);
Assert.AreEqual("TestAttribute1", classObject.AttributeList[0].TypeFullName);
Assert.IsEmpty(classObject.AttributeList[0].ArgumentList);
Assert.AreEqual("TestAttribute2", classObject.AttributeList[1].TypeFullName);
Assert.AreEqual(2, classObject.AttributeList[1].ArgumentList.Count);
Assert.IsNullOrEmpty(classObject.AttributeList[1].ArgumentList[0].ArgumentName);
Assert.AreEqual(123, classObject.AttributeList[1].ArgumentList[0].ArguementValue);
Assert.IsNullOrEmpty(classObject.AttributeList[1].ArgumentList[1].ArgumentName);
Assert.AreEqual(234, classObject.AttributeList[1].ArgumentList[1].ArguementValue);
Assert.AreEqual(123, classObject.AttributeList[1].GetAttributeParameter(0, "Something", true));
Assert.AreEqual(234, classObject.AttributeList[1].GetAttributeParameter(1, "Something", true));
Assert.Throws(typeof(ArgumentNullException), delegate { classObject.AttributeList[1].GetAttributeParameter(0, null, true );});
Assert.Throws(typeof(ArgumentOutOfRangeException), delegate { classObject.AttributeList[1].GetAttributeParameter(-1, "Something", true);});
Assert.Throws(typeof(ArgumentOutOfRangeException), delegate { classObject.AttributeList[1].GetAttributeParameter(2, "Something", true); });
Assert.AreEqual("TestAttribute3", classObject.AttributeList[2].TypeFullName);
Assert.IsNullOrEmpty(classObject.AttributeList[2].ArgumentList[0].ArgumentName);
Assert.AreEqual(123, classObject.AttributeList[2].ArgumentList[0].ArguementValue);
Assert.IsNullOrEmpty(classObject.AttributeList[2].ArgumentList[1].ArgumentName);
Assert.AreEqual("abc", classObject.AttributeList[2].ArgumentList[1].ArguementValue);
Assert.AreEqual(123, classObject.AttributeList[2].GetAttributeParameter(0, "Something", true));
Assert.AreEqual("abc", classObject.AttributeList[2].GetAttributeParameter(1, "Something", true));
Assert.Throws(typeof(ArgumentNullException), delegate { classObject.AttributeList[2].GetAttributeParameter(0, null, true); });
Assert.Throws(typeof(ArgumentOutOfRangeException), delegate { classObject.AttributeList[2].GetAttributeParameter(-1, "Something", true); });
Assert.Throws(typeof(ArgumentOutOfRangeException), delegate { classObject.AttributeList[2].GetAttributeParameter(2, "Something", true); });
Assert.AreEqual("TestAttribute4", classObject.AttributeList[3].TypeFullName);
Assert.AreEqual("Parameter1", classObject.AttributeList[3].ArgumentList[0].ArgumentName);
Assert.AreEqual(123, classObject.AttributeList[3].ArgumentList[0].ArguementValue);
Assert.AreEqual("Parameter2", classObject.AttributeList[3].ArgumentList[1].ArgumentName);
Assert.AreEqual(234, classObject.AttributeList[3].ArgumentList[1].ArguementValue);
Assert.AreEqual(123, classObject.AttributeList[3].GetAttributeParameter(0, "Parameter1", true));
Assert.AreEqual(234, classObject.AttributeList[3].GetAttributeParameter(1, "Parameter2", true));
Assert.Throws(typeof(ArgumentNullException), delegate { classObject.AttributeList[3].GetAttributeParameter(0, null, true); });
Assert.Throws(typeof(ArgumentException), delegate { classObject.AttributeList[3].GetAttributeParameter(0, "Something", true); });
Assert.Throws(typeof(ArgumentException), delegate { classObject.AttributeList[3].GetAttributeParameter(1, "Something", true); });
Assert.Throws(typeof(ArgumentOutOfRangeException), delegate { classObject.AttributeList[3].GetAttributeParameter(-1, "Something", true); });
Assert.Throws(typeof(ArgumentOutOfRangeException), delegate { classObject.AttributeList[3].GetAttributeParameter(2, "Something", true); });
Assert.AreEqual("TestAttribute5", classObject.AttributeList[4].TypeFullName);
Assert.IsNullOrEmpty(classObject.AttributeList[4].ArgumentList[0].ArgumentName);
Assert.AreEqual(123, classObject.AttributeList[4].ArgumentList[0].ArguementValue);
Assert.AreEqual("Parameter2", classObject.AttributeList[4].ArgumentList[1].ArgumentName);
Assert.AreEqual(234, classObject.AttributeList[4].ArgumentList[1].ArguementValue);
Assert.AreEqual(123, classObject.AttributeList[4].GetAttributeParameter(0, "Parameter1", true));
Assert.Throws(typeof(ArgumentException), delegate { classObject.AttributeList[4].GetAttributeParameter(1, "Parameter1", true); });
Assert.AreEqual(234, classObject.AttributeList[4].GetAttributeParameter(1, "Parameter2", true));
Assert.Throws(typeof(ArgumentNullException), delegate { classObject.AttributeList[4].GetAttributeParameter(0, null, true); });
Assert.Throws(typeof(ArgumentException), delegate { classObject.AttributeList[4].GetAttributeParameter(1, "Something", true); });
Assert.Throws(typeof(ArgumentOutOfRangeException), delegate { classObject.AttributeList[4].GetAttributeParameter(-1, "Something", true); });
Assert.Throws(typeof(ArgumentOutOfRangeException), delegate { classObject.AttributeList[4].GetAttributeParameter(2, "Something", true); });
Assert.AreEqual("TestAttribute6", classObject.AttributeList[5].TypeFullName);
}
public void TestPropertyAttributes()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
public string Property1 { get; set; }
[TestAttribute1]
public int Property2 { get; set; }
[TestAttribute2]
[TestAttribute3, Test.Test.TestAttribute4]
public float Property3 { get; set; }
}
}
";
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(3, classObject.PropertyList.Count);
Assert.AreEqual("Property1", classObject.PropertyList[0].PropertyName);
Assert.IsEmpty(classObject.PropertyList[0].AttributeList);
Assert.AreEqual("Property2", classObject.PropertyList[1].PropertyName);
Assert.AreEqual(1, classObject.PropertyList[1].AttributeList.Count);
Assert.AreEqual("TestAttribute1", classObject.PropertyList[1].AttributeList[0].TypeName);
Assert.IsNullOrEmpty(classObject.PropertyList[1].AttributeList[0].TypeNamespace);
Assert.AreEqual("TestAttribute1", classObject.PropertyList[1].AttributeList[0].TypeFullName);
Assert.AreEqual("Property3", classObject.PropertyList[2].PropertyName);
Assert.AreEqual(3, classObject.PropertyList[2].AttributeList.Count);
Assert.AreEqual("TestAttribute2", classObject.PropertyList[2].AttributeList[0].TypeName);
Assert.IsNullOrEmpty(classObject.PropertyList[2].AttributeList[0].TypeNamespace);
Assert.AreEqual("TestAttribute2", classObject.PropertyList[2].AttributeList[0].TypeFullName);
Assert.AreEqual("TestAttribute3", classObject.PropertyList[2].AttributeList[1].TypeName);
Assert.IsNullOrEmpty(classObject.PropertyList[2].AttributeList[1].TypeNamespace);
Assert.AreEqual("TestAttribute3", classObject.PropertyList[2].AttributeList[1].TypeFullName);
Assert.AreEqual("TestAttribute4", classObject.PropertyList[2].AttributeList[2].TypeName);
Assert.AreEqual("Test.Test", classObject.PropertyList[2].AttributeList[2].TypeNamespace);
Assert.AreEqual("Test.Test.TestAttribute4", classObject.PropertyList[2].AttributeList[2].TypeFullName);
}
public void TestClassProtectionLevel()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class PublicClass
{
}
private class PrivateClass
{
}
internal class InternalClass
{
}
protected class ProtectedClass
{
}
}
";
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(4, classList.Count);
Assert.AreEqual("PublicClass", classList[0].ClassName);
Assert.AreEqual(EnumProtectionLevel.Public, classList[0].ProtectionLevel);
Assert.AreEqual("PrivateClass", classList[1].ClassName);
Assert.AreEqual(EnumProtectionLevel.Private, classList[1].ProtectionLevel);
Assert.AreEqual("InternalClass", classList[2].ClassName);
Assert.AreEqual(EnumProtectionLevel.Internal, classList[2].ProtectionLevel);
Assert.AreEqual("ProtectedClass", classList[3].ClassName);
Assert.AreEqual(EnumProtectionLevel.Protected, classList[3].ProtectionLevel);
}
public void TestPropertyProtectionLevel()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
private int PrivateProperty1 { get; set; }
int PrivateProperty2 { get; set; }
public int PublicProperty1 { get; set; }
protected int ProtectedProperty1 { get; set; }
internal int InternalProperty1 { get; set; }
}
}
";
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(5, classObject.PropertyList.Count);
Assert.AreEqual("PrivateProperty1", classObject.PropertyList[0].PropertyName);
Assert.AreEqual(EnumProtectionLevel.Private, classObject.PropertyList[0].ProtectionLevel);
Assert.AreEqual("PrivateProperty2", classObject.PropertyList[1].PropertyName);
Assert.AreEqual(EnumProtectionLevel.Private, classObject.PropertyList[1].ProtectionLevel);
Assert.AreEqual("PublicProperty1", classObject.PropertyList[2].PropertyName);
Assert.AreEqual(EnumProtectionLevel.Public, classObject.PropertyList[2].ProtectionLevel);
Assert.AreEqual("ProtectedProperty1", classObject.PropertyList[3].PropertyName);
Assert.AreEqual(EnumProtectionLevel.Protected, classObject.PropertyList[3].ProtectionLevel);
Assert.AreEqual("InternalProperty1", classObject.PropertyList[4].PropertyName);
Assert.AreEqual(EnumProtectionLevel.Internal, classObject.PropertyList[4].ProtectionLevel);
}
public void TestFields()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
public int TestField1 = 1;
private string TestField2 = ""abc"";
internal Test1.Test2.TestType TestField3;
protected int TestField4;
}
}
";
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.IsEmpty(classObject.PropertyList);
Assert.AreEqual(4, classObject.FieldList.Count);
Assert.AreEqual("TestField1", classObject.FieldList[0].FieldName);
Assert.AreEqual("int", classObject.FieldList[0].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[0].TypeNamespace);
Assert.AreEqual("int", classObject.FieldList[0].TypeFullName);
Assert.AreEqual(EnumProtectionLevel.Public, classObject.FieldList[0].ProtectionLevel);
Assert.AreEqual("TestField2", classObject.FieldList[1].FieldName);
Assert.AreEqual("string", classObject.FieldList[1].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[1].TypeNamespace);
Assert.AreEqual("string", classObject.FieldList[1].TypeFullName);
Assert.AreEqual(EnumProtectionLevel.Private, classObject.FieldList[1].ProtectionLevel);
Assert.AreEqual("TestField3", classObject.FieldList[2].FieldName);
Assert.AreEqual("TestType", classObject.FieldList[2].TypeName);
Assert.AreEqual("Test1.Test2", classObject.FieldList[2].TypeNamespace);
Assert.AreEqual("Test1.Test2.TestType", classObject.FieldList[2].TypeFullName);
Assert.AreEqual(EnumProtectionLevel.Internal, classObject.FieldList[2].ProtectionLevel);
Assert.AreEqual("TestField4", classObject.FieldList[3].FieldName);
Assert.AreEqual("int", classObject.FieldList[3].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[3].TypeNamespace);
Assert.AreEqual("int", classObject.FieldList[3].TypeFullName);
Assert.AreEqual(EnumProtectionLevel.Protected, classObject.FieldList[3].ProtectionLevel);
Assert.AreEqual("TestField2", classObject.FieldList[1].FieldName);
Assert.AreEqual("string", classObject.FieldList[1].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[1].TypeNamespace);
Assert.AreEqual("string", classObject.FieldList[1].TypeFullName);
Assert.AreEqual(EnumProtectionLevel.Private, classObject.FieldList[1].ProtectionLevel);
}
public void TestFieldAttributes()
{
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClass
{
public string Field1;
[TestAttribute1]
public int Field2;
[TestAttribute2]
[TestAttribute3, Test.Test.TestAttribute4]
public float Field3;
}
}
";
ClassParser parser = new ClassParser();
var classList = parser.ParseString(data.ToString(), "C:\\Test", "TestFileName.cs", null);
Assert.AreEqual(1, classList.Count);
var classObject = classList[0];
Assert.AreEqual(3, classObject.FieldList.Count);
Assert.AreEqual("Field1", classObject.FieldList[0].FieldName);
Assert.IsEmpty(classObject.FieldList[0].AttributeList);
Assert.AreEqual("Field2", classObject.FieldList[1].FieldName);
Assert.AreEqual(1, classObject.FieldList[1].AttributeList.Count);
Assert.AreEqual("TestAttribute1", classObject.FieldList[1].AttributeList[0].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[1].AttributeList[0].TypeNamespace);
Assert.AreEqual("TestAttribute1", classObject.FieldList[1].AttributeList[0].TypeFullName);
Assert.AreEqual("Field3", classObject.FieldList[2].FieldName);
Assert.AreEqual(3, classObject.FieldList[2].AttributeList.Count);
Assert.AreEqual("TestAttribute2", classObject.FieldList[2].AttributeList[0].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[2].AttributeList[0].TypeNamespace);
Assert.AreEqual("TestAttribute2", classObject.FieldList[2].AttributeList[0].TypeFullName);
Assert.AreEqual("TestAttribute3", classObject.FieldList[2].AttributeList[1].TypeName);
Assert.IsNullOrEmpty(classObject.FieldList[2].AttributeList[1].TypeNamespace);
Assert.AreEqual("TestAttribute3", classObject.FieldList[2].AttributeList[1].TypeFullName);
Assert.AreEqual("TestAttribute4", classObject.FieldList[2].AttributeList[2].TypeName);
Assert.AreEqual("Test.Test", classObject.FieldList[2].AttributeList[2].TypeNamespace);
Assert.AreEqual("Test.Test.TestAttribute4", classObject.FieldList[2].AttributeList[2].TypeFullName);
}
public void UpdateExistingClass()
{
var existingClass1 = new CSClass()
{
ClassName = "TestClassLeaveAlone",
NamespaceName = "Test.Namespace",
PropertyList = new List<CSProperty>()
{
new CSProperty { TypeName = "int", PropertyName = "TestProperty1" },
new CSProperty { TypeName = "int", PropertyName = "TestProperty2" }
},
FieldList = new List<CSField>()
{
new CSField { TypeName = "int", FieldName = "TestField1" },
new CSField { TypeName = "int", FieldName = "TestField2" }
}
};
var existingClass2 = new CSClass()
{
ClassName = "TestClassUpdate",
NamespaceName = "Test.Namespace",
PropertyList = new List<CSProperty>()
{
new CSProperty { TypeName = "int", PropertyName = "TestProperty1" },
new CSProperty { TypeName = "int", PropertyName = "TestProperty2" }
},
FieldList = new List<CSField>()
{
new CSField { TypeName = "int", FieldName = "TestField1" },
new CSField { TypeName = "int", FieldName = "TestField2" }
}
};
List<CSClass> existingClassList = new List<CSClass>() { existingClass1, existingClass2 };
string data =
@"
using System;
namespace Test.Namespace
{
public class TestClassUpdate
{
public int TestProperty3 { get; set; }
public int TestProperty4 { get; set; }
public int TestField3;
public int TestField4;
}
public class TestClassNew
{
public int TestProperty1 { get; set; }
public int TestProperty2 { get; set; }
public int TestField1;
public int TestField2;
}
}
";
ClassParser parser = new ClassParser();
var newClassList = parser.ParseString(data, "TestFile.cs", "C:\\Test", existingClassList);
Assert.AreEqual(3, newClassList.Count);
var testClassLeaveAlone = newClassList[0];
Assert.AreEqual("Test.Namespace.TestClassLeaveAlone", testClassLeaveAlone.ClassFullName);
Assert.AreEqual(2, testClassLeaveAlone.PropertyList.Count);
Assert.AreEqual("TestProperty1", testClassLeaveAlone.PropertyList[0].PropertyName);
Assert.AreEqual("TestProperty2", testClassLeaveAlone.PropertyList[1].PropertyName);
Assert.AreEqual(2, testClassLeaveAlone.FieldList.Count);
Assert.AreEqual("TestField1", testClassLeaveAlone.FieldList[0].FieldName);
Assert.AreEqual("TestField2", testClassLeaveAlone.FieldList[1].FieldName);
var testClassUpdate = newClassList[1];
Assert.AreEqual("Test.Namespace.TestClassUpdate", testClassUpdate.ClassFullName);
Assert.AreEqual(4, testClassUpdate.PropertyList.Count);
Assert.AreEqual("TestProperty1", testClassUpdate.PropertyList[0].PropertyName);
Assert.AreEqual("TestProperty2", testClassUpdate.PropertyList[1].PropertyName);
Assert.AreEqual("TestProperty3", testClassUpdate.PropertyList[2].PropertyName);
Assert.AreEqual("TestProperty4", testClassUpdate.PropertyList[3].PropertyName);
Assert.AreEqual(4, testClassUpdate.FieldList.Count);
Assert.AreEqual("TestField1", testClassUpdate.FieldList[0].FieldName);
Assert.AreEqual("TestField2", testClassUpdate.FieldList[1].FieldName);
Assert.AreEqual("TestField3", testClassUpdate.FieldList[2].FieldName);
Assert.AreEqual("TestField4", testClassUpdate.FieldList[3].FieldName);
var testClassNew = newClassList[2];
Assert.AreEqual("Test.Namespace.TestClassNew", testClassNew.ClassFullName);
Assert.AreEqual(2, testClassNew.PropertyList.Count);
Assert.AreEqual("TestProperty1", testClassNew.PropertyList[0].PropertyName);
Assert.AreEqual("TestProperty2", testClassNew.PropertyList[1].PropertyName);
Assert.AreEqual(2, testClassNew.FieldList.Count);
Assert.AreEqual("TestField1", testClassNew.FieldList[0].FieldName);
Assert.AreEqual("TestField2", testClassNew.FieldList[1].FieldName);
}
