## Release Notes

### NUnit 2.2.5 - December 22, 2005

#### General

- Context menu for dlls now contains "Open With NUnit"

#### Bug Fixes

- Missing files in source zip
- Exception thrown when Assert.Contains referenced an empty list
- Incorrectly labeled desktop shortcut
- Exception thrown when adding an Assembly

### NUnit 2.2.4 - December 14, 2005

#### General

- The /framework option, introduced in NUnit 2.2.3, has been removed. The same functionality is now provided by the clr.bat command file.
- A number of tests, failing only on certain systems, have been corrected.
  - All tests now pass on Mono 1.1.10, with one exception having to do with FileSystemWatcher. That test is ignored for now, since the watcher is only used in the Windows Gui.
  - A race condition, which caused intermittent failures in the EventPump tests, has been removed.
  - Some culture-specific tests have been corrected
- Common assembly info has been moved to a single file in the source.
- The release documentation has been separated from other information that may change over time. Only the documentation itself is included in the installed package, with a link to the web site providing access to additional resources.

#### Framework

- Two new Assert Methods have been added.
  Assert.Greater
    Tests whether its first argument is greater than the second
  Assert.Less
    Tests whether its first argument is less than the second
- The ExpectedException attribute may now be used with a string argument, representing the full type name of the expected exception. This eliminates the need to have a reference to the assembly defining the exception and will thus allow the test to pass across multiple versions of that assembly.
- When an error or exception in a test is followed by a second error in the TearDown, both errors are now reported.
- A custom configuration file, specified in a test project, is no longer ignored.

#### Console Interface

- The /noshadow parameter now works, suppressing the use of ShadowCopy for the tests. Note: This cannot be seen when running the NUnit tests themselves, because certain tests enable ShadowCopy in AppDomains that they create.
- The /out parameter is no longer ignored.
- The /xml parameter now bases a relative path on the current directory rather than the directory containing the executing assembly.

#### Forms Interface

- Test methods inherited from a base class now appear in the gui prefixed by the name of the base class. As a result, a test method in a derived class can redefine a test method in the base class using new without crashing the Gui.
- Attempting to add a duplicate name to the Gui now gives a warning method as opposed to throwing an exception.
- Fixed an error that occured when creating a new project from the Gui.
- Fixed an error in the progress bar, which caused it to remain green when encountering an ignored TestFixture.
- Provided an advisory message when an assembly that uses the 2.0 framework fails to load under .Net 1.1.

### NUnit Iteration Release 2.2.3 - November 14, 2005

#### General

- NUnit can now be installed and run under .NET 2.0 and used in conjunction with VS2005. A problem that prevented installation when .NET 2.0 Beta 2 was the only installed framework has been corrected. NUnit 2.2.3 installation requires one of the following .NET framework versions to be present: 2.0.50727, 2.0.50215, 2.0.40607, 1.1.4322 or 1.0.3705.
- As an alternative to the use of the config file, both the console and gui runners now accept an option /framework, which provides a simple way to run NUnit under any installed version of the common language runtime.
- Additional NUnit library assemblies are now strongly named: nunit.framework, nunit.core, nunit.util, nunit.uikit, nunit-console-runner and nunit-gui-runner. As in prior releases, only nunit.framework is installed in the GAC.
- Separate assemblies are now used for extensions to the NUnit framework and core. Assemblies nunit.extensions.framework and nunit.extensions.core replace the older nunit.extensions assembly.
- As of this release, the msi files no longer install a copy of the source. To get the source, download the source package.
- Problems in the NAnt build having to do with attempted access to registry keys that may not be set in some systems have been fixed.
- Various image files, missing in the 2.2.2 source download, have been restored.
- Both the console and gui command lines no longer recognize '/' as an option delimiter when run on Unix or Linux systems. This allows use of absolute file paths as arguments to both programs.
- The documentation has been reorganized and is now completely converted to HTML.

Framework

