Recent changes to feature-requests

Faking Static Methods

Anonymous — Fri, 05 Jun 2009 10:55:08 -0000

Currently, I don't see it's possible to fake static methods which is needed maybe in every project.

I think the quickest way to implement this is to have a look at the TypeMock assembly code using .NET Reflector, then finding
out how they are implementing how to fake static methods and finally writing your own customized NMock version.

I attached the assembly as well (it's free to download and try from their site I believe).

Pooya

Can you provide a .net compact version

Arno Kan — Mon, 25 May 2009 03:57:11 -0000

it's every encouraging to see this nice & clean solution, any chance to provide a .net compact version?

Xml Documentation

Anonymous — Wed, 07 May 2008 21:54:35 -0000

Plase add Xml documentation to DLLs.

Please add Generics Support

Anonymous — Tue, 06 May 2008 14:24:31 -0000

NMock2 fails hard with Interfaces that contain generic methods.

For example adding "X GenericMethod<X>();" to the IHelloWorld interface in the AcceptanceTests causes those tests to fail.

Add MockEvent support

Joannes Vermorel — Wed, 19 Mar 2008 09:16:16 -0000

Manicprogrammer has a great article about testing delegates and events with NMock.
http://manicprogrammer.com/cs/blogs/willeke/archive/2007/10/17/testing-delegates-with-nunit-and-nmock.aspx

The amount logic is fairly, I would really need this to be included "by default" in NMock.

Thanks in advance,
Joannès

It would be better to sign all NMock assemblies with .snk

Anonymous — Fri, 14 Dec 2007 15:38:40 -0000

For example I need this feature for InternalsVisibleTo attribute - it works only for signed assemblies, so I have to sign my test library with it, but I can not reference NMock2.dll then, because it is unsigned

Supporting classes as well as interfaces

Anonymous — Tue, 16 Oct 2007 07:37:07 -0000

It would be helpful to support classes as well as just interfaces. Occasionally I had to specifically make an interface to use NMock. I believe there is a minor use case for this.

Enum for method/prop names for expectations

Kareem Fawell — Fri, 17 Aug 2007 05:02:14 -0000

Instead of using a string to specify a method or property name in an expecation call, provide an enum with an enumerator list of the names of the methods and properties. That would be safer in that a misspelling won't happen (thought a mis-selection could). It would be more convenient in that Intellisense would list the available methods and properties and allow for auto completion.

I suppose for overloads, the enum constants could include the arguments in some kind of name mangling, but that seems like overkill.

Provide lazy evaluation of values

Daniel Cazzulino (kzu) — Tue, 10 Jul 2007 03:32:45 -0000

When setting expectations on object values, it's quite useful to evaluate the expected values in a lazy way, so that the test code has a chance to set the value.

i.e. consider the case where I'm setting an expectation on a view interface that will check that an argument passed-in matches a value existing on the correponding presenter, which is what's under test:

Expect.Once.On(view).
Method("SetDatabaseFilename").With(DatabaseFilename);
Expect.Once.On(view).
Method("SetDatabase").With(new LazyEqualsToMatcher(delegate() { return presenter.Database; }));

presenter.DatabaseFileChanged(Path.GetFullPath(DatabaseFilename));

Note that it's the presenter action DatabaseFileChanged the one that actually sets the presenter.Database value that we need in order to verify the expectation on the view. Without a lazy evaluation of that property at the time the method is invoked on the view, we have no way of actually setting the expectation. If we had used:

Expect.Once.On(view).
Method("SetDatabase").With(presenter.Database);

The database would have been null at that point, and the expectation would be wrong.

The LazyEqualsToMatcher is pretty simple:

public delegate object LazyValueHandler();

public class LazyEqualsToMatcher : Matcher
{
LazyValueHandler valueHandler;

public LazyEqualsToMatcher(LazyValueHandler valueHandler)
{
this.valueHandler = valueHandler;
}

public override void DescribeTo(TextWriter writer)
{
Is.EqualTo(valueHandler()).DescribeTo(writer);
}

public override bool Matches(object o)
{
return Is.EqualTo(valueHandler()).Matches(o);
}
}

It just wraps the Is.EqualsTo matcher but evaluates the property at matching time instead of construction time.

Thanks.

Create DelegateMatcher

Daniel Cazzulino (kzu) — Tue, 10 Jul 2007 02:58:11 -0000

Create a matcher that receives a delegate that performs the matching. This would avoid creation of custom matchers for many common scenarios (i.e. lazy check on property values, etc.).

Expect.Once.On(foo).With(new DelegateMatcher(delegate { return bar.Value == "hello"; }));

Note that with C# 3.0 syntax it will look much better:

Expect.Once.On(foo).With(new DelegateMatcher(() => bar.Value == "hello"));