public void IsTestMethodReturnsFalseForMethodThatDoesNotStartWithTest()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
MockMethod method = new MockMethod(c, "RunThis");
Assert.IsFalse(testFramework.IsTestMethod(method));
}
public void Init()
{
base.InitBase();
project = new MockCSharpProject();
MockBuildProjectBeforeTestRun buildProject = new MockBuildProjectBeforeTestRun();
context.MockBuildProjectFactory.AddBuildProjectBeforeTestRun(buildProject);
classToTest = MockClass.CreateMockClassWithoutAnyAttributes();
classToTest.SetDotNetName("MyTestClass");
treeView = new MockTestTreeView();
treeView.SelectedProject = project;
treeView.SelectedClass = classToTest;
runTestCommand.Owner = treeView;
runTestCommand.Run();
buildProject.FireBuildCompleteEvent();
TestResult result = new TestResult("MyTestClass");
result.ResultType = TestResultType.Success;
context.MockTestResultsMonitor.FireTestFinishedEvent(result);
runTestCommand.CallTestsCompleted();
}
MockClass CreateClass()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
c.CompilationUnit.Classes.Add(c);
return(c);
}
public void IsValidReturnsFalseForClassWithoutAnyAttributes()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
IProject project = c.MockProjectContent.ProjectAsIProject;
ClassNode classNode = new ClassNode(project, c);
Assert.IsFalse(testableCondition.IsValid(classNode, null));
}
public void IsTestClassDoesNotThrowNullReferenceExceptionWhenNoTestFrameworkSupportsProject()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
c.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.unknown";
Assert.IsFalse(testFrameworks.IsTestClass(c));
}
public void IsTestClassReturnsFalseForUnknownMbUnitFrameworkTestClass()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
c.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.vbproj";
Assert.IsFalse(testFrameworks.IsTestClass(c));
}
public void TestClassPassedToRegisteredTestFrameworksIsTestClass()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
IProject project = c.MockProjectContent.ProjectAsIProject;
ClassNode classNode = new ClassNode(project, c);
testableCondition.IsValid(classNode, null);
Assert.AreEqual(c, testFrameworks.IsTestClassParameterUsed);
}
public void IsTestMethodReturnsFalseWhenMethodHasNullLanguage()
{
MockClass mockClass = MockClass.CreateMockClassWithoutAnyAttributes();
mockClass.MockProjectContent.Language = null;
MockMethod mockMethod = new MockMethod(mockClass);
Assert.IsFalse(testFramework.IsTestMethod(mockMethod));
}
void CreateTestClass()
{
fakeClass = MockClass.CreateMockClassWithoutAnyAttributes();
fakeTestFramework = new MockTestFramework();
fakeRegisteredTestFrameworks = new MockRegisteredTestFrameworks();
fakeRegisteredTestFrameworks.AddTestFrameworkForProject(fakeClass.Project, fakeTestFramework);
testClass = new TestClass(fakeClass, fakeRegisteredTestFrameworks);
}
public void IsTestMember_FieldThatStartsWithTest_ReturnsFalse()
{
CreateTestFramework();
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
var field = new DefaultField(c, "testField");
bool result = testFramework.IsTestMember(field);
Assert.IsFalse(result);
}
public void IsTestClassReturnsTrueWhenDerivedClassHasBaseClassDerivedFromTestCase()
{
MockClass baseClass = MockClass.CreateClassWithBaseType("unittest.TestCase");
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
DefaultReturnType returnType = new DefaultReturnType(baseClass);
c.BaseTypes.Add(returnType);
Assert.IsTrue(testFramework.IsTestClass(c));
}
public void IsTestMember_MethodThatDoesNotStartWithTest_ReturnsFalse()
{
CreateTestFramework();
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
var method = new MockMethod(c, "RunThis");
bool result = testFramework.IsTestMember(method);
Assert.IsFalse(result);
}
public void IsTestMethodReturnsFalseWhenProjectContentLanguageHasNullNameComparer()
{
MockClass mockClass = MockClass.CreateMockClassWithoutAnyAttributes();
mockClass.MockProjectContent.Language = new LanguageProperties(null);
MockMethod mockMethod = new MockMethod(mockClass);
mockMethod.Attributes.Add(new MockAttribute("Test"));
Assert.IsFalse(testFramework.IsTestMethod(mockMethod));
}
public void IsTestMember_MethodHasNullLanguage_ReturnsFalse()
{
CreateTestFramework();
MockClass mockClass = MockClass.CreateMockClassWithoutAnyAttributes();
mockClass.MockProjectContent.Language = null;
var mockMethod = new MockMethod(mockClass);
bool result = testFramework.IsTestMember(mockMethod);
Assert.IsFalse(result);
}
public void GetMethodReplaceRegion()
{
MockMethod method = new MockMethod(MockClass.CreateMockClassWithoutAnyAttributes());
DomRegion bodyRegion = new DomRegion(0, 4, 1, 4);
method.BodyRegion = bodyRegion;
DomRegion expectedRegion = new DomRegion(bodyRegion.BeginLine + 1, 1, bodyRegion.EndLine + 1, 1);
DomRegion region = generator.GetBodyRegionInDocument(method);
Assert.AreEqual(expectedRegion, region);
}
public void IsTestClass_UnknownMbUnitFrameworkTestClass_ReturnsFalse()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
mbUnitTestFramework.AddTestProject(c.Project);
c.MockProjectContent.ProjectAsIProject.FileName = @"d:\projects\test.vbproj";
bool result = testFrameworks.IsTestClass(c);
Assert.IsFalse(result);
}
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 RemoveClass()
{
// Locate the class we are going to remove.
TestProjectTreeNode projectNode = (TestProjectTreeNode)rootNode;
TestClassTreeNode testClassNode = (TestClassTreeNode)projectNode.Nodes[0];
testClassNode.Expanding();
TestClass testClass = projectNode.TestProject.TestClasses["MyTestFixture"];
projectNode.TestProject.TestClasses.Remove(testClass);
ExtTreeNode testClassNodeAfterRemove = null;
foreach (ExtTreeNode node in rootNode.Nodes)
{
if (node.Text == "MyTestFixture")
{
testClassNodeAfterRemove = node;
break;
}
}
Assert.IsNull(testClassNodeAfterRemove);
Assert.AreEqual(0, projectNode.Nodes.Count);
Assert.IsTrue(testClassNode.IsDisposed);
// Make sure the TestClassTreeNode.Dispose removes all event
// handlers.
// It uses the events:
// TestClass.ResultChanged
// TestClassCollection.TestMethodAdded
// TestClassCollection.TestMethodRemoved
// Make sure the test class result is not a failure already.
testClass.Result = TestResultType.None;
testClass.Result = TestResultType.Failure;
Assert.AreEqual(TestTreeViewImageListIndex.TestNotRun,
(TestTreeViewImageListIndex)testClassNode.ImageIndex,
"Disposed TestClassTreeNode affected by test class result change.");
// Add a new test method to the test class
// and make sure the disposed class node does
// not add a new child node.
Assert.AreEqual(0, testClassNode.Nodes.Count);
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
MockMethod mockMethod = new MockMethod(c, "Method");
TestMember testMethod = new TestMember(mockMethod);
testClass.Members.Add(testMethod);
Assert.AreEqual(0, testClassNode.Nodes.Count);
}
public void WriteTestsAddsTestClassFileNameToResponseFile()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
c.CompilationUnit.FileName = @"d:\mytest.rb";
SelectedTests selectedTests = RubySelectedTestsHelper.CreateSelectedTests(c);
responseFile.WriteTests(selectedTests);
string expectedText = "d:\\mytest.rb\r\n";
Assert.AreEqual(expectedText, responseFileText.ToString());
}
public void IsTestMember_FieldHasOneAttribute_ReturnsFalseAndDoesNotThrowInvalidCastException()
{
CreateTestFramework();
MockClass mockClass = MockClass.CreateMockClassWithoutAnyAttributes();
var field = new DefaultField(mockClass, "MyField");
var testAttribute = new MockAttribute("Test");
field.Attributes.Add(testAttribute);
bool result = testFramework.IsTestMember(field);
Assert.IsFalse(result);
}
public void AddTestFailureAfterAllTestsPassed()
{
AllTestMethodsPass();
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
MockMethod mockMethod = new MockMethod(c, "TestMethod4");
TestMember testMethod4 = new TestMember(mockMethod);
testMethod4.Result = TestResultType.Failure;
testMethods.Add(testMethod4);
Assert.AreEqual(TestResultType.Failure, testMethods.Result);
}
public void WriteTestsWritesSelectedTestClassNameWhenOnlyClassSelected()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
c.FullyQualifiedName = "MyNamespace.MyTests";
SelectedTests tests = new SelectedTests(new MockCSharpProject(), null, c, null);
responseFile.WriteTests(tests);
string expectedText = "MyNamespace.MyTests\r\n";
Assert.AreEqual(expectedText, responseFileText.ToString());
}
public void Init()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
c.CompilationUnit.FileName = @"c:\projects\mytest.cs";
treeView = new MockTestTreeView();
treeView.SelectedClass = c;
fileService = new MockFileService();
gotoDefinitionCommand = new GotoDefinitionCommand(fileService);
gotoDefinitionCommand.Owner = treeView;
gotoDefinitionCommand.Run();
}
public void IsTestMember_ProjectContentLanguageHasNullNameComparer_ReturnsFalse()
{
CreateTestFramework();
MockClass mockClass = MockClass.CreateMockClassWithoutAnyAttributes();
mockClass.MockProjectContent.Language = new LanguageProperties(null);
var mockMethod = new MockMethod(mockClass);
mockMethod.Attributes.Add(new MockAttribute("Test"));
bool result = testFramework.IsTestMember(mockMethod);
Assert.IsFalse(result);
}
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 Init()
{
MockRegisteredTestFrameworks testFrameworks = new MockRegisteredTestFrameworks();
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
TestClass testClass = new TestClass(c, testFrameworks);
TestProject testProject = new TestProject(c.Project, c.ProjectContent, testFrameworks);
testProject.TestClasses.Add(testClass);
TestResult testResult = new TestResult("MyNamespace.MyTests.MyTestMethod");
testResult.ResultType = TestResultType.Ignored;
testResult.Message = "Test ignored";
task = TestResultTask.Create(testResult, testProject);
}
public void CreateProcessInfoReturnsCommandLineWithTestMethodOption()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
MockMethod method = new MockMethod(c, "MyMethod");
SelectedTests selectedTests = RubySelectedTestsHelper.CreateSelectedTests(method);
ProcessStartInfo processStartInfo = GetProcessStartInfoFromTestRunnerApp(selectedTests);
string expectedCommandLine =
"--disable-gems " +
"\"-Ic:\\rubybinding\\TestRunner\" " +
"\"c:\\rubybinding\\TestRunner\\sdtest.rb\" " +
"--name=MyMethod " +
"-- " +
"\"results.txt\" " +
"\"temp.tmp\"";
Assert.AreEqual(expectedCommandLine, processStartInfo.Arguments);
}
public void Init()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
c.CompilationUnit.FileName = @"c:\projects\mytest.cs";
int beginLine = 3; // 1 based.
int beginColumn = 6; // 1 based.
c.Region = new DomRegion(beginLine, beginColumn);
treeView = new MockTestTreeView();
treeView.SelectedClass = c;
fileService = new MockFileService();
gotoDefinitionCommand = new GotoDefinitionCommand(fileService);
gotoDefinitionCommand.Owner = treeView;
gotoDefinitionCommand.Run();
}
public void Init()
{
List <TestFrameworkDescriptor> descriptors = new List <TestFrameworkDescriptor>();
MockTestFrameworkFactory factory = new MockTestFrameworkFactory();
Properties mbUnitProperties = new Properties();
mbUnitProperties["id"] = "mbunit";
mbUnitProperties["class"] = "MBUnitTestFramework";
mbUnitProperties["supportedProjects"] = ".vbproj";
mbUnitTestFramework = new MockTestFramework();
factory.Add("MBUnitTestFramework", mbUnitTestFramework);
Properties nunitProperties = new Properties();
nunitProperties["id"] = "nunit";
nunitProperties["class"] = "NUnitTestFramework";
nunitProperties["supportedProjects"] = ".csproj";
nunitTestFramework = new MockTestFramework();
factory.Add("NUnitTestFramework", nunitTestFramework);
TestFrameworkDescriptor mbUnitDescriptor = new TestFrameworkDescriptor(mbUnitProperties, factory);
TestFrameworkDescriptor nunitDescriptor = new TestFrameworkDescriptor(nunitProperties, factory);
descriptors.Add(mbUnitDescriptor);
descriptors.Add(nunitDescriptor);
MockAddInTree addinTree = new MockAddInTree();
addinTree.AddItems("/SharpDevelop/UnitTesting/TestFrameworks", descriptors);
testFrameworks = new RegisteredTestFrameworks(addinTree);
project = new MockCSharpProject();
nunitTestFramework.AddTestProject(project);
mbUnitTestFramework.AddTestProject(project);
method = MockMethod.CreateMockMethodWithoutAnyAttributes();
method.MockDeclaringType.MockProjectContent.Project = project;
clazz = MockClass.CreateMockClassWithoutAnyAttributes();
clazz.MockProjectContent.Project = project;
}
public void CreateProcessInfoReturnsCommandLineWithTestClassOption()
{
MockClass c = MockClass.CreateMockClassWithoutAnyAttributes();
c.FullyQualifiedName = "MyTests";
SelectedTests selectedTests = RubySelectedTestsHelper.CreateSelectedTests(c);
ProcessStartInfo processStartInfo = GetProcessStartInfoFromTestRunnerApp(selectedTests);
string expectedCommandLine =
"--disable-gems " +
"\"-Ic:\\rubybinding\\TestRunner\" " +
"\"c:\\rubybinding\\TestRunner\\sdtest.rb\" " +
"--testcase=MyTests " +
"-- " +
"\"results.txt\" " +
"\"temp.tmp\"";
Assert.AreEqual(expectedCommandLine, processStartInfo.Arguments);
}