- The NUnit core now creates an additional thread for use in pumping events back to the GUI. This avoids problems that occur in earlier releases when the system under test changes the thread context, as in the case of context-bound objects. One result of this change is that it is no longer necessary to save and restore the thread Principal when the test changes it.
- As an aid to those converting from csUnit, NUnit can now run test assemblies built against csUnit without change or recompilation. Assemblies using NUnit and csUnit attributes can be mixed in the same test project but only one framework may be used per assembly. The NUnit emulation has been tested by executing the tests provided with csUnit 1.94 and gives the same results (1 failure) as csUnit.
- Assert.AreEqual now succeeds when the expected and actual values are both NaNs. [For the rationale behind this, see the extended discussion on the Yahoo testdrivendevelopment list]
- A number of new Assert Methods have been added.
  Assert.IsNaN(double)
    Tests whether it's argument is NaN.
  Assert.IsEmpty(string)
    Tests that it's argument is the empty string.
  Assert.IsNotEmpty(string)
    Tests that it's argument is not the empty string.
  Assert.IsEmpty(ICollection)
    Tests that an array, list or collection is empty.
  Assert.IsNotEmpty(ICollection)
    Tests that an array, list or collection is not empty.
  Assert.IsInstanceOf(Type,object)
    Tests that an object is an instance of the supplied Type.
  Assert.IsNotInstanceOf(Type,object)
    Tests that an object is an not instance of the supplied Type.
  Assert.IsAssignableFrom(Type,object)
    Tests that an object may be assigned to an object of the supplied Type.
  Assert.IsNotAssignableFrom(Type,object)
    Tests that an object may not be assigned to an object of the supplied Type.
  Assert.Contains(object,IList)
    Tests whether an object is in a list or array.
- The StringAssert class has been moved from the extensions assembly into nunit.framework. It supports the following methods
  StringAssert.Contains(string,string)
    Tests whether a string contains an expected string.
  StringAssert.StartsWith(string,string)
    Tests whether a string begins with an expected string.
  StringAssert.EndsWith(string,string)
    Tests whether a string ends with an expected string.
  StringAssert.AreEqualIgnoringCase(string,string)
    Compares two strings for equality without regard to case and gives an error message showing the actual strings, without case adjustment.
- The interface used for extending Assert has been changed from prior versions. Extensions written using the older interface may require modification in order to work with this version.
- The following additional information has been added to the XML output:
  - NUnit famework version
  - Common language runtime version
  - Operating system and platform id
  - Current working directory at start of the run
  - Machine name
  - User name and domain
  - Current culture and ui culture
- Special characters in CDATA sections of the XML file are now encoded correctly.
- Restored assert overloads erroneously removed from NUnit 2.2.2. These were removed because they were redundant when using C#, but their absence caused certain managed C++ and J# programs to fail to compile.
- Various bugs related to opening Visual Studio projects have been resolved.
- A problem has been fixed that caused TestFixtureSetUp and TestFixtureTearDown to run between each test in certain circumstances.
- Exceptions thrown by the framework in attempting to access the stack trace of certain COM exceptions are now caught and the stack trace is reported as unavailable.
- Fixed a bug whereby an exception, thrown in the constructor of a TestFixture, was causing NUnit to crash.

#### Forms Interface

- The project editor now allows setting an arbitrary AppBase. Previously, it had to be at or below the directory containing the project file itself.
- The Options dialog is now divided into two tabs. An additional option has been added to allow disabling the tooltip-like windows that appear over the Errors and Failures display and stacktrace when hovering.
- The status bar now displays the full name of the running test, provided there is room to display it. If there is not enough room, the class name is displayed and a tooltip shows the full name when the mouse is held over that panel.
- The space bar no longer exits the application. This feature was originally added to emulate a feature of VBUnit, but has been the source of numerous complaints by users.
- The application no longer crashes when attempting to save to a project file marked as read-only.
- Fixed a bug that occured when custom exceptions were passed back to the GUI.
- Fixed a bug that occured in debug mode, when attempting to display stack trace information from an ExpectedException failure, which doesn't report a stack trace location.

### NUnit Iteration Release 2.2.2 - December 7, 2004

#### General

