Download>Old Release Notes

Old Release Notes

New and Noteworthy - Version 4.1

• Support of .NET 3.5 syntax changes
  

  TypeMock can now be with the .NET 3.5 new features:

  • Mocking automatic properties.
  • Mocking Anonymous Types.

    using (RecorderManager.StartRecording())
    {
      // Mock Anonymous Type
      var AnonymousType = new { Name="John", City="LA" };
    }

  • Mocking Lambda Expressions.
  • Verifying New Initialziers.
  • Mocking Extension Methods.

    using (RecordExpectations recorder = RecorderManager.StartRecording())
    {
      // Mock Extension Method ExtendInt
      int x = 5;
      x.ExtendInt();
      recorder.Return(1);
    }

  • Mocking LINQ statements.

    var dummyData = new[] {new {Name="fake",City="typemock"},
                           new {Name="another",City="typemock"}};
    using (RecordExpectations recorder = RecorderManager.StartRecording())
    {
      // Mock Linq
      var queryResult = from c in myCustomerList
          where c.City == "Sarasota"
          select new {c.Name, c.City };
      // return fake results
      recorder.Return(dummyData);
    }

• Integration API for tools developers
  New API was released to ease integrating TypeMock with other developer tools.
  
• Tracer Enhancement (Professional Editions)
  The tracer tool has been enhanced with the ability to pause and resume trace gathering, the ability to resize its different panes, and the marking of the start and end of each test.
  
  
  
• NCover 2.0 Support (Professional Editions)
  The new release of NCover tool (2.0.1) is now supported and can be linked to run with TypeMock
• Support of Visual Studio Orcas Beta 2
  TypeMock.NET can be run on Visual Studio Orcas Beta 2.

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())
  {
     // Mock Click Events of all Button
     recorder.MockAllInstances = true;
     Button buttonMock = new Button();
     buttonMock.Click += null; // This event is mocked
     recorder.RepeatAlways();
  }
  
  // fire the event for 1st Button
  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

• 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; // This event is mocked
  }
  
  // fire the event.
  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())
  {
     // for all runs always check arguments
     recorder.DefaultBehavior.RepeatAlways().CheckArguments();
     // mock the following...
     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

• 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.
• Deferred argument checking
  It is now possible to defer arguments checking until the verify command is called.
• 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

• 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.