Array Assertion class

Use this attribute to identify the class containing setup and teardown methods for an assembly of tests. The setup method will be run before any other tests or setup methods in the assembly and the teardown method will be run after any other teardown methods in the assembly.

Use this attribute to identify an assembly whose tests must execute successfully before the tests in this assembly are executed

Registers a custom assembly resolver.

Class containing generic assert methods for the comparison of values and object references, the existence of objects within a collection type and basic object properties - for example, whether or not it is assignable to. Also contains a set of Fail asserts which will automatically fail a test straight away.

Associates the author's name and email address with a test fixture, test method, test parameter or other test component.

Used in strategies for testing classes and tests for null arguments. For more info, see this article

Assertion helper for the ICollection class.

Collection indexing pattern.

Collection Order Pattern implementations.

Tag use to mark a mark a combinatorial unit test method. This tells MbUnit to do a pairwise enumeration over the different data sample of each parameter for the test

Assertion helper for compilation.

Composite fixture pattern implementation.

Tags method that should throw an exception if a predicate is true.

When you need to test a console application, this task usually involves calling the application using Process.Start and monitoring that process. This class simplifies this.

• it redirects output and error streams so that they are logged in the report
• it checks the exit code
• a time out can be specified

Class containing generic assert methods for the comparison of Windows Form Controls.

Tags a class whose assembly file and associated pdb file should be copied elsewhere

Tags a method that provides a new IEnumerable object containing data for testing

Used in conjunction, e.g. with an AutoRunner to identify only the tests that it should run

Assertion class for Database related object.

The DataFixture tags a test class that will be using provider classes to push values to the tests it contains.

The DataProvider method attribute allows you to mark a method as your collection populator for tests.

Abstract class to derive (XML) DataProvider attribute classes from.

Abstract class describing attribute used to tag a class and declare a backup be restored to it before the test is executed on request by tagging a test method with a RestoreDatabaseAttribute. This class represents the generic case. The specific implementation for SQL Server is SqlRestoreInfoAttribute

Use this attribute to identify the parent text fixture class or classes whose tests must execute successfully before the tests in this class are executed

Use this attribute to specify that the tagged method should return in a given number of seconds or fail otherwise.

Tags a class as a specialized fixture for testing classes derived from IEnumerable or IEnumerator. The fixture class will automatically test that objects returned by test methods within the class tagged with either DataProviderAttribute or CopyToProviderAttribute follow the enumerator specification.

Subtype of the ExpectedExceptionAttribute that automatically expects an ArgumentException.

Subtype of the ExpectedExceptionAttribute that automatically expects an ArgumentNullException.

Tags a test method to indicate that it should throw an exception.

Used when dynamically adding ITestCases that expect an exception to a TestSuite

Tags test fixture classes and individual test methods to not be run unless explicitly selected, either using the GUI or command line arguments.

Test methods annotated with this attribute will have the specified embedded resource extracted.

Used with Combinatorial Tests to indicate how to generate values for a test parameter. Can be tagged onto a parameter directly or a method which yields values.

Class containing generic assert methods for the comparison of files and streams.

Used to tag methods within test fixtures implementing the collection order pattern that fill collections with data.

Used to tag a test fixture class with a category for use in the MbUnit GUi or console runner

Used to tag a test method to specify the information contained in an XML file that should be used as parameters for that test. To be used in conjunction with the DataFixtureAttribute and XmlDataProviderAttribute.

Assertion class

Identifies the tagged method as a Production Grammar

Identifies the tagged class as a Production Grammar Fixture

Represents a run of tests as generated according to the production grammar which provides a test method with data

A class that knows how to invoke a test using input from a production grammar.

Indicates that a test is to be ignored by the framework and will not be run. The test will still appear in test reports along with the reason that it was ignored, if provided.

This attribute can be used to disable tests that are broken or expensive without commenting them out or removing them from the source code.

Associates a TestImportance with a test fixture, test method, test parameter or other test component.

Tags a method that returns an object which can be iterated over using a class implementing IBidirectionalIterator

Derive from this class to tag any class, method or property and associate information with it to be picked up by console or GUI test runners. For example, author name and test importance

