public void Init()
{
base.InitBase();
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
oldUnit.Classes.Add(outerClass);
// Create new compilation unit with inner class that no longer has the TestFixture attribute.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
MockClass newOuterClass = new MockClass("MyTests.A");
newOuterClass.ProjectContent = projectContent;
projectContent.Classes.Add(newOuterClass);
newOuterClass.SetCompoundClass(newOuterClass);
newUnit.Classes.Add(newOuterClass);
// Create the inner test class.
MockClass newInnerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest");
newInnerClass.ProjectContent = projectContent;
newInnerClass.DeclaringType = outerClass; // Declaring type is outer class.
newInnerClass.SetCompoundClass(newInnerClass);
newOuterClass.InnerClasses.Add(newInnerClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
}
public void Init()
{
base.InitBase();
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
oldUnit.Classes.Add(outerClass);
// Create new compilation unit with inner class that has its method renamed.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
MockClass newOuterClass = new MockClass(projectContent, "MyTests.A");
projectContent.Classes.Add(newOuterClass);
newUnit.Classes.Add(newOuterClass);
// Create the inner test class.
MockClass newInnerClass = new MockClass(projectContent, "MyTests.A.InnerATest", outerClass);
newInnerClass.SetDotNetName("MyTests.A+InnerATest");
newInnerClass.Attributes.Add(new MockAttribute("TestFixture"));
newOuterClass.InnerClasses.Add(newInnerClass);
MockMethod method = new MockMethod(newInnerClass, "FooBarRenamed");
method.Attributes.Add(new MockAttribute("Test"));
newInnerClass.Methods.Add(method);
outerClass.InnerClasses.Add(newInnerClass);
MockClass innerClassInInnerClass = new MockClass(projectContent, "MyTests.A.InnerATest.InnerInnerTest", innerClass);
innerClassInInnerClass.SetDotNetName("MyTests.A+InnerATest+InnerInnerTest");
innerClassInInnerClass.Attributes.Add(new MockAttribute("TestFixture"));
newInnerClass.InnerClasses.Add(innerClassInInnerClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
innerTestClass = testProject.TestClasses["MyTests.A+InnerATest"];
}
void CreateCompilationUnit(IProjectContent projectContent, string fileName)
{
compilationUnit = new DefaultCompilationUnit(projectContent);
compilationUnit.FileName = fileName;
CreateUsingScopeForCompilationUnit(fileName);
}
public void Init()
{
base.InitBase();
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
oldUnit.Classes.Add(outerClass);
// Create new compilation unit with inner class that has its method renamed.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
MockClass newOuterClass = new MockClass("MyTests.A");
newOuterClass.ProjectContent = projectContent;
projectContent.Classes.Add(newOuterClass);
newOuterClass.SetCompoundClass(newOuterClass);
newUnit.Classes.Add(newOuterClass);
// Create the inner test class.
MockClass newInnerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest");
newInnerClass.Attributes.Add(new MockAttribute("TestFixture"));
newInnerClass.ProjectContent = projectContent;
newInnerClass.DeclaringType = outerClass; // Declaring type is outer class.
newInnerClass.SetCompoundClass(newInnerClass);
newOuterClass.InnerClasses.Add(newInnerClass);
MockMethod method = new MockMethod("FooBarRenamed");
method.Attributes.Add(new MockAttribute("Test"));
method.DeclaringType = newInnerClass;
newInnerClass.Methods.Add(method);
outerClass.InnerClasses.Add(newInnerClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
innerTestClass = testProject.TestClasses["MyTests.A+InnerATest"];
}
public void Init()
{
base.InitBase();
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
oldUnit.Classes.Add(outerClass);
// Create new compilation unit with extra class.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
MockClass newOuterClass = new MockClass("MyTests.A");
newOuterClass.ProjectContent = projectContent;
projectContent.Classes.Add(newOuterClass);
newOuterClass.SetCompoundClass(newOuterClass);
newUnit.Classes.Add(newOuterClass);
// Create the inner test class.
// Note the use of the DotNetName "MyTests.A+InnerTest".
MockClass newInnerClass = new MockClass("MyTests.A.InnerATestMod", "MyTests.A+InnerATestMod");
newInnerClass.Attributes.Add(new MockAttribute("TestFixture"));
newInnerClass.ProjectContent = projectContent;
newInnerClass.DeclaringType = outerClass; // Declaring type is outer class.
newOuterClass.InnerClasses.Add(newInnerClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
}
public void TestFixtureAttributeAdded()
{
// Create an old compilation unit with the test class
// but without a [TestFixture] attribute.
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
MockClass newClass = new MockClass("RootNamespace.MyNewTestFixture");
newClass.ProjectContent = projectContent;
newClass.SetCompoundClass(newClass);
oldUnit.Classes.Add(newClass);
// Create a new compilation unit with the test class
// having a [TestFixture] attribute.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
newClass = new MockClass("RootNamespace.MyNewTestFixture");
newClass.Attributes.Add(new MockAttribute("TestFixture"));
newClass.ProjectContent = projectContent;
newClass.SetCompoundClass(newClass);
newUnit.Classes.Add(newClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
Assert.IsTrue(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"),
"New class should have been added to the set of TestClasses.");
}
public void ExpressionResultContextShowItemReturnsTrueForIMethod()
{
MockProjectContent projectContent = new MockProjectContent();
DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
DefaultClass c = new DefaultClass(unit, "MyClass");
DefaultMethod method = new DefaultMethod(c, "Test");
Assert.IsTrue(expressionResult.Context.ShowEntry(method));
}
public PythonResolverTestsHelper(string code)
{
ProjectContent = new ScriptingUtils.MockProjectContent();
PythonParser parser = new PythonParser();
string fileName = @"test.py";
CompilationUnit = parser.Parse(ProjectContent, fileName, code) as DefaultCompilationUnit;
ParseInfo = new ParseInformation(CompilationUnit);
Resolver = new PythonResolver();
}
public void Init()
{
DefaultProjectContent projectContent = new DefaultProjectContent();
DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
existingParseInfo = new ParseInformation(unit);
parserService = new MockParserService();
parserService.SetExistingParseInformation(@"d:\projects\test.xml", existingParseInfo);
}
public void TestProjectRemovesTestClassWhenItIsNoLongerATestClass()
{
testFrameworks.RemoveTestClass(myTestClass);
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(myTestClass.ProjectContent);
newUnit.Classes.Add(myTestClass);
testProject.UpdateParseInfo(oldUnit, newUnit);
Assert.AreEqual(0, testProject.TestClasses.Count);
}
ICompilationUnit Prepare(LanguageProperties language)
{
DefaultProjectContent pc = new DefaultProjectContent();
pc.ReferencedContents.Add(projectContentRegistry.Mscorlib);
pc.Language = language;
DefaultCompilationUnit cu = new DefaultCompilationUnit(pc);
if (language == LanguageProperties.VBNet)
cu.UsingScope.Usings.Add(CreateUsing(pc, "syStEm"));
else
cu.UsingScope.Usings.Add(CreateUsing(pc, "System"));
return cu;
}
public void Init()
{
testFrameworks = new MockRegisteredTestFrameworks();
myTestClass = MockClass.CreateMockClassWithoutAnyAttributes();
myTestClass.SetDotNetName("MyTests");
testFrameworks.AddTestClass(myTestClass);
oldUnit = new DefaultCompilationUnit(myTestClass.ProjectContent);
oldUnit.Classes.Add(myTestClass);
testProject = new TestProject(myTestClass.Project, myTestClass.ProjectContent, testFrameworks);
}
public void Init()
{
MockProjectContent projectContent = new MockProjectContent();
MockProjectContent winFormsReferenceProjectContent = new MockProjectContent();
List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
winFormsReferenceProjectContent.AddExistingNamespaceContents("System.Windows.Forms", namespaceItems);
projectContent.ReferencedContents.Add(winFormsReferenceProjectContent);
DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
parseInfo = new ParseInformation(unit);
resolverContext = new PythonResolverContext(parseInfo);
}
void CreateParseInfoWithOneClassWithOneProperty()
{
projectContent = new ScriptingUtils.MockProjectContent();
myClass = new MockClass(projectContent, "MyClass");
myClassProperty = AddPropertyToClass("MyProperty", myClass);
DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
parseInfo = new ParseInformation(unit);
projectContent.SetClassToReturnFromGetClass("MyClass", myClass);
}
public void Init()
{
// Create a project to display.
project = new MockCSharpProject();
project.Name = "TestProject";
ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project);
nunitFrameworkReferenceItem.Include = "NUnit.Framework";
ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem);
// Add a test class.
projectContent = new MockProjectContent();
projectContent.Language = LanguageProperties.None;
MockClass c = new MockClass("RootNamespace.MyTestFixture");
c.Attributes.Add(new MockAttribute("TestFixture"));
c.ProjectContent = projectContent;
c.SetCompoundClass(c);
MockMethod test1Method = new MockMethod("Test1");
test1Method .DeclaringType = c;
test1Method .Attributes.Add(new MockAttribute("Test"));
c.Methods.Add(test1Method);
// Test 2 method is from a duplicate test class.
MockMethod test2Method = new MockMethod("Test2");
test2Method.DeclaringType = c;
test2Method.Attributes.Add(new MockAttribute("Test"));
c.Methods.Add(test2Method);
projectContent.Classes.Add(c);
testProject = new TestProject(project, projectContent);
// Make sure test methods are created, otherwise
// the Test2 method will never be looked at due to lazy evaluation
// of test method.s
int count = testProject.TestClasses[0].TestMethods.Count;
// Change the name of the second test class.
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
oldUnit.Classes.Add(c);
c.Methods.Remove(test2Method); // Remove duplicate test class method.
// Create new compilation unit with inner class that has its method renamed.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
MockClass newTestClass = new MockClass("RootNamespace.MyNewTestFixture");
newTestClass.ProjectContent = projectContent;
newTestClass.Attributes.Add(new MockAttribute("TestFixture"));
newTestClass.SetCompoundClass(newTestClass);
projectContent.Classes.Add(newTestClass);
newTestClass.Methods.Add(test2Method);
newUnit.Classes.Add(newTestClass);
testProject.UpdateParseInfo(oldUnit, newUnit);
}
public void Init()
{
projectContent = new MockProjectContent();
completion = new PythonImportCompletion(projectContent);
DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
ParseInformation parseInfo = new ParseInformation(unit);
c = new DefaultClass(unit, "Class");
List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
namespaceItems.Add(c);
projectContent.AddExistingNamespaceContents("System", namespaceItems);
}
public void NewClassInParserInfo()
{
// Create new compilation unit with extra class.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
MockClass newClass = new MockClass(projectContent, "RootNamespace.MyNewTestFixture");
newClass.Attributes.Add(new MockAttribute("TestFixture"));
newUnit.Classes.Add(newClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(null, newUnit);
Assert.IsTrue(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"));
}
public void Init()
{
string code = "from System import Console";
importExpression = new PythonImportExpression(code);
resolveResult = new PythonImportModuleResolveResult(importExpression);
projectContent = new MockProjectContent();
DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
DefaultClass c = new DefaultClass(unit, "Test");
List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
namespaceItems.Add(c);
projectContent.AddExistingNamespaceContents("System", namespaceItems);
}
/// <summary>
/// Builds Visual Basic's "My" namespace for the specified project.
/// </summary>
public static void BuildNamespace(VBNetProject project, IProjectContent pc)
{
if ("custom".Equals(project.GetEvaluatedProperty("MyType"), StringComparison.OrdinalIgnoreCase))
return;
ICompilationUnit cu = new DefaultCompilationUnit(pc);
//cu.FileName = "GeneratedMyNamespace.vb"; // leave FileName null - fixes SD2-854
string ns;
if (project.RootNamespace == null || project.RootNamespace.Length == 0)
ns = "My";
else
ns = project.RootNamespace + ".My";
IClass myApp = CreateMyApplication(cu, project, ns);
IClass myComp = CreateMyComputer(cu, ns);
cu.Classes.Add(myApp);
cu.Classes.Add(myComp);
IClass myForms = null;
if (project.OutputType == OutputType.WinExe) {
myForms = CreateMyForms(cu, ns);
cu.Classes.Add(myForms);
}
DefaultClass c = new DefaultClass(cu, ns + ".MyProject");
c.ClassType = ClassType.Module;
c.Modifiers = ModifierEnum.Internal | ModifierEnum.Partial | ModifierEnum.Sealed | ModifierEnum.Synthetic;
c.Attributes.Add(new DefaultAttribute(CreateTypeRef(cu, "Microsoft.VisualBasic.HideModuleNameAttribute")));
// we need to use GetClassReturnType instead of DefaultReturnType because we need
// a reference to the compound class.
c.Properties.Add(new DefaultProperty("Application",
new GetClassReturnType(pc, myApp.FullyQualifiedName, 0),
ModifierEnum.Public | ModifierEnum.Static,
DomRegion.Empty, DomRegion.Empty, c));
c.Properties.Add(new DefaultProperty("Computer",
new GetClassReturnType(pc, myComp.FullyQualifiedName, 0),
ModifierEnum.Public | ModifierEnum.Static,
DomRegion.Empty, DomRegion.Empty, c));
if (myForms != null) {
c.Properties.Add(new DefaultProperty("Forms",
new GetClassReturnType(pc, myForms.FullyQualifiedName, 0),
ModifierEnum.Public | ModifierEnum.Static,
DomRegion.Empty, DomRegion.Empty, c));
}
c.Properties.Add(new DefaultProperty("User",
new GetClassReturnType(pc, "Microsoft.VisualBasic.ApplicationServices.User", 0),
ModifierEnum.Public | ModifierEnum.Static,
DomRegion.Empty, DomRegion.Empty, c));
cu.Classes.Add(c);
pc.UpdateCompilationUnit(null, cu, cu.FileName);
}
public void FixtureSetup()
{
ProjectContentRegistry r = new ProjectContentRegistry();
msc = r.Mscorlib;
swf = r.GetProjectContentForReference("System.Windows.Forms", typeof(System.Windows.Forms.Form).Module.FullyQualifiedName);
DefaultProjectContent dpc = new DefaultProjectContent();
dpc.ReferencedContents.Add(msc);
DefaultCompilationUnit cu = new DefaultCompilationUnit(dpc);
dummyClass = new DefaultClass(cu, "DummyClass");
cu.Classes.Add(dummyClass);
methodForGenericCalls = new DefaultMethod(dummyClass, "DummyMethod");
dummyClass.Methods.Add(methodForGenericCalls);
}
public void Init()
{
DefaultProjectContent projectContent = new DefaultProjectContent();
unit = new DefaultCompilationUnit(projectContent);
DefaultClass c = new DefaultClass(unit, "Foo");
DefaultMethod buttonClickMethod = new DefaultMethod(c, "ButtonClick");
AddSenderAndEventArgsParameters(buttonClickMethod);
c.Methods.Add(buttonClickMethod);
projectContent.AddClassToNamespaceList(c);
parseInfo = new ParseInformation(unit);
}
public void NewInnerTestClassInNewCompilationUnitAddedToTestProjectTestClasses()
{
MockClass myNewInnerTestClass = MockClass.CreateMockClassWithoutAnyAttributes();
myNewInnerTestClass.SetDotNetName("MyNewInnerTests");
testFrameworks.AddTestClass(myNewInnerTestClass);
myTestClass.InnerClasses.Add(myNewInnerTestClass);
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(myTestClass.ProjectContent);
newUnit.Classes.Add(myTestClass);
testProject.UpdateParseInfo(oldUnit, newUnit);
Assert.AreEqual(myNewInnerTestClass, testProject.TestClasses[1].Class);
}
public void SetUpFixture()
{
resolver = new PythonResolver();
mockProjectContent = new MockProjectContent();
DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent);
cu.FileName = @"C:\Projects\Test\test.py";
ParseInformation parseInfo = new ParseInformation(cu);
string python = "from System";
PythonExpressionFinder finder = new PythonExpressionFinder();
ExpressionResult expressionResult = finder.FindExpression(python, python.Length);
resolveResult = resolver.Resolve(expressionResult, parseInfo, python) as PythonImportModuleResolveResult;
}
public void ConvertedRubyCode()
{
string expectedCode =
"class Foo\r\n" +
" def initialize()\r\n" +
" button = Button.new()\r\n" +
" button.Click { self.ButtonClick() }\r\n" +
" button.MouseDown { self.OnMouseDown() }\r\n" +
" end\r\n" +
"end";
DefaultProjectContent projectContent = new DefaultProjectContent();
DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
ParseInformation parseInfo = new ParseInformation(unit);
NRefactoryToRubyConverter converter = new NRefactoryToRubyConverter(SupportedLanguage.CSharp, parseInfo);
converter.IndentString = " ";
string code = converter.Convert(csharp);
Assert.AreEqual(expectedCode, code, code);
}
public void SetUpFixture()
{
resolver = new PythonResolver();
mockProjectContent = new ICSharpCode.Scripting.Tests.Utils.MockProjectContent();
mockProjectContent.NamespacesToAdd.Add("Test");
myTestClass = new MockClass(mockProjectContent, "MyTestClass");
List<ICompletionEntry> namespaceItems = new List<ICompletionEntry>();
namespaceItems.Add(myTestClass);
mockProjectContent.AddExistingNamespaceContents("MyNamespace", namespaceItems);
DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent);
// Add usings.
DefaultUsing newUsing = new DefaultUsing(cu.ProjectContent);
newUsing.Usings.Add("MyNamespace");
DefaultUsingScope usingScope = new DefaultUsingScope();
usingScope.Usings.Add(newUsing);
cu.UsingScope = usingScope;
ParseInformation parseInfo = new ParseInformation(cu);
results = resolver.CtrlSpace(0, "".Length, parseInfo, "", ExpressionContext.Default);
}
// usingMode: 0 = one using-statement for each namespace (correctly cased)
// 1 = mixture of using statements and default imports (incorrectly cased)
// 2 = all default imports (incorrectly cased)
ICompilationUnit Prepare(LanguageProperties language, int usingMode)
{
DefaultProjectContent pc = new DefaultProjectContent();
pc.ReferencedContents.Add(projectContentRegistry.Mscorlib);
pc.Language = language;
DefaultCompilationUnit cu = new DefaultCompilationUnit(pc);
if (usingMode == 1) {
cu.UsingScope.Usings.Add(CreateUsing(pc, "syStEm.coLLectIons"));
pc.DefaultImports = new DefaultUsing(pc);
pc.DefaultImports.Usings.Add("syStEm");
pc.DefaultImports.Usings.Add("syStEm.coLLEctionS.GeNeRic");
} else if (usingMode == 2) {
pc.DefaultImports = new DefaultUsing(pc);
pc.DefaultImports.Usings.Add("syStEm");
pc.DefaultImports.Usings.Add("syStEm.coLLEctioNs");
pc.DefaultImports.Usings.Add("syStEm.coLLEctionS.GeNeRic");
} else { // usingMode == 0
cu.UsingScope.Usings.Add(CreateUsing(pc, "System"));
cu.UsingScope.Usings.Add(CreateUsing(pc, "System.Collections"));
cu.UsingScope.Usings.Add(CreateUsing(pc, "System.Collections.Generic"));
}
return cu;
}
public void TestFixtureAttributeRemoved()
{
// Add the test class first.
TestFixtureAttributeAdded();
// Create an old compilation unit with the test class
// having a [TestFixture] attribute.
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
MockClass newClass = new MockClass(projectContent, "RootNamespace.MyNewTestFixture");
newClass.Attributes.Add(new MockAttribute("TestFixture"));
oldUnit.Classes.Add(newClass);
// Create a new compilation unit with the test class
// but without a [TestFixture] attribute.
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(projectContent);
newClass = new MockClass(projectContent, "RootNamespace.MyNewTestFixture");
newUnit.Classes.Add(newClass);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, newUnit);
Assert.IsFalse(testProject.TestClasses.Contains("RootNamespace.MyNewTestFixture"),
"Class should have been removed.");
}
// DC
//DC
/*public void loadCode(string code)
{
code = (code.fileExists()) ? code.fileContents() : code;
var parser = code.csharpAst();
loadCompilationUnit(parser.CompilationUnit);
}*/
//DC
public void loadCompilationUnit(NRefactoryAST.CompilationUnit compilationUnit)
{
cu = new DefaultCompilationUnit(defaultProjectContent);
compilationUnit.AcceptVisitor(this, null);
}
public ICompilationUnit Parse(IProjectContent projectContent, string fileName, ITextBuffer fileContent)
{
Init(fileContent.Text);
SimpleCocoParser parser = new SimpleCocoParser(new Scanner(new StringStream(fileContent.Text)));
parser.Parse();
DefaultCompilationUnit cu = new DefaultCompilationUnit(projectContent);
Location start, end;
if (parser.CopySection != null) {
start = OffsetToLocation(parser.CopySection.StartOffset);
end = OffsetToLocation(parser.CopySection.EndOffset);
cu.FoldingRegions.Add(new FoldingRegion("[copy]", new DomRegion(start.Line, start.Column, end.Line, end.Column)));
}
if (parser.UsingSection != null) {
start = OffsetToLocation(parser.UsingSection.StartOffset);
end = OffsetToLocation(parser.UsingSection.EndOffset);
cu.FoldingRegions.Add(new FoldingRegion("[...]", new DomRegion(start.Line, start.Column, end.Line, end.Column)));
}
DefaultClass parserClass = null;
if (parser.ParserSection != null) {
start = OffsetToLocation(parser.ParserSection.StartOffset);
end = OffsetToLocation(parser.ParserSection.EndOffset);
parserClass = new DefaultClass(cu, parser.ParserName);
parserClass.ClassType = ClassType.Class;
parserClass.Modifiers = ModifierEnum.None;
parserClass.Region = new DomRegion(start.Line, start.Column, end.Line, end.Column);
cu.Classes.Add(parserClass);
foreach (var info in parser.Lists) {
start = OffsetToLocation(info.segment.StartOffset);
end = OffsetToLocation(info.segment.EndOffset);
var region = new DomRegion(start.Line, start.Column, start.Line, start.Column + info.name.Length);
var body = new DomRegion(start.Line, start.Column, end.Line, end.Column);
var prop = new DefaultProperty(parserClass, info.name) {
Region = region, BodyRegion = body, Modifiers = ModifierEnum.Public
};
parserClass.Properties.Add(prop);
}
foreach (var info in parser.Productions) {
start = OffsetToLocation(info.segment.StartOffset);
end = OffsetToLocation(info.segment.EndOffset);
var region = new DomRegion(start.Line, start.Column, start.Line, start.Column + info.name.Length);
var body = new DomRegion(start.Line, start.Column, end.Line, end.Column);
var method = new DefaultMethod(parserClass, info.name) {
Region = region, BodyRegion = body, Modifiers = ModifierEnum.Public
};
parserClass.Methods.Add(method);
}
}
return cu;
}
void CreateParseInfo()
{
MockProjectContent projectContent = new MockProjectContent();
DefaultCompilationUnit unit = new DefaultCompilationUnit(projectContent);
parseInfo = new ParseInformation(unit);
}