Skip to content
This repository has been archived by the owner on Oct 21, 2018. It is now read-only.

Commit

Permalink
Moving tests from MbUnit to xUnit
Browse files Browse the repository at this point in the history
  • Loading branch information
@ayende
ayende committed Oct 24, 2009
1 parent d0ba506 commit c108cc7
Show file tree
Hide file tree
Showing 232 changed files with 9,742 additions and 35,271 deletions.
233 changes: 120 additions & 113 deletions Rhino.Mocks.Tests/ArgConstraintTests.cs
View file

Large diffs are not rendered by default.

46 changes: 24 additions & 22 deletions Rhino.Mocks.Tests/BackToRecord.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,51 +29,51 @@

using System;
using System.Text;
using MbUnit.Framework;
using Xunit;
using Rhino.Mocks.Exceptions;
using Rhino.Mocks.Interfaces;
using Rhino.Mocks.Tests.FieldsProblem;

namespace Rhino.Mocks.Tests
{
[TestFixture]

public class BackToRecord
{
[Test]
[Fact]
public void CanMoveToRecordAndThenReplay()
{
MockRepository mocks = new MockRepository();
IDemo demo = (IDemo)mocks.StrictMock(typeof(IDemo));
Expect.Call(demo.Prop).Return("ayende");
mocks.Replay(demo);
Assert.AreEqual("ayende", demo.Prop);
Assert.Equal("ayende", demo.Prop);
mocks.BackToRecord(demo);
Expect.Call(demo.Prop).Return("rahien");
mocks.Replay(demo);
Assert.AreEqual("rahien", demo.Prop);
Assert.Equal("rahien", demo.Prop);
mocks.VerifyAll();
}

[Test]
[Fact]
public void CanMoveToRecordFromVerified()
{
MockRepository mocks = new MockRepository();
IDemo demo = (IDemo)mocks.StrictMock(typeof(IDemo));
Expect.Call(demo.Prop).Return("ayende");

mocks.Replay(demo);
Assert.AreEqual("ayende", demo.Prop);
Assert.Equal("ayende", demo.Prop);
mocks.VerifyAll();

mocks.BackToRecord(demo);

Expect.Call(demo.Prop).Return("rahien");
mocks.Replay(demo);
Assert.AreEqual("rahien", demo.Prop);
Assert.Equal("rahien", demo.Prop);
mocks.VerifyAll();
}

[Test]
[Fact]
public void CanSpecifyClearOnlyEvents()
{
MockRepository mocks = new MockRepository();
Expand All @@ -85,11 +85,10 @@ public void CanSpecifyClearOnlyEvents()

raiser.Raise(this, EventArgs.Empty);

Assert.IsFalse(called);
Assert.False(called);
}

[Test]
[ExpectedException(typeof(ExpectationViolationException), "AbstractClass.Add(5); Expected #0, Actual #1.")]
[Fact]
public void CanClearOnlyOriginalMethodCalls()
{
MockRepository mocks = new MockRepository();
Expand All @@ -98,12 +97,12 @@ public void CanClearOnlyOriginalMethodCalls()
mocks.BackToRecord(abstractClass, BackToRecordOptions.OriginalMethodsToCall);
mocks.ReplayAll();

abstractClass.Add(5);
Assert.Throws<ExpectationViolationException>(
"AbstractClass.Add(5); Expected #0, Actual #1.",
() => abstractClass.Add(5));
}

[Test]
[ExpectedException(typeof(ExpectationViolationException),
"IDemo.get_Prop(); Expected #0, Actual #1.")]
[Fact]
public void CanClearOnlyPropertyBehavior()
{
MockRepository mocks = new MockRepository();
Expand All @@ -114,12 +113,13 @@ public void CanClearOnlyPropertyBehavior()

mocks.ReplayAll();

string prop = mock.Prop;
Assert.Throws<ExpectationViolationException>("IDemo.get_Prop(); Expected #0, Actual #1.", delegate
{
string prop = mock.Prop;
});
}

[Test]
[ExpectedException(typeof(ExpectationViolationException),
"IDemo.VoidNoArgs(); Expected #1, Actual #0.")]
[Fact]
public void CanMoveToRecordFromReplyWithoutClearingExpectations()
{
MockRepository mocks = new MockRepository();
Expand All @@ -135,10 +135,12 @@ public void CanMoveToRecordFromReplyWithoutClearingExpectations()

mock.VoidNoArgs();

mocks.VerifyAll();
Assert.Throws<ExpectationViolationException>(
"IDemo.VoidNoArgs(); Expected #1, Actual #0.",
() => mocks.VerifyAll());
}

[Test]
[Fact]
public void CanMoveToRecordFromVerifiedWithoutClearingExpectations()
{
MockRepository mocks = new MockRepository();
Expand Down
22 changes: 12 additions & 10 deletions Rhino.Mocks.Tests/CallOriginalMethodTests.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -32,13 +32,13 @@

namespace Rhino.Mocks.Tests
{
using MbUnit.Framework;
using Xunit;

[TestFixture]

public class CallOriginalMethodTests
{

[Test]
[Fact]
public void CallOriginalMethodOnPropGetAndSet()
{
MockRepository mocks = new MockRepository();
Expand All @@ -53,27 +53,29 @@ public void CallOriginalMethodOnPropGetAndSet()
for (int i = 0; i < 10; i++)
{
demo.Prop = i;
Assert.AreEqual(i, demo.Prop);
Assert.Equal(i, demo.Prop);
}
mocks.VerifyAll();
}

[Test]
[ExpectedException(typeof(InvalidOperationException), "Can't use CallOriginalMethod on method ReturnIntNoArgs because the method is abstract.")]
[Fact]
public void CantCallOriginalMethodOnInterface()
{
MockRepository mocks = new MockRepository();
IDemo demo = (IDemo)mocks.StrictMock(typeof(IDemo));
SetupResult.For(demo.ReturnIntNoArgs()).CallOriginalMethod(OriginalCallOptions.CreateExpectation);
Assert.Throws<InvalidOperationException>(
"Can't use CallOriginalMethod on method ReturnIntNoArgs because the method is abstract.",
() => SetupResult.For(demo.ReturnIntNoArgs()).CallOriginalMethod(OriginalCallOptions.CreateExpectation));
}

[Test]
[ExpectedException(typeof(InvalidOperationException), "Can't use CallOriginalMethod on method Six because the method is abstract.")]
[Fact]
public void CantCallOriginalMethodOnAbstractMethod()
{
MockRepository mocks = new MockRepository();
MockingClassesTests.AbstractDemo demo = (MockingClassesTests.AbstractDemo)mocks.StrictMock(typeof(MockingClassesTests.AbstractDemo));
SetupResult.For(demo.Six()).CallOriginalMethod(OriginalCallOptions.CreateExpectation);
Assert.Throws<InvalidOperationException>(
"Can't use CallOriginalMethod on method Six because the method is abstract.",
() => SetupResult.For(demo.Six()).CallOriginalMethod(OriginalCallOptions.CreateExpectation));
}

}
Expand Down
89 changes: 43 additions & 46 deletions Rhino.Mocks.Tests/Callbacks/CallbackTests.cs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -29,64 +29,58 @@

using System;
using System.Runtime.InteropServices;
using MbUnit.Framework;
using Xunit;
using Rhino.Mocks.Constraints;
using Rhino.Mocks.Exceptions;

namespace Rhino.Mocks.Tests.Callbacks
{
[TestFixture]

public class CallbackTests
{
private MockRepository mocks;
private IDemo demo;
private bool callbackCalled;

[TestFixtureSetUp]
public void TestFixtureSetUp()
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
}

[SetUp]
public void SetUp()
public CallbackTests()
{
System.Threading.Thread.CurrentThread.CurrentCulture = System.Globalization.CultureInfo.InvariantCulture;
mocks = new MockRepository();
demo = (IDemo) mocks.StrictMock(typeof (IDemo));
callbackCalled = false;
}

[Test]
[Fact]
public void CallbackIsCalled()
{
demo.VoidStringArg("Ayende");
LastCall.On(demo).Callback<string>(StringMethod);
mocks.Replay(demo);
demo.VoidStringArg("");
mocks.Verify(demo);
Assert.IsTrue(callbackCalled);
Assert.True(callbackCalled);
}

[Test]
[Fact]
public void GetSameArgumentsAsMethod()
{
demo.VoidThreeArgs(0, "", 0f);
LastCall.On(demo).Callback<int, string, float>(ThreeArgsAreSame);
mocks.Replay(demo);
demo.VoidThreeArgs(1, "Ayende", 3.14f);
mocks.Verify(demo);
Assert.IsTrue(callbackCalled);
Assert.True(callbackCalled);
}

[Test]
[ExpectedException(typeof (InvalidOperationException), "Callback arguments didn't match the method arguments")]
[Fact]
public void DifferentArgumentsFromMethodThrows()
{
demo.VoidThreeArgs(0, "", 0f);
LastCall.On(demo).Callback<int, string, string>(OtherThreeArgs);
Assert.Throws<InvalidOperationException>("Callback arguments didn't match the method arguments",
()=> LastCall.On(demo).Callback<int, string, string>(OtherThreeArgs));
}

[Test]
[Fact]
public void IgnoreArgsWhenUsingCallbacks()
{
demo.VoidThreeArgs(0, "", 0f);
Expand All @@ -96,84 +90,87 @@ public void IgnoreArgsWhenUsingCallbacks()
mocks.Verify(demo);
}

[Test]
[Fact]
public void SetReturnValueOnMethodWithCallback()
{
demo.ReturnIntNoArgs();
LastCall.On(demo).Callback(NoArgsMethod).Return(5);
mocks.Replay(demo);
Assert.AreEqual(5, demo.ReturnIntNoArgs());
Assert.Equal(5, demo.ReturnIntNoArgs());
mocks.Verify(demo);
}

[Test]
[ExpectedException(typeof (InvalidOperationException), "Callback arguments didn't match the method arguments")]
[Fact]
public void CallbackWithDifferentSignatureFails()
{
demo.VoidThreeArgs(0, "", 0f);
LastCall.On(demo).Callback<string>(StringMethod);
Assert.Throws<InvalidOperationException>(
"Callback arguments didn't match the method arguments",
() => LastCall.On(demo).Callback<string>(StringMethod));
}

[Test]
[ExpectedException(typeof (ExpectationViolationException), "IDemo.VoidThreeArgs(callback method: CallbackTests.ThreeArgsAreSame); Expected #1, Actual #0.")]
[Fact]
public void GetMessageFromCallbackWhenNotReplaying()
{
demo.VoidThreeArgs(0, "", 0f);
LastCall.On(demo).Callback<int, string, float>(ThreeArgsAreSame);
mocks.Replay(demo);
mocks.Verify(demo);
Assert.Throws<ExpectationViolationException>(
"IDemo.VoidThreeArgs(callback method: CallbackTests.ThreeArgsAreSame); Expected #1, Actual #0.",
() => mocks.Verify(demo));
}

[Test]
[ExpectedException(typeof (ExpectationViolationException), "IDemo.VoidThreeArgs(1, \"Ayende\", 3.14); Expected #1, Actual #2.")]
[Fact]
public void GetMessageFromCallbackWhenCalledTooMuch()
{
demo.VoidThreeArgs(0, "", 0f);
LastCall.On(demo).Callback<int, string, float>(ThreeArgsAreSame);
mocks.Replay(demo);
demo.VoidThreeArgs(1, "Ayende", 3.14f);
demo.VoidThreeArgs(1, "Ayende", 3.14f);
mocks.Verify(demo);

Assert.Throws<ExpectationViolationException>("IDemo.VoidThreeArgs(1, \"Ayende\", 3.14); Expected #1, Actual #2.",
() => demo.VoidThreeArgs(1, "Ayende", 3.14f));
}


[Test]
[ExpectedException(typeof (InvalidOperationException), "Previous method 'IDemo.ReturnIntNoArgs(callback method: CallbackTests.NoArgsMethod);' requires a return value or an exception to throw.")]
[Fact]
public void CallbackWhenMethodHasReturnValue()
{
demo.ReturnIntNoArgs();
LastCall.On(demo).Callback(NoArgsMethod);
mocks.Replay(demo);
Assert.Throws<InvalidOperationException>(
"Previous method 'IDemo.ReturnIntNoArgs(callback method: CallbackTests.NoArgsMethod);' requires a return value or an exception to throw.",
() => mocks.Replay(demo));
}


[Test]
[ExpectedException(typeof (InvalidOperationException), "This method has already been set to CallbackExpectation.")]
[Fact]
public void CallbackAndConstraintsOnSameMethod()
{
demo.StringArgString("");
LastCall.On(demo).Callback<string>(StringMethod)
.Constraints(Is.Anything());
Assert.Throws<InvalidOperationException>("This method has already been set to CallbackExpectation.",
() => LastCall.On(demo).Callback<string>(StringMethod)
.Constraints(Is.Anything()));
}

[Test]
[ExpectedException(typeof (ExternalException), "I'm not guilty, is was /him/")]
[Fact]
public void ExceptionInCallback()
{
demo.ReturnIntNoArgs();
LastCall.On(demo).Callback(NoArgsThrowing).Return(5);
mocks.Replay(demo);
Assert.AreEqual(5, demo.ReturnIntNoArgs());
Assert.Throws<ExternalException>("I'm not guilty, is was /him/",
() => Assert.Equal(5, demo.ReturnIntNoArgs()));
}

[Test]
[ExpectedException(typeof (ExpectationViolationException), "IDemo.VoidThreeArgs(1, \"Ayende\", 3.14); Expected #0, Actual #1.")]
[Fact]
public void CallbackCanFailExpectationByReturningFalse()
{
demo.VoidNoArgs();
LastCall.On(demo).Callback(NoArgsMethodFalse);
mocks.Replay(demo);
demo.VoidThreeArgs(1, "Ayende", 3.14f);
Assert.Throws<ExpectationViolationException>("IDemo.VoidThreeArgs(1, \"Ayende\", 3.14); Expected #0, Actual #1.",
() => demo.VoidThreeArgs(1, "Ayende", 3.14f));
}

#region Implementation Details
Expand All @@ -191,9 +188,9 @@ private bool OtherThreeArgs(int i, string s, string s2)

private bool ThreeArgsAreSame(int i, string s, float f)
{
Assert.AreEqual(1, i);
Assert.AreEqual("Ayende", s);
Assert.AreEqual(3.14f, f);
Assert.Equal(1, i);
Assert.Equal("Ayende", s);
Assert.Equal(3.14f, f);
callbackCalled = true;
return true;
}
Expand Down
Loading

0 comments on commit c108cc7

Please sign in to comment.