Simple class implementing IBidirectionalIterator that returns the next or previous integer in sequence

Contains methods that will show a dialog to the tester that diplays steps to take. The dialog also lets the tester adding comments.

Represents a test case for a method on an object. It tests a method given a set of parameters if applicable. Can be added to a TestSuite.

Used in strategies for testing classes and tests for null arguments. For more info, see this article

Used to tag any test method that needs to be run under a number of different cultures.

Tags a class as a namespace provider. For use with a TypeFixtureAttribute tagged class instead of a ProviderFactoryAttribute tagged type.

In the case where your test class inherits test methods from a parent class, use this tag to indicate that the test in the subclass should expect a different type of exception

Tag your assembly with this to identify the class you've created to identify parameters in your test methods that can be null.

Performance Assertion class

Tags a test fixture class or test method with implicit assertions about the values of a performance counter on your machine.

Class that understands how to invoke a test given and monitor a performance counter nominated by a PerfCounterAttribute tagging the test method

Class containing static helper methods for retrieving performance counters. For use in conjunction with PerfCounterAttribute

.Net CLR Data

Current number of pools associated with the process.

Current number of connections, pooled or not.

Current number of connections in all pools associated with the process.

The highest number of connections in all pools since the process started.

The total number of command executes that have failed for any reason.

The total number of connection open attempts that have failed for any reason.

Runtime statistics on CLR exception handling.

This counter displays the total number of exceptions thrown since the start of the application. These include both .NET exceptions and unmanaged exceptions that get converted into .NET exceptions e.g. null pointer reference exception in unmanaged code would get re-thrown in managed code as a .NET System.NullReferenceException; this counter includes both handled and unhandled exceptions. Exceptions that are re-thrown would get counted again. Exceptions should only occur in rare situations and not in the normal control flow of the program.

This counter displays the number of exceptions thrown per second. These include both .NET exceptions and unmanaged exceptions that get converted into .NET exceptions e.g. null pointer reference exception in unmanaged code would get re-thrown in managed code as a .NET System.NullReferenceException; this counter includes both handled and unhandled exceptions. Exceptions should only occur in rare situations and not in the normal control flow of the program; this counter was designed as an indicator of potential performance problems due to large (>100s) rate of exceptions thrown. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the number of .NET exception filters executed per second. An exception filter evaluates whether an exception should be handled or not. This counter tracks the rate of exception filters evaluated; irrespective of whether the exception was handled or not. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the number of finally blocks executed per second. A finally block is guaranteed to be executed regardless of how the try block was exited. Only the finally blocks that are executed for an exception are counted; finally blocks on normal code paths are not counted by this counter. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the number of stack frames traversed from the frame that threw the .NET exception to the frame that handled the exception per second. This counter resets to 0 when an exception handler is entered; so nested exceptions would show the handler to handler stack depth. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

Stats for CLR interop.

This counter displays the current number of Com-Callable-Wrappers (CCWs). A CCW is a proxy for the .NET managed object being referenced from unmanaged COM client(s). This counter was designed to indicate the number of managed objects being referenced by unmanaged COM code.

This counter displays the total number of times arguments and return values have been marshaled from managed to unmanaged code and vice versa since the start of the application. This counter is not incremented if the stubs are inlined. (Stubs are responsible for marshalling arguments and return values). Stubs usually get inlined if the marshalling overhead is small.

This counter displays the current number of stubs created by the CLR. Stubs are responsible for marshalling arguments and return values from managed to unmanaged code and vice versa; during a COM Interop call or PInvoke call.

Reserved for future use.

Reserved for future use.

Stats for CLR Jit.

This counter displays the rate at which IL bytes are jitted per second. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the total IL bytes jitted since the start of the application. This counter is exactly equivalent to the "Total # of IL Bytes Jitted" counter.

This counter displays the total number of methods compiled Just-In-Time (JIT) by the CLR JIT compiler since the start of the application. This counter does not include the pre-jitted methods.

Not Displayed.

This counter displays the peak number of methods the JIT compiler has failed to JIT since the start of the application. This failure can occur if the IL cannot be verified or if there was an internal error in the JIT compiler.

