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