- With this version of NUnit, all references from the core to the framework assembly have been removed. It is now possible to run tests built against older versions of the framework, either debug or release build.
- The Assert class now provides an AreNotEqual method which gives an error if the two arguments are equal.
- A StringAssert class has been added to the extensions assembly. It provides methods Contains, ContainsAny, StartsWith, EndsWith and AreEqualIgnoringCase.
- The logic for each type of Assert is now been encapsulated in a class that implements the IAsserter interface. Asserter object instances are created for each individual assertion. This allows creating extended asserts by implementing new asserter classes. Several base classes are available for extension. The StringAssert class discussed above provides a model for making such extensions.
- A PlatformAttribute may be applied to test fixtures or tests, causing the tests to be run only on certain OS or runtime platforms. This is still experimental and may change - see the source for documentation.
- Applications built with Visual Studio 2005 may now be debugged using NUnit. NUnit itself may now be built and debugged under Visual Studio 2005.
- Trace output may be directed to standard output by setting TestContext.Tracing to true.
- Solution files containing web applications now be loaded without an exception. The web application is ignored.
- Solution files containing projects specified using UNC paths may now be loaded without an exception. As before, changes to security settings are required to enable loading tests from shares.
- An error in one of the timing tests was corrected.
- The xml results file now uses the correct standard format for date and time independent of the system culture.
- Classes in the nunit.util assembly that were specific to either nunit-gui or nunit-console have been removed. As a result, nunit.util no longer refers to the Windows.Forms or System.Drawing assemblies. The classes are now in the nunit-gui-runner or nunit-console-runner assembly as appropriate.
- The NAnt build scripts in each subdirectory are now directly executable for convenience in working on a single component and for testing the scripts themselves.

#### Forms Interface

- Visual Studio projects and solutions may now be opened by dragging them to the tree control.
- The namespace hierarchy is no longer ignored, with only fixtures displayed, when nunit-gui was run with /fixture: plus a namespace argument.
- The TipWindow displayed over the errors and failures tab in the gui was throwing an exception under certain conditions. This is fixed and further usability improvements have been made.
- Further cases in which gui controls were being called on the wrong thread have been identified and corrected.

### NUnit 2.2.1 Iteration Release - October 26, 2004

#### General

- Reorganized source code into separate components, each with associated tests. An NUnit project file is now provided to facilitate running all the tests together. Config files are provided for running the project and for each separate assembly.
- Both the gui and console runners are now dlls for those who want to link them with their own programs. New exe projects simply reference the dlls and work just as before.
- An experimental extensibility mechanism is now provided, which allows uses to create special types of test cases and suites, marked by their own attributes.
- The nunit.core.dll assembly is no longer registered in the GAC. An assembly resolution event handler is used to "inject" the current version of the core assembly into the user's appdomain. The nunit.framework.dll assembly continues to reside in the GAC for easier reference by user test assemblies.
- The NAnt build has been revised to work with the new directory structure. It is now possible to use NAnt to build individual components and assemblies, without building the entire application. To do this, simply run NAnt in the individual directory. Note that you must ensure that any referenced assemblies have been built first.
- Tests may now be run without the source code being present.
- NUnit can now open Visual Studio 2005 projects and solutions.
- Old style test cases ("Test....") are no longer recognized by default. A setting in the test config file may be used to allow their use on an assembly by assembly basis.
- Added a protected constructor to Assert so those wanting to inherit from it may do so.
- Fixed a buffering problem that caused test case labels to appear out of synch with the test output.
- Fixed a problem causing shadow copies to appear in the root of the current drive if no config file was present or if the setting was not provided in the config file.

#### Forms Interface

- Code that fires events has been modified to ensure that controls are invoked on the correct thread. We believe this will solve many of the problems that occur when running tests under the VS 2005 debugger. However, we have not completed testing in this environment, so some problems may still be present.
- Fixed a problem causing the console output tab to contain old data if the tab had not been selected during the prior test run.
- Fixed a number of problems with the tipwindow used to display error details that don't fit in the normal display area.
- Fixed a problem whereby only the first of several selected tests run was expanded in the gui at completion of the run.

#### Further Documentation

- The included documentation has not changed substantially from NUnit 2.2. The following files in the doc directory provide additional information about changes in this iteration.
  - Installation.txt
  - TestConfig.txt
  - Extensibility.txt

### NUnit 2.2 - August 8, 2004

#### General