This counter displays the percentage of elapsed time spent in JIT compilation since the last JIT compilation phase. This counter is updated at the end of every JIT compilation phase. A JIT compilation phase is the phase when a method and its dependencies are being compiled.

This counter displays the total IL bytes jitted since the start of the application. This counter is exactly equivalent to the "# of IL Bytes Jitted" counter.

Statistics for CLR Class Loader.

Reserved for future use.

This counter displays the current size (in bytes) of the memory committed by the class loader across all AppDomains. (Committed memory is the physical memory for which space has been reserved on the disk paging file.)

This counter displays the current number of AppDomains loaded in this application. AppDomains (application domains) provide a secure and versatile unit of processing that the CLR can use to provide isolation between applications running in the same process.

This counter displays the current number of Assemblies loaded across all AppDomains in this application. If the Assembly is loaded as domain-neutral from multiple AppDomains then this counter is incremented once only. Assemblies can be loaded as domain-neutral when their code can be shared by all AppDomains or they can be loaded as domain-specific when their code is private to the AppDomain.

This counter displays the current number of classes loaded in all Assemblies.

This counter displays the number of AppDomains loaded per second. AppDomains (application domains) provide a secure and versatile unit of processing that the CLR can use to provide isolation between applications running in the same process. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the number of AppDomains unloaded per second. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the number of Assemblies loaded across all AppDomains per second. If the Assembly is loaded as domain-neutral from multiple AppDomains then this counter is incremented once only. Assemblies can be loaded as domain-neutral when their code can be shared by all AppDomains or they can be loaded as domain-specific when their code is private to the AppDomain. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the number of classes loaded per second in all Assemblies. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the number of classes that failed to load per second. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval. These load failures could be due to many reasons like inadequate security or illegal format. Full details can be found in the profiling services help.

Reserved for future use.

This counter displays the peak number of AppDomains loaded since the start of this application. AppDomains (application domains) provide a secure and versatile unit of processing that the CLR can use to provide isolation between applications running in the same process.

This counter displays the total number of AppDomains unloaded since the start of the application. If an AppDomain is loaded and unloaded multiple times this counter would count each of those unloads as separate.

This counter displays the total number of Assemblies loaded since the start of this application. If the Assembly is loaded as domain-neutral from multiple AppDomains then this counter is incremented once only. Assemblies can be loaded as domain-neutral when their code can be shared by all AppDomains or they can be loaded as domain-specific when their code is private to the AppDomain.

This counter displays the cumulative number of classes loaded in all Assemblies since the start of this application.

This counter displays the peak number of classes that have failed to load since the start of the application. These load failures could be due to many reasons like inadequate security or illegal format. Full details can be found in the profiling services help.

Stats for CLR Locks and Threads.

Rate at which threads in the runtime attempt to acquire a managed lock unsuccessfully. Managed locks can be acquired in many ways; by the "lock" statement in C# or by calling System.Monitor.Enter or by using MethodImplOptions.Synchronized custom attribute.

This counter displays the total number of threads currently waiting to acquire some managed lock in the application. This counter is not an average over time; it displays the last observed value.

This counter displays the number of current .NET thread objects in the application. A .NET thread object is created either by new System.Threading.Thread or when an unmanaged thread enters the managed environment. This counters maintains the count of both running and stopped threads. This counter is not an average over time; it just displays the last observed value.

This counter displays the number of native OS threads created and owned by the CLR to act as underlying threads for .NET thread objects. This counters value does not include the threads used by the CLR in its internal operations; it is a subset of the threads in the OS process.

This counter displays the number of threads that are currently recognized by the CLR; they have a corresponding .NET thread object associated with them. These threads are not created by the CLR; they are created outside the CLR but have since run inside the CLR at least once. Only unique threads are tracked; threads with same thread ID re-entering the CLR or recreated after thread exit are not counted twice.

This counter displays the total number of threads that have been recognized by the CLR since the start of this application; these threads have a corresponding .NET thread object associated with them. These threads are not created by the CLR; they are created outside the CLR but have since run inside the CLR at least once. Only unique threads are tracked; threads with same thread ID re-entering the CLR or recreated after thread exit are not counted twice.

This counter displays the total number of threads that waited to acquire some managed lock since the start of the application.

