Download>Old Release Notes
Old Release Notes
New and Noteworthy - Version 4.1
More information can be found in the Release Notes
New and Noteworthy - Version 4.0
- Natural TypeMocks™ easier recording (Enterprise Editions)
Natural TypeMocks now supports creating return values within the recording block, saving even more time and having an easier flow.
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
// Mock Click Event of next Button
MockedType.CallMethod();
recorder.Return(new SomeReturnType(1,2));// SomeReturnType is NOT mocked
}
- Generic reflective API (Professional Editions)
It is possible to use generics to ease the creation of mocks.
Mock theMock = MockManager.Mock<MockedClass>();
MockObject<Interface> theMock = MockManager.MockObject<Interface>();
- Test attributes (Professional Editions)
Using attributes makes testing even easier; works on all testing frameworks.
[Test]
[VerifyMocks(Timeout=150)] // Verify this test
public void TestVerificationWithTimeout()
{
}
- Generic test decorator (Enterprise Editions)
TypeMock is more than just a mocking framework. It now enables you to write custom test decorators. These are test-framework agnostic and make it simple to add more features to your tests.
Examples:
- Tracing
- Database rollback
- Repeating
- 30-day evaluation license
Due to the pressure that we have creating evaluation licenses, we now give a 30-day trial with each installation.
- Support of Visual Studio Orcas Beta 1
TypeMock.NET can be run on Visual Studio Orcas Beta 1.
More information can be found in the Release Notes
New and Noteworthy in Version 3.7
- Windows Vista Support
TypeMock.NET runs on Windows Vista.
- Mocking mscorlib interfaced (Enterprise Editions)
You can now mock mscorlib interfaces!
- Control mocking 'hidden' methods
It is now possible to control hidden methods. This includes:
- Base methods with the same name
- Static and instance methods with the same name
- Chained constructors
- Firing events with multiple instances (Professional and Enterprise Editions)
You can now register events on multiple instances of a type and control the firing of each instance.
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
recorder.MockAllInstances = true;
Button buttonMock = new Button();
buttonMock.Click += null;
recorder.RepeatAlways();
}
RecorderManager.LastMockedEvent.Instance[0].Fire(this, EventArgs.Empty);
- Natural TypeMocks™ Custom Security Attribute
TypeMock handles Custom Security Attributes gracefully.
- Natural TypeMock Automated Singleton Mocking
TypeMock handles Singletons automatically with Chained Natural TypeMock.
More information can be found in the Release Notes
New and Noteworthy in Version 3.6
- Event firing (Professional and Enterprise Editions)
TypeMock.NET now supports event firing. It is now easy to test events by firing them and verifying that the handlers were called.
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
// Mock Click Event of next Button
Button buttonMock = new Button();
buttonMock.Click += null;
}
RecorderManager.LastMockedEvent.Fire(this, EventArgs.Empty);
- Natural TypeMocks Conditional Expectations (Enterprise Edition only)
With conditional expectations, the mock depends on the arguments passed. This allows controlling different behaviors according to the passed parameters and makes testing code cleaner.
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
// return "TypeMock" when mockedClass.Lookup is called with 1
mockedClass.Lookup(1);
recorder.Return("TypeMock").RepeatAlways().WhenArgumentsMatch();
}
- Natural TypeMocks default behavior (Professional and Enterprise editions)
It is now possible to set the default behavior for all mocks, including:
- Time to repeat
- Validate arguments
- Conditional expectations
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
recorder.DefaultBehavior.RepeatAlways().CheckArguments();
DataBases.GetDatabase("typemock").Perform("select");
}
- Automatic concrete mock object
TypeMock now supports automatic creation of default argument for any concrete mock object.
When no constructor arguments are passed to MockManager.MockObject() TypeMock will create the required arguments to enable objects creation.
- Natural TypeMocks private methods
It is now possible to use Natural TypeMocks with private methods using Visual Studio Test - Private Accessors
More information can be found in the Release Notes
New and Noteworthy in Version 3.5
- Natural TypeMocks (Professional and Enterprise editions)
TypeMock.NET now supports the innovative Natural TypeMocks way of defining expectations.
Using Natural TypeMocks refactoring and compiler, strong typing can be used with mocked objects.
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
// CAUTION: ALL calls here are mocked!!!
Logger.Log(Logger.NORMAL,null); // This is mocked
}
- Chained Natural TypeMocks (Enterprise Edition only)
With Chained Natural TypeMocks, you can now set expectations for a full sequence of calls.
using (RecordExpectations recorder = RecorderManager.StartRecording())
{
// CAUTION: ALL calls here are mocked!!!
Dogs.GetDog("rusty").Tail.Wag().Speed(5); // All calls are mocked
}
- Better static constructor story
TypeMock.NET now handles mocking static constructors much better.
The static constructor will be called if it was mocked in a previous test and is not the current one.
- Autodeploy for Build Servers (Enterprise Edition only)
It is now possible to run TypeMock.NET tests without installing the software.
- 64 bit side by side
64 bit and 32 bit TypeMock.NET versions can now work together on the same machine.
- Better Logs and traces