- NUnit 2.2 is available in separate Microsoft .NET and Mono distributions. The .NET version can run under Microsoft .NET 1.0, 1.1 or 2.0. The Mono version runs under Mono 1.0. The Microsoft distribution is built using Visual Studio 2003. The Mono version is limited to use of nunit-console to run tests. Note that Mono is distributed with a version of NUnit pre-installed. It may be necessary replace some of the installed components in order to get a newer version of NUnit to work. A note will be published when we have more information on this issue.
- Separate config files for each .NET version are no longer needed. Instead, binding redirects are provided in each config which apply when running under version 1.0 or 2.0 of hte .NET framework. By default, the highest level of the framework installed is used. The user may edit the config file if a different preference is desired.
- The NUnit framework and core are now in separate assemblies, both of which are installed in the GAC. The framework assembly contains all types that are normally referenced by tests, while the core contains those types used by the gui and console runners to execute those tests. Tests requiring use of core types – TestSuite, for example – will need to add a reference to the nunit.core.dll assembly.
- The NAnt build script now supports building NUnit using version 1.0, 1.1 or 2.0 of the .NET framework or with Mono 1.0. The Mono build is limited to those assemblies used under Mono.
- Assert.AreEqual has been extended to allow comparison of two arrays. To compare as equal, the arrays must be of the same or compatible types, contain the same number of elements and each pair of elements must compare as equal.
- All Assert methods that take an optional message argument now also may take an optional array of objects to be used in formatting the message.
- An Assert.Ignore method has been added, which allows individual test cases to be ignored dynamically - for example, on the basis of products installed on the test system. Assert.Ignore may also be called from a SetUp or TestFixtureSetUp method. In the latter case, all the tests are ignored.
- Failure in TestFixtureSetUp or TestFixtureCleanUp now results in an error, rather than in ignoring all the tests.
- The core interfaces used to run tests have been changed substantially. These will continue to change to some extent as we attempt to reach a stable set of interfaces for use by third-party clients that run tests through NUnit. In particular, the interfaces now support passing in an array of tests to be run and return an array of test results. Other new features described in this document have required interface changes as well.
- There is a new CategoryAttribute which allows test fixtures and methods to be grouped into one or more categories using strings as identifiers. Support is provided for running only those tests in selected categories or all tests except those in selected categories.
- A new ExplicitAttribute designates a test case or fixture that should only be run when explicitly chosen by the user - selected directly or included by means of a Category selection. It will not be run merely because its parent suite is selected.
- Tests may now be run using a filter. Currently, this support is used only by the new Category feature, but it is intended to be of general application for clients and – eventually – users.
- NUnit now recognizes when the loaded tests were built using an earlier version of the nunit framework and issues an appropriate message. Earlier versions simply failed to show any tests present in the assembly.
- NUnit now captures and issues a message when a worker thread, created during the running of a test, throws an exception. Previously, such exceptions were silently ignored.
- The XML output from a test run now shows the number of Asserts executed by each test.
- When a test with ExpectedException fails because of an Assert, the message from the assert is now given priority over the message indicating that the wrong type of exception was thrown.
- Private SetUp and TearDown methods are now ignored as intended.
- SetUp and TearDown are no longer executed for ignored tests.
- The documentation is now provided as a set of HTML files.

#### Forms Interface

- The tree of tests now optionally displays checkboxes. These may be used to select multiple tests to be run. Buttons allow clearing all checkboxes and checking only failing tests.
- There is now an option to display the name of each test in the standard output.
- The thread used to run tests is now created in the test AppDomain. The priority and apartment state for this thread may now be specified in the config file for the test. A separate configuration section is now used for NUnit settings, to avoid name collision with settings required by the application under test.
- Command-line options are provided to allow the gui to load and begin running a test suite and to load a specific fixture from an assembly. The properties dialog now shows the number of asserts executed for each test and any description associated with a test.
- A cancel button has been added to the project save dialog that appears on shutdown.
- The display of the last exception is now scrollable, allowing the entire stack to be seen.

#### Console Interface

- The console program has been reorganized to remove differences in how tests are run between the console and gui runners.
- The console interface command line parameters now include provision for selecting or excluding tests based on category, for displaying the name of each test in the standard output and for redirecting standard or error output from tests to a file.
- The /noshadow option eliminates creation of a shadow copy and the /thread option causes the console tests to be run on a separate thread. When a separate thread is used, the config file settings for apartment state will be honored.
- A namespace may now be specified after /fixture and all tests in that namespace will be executed.

#### Mock Objects