This counter displays the number of threads per second waiting to acquire some lock in the application. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the number of threads per second that have been recognized by the CLR; these threads have a corresponding .NET thread object associated with them. These threads are not created by the CLR; they are created outside the CLR but have since run inside the CLR at least once. Only unique threads are tracked; threads with same thread ID re-entering the CLR or recreated after thread exit are not counted twice. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the total number of times threads in the CLR have attempted to acquire a managed lock unsuccessfully. Managed locks can be acquired in many ways; by the "lock" statement in C# or by calling System.Monitor.Enter or by using MethodImplOptions.Synchronized custom attribute.

Counters for CLR Garbage Collected heap.

This counter displays the rate of bytes per second allocated on the GC Heap. This counter is updated at the end of every GC; not at each allocation. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the number of garbage collected objects that survive a collection because they are waiting to be finalized. If these objects hold references to other objects then those objects also survive but are not counted by this counter; the "Promoted Finalization-Memory from Gen 0" and "Promoted Finalization-Memory from Gen 1" counters represent all the memory that survived due to finalization. This counter is not a cumulative counter; its updated at the end of every GC with count of the survivors during that particular GC only. This counter was designed to indicate the extra overhead that the application might incur because of finalization.

This counter displays the maximum bytes that can be allocated in generation 0 (Gen 0); its does not indicate the current number of bytes allocated in Gen 0. A Gen 0 GC is triggered when the allocations since the last GC exceed this size. The Gen 0 size is tuned by the Garbage Collector and can change during the execution of the application. At the end of a Gen 0 collection the size of the Gen 0 heap is infact 0 bytes; this counter displays the size (in bytes) of allocations that would trigger the next Gen 0 GC. This counter is updated at the end of a GC; its not updated on every allocation.

This counter displays the bytes per second that are promoted from generation 0 (youngest) to generation 1; objects that are promoted just because they are waiting to be finalized are not included in this counter. Memory is promoted when it survives a garbage collection. This counter was designed as an indicator of relatively long-lived objects being created per sec. This counter displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the current number of bytes in generation 1 (Gen 1); this counter does not display the maximum size of Gen 1. Objects are not directly allocated in this generation; they are promoted from previous Gen 0 GCs. This counter is updated at the end of a GC; its not updated on every allocation.

This counter displays the bytes per second that are promoted from generation 1 to generation 2 (oldest); objects that are promoted just because they are waiting to be finalized are not included in this counter. Memory is promoted when it survives a garbage collection. Nothing is promoted from generation 2 since it is the oldest. This counter was designed as an indicator of very long-lived objects being created per sec. This counter displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the current number of bytes in generation 2 (Gen 2). Objects are not directly allocated in this generation; they are promoted from Gen 1 during previous Gen 1 GCs. This counter is updated at the end of a GC; its not updated on every allocation.

This counter displays the current size of the Large Object Heap in bytes. Objects greater than 20 KBytes are treated as large objects by the Garbage Collector and are directly allocated in a special heap; they are not promoted through the generations. This counter is updated at the end of a GC; its not updated on every allocation.

This counter is the sum of four other counters; Gen 0 Heap Size; Gen 1 Heap Size; Gen 2 Heap Size and the Large Object Heap Size. This counter indicates the current memory allocated in bytes on the GC Heaps.

This counter displays the current number of GC Handles in use. GCHandles are handles to resources external to the CLR and the managed environment. Handles occupy small amounts of memory in the GCHeap but potentially expensive unmanaged resources.

This counter displays the number of times the generation 0 objects (youngest; most recently allocated) are garbage collected (Gen 0 GC) since the start of the application. Gen 0 GC occurs when the available memory in generation 0 is not sufficient to satisfy an allocation request. This counter is incremented at the end of a Gen 0 GC. Higher generation GCs include all lower generation GCs. This counter is explicitly incremented when a higher generation (Gen 1 or Gen 2) GC occurs. _Global_ counter value is not accurate and should be ignored. This counter displays the last observed value.

This counter displays the number of times the generation 1 objects are garbage collected since the start of the application. The counter is incremented at the end of a Gen 1 GC. Higher generation GCs include all lower generation GCs. This counter is explicitly incremented when a higher generation (Gen 2) GC occurs. _Global_ counter value is not accurate and should be ignored. This counter displays the last observed value.