More information can be found in the Release Notes
New and Noteworthy in Version 3.1
- Build integration enhancement
TypeMock.NET now supports NAnt and MSBuild scripts.
(Professional and Enterprise Editions)
- More code coverage supported
We have expanded our partners base and TypeMock.NET now supports code coverage from:
- Clover.NET from Cenqua
- TestRunner from Mailframe
- Team Studio Code Coverage from Microsoft
(Professional and Enterprise Editions)
- Automatic initialization
TypeMock.NET now automatically recognizes known testing frameworks and starts inserting mock code. This is essential for enterprise wide tests to be consistent.
- Support of multiple .NET frameworks
You can choose the .NET runtime environment from all command-line tools (NAnt, MSBuild and TMockRunner).
More information can be found in the Release Notes
New and noteworthy in Version 3.0
- TypeMock.NET now supports .NET 2.0
It is possible to mock Generic Types and Methods and Anonymous Methods.
TypeMock.NET supports a dual .NET environment and can work on both versions 1.1 and 2.0 of .NET.
-
- New TypeMock.NET Tracing Utility
It is possible to visually see the mocked types and the calls that where made to them.
(Enterprise Edition only)

More information can be found in the Release Notes
New and Noteworthy in Version 2.3
- Support of multithread and asynchronous code
TypeMock.NET supports testing of multiple threads and asynchronous code.
- More argument checking
New argument checks have been added.
- MockObject now supports concrete classes
TypeMock now supports the ability to create MockObjects from concrete classes.
- Auto-updater
More control of the auto-updater feature.
- Registered users now receive a demo license
With this license, all Enterprise features are available for evaluation
- TypeMock.NET can now run with code coverage tools and profilers
(Professional & Enterprise Editions only)
- Conditional expectations (Enterprise Edition only)
Using conditional expectations you can now control different behaviors according to the passed parameters (see Conditional Expectations).
- Control your expectations (Enterprise Edition only)
Using expectation blocks, you can now create a mocking infrastructure (see Building a Mock Infrastructure).
- Swapping arguments (Enterprise Edition only)
Using this innovative feature, you can now swap the actual arguments passed to a mocked method (see Swapping Arguments).
- Help integrated into Visual Studio (Enterprise Edition only)
Integrated help can be downloaded for Enterprise Edition users
More information can be found in the Release Notes
New and Noteworthy in Version 2.2
- Precompiled assemblies are now supported
It is now possible to mock types from predefined assemblies (except for mscorlib types).
- More argument checking.
Constructor arguments and all xxxAlways expectation arguments can now be validated (see Mocking Constructors).
- Set multiple expectations
All expectations can now be set to one or more times (see Tip in First Mock).
- Clearer failure messages
Failure messages are now clearer. It is also possible to add custom messages to built-in and custom argument checkers (see Tip in Custom Argument Checking).
- More Properties in MockManager
New properties have been added to query the MockManager state.
- Arbitrary calls
Arbitrary calls behavior (strict) can now be defined on a per-method level (see Arbitrary Calls).
- Call events
It is possible to receive an event each time a mocked method is called and verified. This can be set on a mock-instance level or on a per-method level (see Call Events).
- Extended Help
Extended Help with C# and VB.NET is now included in the download.
- Auto-updater.
No need to check this site to know when a newer version of TypeMock is released. TypeMock will tell you.
More information can be found in the Release Notes
New and Noteworthy in Version 2.1
- Performance has been boosted
A lot of work has been put in improving TypeMock.NET performance
- Examples are distributed
Examples in C# and VB.NET are now distributed with the Installer
- Better Visual Studio integration

It is now possible to run TypeMock.NET from Visual Studio add-ins without running the batch file.
- Support for ref and out parameters
Complete support for mocking ref and out parameters (see Handling ref and out Parameters).
- Clear expectations
It is possible to clear expectations from a mock.
- Built-in argument checks
16 new, predefined, built-in argument checks are now distributed with TypeMock (see Built in Argument Checking).
- CallCounter now supports Properties and Indexes (see Call Counters)
Complete support for checking the number of calls made to Properties and Indexes.
- Fine tuning constructor mocking
The constructor can be mocked without mocking the static fields initializer constructor (see Mocking Constructors).
- FastMode.
To make mocks even faster, there is a fast mode. Caution must be exercised when using this mode. Please read the documentation.