- This version of NUnit comes with a built-in, lightweight mock object facility. The functions provided include dynamic creation of an implementation of any interface or MBR class, setting of expectations, specification of return values and verification that the expected actions occurred.
- This facility is in no way a replacement for full-fledged mock frameworks such as NMock and is not expected to add significant features in upcoming releases. Its primary purpose is to support NUnit’s own tests. We wanted to do that without the need to choose a particular mock framework and without having to deal with versioning issues outside of NUnit itself.
- At the same time, we hope that easy availability of a minimal mock object facility will inspire users who are not familiar with mock objects to experiment with them using our built-in facility and to migrate to a more complete framework as your needs call for it.

#### Limitations

- The CategoryAttribute was originally designed to have an Explicit property. This was included in some early releases and is described in the Pragmatic Programmers’ recent book. This property has been removed and is replaced by the ExplicitAttribute, which can be used in conjunction with Category to achieve the same effect as shown in their examples.

### NUnit 2.1 - September 1, 2003

#### General

- The distributed version of NUnit 2.1 is now built using Visual Studio 2003 The solution and project files in this Beta can only be loaded by Visual Studio 2003. Those needing to build with Visual Studio 2002 will need to convert the project, solution and resx files. NUnit can run against .NET framework versions 1.0 or 1.1. Separate config files are provided for using either version. The install detects the highest version installed and sets up the config for that version.
- NUnit now supports loading and running tests across multiple assemblies in both the console and the GUI. This may be done on an adhoc basis or by creating NUnit test projects saved in files of type NUnit.
- Information about one or more test assemblies may now be persisted as NUnit Test Projects. This is a file of type .nunit in XML format which supports the definition of multiple configurations each containing one or more assemblies.
- TestFixtureSetUp and TestFixtureTearDown attributes are now recognized. Methods marked with these attributes will be run before and after the tests in a fixture. Unlike the standard SetUp and TearDown attributes, these methods are invoked only once, before and after all the tests are run.
- The Assertion class is now deprecated and has been replaced with the Assert class supporting a new set of static method names.
- The reporting of test failures and errors provides more information. The specific type of an exception is reported as well as any inner exceptions. Exceptions in TearDown no longer hide the original test exception.
- NUnit now runs under Windows 98 and ME. Automatic reload of changed assemblies is disabled in non-NT environments.

#### Forms Interface

- There are a number of additional menu items. [Specify]
- The GUI interface now runs tests on a separate thread. This allows the tree display to update as execution proceeds. A Stop button now allows cancelling a test run. An option to cancel the run is also displayed if the user attempts to exit while a test is running. The GUI test threads run in the MTA by default. A configuration file setting may be used to run them in an STA.
- XML output from a test run may now be saved using the Tools | Save Results as XML… menu item. The format is the same as that used by the Console runner.
- When an exception occurs while trying to load, unload or run a test, the complete stack trace for that exception is available through the Tools | Exception Details… menu item.
- The Tools | Options… menu item allows setting a number of options. [Specify]
- Automatic reloading of test assemblies may now be disabled. An alternate approach of reloading assemblies whenever a run begins is also available as an option.
- If Visual Studio support is enabled, Visual Studio project and solution files may be opened and Visual Studio projects may be added to an NUnit test project. Currently, C#, VB.NET, J# and managed C++ projects are supported.
- When a Visual Studio or NUnit project is loaded, the user may switch between the available configurations causing the tests to be reloaded. A Configuration Editor allows adding, deleting or renaming configurations.
- The GUI allows creating and modifying NUnit Test Projects through the Project Editor. A Properties window is now availble to display information about any test in the tree. It may be pinned to allow quickly examining the results of different tests.
- Window layout has been streamlined, eliminating one splitter and reducing the area above the tabs to the minimum size needed.
- The File | Recent Assemblies menu item is now called Recent Files since it may hold Visual Studio or NUnit project names. The user may now set the number of items kept in the list.
- Loading of the most recently used file may be disabled by a command line switch.
- Nested Classes are now shown in the TreeView using the format OuterClass+InnerClass. [Showing InnerClass under OuterClass was confusing when both classes contained tests.]
- The contents of the TreeView display are now sorted by name and tests execute in the order of the display to allow easier tracking.
- Splitter positions are now saved in the registry and restored on startup.
- A View menu includes options for Expanding and Collapsing tree nodes, including Expand All, Collapse All, Expand Fixtures and Collapse Fixtures.