This counter displays the number of times the generation 2 objects (older) are garbage collected since the start of the application. The counter is incremented at the end of a Gen 2 GC (also called full GC). _Global_ counter value is not accurate and should be ignored. This counter displays the last observed value.

This counter displays the peak number of times a garbage collection was performed because of an explicit call to GC.Collect. Its a good practice to let the GC tune the frequency of its collections.

This counter displays the number of pinned objects encountered in the last GC. This counter tracks the pinned objects only in the heaps that were garbage collected e.g. a Gen 0 GC would cause enumeration of pinned objects in the generation 0 heap only. A pinned object is one that the Garbage Collector cannot move in memory.

This counter displays the current number of sync blocks in use. Sync blocks are per-object data structures allocated for storing synchronization information. Sync blocks hold weak references to managed objects and need to be scanned by the Garbage Collector. Sync blocks are not limited to storing synchronization information and can also store COM interop metadata. This counter was designed to indicate performance problems with heavy use of synchronization primitives.

This counter displays the amount of virtual memory (in bytes) currently committed by the Garbage Collector. (Committed memory is the physical memory for which space has been reserved on the disk paging file).

This counter displays the amount of virtual memory (in bytes) currently reserved by the Garbage Collector. (Reserved memory is the virtual memory space reserved for the application but no disk or main memory pages have been used.)

Not Displayed.

This counter displays the bytes of memory that are promoted from generation 0 to generation 1 just because they are waiting to be finalized. This counter displays the value observed at the end of the last GC; its not a cumulative counter.

This counter displays the bytes of memory that are promoted from generation 1 to generation 2 just because they are waiting to be finalized. This counter displays the value observed at the end of the last GC; its not a cumulative counter. This counter is reset to 0 if the last GC was a Gen 0 GC only.

This counter displays the bytes of memory that survive garbage collection (GC) and are promoted from generation 0 to generation 1; objects that are promoted just because they are waiting to be finalized are not included in this counter. This counter displays the value observed at the end of the last GC; its not a cumulative counter.

This counter displays the bytes of memory that survive garbage collection (GC) and are promoted from generation 1 to generation 2; objects that are promoted just because they are waiting to be finalized are not included in this counter. This counter displays the value observed at the end of the last GC; its not a cumulative counter. This counter is reset to 0 if the last GC was a Gen 0 GC only.

% Time in GC is the percentage of elapsed time that was spent in performing a garbage collection (GC) since the last GC cycle. This counter is usually an indicator of the work done by the Garbage Collector on behalf of the application to collect and compact memory. This counter is updated only at the end of every GC and the counter value reflects the last observed value; its not an average.

Help not available.

The cumulative total number of bytes received over all open socket connections since the process was started. This number includes data and any protocol information that is not defined by the TCP/IP protocol.

The cumulative total number of bytes sent over all open socket connections since the process was started. This number includes data and any protocol information that is not defined by the TCP/IP protocol.

The cumulative total number of socket connections established for this process since the process was started.

The cumulative total number of datagram packets received since the process was started.

The cumulative total number of datagram packets sent since the process was started.

Stats for CLR Remoting.

This counter displays the total number of remoting channels registered across all AppDomains since the start of the application. Channels are used to transport messages to and from remote objects.

This counter displays the current number of context-bound classes loaded. Classes that can be bound to a context are called context-bound classes; context-bound classes are marked with Context Attributes which provide usage rules for synchronization; thread affinity; transactions etc.

This counter displays the number of context-bound objects allocated per second. Instances of classes that can be bound to a context are called context-bound objects; context-bound classes are marked with Context Attributes which provide usage rules for synchronization; thread affinity; transactions etc. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the total number of remoting proxy objects created in this process since the start of the process. Proxy object acts as a representative of the remote objects and ensures that all calls made on the proxy are forwarded to the correct remote object instance.

This counter displays the current number of remoting contexts in the application. A context is a boundary containing a collection of objects with the same usage rules like synchronization; thread affinity; transactions etc.

