Recent changes to feature-requests

Faking Static Methods

2009-06-05T10:55:08Z

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

2009-05-25T03:57:11Z

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

Xml Documentation

2008-05-07T21:54:35Z

Plase add Xml documentation to DLLs.

Please add Generics Support

2008-05-06T14:24:31Z

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

2008-03-19T09:16:16Z

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

2007-12-14T15:38:40Z

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

2007-10-16T07:37:07Z

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

2007-08-17T05:02:14Z

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

2007-07-10T03:32:45Z

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

2007-07-10T02:58:11Z

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"));