public void Init()
{
var en = CultureInfo.CreateSpecificCulture("en");
Thread.CurrentThread.CurrentCulture = en;
Thread.CurrentThread.CurrentUICulture = en;
helper = new FormHelper();
subscription = new Subscription();
mock = new MockClass();
months = new[] {new Month(1, "January"), new Month(1, "February")};
product = new Product("memory card", 10, (decimal) 12.30);
user = new SimpleUser();
users = new[] { new SimpleUser(1, false), new SimpleUser(2, true), new SimpleUser(3, false), new SimpleUser(4, true) };
mock.Values = new[] { 2, 3 };
var controller = new HomeController();
var context = new ControllerContext();
context.PropertyBag.Add("product", product);
context.PropertyBag.Add("user", user);
context.PropertyBag.Add("users", users);
context.PropertyBag.Add("roles", new[] { new Role(1, "a"), new Role(2, "b"), new Role(3, "c") });
context.PropertyBag.Add("sendemail", true);
context.PropertyBag.Add("confirmation", "abc");
context.PropertyBag.Add("fileaccess", FileAccess.Read);
context.PropertyBag.Add("subscription", subscription);
context.PropertyBag.Add("months", months);
context.PropertyBag.Add("mock", mock);
helper.SetController(controller, context);
}
public void CreatePropertyGetDelegateTest()
{
var testClass = new MockClass() { MockProperty = "FooBar" };
PropertyInfo property = testClass.GetType().GetProperty("MockProperty");
string result = LazyBinding.CreatePropertyGetDelegate<string>(testClass, property)();
Assert.AreEqual("FooBar", result);
}
public void ShouldCallTargetMethod()
{
string methodName = "TargetMethod";
MockClass mockTarget = new MockClass();
DynamicObject dynamic = new DynamicObject(mockTarget);
dynamic.Methods[methodName]();
Assert.AreEqual(1, mockTarget.CallCount, "The target method was not called!");
}
public void Init()
{
firstAttribute = new MockAttribute("first");
secondAttribute = new MockAttribute("second");
List<MockAttribute> attributes = new List<MockAttribute>();
attributes.Add(firstAttribute);
attributes.Add(secondAttribute);
mockClass = MockClass.CreateMockClassWithAttributes(attributes);
}
public void ShouldBeAbleToMixAnotherClassInstance()
{
MockClass test = new MockClass();
DynamicObject dynamic = new DynamicObject(new object());
string methodName = "TargetMethod";
dynamic.MixWith(test);
dynamic.Methods[methodName]();
Assert.AreEqual(1, test.CallCount);
}
public void Given_DoubleParameterCommand_When_ExecuteIsCalled_Then_DelegateIsFired()
{
var expected1 = "pizza";
var expected2 = 42;
var sut = new MockClass();
sut.DoubleParameterCommand.Execute(expected1, expected2);
Assert.AreEqual(expected1, sut.ParameterValue1);
Assert.AreEqual(expected2, sut.ParameterValue2);
}
public void ShouldBeAbleToImplicitlyCastAnExpandoObjectToADuckTypeIfExpandoLooksLikeDuckType()
{
var mock = new MockClass();
var target = new DynamicObject(mock);
dynamic expando = new ExpandoObject(target);
ITest test = expando;
test.TargetMethod();
Assert.AreEqual(1, mock.CallCount);
}
public void InvokeCtor()
{
var dto = new MockDto
{
A = 1,
B = 2,
C = 3
};
@class = InvokeUtil.InvokeCtor<MockClass,MockDto>(dto);
Assert.That(@class.A,Is.EqualTo(dto.A));
}
public void ShouldCallTargetProperty()
{
string propertyName = "TargetProperty";
MockClass mockTarget = new MockClass();
DynamicObject dynamic = new DynamicObject(mockTarget);
// Call the getter and the setter
dynamic.Properties[propertyName] = 0;
object value = dynamic.Properties[propertyName];
Assert.AreEqual(2, mockTarget.CallCount, "The target property was not called!");
}
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 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 NewCompilationUnitNull()
{
// Create old compilation unit.
projectContent.Classes.Clear();
DefaultCompilationUnit oldUnit = new DefaultCompilationUnit(projectContent);
MockClass mockClass = (MockClass)testClass.Class;
mockClass.SetCompoundClass(mockClass);
oldUnit.Classes.Add(testClass.Class);
// Update TestProject's parse info.
testProject.UpdateParseInfo(oldUnit, null);
Assert.AreEqual(0, testProject.TestClasses.Count);
Assert.AreEqual(1, classesRemoved.Count);
Assert.AreSame(testClass, classesRemoved[0]);
}
public void EmptyNamespaceNodesRemoved()
{
// Expand the project node.
TestProjectTreeNode projectNode = (TestProjectTreeNode)pad.TestTreeView.Nodes[0];
projectNode.Expanding();
// Add a new class to a non-empty namespace so it gets
// added to a new namespace node.
MockClass mockClass = new MockClass("RootNamespace.Tests.MyTestFixture");
TestClass testClass = new TestClass(mockClass);
projectNode.TestProject.TestClasses.Add(testClass);
// Expand RootNamespace tree node.
TestNamespaceTreeNode rootNamespaceNode = (TestNamespaceTreeNode)projectNode.Nodes[0];
rootNamespaceNode.Expanding();
// Expand the Tests namespace tree node.
TestNamespaceTreeNode testsNamespaceNode = (TestNamespaceTreeNode)rootNamespaceNode.Nodes[0];
testsNamespaceNode.Expanding();
// Get the test class node.
TestClassTreeNode classNode = (TestClassTreeNode)testsNamespaceNode.Nodes[0];
// Remove the test class from the test project.
projectNode.TestProject.TestClasses.Remove(testClass);
Assert.AreEqual(0, projectNode.Nodes.Count,
"Namespace nodes should have been removed from project node.");
// Make sure the two namespace nodes are properly disposed.
Assert.IsTrue(testsNamespaceNode.IsDisposed);
Assert.IsTrue(rootNamespaceNode.IsDisposed);
// Make sure the test class node has been disposed.
Assert.IsTrue(classNode.IsDisposed);
// Make sure the namespace node Dispose method removes
// the TestProject.TestClasses.TestClassAdded event handler.
Assert.AreEqual(0, testsNamespaceNode.Nodes.Count);
projectNode.TestProject.TestClasses.Add(testClass);
Assert.AreEqual(0, testsNamespaceNode.Nodes.Count);
}
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()
{
projects = new List <IProject>();
projects.Add(new MockCSharpProject());
projects.Add(new MockCSharpProject());
project = new MockCSharpProject();
c = new MockClass();
MockTestTreeView treeView = new MockTestTreeView();
treeView.SelectedProject = project;
treeView.SelectedClass = c;
selectedTests = new SelectedTests(treeView, projects.ToArray());
}
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 ClassNodeAddedAfterProjectNodeExpanded()
{
// Expand the project node.
TestProjectTreeNode projectNode = (TestProjectTreeNode)pad.TestTreeView.Nodes[0];
projectNode.Expanding();
// Add a new class to a non-empty namespace so it gets
// added to a new namespace node.
MockClass mockClass = new MockClass("RootNamespace.MyTestFixture");
TestClass testClass = new TestClass(mockClass);
projectNode.TestProject.TestClasses.Add(testClass);
Assert.AreEqual(1, projectNode.Nodes.Count,
"Project node should have one child node.");
}
public void GetAllMustGetAllAddedItems()
{
// Given
MockRepository rep = new MockRepository();
MockClass data1 = new MockClass();
MockClass data2 = new MockClass();
MockClass data3 = new MockClass();
// When
rep.Add(data1);
rep.Add(data2);
rep.Add(data3);
List <MockClass> resp = rep.GetAll().ToList();
// Then
Assert.AreEqual(resp.Count, 3, "Returned list must have same number of added objects");
}
public async Task EventsCanBePublishedAsync()
{
// Arrange
IEventAggregator eventAggregator = new InProcessEventAggregator();
MockClass mockClass = new MockClass(eventAggregator);
MockEvent @event = new MockEvent();
// Act
await eventAggregator.PublishAsync(@event);
// Assert
Assert.IsNotNull(mockClass.ReceivedAsyncMockEventId);
Assert.AreEqual(@event.Guid, mockClass.ReceivedAsyncMockEventId);
Assert.AreEqual(default(Guid), mockClass.ReceivedMockEventId);
Assert.AreEqual(default(Guid), mockClass.ReceivedAutoMockEventId);
Assert.AreEqual(default(Guid), mockClass.ReceivedAutoAsyncMockEventId);
}
public void ParserInfoUpdated()
{
DefaultCompilationUnit newUnit = new DefaultCompilationUnit(pad.ProjectContent);
MockClass mockClass = new MockClass(pad.ProjectContent, "MyTestFixture");
mockClass.Attributes.Add(new MockAttribute("TestFixture"));
newUnit.Classes.Add(mockClass);
ExtTreeNode rootNode = (ExtTreeNode)pad.TestTreeView.Nodes[0];
rootNode.Expanding();
pad.CallUpdateParseInfo(null, newUnit);
Assert.AreEqual(1, rootNode.Nodes.Count);
Assert.AreEqual("MyTestFixture", rootNode.Nodes[0].Text);
}
public void ClassWithMethods_NotUsingAnyOfClassFields_HasCohesionError()
{
var cohesionRule = QualityRules.ClassCohesion;
var method1 = MockMethod.EmptyMethod("Method1");
var method2 = MockMethod.EmptyMethod("Method2");
var classFields = new[] { "field1", "field2" };
var classDef = MockClass.GetClass(classFields, new[] { method1, method2 });
var cohesionAnalyzer = new ClassCohesion(TestBootStrapped.GetInstanceOfICohesion());
cohesionAnalyzer.Analyze(classDef);
var analyzeResult = cohesionAnalyzer.GetResult();
var isCohesive = !analyzeResult.Any(a => a.ViolatedRule.Equals(cohesionRule));
Assert.IsFalse(isCohesive);
}
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 DuplicateClassName()
{
MockClass c = new MockClass("RootNamespace1.MyTestFixture2");
c.Attributes.Add(new MockAttribute("TestFixture"));
c.ProjectContent = projectContent;
TestClass testClass = new TestClass(c);
testProject.TestClasses.Add(testClass);
testClass.Result = TestResultType.Failure;
TestClass testClass2 = testProject.TestClasses["RootNamespace2.MyTestFixture2"];
testClass2.Result = TestResultType.Failure;
Assert.AreEqual(TestResultType.Failure, testProject.TestClasses.Result);
}
public void SetUpFixture()
{
mockClass = new MockClass("Tests.MyTestFixture");
mockMethod = new MockMethod("MyMethod");
mockMethodRegion = new DomRegion(0, 0, 0, 10);
mockMethod.Region = mockMethodRegion;
mockMethodBodyRegion = new DomRegion(1, 0, 2, 5);
mockMethod.BodyRegion = mockMethodBodyRegion;
mockMethod.Modifiers = ModifierEnum.Public;
MockClass returnTypeClass = new MockClass("Tests.ReturnType");
returnType = new DefaultReturnType(returnTypeClass);
mockMethod.ReturnType = returnType;
baseTestMethod = new BaseTestMethod(mockClass, mockMethod);
}
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()
{
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 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 GivenANonNull_ShouldReturnSelectedValue(
object objectValue,
int intValue,
long longValue,
DateTime dateTimeValue)
{
var @object = new MockClass
{
ObjectProperty = objectValue,
LongProperty = longValue,
IntProperty = intValue,
DateTimeProperty = dateTimeValue
};
@object.IfNotNull(v => v.ObjectProperty).Should().Be(objectValue);
@object.IfNotNull(v => v.LongProperty).Should().Be(longValue);
@object.IfNotNull(v => v.IntProperty).Should().Be(intValue);
@object.IfNotNull(v => v.DateTimeProperty).Should().Be(dateTimeValue);
}
public void GetAllMustReturnClonedObjects()
{
// Given
MockRepository rep = new MockRepository();
MockClass data1 = new MockClass();
MockClass data2 = new MockClass();
MockClass data3 = new MockClass();
// When
rep.Add(data1);
rep.Add(data2);
rep.Add(data3);
List <MockClass> resp = rep.GetAll().ToList();
// Then
Assert.IsFalse(resp.Contains(data1), "Returned list must not contain the original objects");
Assert.IsFalse(resp.Contains(data2), "Returned list must not contain the original objects");
Assert.IsFalse(resp.Contains(data3), "Returned list must not contain the original objects");
}
public void ResetTestResults()
{
foreach (IProject project in projects)
{
TestProject testProject = treeView.GetTestProject(project);
MockClass mockClass = new MockClass("MyTestFixture");
TestClass testClass = new TestClass(mockClass);
testClass.Result = TestResultType.Failure;
testProject.TestClasses.Add(testClass);
Assert.AreEqual(testProject.TestClasses.Result, TestResultType.Failure);
}
treeView.ResetTestResults();
foreach (IProject project in projects)
{
TestProject testProject = treeView.GetTestProject(project);
Assert.AreEqual(testProject.TestClasses.Result, TestResultType.None);
}
}
public void ClassWithMethods_HaveNotUsedCommonClassFields_HasCohesionError()
{
var classFields = new[] { "field1", "field2" };
var cohesionRule = QualityRules.ClassCohesion;
var method1 = GetMethodWithAccessingToClassFieldsInBlock("Method1", new[] { classFields[0] });
var method2 = GetMethodWithAccessingToClassFieldsInBlock("Method2", new[] { classFields[1] });
var classDef = MockClass.GetClass(classFields, new[] { method1, method2 });
var cohesionAnalyzer = new ClassCohesion(TestBootStrapped.GetInstanceOfICohesion());
cohesionAnalyzer.Analyze(classDef);
var analyzeResult = cohesionAnalyzer.GetResult();
var isCohesive = !analyzeResult.Any(a => a.ViolatedRule.Equals(cohesionRule));
Assert.IsFalse(isCohesive);
}
public void XmlOutputFileNameSpecifiedOnCommandLine()
{
UnitTestingOptions options = new UnitTestingOptions(new Properties());
options.CreateXmlOutputFile = true;
MockClass testFixture = new MockClass("MyTests.TestFixture.MyTest");
SelectedTests selectedTests = new SelectedTests(project, null, testFixture, null);
NUnitConsoleApplication app = new NUnitConsoleApplication(selectedTests, options);
app.NoLogo = false;
app.ShadowCopy = true;
string expectedCommandLine =
"\"C:\\Projects\\MyTests\\MyTests.dll\" " +
"/xml=\"C:\\Projects\\MyTests\\MyTests-TestResult.xml\" " +
"/run=\"MyTests.TestFixture.MyTest\"";
Assert.AreEqual(expectedCommandLine, app.GetArguments());
}
public void SetUp()
{
base.InitBase();
baseClass = new MockClass(projectContent, "MyTests.BaseClass");
testMethodInBaseClass = new MockMethod(baseClass, "BaseFoo");
testMethodInBaseClass.Attributes.Add(new MockAttribute("Test"));
baseClass.Methods.Add(testMethodInBaseClass);
//Add TestFixture attribute to outer class
outerClass.Attributes.Add(new MockAttribute("TestFixture"));
//Add inner class nested in test class
classNestedInInnerClass = new MockClass(projectContent, "MyTests.A.InnerATest.InnerTestLevel2", "MyTests.A+InnerATest+InnerTestLevel2", innerClass);
innerClass.InnerClasses.Add(classNestedInInnerClass);
classNestedInInnerClass.AddBaseClass(baseClass);
testProject = new TestProject(null, projectContent, testFrameworks);
}
public void PropertyAccessorsExpressionCreator_Must_Do_Null_Proposition()
{
var pa = new PropertyAccessorsExpressionCreator(typeof(MockClass));
var obj = new MockClass();
var aGetter = pa.TakeGetterForProperty("A");
var subAGetter = pa.TakeGetterForProperty("SubClass.A");
Assert.NotNull(subAGetter);
Assert.DoesNotThrow(() => aGetter(null));
Assert.DoesNotThrow(() => aGetter(obj));
Assert.DoesNotThrow(() => subAGetter(null));
Assert.DoesNotThrow(() => subAGetter(obj));
Assert.AreEqual(default(int), subAGetter(obj));
}
public void Init()
{
projects = new List <IProject>();
projects.Add(new MockCSharpProject());
projects.Add(new MockCSharpProject());
project = new MockCSharpProject();
c = new MockClass();
method = new MockMethod(c);
MockTestTreeView treeView = new MockTestTreeView();
treeView.SelectedProject = project;
treeView.SelectedNamespace = "MyNamespace";
treeView.SelectedMember = method;
selectedTests = new SelectedTests(treeView, projects.ToArray());
}
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);
}
public void UpdatingDataMustChangeDataInSet()
{
// Given
MockRepository rep = new MockRepository();
MockClass obj = new MockClass();
string data = "Data";
// When
long resp = (long)rep.Add(obj);
MockClass addedData = rep.Get(resp);
addedData.Data = data;
rep.Update(addedData);
// Then
Assert.AreEqual(rep.Get(resp).Data, data, "Object's data must be same as updated one");
}
public void PropertyAccessorsExpressionCreator_Should_Correctly_Get_And_Set()
{
var pa = new PropertyAccessorsExpressionCreator(typeof(MockClass));
var initialA = 333;
var initialB = "444";
var initialSubA = 777;
var initialSubB = "888";
var obj = new MockClass {
A = initialA, B = initialB
};
var sub = new SubClass {
A = initialSubA, B = initialSubB, Parent = obj, AnotherParent = null
};
obj.SubClass = sub;
var aGetter = pa.TakeGetterForProperty("A");
var bGetter = pa.TakeGetterForProperty("B");
var subAGetter = pa.TakeGetterForProperty("SubClass.A");
var subBGetter = pa.TakeGetterForProperty("SubClass.B");
var subASetter = pa.TakeSetterForProperty("SubClass.A");
var subBSetter = pa.TakeSetterForProperty("SubClass.B");
Assert.NotNull(subAGetter);
Assert.NotNull(subBGetter);
Assert.NotNull(subASetter);
Assert.NotNull(subBSetter);
Assert.AreEqual(initialA, aGetter(obj));
Assert.AreEqual(initialB, bGetter(obj));
Assert.AreEqual(initialSubA, subAGetter(obj));
Assert.AreEqual(initialSubB, subBGetter(obj));
subASetter(obj, -333);
Assert.AreEqual(-333, obj.SubClass.A);
}
public void SetUpFixture()
{
resolver = new PythonResolver();
mockProjectContent = new ICSharpCode.Scripting.Tests.Utils.MockProjectContent();
systemConsoleClass = new MockClass(mockProjectContent, "System.Console");
mockProjectContent.SetClassToReturnFromGetClass("System.Console", systemConsoleClass);
compilationUnit = CreateCompilationUnit(mockProjectContent);
ParseInformation parseInfo = new ParseInformation(compilationUnit);
string python = GetPythonScript();
ExpressionResult expressionResult = new ExpressionResult("System.Console", new DomRegion(3, 2), null, null);
resolveResult = resolver.Resolve(expressionResult, parseInfo, python);
// Check that the best compilation unit is used and the resolve
// still works.
invalidMostRecentCompilationUnitResolveResult = resolver.Resolve(expressionResult, parseInfo, python);
}
public void Init()
{
firstAttribute = new MockAttribute("first");
mockClass = MockClass.CreateMockClassWithAttribute(firstAttribute);
}
public void ShouldAllowDuckTyping()
{
MockClass test = new MockClass();
DynamicObject dynamic = new DynamicObject(new object());
ITest duck = dynamic.CreateDuck<ITest>();
// Combine the MockClass implementation with the current
// object instance
dynamic.MixWith(test);
duck.TargetMethod();
duck.TargetMethod<int>();
Assert.AreEqual(2, test.CallCount);
}
public void Given_PropertySetterUsesSetProperty_When_PropertyIsNotChanged_Then_NotNotified()
{
var sut = new MockClass();
sut.ShouldNotNotifyOn(m => m.TestString2).When(m => m.TestString2 = m.TestString2);
}
public void Given_SetterCallsOnPropertyChanged_When_PropertyIsNotChanged_Then_NotNotified()
{
var sut = new MockClass();
sut.ShouldNotNotifyOn(m => m.TestString1).When(m => m.TestString1 = m.TestString1);
}
public void CreatePropertyGetDelegateByNameTest()
{
var testClass = new MockClass() { MockProperty = "FooBar" };
string result = LazyBinding.CreatePropertyGetDelegate<string>(testClass, "MockProperty")();
Assert.AreEqual("FooBar", result);
}
public void CreateMethodDelegateTest()
{
var testClass = new MockClass();
LazyBinding.CreateMethodDelegate<Action>(testClass, testClass.GetType().GetMethod("MockMethod"))();
Assert.AreEqual(1, testClass.TimesCalled);
}
public void Given_SingleParameterCommand_When_ExecuteIsCalled_Then_DelegateIsFired()
{
var expected1 = "robble";
var sut = new MockClass();
sut.SingleParameterCommand.Execute(expected1);
Assert.AreEqual(expected1, sut.ParameterValue1);
}