This counter displays the number of remote procedure calls invoked per second. A remote procedure call is a call on any object outside the caller;s AppDomain. This counter is not an average over time; it displays the difference between the values observed in the last two samples divided by the duration of the sample interval.

This counter displays the total number of remote procedure calls invoked since the start of this application. A remote procedure call is a call on any object outside the caller;s AppDomain.

Stats for CLR Security.

This counter displays the total number of linktime Code Access Security (CAS) checks since the start of the application. Linktime CAS checks are performed when a caller makes a call to a callee demanding a particular permission at JIT compile time; linktime check is performed once per caller. This count is not indicative of serious performance issues; its indicative of the security system activity.

Not Displayed.

This counter displays the depth of the stack during that last runtime Code Access Security check. Runtime Code Access Security check is performed by crawling the stack. This counter is not an average; it just displays the last observed value.

This counter displays the percentage of elapsed time spent in performing runtime Code Access Security (CAS) checks since the last such check. CAS allows code to be trusted to varying degrees and enforces these varying levels of trust depending on code identity. This counter is updated at the end of a runtime security check; it represents the last observed value; its not an average.

Reserved for future use.

This counter displays the total number of runtime Code Access Security (CAS) checks performed since the start of the application. Runtime CAS checks are performed when a caller makes a call to a callee demanding a particular permission; the runtime check is made on every call by the caller; the check is done by examining the current thread stack of the caller. This counter used together with "Stack Walk Depth" is indicative of performance penalty for security checks.

Counters for System.Data.OracleClient

The number of actual connections per second that are being made to servers

The number of actual disconnects per second that are being made to servers

The number of unique connection strings

The number of connection pools

The number of connections currently in-use

The number of connections currently available for use

The number of unique connection strings waiting for pruning

The number of connection pools

The number of connections that are not using connection pooling

The number of connections that are managed by the connection pooler

The number of connections we reclaim from GCed from external connections

The number of connections currently waiting to be made ready for use

The number of connections we get from the pool per second

The number of connections we return to the pool per second

Counters for System.Data.SqlClient

The number of actual connections per second that are being made to servers

The number of actual disconnects per second that are being made to servers

The number of unique connection strings

The number of connection pools

The number of connections currently in-use

The number of connections currently available for use

The number of unique connection strings waiting for pruning

The number of connection pools

The number of connections that are not using connection pooling

The number of connections that are managed by the connection pooler

The number of connections we reclaim from GCed from external connections

The number of connections currently waiting to be made ready for use

The number of connections we get from the pool per second

The number of connections we return to the pool per second

Tags fixture class, test method or method property with a 'postit' from an author regarding that class, method or property.

Tags method that provide new objects to be used by tests within a TypeFixtureAttribute tagged fixture class. The type-specific fixture assumes that all tests contained in the fixture that have an argument of the same type specified in the TypeFixtureAttribute will be provided by the methods tagged by ProviderAttribute or by a class specified by the ProviderFactoryAttribute tagging the same fixture class as the TypeFixtureAttribute.

Tags a class also tagged by a TypeFixtureAttribute to indicate a class that contains properties returning objects of the type required by the TypeFixtureAttribute.

This is the base class for attributes that can decorate fixtures identifying them as using provider classes.

Tag use to mark a method that reads data from a device.

Class containing generic assert methods for the verification of Type information by reflection.

This attribute decorates a test method or fixture and causes it to be invoked repeatedly within the same thread.

This attribute decorates a test method and causes it to be invoked repeatedly within the same thread.

Tags a method to indicate that a database must be restored according to a schedule around the execution of the test

Tags a test method to indicate that a database must be restored before the execution of the test

Tags a test method whose database operation must be executed within a transaction and rolled back when it has finished executing

Provides a row of values using in conjunction with RowTestAttribute to bind values to the parameters of a row test method.

Declares a row test when applied to a test method along with one or more RowAttribute attributes.

Class containing generic assert methods for the verification of Roles and Identity information.

Tags a method as producing a seed value for a production grammar test fixture

Class containing generic assert methods on the serialization capability of a type or object

The setup attribute is applied to a method that is to be invoked before each test in a fixture executes. The method will run once for each test.

