public void Init() { testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport(); projectContent = new MockProjectContent(); pad.ProjectContent = projectContent; solution = new Solution(new MockProjectChangeWatcher()); project = new MockCSharpProject(); projectContent.Project = project; projectContent.Language = LanguageProperties.None; ReferenceProjectItem refProjectItem = new ReferenceProjectItem(project); refProjectItem.Include = "NUnit.Framework"; ProjectService.AddProjectItem(project, refProjectItem); solution.Folders.Add(project); pad.CallSolutionLoaded(solution); }
public void IsValidWhenClassHasTestFixtureAttribute() { IProject project = new MockCSharpProject(); MockClass mockClass = new MockClass(); mockClass.Attributes.Add(new MockAttribute("TestFixture")); MockProjectContent mockProjectContent = new MockProjectContent(); mockProjectContent.Project = project; mockProjectContent.Language = LanguageProperties.None; mockClass.ProjectContent = mockProjectContent; ClassNode classNode = new ClassNode(project, mockClass); TestableCondition testableCondition = new TestableCondition(); Assert.IsTrue(testableCondition.IsValid(classNode, null)); }
public void SetUp() { MockProjectContent projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; // Create the base test class. MockClass baseClass = new MockClass("ICSharpCode.Tests.BaseClass"); baseClass.ProjectContent = projectContent; // Add a virtual method to base class. MockMethod baseMethod = new MockMethod("VirtualTestMethod"); baseMethod.Attributes.Add(new MockAttribute("Test")); baseMethod.DeclaringType = baseClass; baseMethod.IsVirtual = true; baseClass.Methods.Add(baseMethod); // Add a second method that is virtual but will not be overriden. baseMethod = new MockMethod("VirtualNonOverriddenTestMethod"); baseMethod.Attributes.Add(new MockAttribute("Test")); baseMethod.DeclaringType = baseClass; baseMethod.IsVirtual = true; baseClass.Methods.Add(baseMethod); // Create the derived test class. c = new MockClass("ICSharpCode.Tests.DerivedClass"); c.Attributes.Add(new MockAttribute("TestFixture")); c.ProjectContent = projectContent; projectContent.Classes.Add(c); // Create a new test method that overrides one of the base class methods. MockMethod method = new MockMethod("VirtualTestMethod"); method.Attributes.Add(new MockAttribute("Test")); method.DeclaringType = c; method.IsOverride = true; c.Methods.Add(method); // Set derived class's base class. c.BaseClass = baseClass; // Create TestClass. testClass = new TestClass(c); }
public void Resolve_FieldHasNoReturnType_DoesNotThrowNullReferenceException() { MockProjectContent projectContent = new MockProjectContent(); UnitTestingUtils.MockClass c = new UnitTestingUtils.MockClass(projectContent, "Test"); projectContent.SetClassToReturnFromGetClass("self", c); DefaultField field = c.AddField("randomNumber"); field.ReturnType = null; ParseInformation parseInfo = new ParseInformation(c.CompilationUnit); ExpressionResult expression = new ExpressionResult("self.randomNumber.randint", ExpressionContext.Default); PythonClassResolver classResolver = new PythonClassResolver(); PythonLocalVariableResolver localVariableResolver = new PythonLocalVariableResolver(classResolver); PythonMemberResolver resolver = new PythonMemberResolver(classResolver, localVariableResolver); PythonResolverContext context = new PythonResolverContext(parseInfo, expression, "class Test:\r\npass"); Assert.DoesNotThrow(delegate { resolver.Resolve(context); }); }
protected void InitBase() { projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; // Create the base test class. outerClass = new MockClass("MyTests.A"); outerClass.ProjectContent = projectContent; projectContent.Classes.Add(outerClass); // Create the inner test class. // Note the use of the DotNetName "MyTests.A+InnerTest". innerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest"); innerClass.Attributes.Add(new MockAttribute("TestFixture")); innerClass.ProjectContent = projectContent; innerClass.DeclaringType = outerClass; // Declaring type is outer class. MockMethod method = new MockMethod("FooBar"); method.Attributes.Add(new MockAttribute("Test")); method.DeclaringType = innerClass; innerClass.Methods.Add(method); outerClass.InnerClasses.Add(innerClass); // Add another inner class that is not a test class. MockClass nonTestInnerClass = new MockClass("MyTests.A.InnerBClass"); nonTestInnerClass.ProjectContent = projectContent; nonTestInnerClass.DeclaringType = outerClass; // Declaring type is outer class. outerClass.InnerClasses.Add(nonTestInnerClass); // Add another inner class with the same name as the InnerATest. // This makes sure duplicate classes are not added. MockClass duplicateInnerClass = new MockClass("MyTests.A.InnerATest", "MyTests.A+InnerATest"); duplicateInnerClass.Attributes.Add(new MockAttribute("TestFixture")); duplicateInnerClass.ProjectContent = projectContent; duplicateInnerClass.DeclaringType = outerClass; // Declaring type is outer class. outerClass.InnerClasses.Add(duplicateInnerClass); testProject = new TestProject(null, projectContent); if (testProject.TestClasses.Count > 0) { testClass = testProject.TestClasses[0]; } }
public void Init() { // Create a project to display. IProject project = new MockCSharpProject(); project.Name = "TestProject"; ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project); nunitFrameworkReferenceItem.Include = "NUnit.Framework"; ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem); projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport(); testProject = new TestProject(project, projectContent, testFrameworks); }
public void SetUpFixture() { resolver = new PythonResolver(); ParseInformation parseInfo = new ParseInformation(); mockProjectContent = new MockProjectContent(); DefaultCompilationUnit cu = new DefaultCompilationUnit(mockProjectContent); cu.ErrorsDuringCompile = true; cu.FileName = @"C:\Projects\Test\test.py"; parseInfo.SetCompilationUnit(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 SetUpFixture() { AvalonEdit.TextEditor textEditor = new AvalonEdit.TextEditor(); document = textEditor.Document; textEditor.Text = GetTextEditorCode(); RubyParser parser = new RubyParser(); MockProjectContent projectContent = new MockProjectContent(); MockProject project = new MockProject(); project.RootNamespace = "RootNamespace"; projectContent.Project = project; ICompilationUnit compilationUnit = parser.Parse(projectContent, @"test.py", document.Text); using (DesignSurface designSurface = new DesignSurface(typeof(Form))) { IDesignerHost host = (IDesignerHost)designSurface.GetService(typeof(IDesignerHost)); IEventBindingService eventBindingService = new MockEventBindingService(host); Form form = (Form)host.RootComponent; form.ClientSize = new Size(200, 300); PropertyDescriptorCollection descriptors = TypeDescriptor.GetProperties(form); PropertyDescriptor namePropertyDescriptor = descriptors.Find("Name", false); namePropertyDescriptor.SetValue(form, "MainForm"); // Add picture box PictureBox pictureBox = (PictureBox)host.CreateComponent(typeof(PictureBox), "pictureBox1"); pictureBox.Location = new Point(0, 0); pictureBox.Image = new Bitmap(10, 10); pictureBox.Size = new Size(100, 120); pictureBox.TabIndex = 0; form.Controls.Add(pictureBox); MockTextEditorOptions options = new MockTextEditorOptions(); options.ConvertTabsToSpaces = true; options.IndentationSize = 4; DesignerSerializationManager serializationManager = new DesignerSerializationManager(host); using (serializationManager.CreateSession()) { AvalonEditDocumentAdapter docAdapter = new AvalonEditDocumentAdapter(document, null); RubyDesignerGenerator generator = new RubyDesignerGenerator(options); generator.Merge(host, docAdapter, compilationUnit, serializationManager); } } }
public void IsValidWhenMethodHasTestAttribute() { MockMethod mockMethod = new MockMethod(); mockMethod.Attributes.Add(new MockAttribute("Test")); IProject project = new MockCSharpProject(); MockClass mockClass = new MockClass(); MockProjectContent mockProjectContent = new MockProjectContent(); mockProjectContent.Project = project; mockProjectContent.Language = LanguageProperties.None; mockClass.ProjectContent = mockProjectContent; mockMethod.DeclaringType = mockClass; MockMemberNode memberNode = new MockMemberNode(mockMethod); TestableCondition testableCondition = new TestableCondition(); Assert.IsTrue(testableCondition.IsValid(memberNode, null)); }
public void Init() { solution = new Solution(new MockProjectChangeWatcher()); testProject = new MockCSharpProject(solution, "A"); solution.Folders.Add(testProject); nonTestProject = new MockCSharpProject(solution, "Z"); solution.Folders.Add(nonTestProject); MockProjectContent projectContent = new MockProjectContent(); testFrameworks = new MockRegisteredTestFrameworks(); testFrameworks.AddTestProject(testProject); treeView = new DummyParserServiceTestTreeView(testFrameworks); treeView.ProjectContentForProject = projectContent; treeView.AddSolution(solution); projects = treeView.GetProjects(); }
public void SetUpFixture() { resolver = new PythonResolver(); ParseInformation parseInfo = new ParseInformation(); mockProjectContent = new MockProjectContent(); ArrayList namespaceItems = new ArrayList(); namespaceItems.Add("Test"); mockProjectContent.AddExistingNamespaceContents(String.Empty, namespaceItems); // Set the dirty compilation unit and the valid compilation unit // so we make sure that the most recent compilation unit // (i.e the dirty compilation unit) is being taken. parseInfo.SetCompilationUnit(new DefaultCompilationUnit(new MockProjectContent())); parseInfo.SetCompilationUnit(new DefaultCompilationUnit(mockProjectContent)); results = resolver.CtrlSpace(0, "import".Length, parseInfo, "import", ExpressionContext.Namespace); }
static MockMethod CreateMockMethod(IList <MockAttribute> attributes) { MockMethod mockMethod = new MockMethod(); MockClass mockClass = new MockClass(); MockProjectContent mockProjectContent = new MockProjectContent(); mockProjectContent.Language = LanguageProperties.None; IProject project = new MockCSharpProject(); mockProjectContent.Project = project; mockClass.ProjectContent = mockProjectContent; mockMethod.DeclaringType = mockClass; foreach (MockAttribute attribute in attributes) { mockMethod.Attributes.Add(attribute); } return(mockMethod); }
public void SetUp() { MockProjectContent projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; // Create the base test class. MockClass baseClass = new MockClass(projectContent, "ICSharpCode.Tests.BaseClass"); // Add a virtual method to base class. MockMethod baseMethod = new MockMethod(baseClass, "VirtualTestMethod"); baseMethod.Attributes.Add(new MockAttribute("Test")); baseMethod.Modifiers = ModifierEnum.Virtual; baseClass.Methods.Add(baseMethod); // Add a second method that is virtual but will not be overriden. baseMethod = new MockMethod(baseClass, "VirtualNonOverriddenTestMethod"); baseMethod.Attributes.Add(new MockAttribute("Test")); baseMethod.Modifiers = ModifierEnum.Virtual; baseClass.Methods.Add(baseMethod); // Create the derived test class. c = new MockClass(projectContent, "ICSharpCode.Tests.DerivedClass"); c.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(c); // Create a new test method that overrides one of the base class methods. MockMethod method = new MockMethod(c, "VirtualTestMethod"); method.Attributes.Add(new MockAttribute("Test")); method.Modifiers = ModifierEnum.Override; c.Methods.Add(method); // Set derived class's base class. c.AddBaseClass(baseClass); // Create TestClass. testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport(); testClass = new TestClass(c, testFrameworks); }
public void SetUpFixture() { resolver = new PythonResolver(); mockProjectContent = new MockProjectContent(); mockProjectContent.AddExistingNamespaceContents("System", new List <ICompletionEntry>()); string python = "import System\r\n" + "class Test:\r\n" + " def __init__(self):\r\n" + " System.\r\n"; PythonParser parser = new PythonParser(); string fileName = @"C:\Projects\Test\test.py"; DefaultCompilationUnit cu = parser.Parse(mockProjectContent, fileName, python) as DefaultCompilationUnit; ParseInformation parseInfo = new ParseInformation(cu); ExpressionResult expressionResult = new ExpressionResult("System", new DomRegion(4, 2), null, null); resolveResult = resolver.Resolve(expressionResult, parseInfo, python) as NamespaceResolveResult; }
public void ParserInfoForDifferentProject() { // Create old compilation unit. MockProjectContent differentProjectContent = new MockProjectContent(); DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(differentProjectContent); MockClass mockClass = (MockClass)testClass.Class; mockClass.SetCompoundClass(mockClass); oldUnit.Classes.Add(testClass.Class); // Create new compilation unit with the original test class // removed. DefaultCompilationUnit newUnit = new DefaultCompilationUnit(differentProjectContent); // Update TestProject's parse info. testProject.UpdateParseInfo(oldUnit, newUnit); Assert.AreEqual(1, testProject.TestClasses.Count); Assert.AreEqual(0, classesRemoved.Count); Assert.AreEqual(0, classesAdded.Count); }
public void SetUp() { // Create solution. solution = new Solution(); // Create a project to display in the test tree view. project = new MockCSharpProject(solution); project.Name = "TestProject"; ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project); nunitFrameworkReferenceItem.Include = "NUnit.Framework"; ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem); // Add a test class with a TestFixture attributes. projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; testClass1 = new MockClass("Project.Tests.MyTestFixture"); testClass1.Attributes.Add(new MockAttribute("TestFixture")); testClass1.ProjectContent = projectContent; projectContent.Classes.Add(testClass1); testClass2 = new MockClass("Project.MyTestFixture"); testClass2.Attributes.Add(new MockAttribute("TestFixture")); testClass2.ProjectContent = projectContent; projectContent.Classes.Add(testClass2); // Init mock project content to be returned. dummyTreeView = new DummyParserServiceTestTreeView(); dummyTreeView.ProjectContentForProject = projectContent; // Load the projects into the test tree view. treeView = dummyTreeView as TestTreeView; solution.Folders.Add(project); treeView.AddSolution(solution); nodes = treeView.Nodes; rootNode = (ExtTreeNode)treeView.Nodes[0]; treeView.SelectedNode = rootNode; testProject = treeView.SelectedTestProject; }
public void SetUpFixture() { resolver = new PythonResolver(); ParseInformation parseInfo = new ParseInformation(); mockProjectContent = new MockProjectContent(); testClass = new MockClass(mockProjectContent, "Test.Test1"); mockProjectContent.ClassesInProjectContent.Add(testClass); mockProjectContent.ClassToReturnFromGetClass = testClass; mockProjectContent.ClassNameForGetClass = "Test.Test1"; compilationUnit = new DefaultCompilationUnit(mockProjectContent); compilationUnit.FileName = @"C:\Projects\Test\test.py"; parseInfo.SetCompilationUnit(compilationUnit); string python = "a = Test1()\r\n" + "a"; ExpressionResult expressionResult = new ExpressionResult("a", new DomRegion(2, 1), null, null); resolveResult = resolver.Resolve(expressionResult, parseInfo, python) as LocalResolveResult; }
public void SetUp() { MockProjectContent projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; // Create the top base test class. MockClass baseBaseClass = new MockClass("ICSharpCode.SharpDevelop.Tests.BaseBaseTestFixture"); baseBaseClass.ProjectContent = projectContent; MockMethod baseMethod = new MockMethod("BaseBaseTest"); baseMethod.Attributes.Add(new MockAttribute("Test")); baseMethod.DeclaringType = baseBaseClass; baseBaseClass.Methods.Add(baseMethod); // Create the next level test class. MockClass baseClass = new MockClass("ICSharpCode.SharpDevelop.Tests.BaseTestFixture"); baseClass.ProjectContent = projectContent; baseMethod = new MockMethod("BaseTest"); baseMethod.Attributes.Add(new MockAttribute("Test")); baseMethod.DeclaringType = baseClass; baseClass.Methods.Add(baseMethod); // Create the derived test class. c = new MockClass("ICSharpCode.SharpDevelop.Tests.MainTestFixture"); c.Attributes.Add(new MockAttribute("TestFixture")); c.ProjectContent = projectContent; projectContent.Classes.Add(c); // Set the base class for each class in the hierarchy. c.BaseClass = baseClass; baseClass.BaseClass = baseBaseClass; // Create TestClass. testClass = new TestClass(c); }
public void SetUp() { // Create solution. solution = new Solution(new MockProjectChangeWatcher()); // Create a project to display in the test tree view. project = new MockCSharpProject(); project.Name = "TestProject"; ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project); nunitFrameworkReferenceItem.Include = "NUnit.Framework"; ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem); // Add a test class with a TestFixture attributes. projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; testClass = new MockClass(projectContent, "MyTestFixture"); testClass.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(testClass); testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport(); dummyTreeView = new DummyParserServiceTestTreeView(testFrameworks); dummyTreeView.ProjectContentForProject = projectContent; // Load the projects into the test tree view. treeView = dummyTreeView as TestTreeView; solution.Folders.Add(project); treeView.AddSolution(solution); nodes = treeView.Nodes; rootNode = (ExtTreeNode)treeView.Nodes[0]; // Expand the root node so any child nodes are // lazily created. rootNode.Expanding(); rootChildNodes = rootNode.Nodes; testFixtureNode = (ExtTreeNode)rootNode.Nodes[0]; }
public void Init() { IProject project = new MockCSharpProject(); project.Name = "TestProject"; ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project); nunitFrameworkReferenceItem.Include = "NUnit.Framework"; ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem); MockProjectContent projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; mockClass = new MockClass("RootNamespace.Tests.MyTestFixture"); mockClass.Namespace = "RootNamespace.Tests"; mockClass.ProjectContent = projectContent; mockClass.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(mockClass); // Add a method to the test class MockMethod mockMethod = new MockMethod("TestMethod1"); mockMethod.DeclaringType = mockClass; mockMethod.Attributes.Add(new MockAttribute("Test")); mockClass.Methods.Add(mockMethod); mockMethod = new MockMethod("TestMethod2"); mockMethod.DeclaringType = mockClass; mockMethod.Attributes.Add(new MockAttribute("Test")); mockClass.Methods.Add(mockMethod); testProject = new TestProject(project, projectContent); testClass = testProject.TestClasses[0]; testMethod1 = testClass.TestMethods[0]; testMethod2 = testClass.TestMethods[1]; }
public void Init() { testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport(); // Add a test class. MockProjectContent projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; MockClass c = new MockClass(projectContent, "RootNamespace.MyTestFixture"); c.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(c); // Add first method. var method = new MockMethod(c, "MyTest"); method.Attributes.Add(new MockAttribute("Test")); c.Methods.Add(method); // Add duplicate method. c.Methods.Add(method); // Add a base class that has duplicate methods. MockClass baseClass = new MockClass(projectContent, "RootNamespace.MyTestFixtureBase"); baseClass.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(baseClass); c.AddBaseClass(baseClass); var baseClassMethod = new MockMethod(baseClass, "MyTest"); baseClassMethod.Attributes.Add(new MockAttribute("Test")); baseClass.Methods.Add(baseClassMethod); baseClass.Methods.Add(baseClassMethod); // Create test class. testClass = new TestClass(c, testFrameworks); }
public void Init() { resultChangedCalled = false; classesAdded = new List <TestClass>(); classesRemoved = new List <TestClass>(); // Create a project. project = new MockCSharpProject(); project.Name = "TestProject"; ReferenceProjectItem nunitFrameworkReferenceItem = new ReferenceProjectItem(project); nunitFrameworkReferenceItem.Include = "NUnit.Framework"; ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem); // Add a test class with a TestFixture attributes. projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; MockClass c = new MockClass("RootNamespace.MyTestFixture"); c.SetCompoundClass(c); c.Attributes.Add(new MockAttribute("TestFixture")); c.ProjectContent = projectContent; projectContent.Classes.Add(c); // Add a second class that has no test fixture attribute. MockClass nonTestClass = new MockClass(); nonTestClass.ProjectContent = projectContent; projectContent.Classes.Add(nonTestClass); testProject = new TestProject(project, projectContent); testProject.TestClasses.TestClassAdded += TestClassAdded; testProject.TestClasses.TestClassRemoved += TestClassRemoved; testClass = testProject.TestClasses[0]; }
public void Init() { projectContent = new MockProjectContent(); }
public void SetUp() { // Create a project to display in the test tree view. project = new MockCSharpProject(); project.Name = "TestProject"; nunitFrameworkReferenceItem = new ReferenceProjectItem(project); nunitFrameworkReferenceItem.Include = "NUnit.Framework"; ProjectService.AddProjectItem(project, nunitFrameworkReferenceItem); List <IProject> projects = new List <IProject>(); projects.Add(project); // Add second non-test project. projects.Add(new MockCSharpProject()); // Add a test class with a TestFixture attributes. projectContent = new MockProjectContent(); projectContent.Language = LanguageProperties.None; testClass = new MockClass(projectContent, "RootNamespace.Tests.MyTestFixture"); testClass.Attributes.Add(new MockAttribute("TestFixture")); projectContent.Classes.Add(testClass); // Add two methods to the test class only // one of which has test attributes. testMethod = new MockMethod(testClass, "NameExists"); testMethod.Attributes.Add(new MockAttribute("Test")); testClass.Methods.Add(testMethod); testClass.Methods.Add(new MockMethod(testClass)); // Add a second class that has no test fixture attribute. MockClass nonTestClass = new MockClass(projectContent); projectContent.Classes.Add(nonTestClass); testFrameworks = new MockTestFrameworksWithNUnitFrameworkSupport(); dummyTreeView = new DummyParserServiceTestTreeView(testFrameworks); dummyTreeView.ProjectContentForProject = projectContent; // Load the projects into the test tree view. treeView = dummyTreeView as TestTreeView; treeView.AddProjects(projects); nodes = treeView.Nodes; rootNode = (ExtTreeNode)treeView.Nodes[0]; // Expand the root node so any child nodes are // lazily created. rootNode.Expanding(); rootChildNodes = rootNode.Nodes; rootNamespaceNode = (ExtTreeNode)rootNode.Nodes[0]; // Expand the first namespace node. rootNamespaceNode.Expanding(); rootNamespaceChildNodes = rootNamespaceNode.Nodes; testsNamespaceNode = (ExtTreeNode)rootNamespaceNode.Nodes[0]; // Expand the tests namespace node. testsNamespaceNode.Expanding(); testsNamespaceChildNodes = testsNamespaceNode.Nodes; testFixtureNode = (ExtTreeNode)testsNamespaceNode.Nodes[0]; // Expand the test node. testFixtureNode.Expanding(); testFixtureChildNodes = testFixtureNode.Nodes; testNode = (ExtTreeNode)testFixtureChildNodes[0]; }
public void ExpressionResultContextShowItemReturnsFalseForProjectContent() { MockProjectContent projectContent = new MockProjectContent(); Assert.IsFalse(expressionResult.Context.ShowEntry(projectContent)); }
public void Init() { projectContent = new MockProjectContent(); items = new ArrayList(); }