#### Console Interface

- The console interface command line parameters have been modified to support loading of multiple assemblies, Visual Studio projects and NUnit projects. Several new switches are available. See the Command Line Parameters section in this document for details.
- The console runner and tests now run in an STA.
- When run in debug mode, the console output is now sent to the Visual Studio Output window.
- Clicking on a test failure brings up the test file in the editor at location of the Assert. Formatting of console output has been improved so that redirected output may be examined conveniently in an editor that requires CRLF at the end of each line.
- All errors are now trapped and a message is displayed.

#### Limitations

- NUnit can only load assemblies as permitted under .NET’s Code Access Security. Using the default settings, this means that you will be unable to load from any UNC path, including one that specifies the name of the local computer. Although you may use the .NET Framework configuration utility to allow loading of such applications, you must do this with care. Often, the simplest approach is to copy assemblies being tested to your local drive. See Visual Studio Support for limitations on loading Visual Studio solution files.

### NUnit 2.0 - October 3, 2002

#### General

- Attribute based mechanism for identifying test fixtures and test methods. In previous versions of NUnit and JUnit for that matter, inheritance was used as the mechanism for identifying which classes were test fixtures and a naming convention was used to identify test methods in these classes. The Custom Attributes available in .NET provide a much more straightforward and less ambiguous mechanism for identification.
- Automatic creation of test suites. In previous versions of NUnit it was required to manually construct suites of tests using a Suite property. This has been replaced with dynamic creation of suites based on namespaces. Given an assembly the program will search through the assembly looking for test fixtures. Once it finds one it creates a suite based for each namespace and the specific test fixture. For example, NUnit.Tests.SuccessTests will build a containing Suite called “NUnit” which will contain another suite called “Tests” which in turn will create another suite called “SuccessTests” which finally will hold the individual test methods. This corrects an error prone task where things may or may not have been included in a suite.
- Additional samples, Managed C++ and Visual J#. The existing samples (C#, VB.NET, Money) have been upgraded to the new version. Money-port has been included to demonstrate the minimal amount of effort required to upgrade.
- A class TestCase in nunit.framework.dll has been provided for backwards compatibility. See the “Money-port” project as a sample of what is required to upgrade to the new version. The only change is to update the reference to the new framework dll and provide a default constructor.
- The exception that is thrown when an Assertion fails is now called AssertionException. In previous versions this was called AssertionFailedError.

#### Forms Interface

- Tree based display in forms interface with test status indication and the ability to run individual tests or suites from the tree.
- Dynamic reloading of an assembly using AppDomains and shadow copying. This also applies if you add or change tests. The assembly will be reloaded and the display will be updated automatically. The shadow copies use we use a configurable directory specified in the executable’s (nunit-gui and nunit-console) config files.
- A reload command menu option to load and assemblies that may have been modified.
- Window sizes are flexible due to the introduction of splitters on major sub-areas of the screen.
- File->Recent Assemblies menu item. The program keeps track of the 5 most recently used assemblies. If no command line arguments are used to start the forms executable the most recent assembly is loaded by default.
- The “Run” button is the default button on the form, which allows hitting return to start the tests.
- Patches suggested by Al Gonzalez
  - The AboutBox was modified so its start position is set to CenterParent
  - The AboutBox border was changed to Fixed3D
  - The size and position of the main form is saved in the registry and restored when the program is launched
- Patch suggested by Rob Jeffries
  - When the main form has the focus hitting the space bar will cause the program to exit. This is present in the current version of the VBunit.

#### Console Interface

- The console interface command line parameters have been modified to be more explicit and conform to similar programs available in .NET. See the Command line parameters section in this document for details.
- XML Output. The console program produces XML output suitable for inclusion into other existing systems.
- Customizing of console output is provided through the use of XSLT. See Summary.xslt for the translation that is provided for the release. Using your own transform file is possible via a command line argument.
- Backwards compatibility with running suites. The Forms interface currently has no mechanism to run suites defined with the suite property. Using the fixture command line argument you must specify a class that is either a TestFixture or contains a Suite attribute.