Tags a class with the information needed to restore a SQL Server database from a backup. Test method within the tagged class must themselves be tagged with an attribute derived from RestoreDatabaseAttribute to make use of this information.

Class containing generic assert methods for Strings

Used to tag a test method within a test suite to specify the information contained in an XML file that should be used as parameters for that test.

The tear down attribute is applied to a method that is to be invoked after each test in a fixture executes. The method will run once for each test.

The test attribute is applied to a method that represents a single test case within a fixture. By default, if the method throws an unexpected exception, the test will be deemed to have failed. Otherwise, the test will pass.

The default behavior may be modified by test decorator attributes that may alter the execution environment of the test, catch and reinterpret any exceptions it throws, or impose additional constraints upon its execution.

Output from the test, such as text written to the console, is captured by the framework and will be included in the test report.

A single test case of a TestSuite.

Base class for test case decorators

Factory class that wraps test delegates inside instances ITestCase for inclusion in test suites.

Associates a category name with a test method. The category name can be used to classify tests and build test suites of related tests.

The test fixture attribute is applied to a class that contains a suite of related test cases. If an error occurs while initializing the fixture or if at least one of the test cases within the fixture fails, then the fixture itself will be deemed to have failed. Otherwise the fixture will pass. Output from the fixture, such as text written to the console, is captured by the framework and will be included in the test report.

Contributes additional tests and setup or teardown steps to the lifecycle defined by TestFixtureAttribute.

Tags a method to be run before any tests in the fixture class are run The method to which this attribute is applied must be declared by the fixture class and must not have any parameters. The method may be static.

Tags a method to be run after all the tests in the fixture class have run. The method to which this attribute is applied must be declared by the fixture class and must not have any parameters. The method may be static.

Tags a class with the object type being tested by the methods it contains. The MbUnit GUI runner uses this information to group tests under the TestsOns tree. The default value is "Unknown"

A named collection of uniquely named TestCase.

Tags a method that returns a TestSuite. Use within a class tagged with a TestSuiteFixtureAttribute

Idnetifies a class that will dynamically generate tests and group them in TestSuites.

Tag used to mark a method that needs to be run before TestSuite generation.

This attribute decorates a test method or fixture class and causes it to be invoked repeatedly on multiple concurrent threads.

Class that runs a (test) Winforms method on a new thread.

Tags the class as a TypeFixture

Base class for the [Using*] attributes that tag parameters in camobinatorial test methods

Tags a parameter within a [CombinatorialTest]-tagged method to indicate that it should use values from the named enumeration

Tags a parameter within a [CombinatorialTest]-tagged method to indicate that it should use values from provided by the named factory method(s)

Tags a parameter within a [CombinatorialTest]-tagged method to indicate that it should use all instances of a (parent) type defined within the same assembly as the test for use with the parameter

Tags a parameter within a [CombinatorialTest]-tagged method to indicate that it should use integer values from within a specified range

Tags a parameter within a [CombinatorialTest]-tagged method to indicate that it should use string literals from the semi-colon delimited list provided

Used when dynamically adding ITestCases with an expected result to a TestSuite

Class containing generic assert methods for web controls and the Page object

Tag use to mark a method that writes data to a device.

Class containing generic assert methods for XML markup

Used to tag a test fixture class to indicate that it uses information contained in an XML file that should be used as parameters for test contained in the class. To be used in conjunction with the DataFixtureAttribute and ForEachTestAttribute.

A basic count down timer for use with PerfAssert tests. Creates an instance of TimeMonitor, starts and stops it

Defines standard interface for Custom Assembly Resolver classes

Defines an interface for iterator providers that are backwards-only

Defines an interface for iterator providers that can move back and forth in their collection of values

Defines an interface for iterator providers that are forward-only

Interface defining a test case to be added to a test suite

Interface defining a test component containing a test suite

Interface defining a test suite

Delegate used to identify test methods being wrapped in a TestCase object for inclusion in a TestSuite

Defines the two collection sort orders for use with the CollectionOrderFixtureAttribute.

Defines how sets of values will be combined in a Combinatorial Test

Used to specify whether or not the test should delete the extracted resource when the test is complete.

Specifies options for the execution of a helper method with respect to the running of a test