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