xunit.core

Attribute used to decorate an assembly with arbitrary name/value pairs ("traits").

Creates a new instance of the class.

The trait name The trait value

Provides a data source for a data theory, with the data coming from a class which must implement IEnumerable<object[]>. Caution: the property is completely enumerated by .ToList() before any test is run. Hence it should return independent object sets.

Initializes a new instance of the class.

The class that provides the data.

Gets the type of the class that provides the data.

Used to declare a specific test collection for a test class.

Initializes a new instance of the class.

The test collection name.

Defines the built-in behavior types for collections in xUnit.net.

By default, generates a collection per assembly, and any test classes that are not decorated with will be placed into the assembly-level collection.

By default, generates a collection per test class for any test classes that are not decorated with .

Used to declare the default test collection behavior for the assembly.

Initializes a new instance of the class.

The collection behavior for the assembly.

Initializes a new instance of the class.

The type name of the test collection factory (that implements ). The assembly that exists in.

Determines whether tests in this assembly are run in parallel.

Determines how many tests can run in parallel with each other. If set to 0, the system will use . If set to a negative number, then there will be no limit to the number of threads.

Used to declare a test collection container class. The container class gives developers a place to attach interfaces like and that will be applied to all tests classes that are members of the test collection.

Initializes a new instance of the class.

The test collection name.

Determines whether tests in this collection runs in parallel with any other collections.

Attribute that is applied to a method to indicate that it is a fact that should be run by the test runner. It can also be extended to support a customized definition of a test method.

Gets the name of the test to be used when the test is skipped. Defaults to null, which will cause the fully qualified test name to be used.

Marks the test so that it will not be run, and gets or sets the skip reason

Marks the test as having a timeout, and gets or sets the timeout (in milliseconds). WARNING: Using this with parallelization turned on will result in undefined behavior. Timeout is only supported when parallelization is disabled, either globally or with a parallelization-disabled test collection.

Used to provide asynchronous lifetime functionality. Currently supported: - Test classes - Classes used in - Classes used in .

Called immediately after the class has been created, before it is used.

Called when an object is no longer needed. Called just before if the class also implements that.

Used to decorate xUnit.net test classes and collections to indicate a test which has per-test-class fixture data. An instance of the fixture data is initialized just before the first test in the class is run, and if it implements IDisposable, is disposed after the last test in the class is run. To gain access to the fixture data from inside the test, a constructor argument should be added to the test class which exactly matches the . Class fixtures must have a single parameterless constructor, and may take collection fixture types as constructor arguments.

The type of the fixture. If asynchronous setup of is required it should implement the interface.

Used to decorate xUnit.net test classes and collections to indicate a test which has per-test-collection fixture data. An instance of the fixture data is initialized just before the first test in the collection is run, and if it implements IDisposable, is disposed after the last test in the collection is run. To gain access to the fixture data from inside the test, a constructor argument should be added to the test class which exactly matches the .

The type of the fixture. If asynchronous setup of is required it should implement the interface.

Provides a data source for a data theory, with the data coming from inline values.

Initializes a new instance of the class.

The data values to pass to the theory.

A class implements this interface to participate in ordering tests for the test runner. Test collection orderers are applied using the , which can be applied at the assembly level.

Orders test collections for execution.

The test collections to be ordered. The test collections in the order to be run.

Provides a data source for a data theory, with the data coming from one of the following sources: 1. A static property 2. A static field 3. A static method (with parameters) The member must return something compatible with IEnumerable<object[]> with the test data. Caution: the property is completely enumerated by .ToList() before any test is run. Hence it should return independent object sets.

Initializes a new instance of the class.

The name of the public static member on the test class that will provide the test data The parameters for the member (only supported for methods; ignored for everything else)

Provides a base class for attributes that will provide member data. The member data must return something compatible with . Caution: the property is completely enumerated by .ToList() before any test is run. Hence it should return independent object sets.

Initializes a new instance of the class.

The name of the public static member on the test class that will provide the test data The parameters for the member (only supported for methods; ignored for everything else)

Returns true if the data attribute wants to skip enumerating data during discovery. This will cause the theory to yield a single test case for all data, and the data discovery will be during test execution instead of discovery.

Gets the member name.

Gets or sets the type to retrieve the member from. If not set, then the property will be retrieved from the unit test class.

Gets or sets the parameters passed to the member. Only supported for static methods.

Converts an item yielded by the data member to an object array, for return from .

The method that is being tested. An item yielded from the data member. An suitable for return from .

Allows the user to record actions for a test.

Records any exception which is thrown by the given code.

The code which may throw an exception. Returns the exception that was thrown by the code; null, otherwise.

Records any exception which is thrown by the given code that has a return value. Generally used for testing property accessors.

The code which may throw an exception. Returns the exception that was thrown by the code; null, otherwise.

Records any exception which is thrown by the given task.

The task which may throw an exception. Returns the exception that was thrown by the code; null, otherwise.

The implementation of which returns the trait values for .

Utility class for dealing with asynchronous operations.

Determines if the given method is async, as matters to xUnit.net. This means it either (a) returns a ; or, (b) is a C#/VB method that is async void with the compiler-generated on it; or (c) it is an F# function which was declared as async. Note that this is not the same thing as an "awaitable" method, since xUnit.net does not recreate the compiler's await machinery at runtime.

The method to test Returns true if the method is async; returns false otherwise.

Determines if the given method is async void by looking for the on the method definition.

The method to test Returns true if the method is async void; returns false otherwise.

Given an object, will attempt to convert instances into as appropriate. Will return null if the object is not a task of any supported type. Note that this list of supported tasks is purposefully identical to the list used by (minus async void, of course; that's handled separately).

The object to convert Returns a for the given object, if it's compatible; returns null otherwise.

Base attribute which indicates a test method interception (allows code to be run before and after the test is run).

This method is called after the test method is executed.

The method under test

This method is called before the test method is executed.

The method under test

Abstract attribute which represents a data source for a data theory. Data source providers derive from this attribute and implement GetData to return the data for the theory. Caution: the property is completely enumerated by .ToList() before any test is run. Hence it should return independent object sets.

Returns the data to be used to test the theory.

The method that is being tested One or more sets of theory data. Each invocation of the test method is represented by a single object array.

Marks all test cases generated by this data source as skipped.

Default implementation of . Uses reflection to find the data associated with ; may return null when called without reflection-based abstraction implementations.

An attribute used to decorate classes which derive from , to indicate how data elements should be discovered.

Initializes an instance of .

The fully qualified type name of the discoverer (f.e., 'Xunit.Sdk.DataDiscoverer') The name of the assembly that the discoverer type is located in, without file extension (f.e., 'xunit.execution')

Aggregates exceptions. Intended to run one or more code blocks, and collect the exceptions thrown by those code blocks.

Initializes a new instance of the class.

Initializes a new instance of the class that contains the exception list of its parent.

The parent aggregator to copy exceptions from.

Returns true if the aggregator has at least one exception inside it.

Adds an exception to the aggregator.

The exception to be added.

Adds exceptions from another aggregator into this aggregator.

The aggregator whose exceptions should be copied.

Clears the aggregator.

Runs the code, catching the exception that is thrown and adding it to the aggregate.

The code to be run.

Runs the code, catching the exception that is thrown and adding it to the aggregate.

The code to be run.

Runs the code, catching the exception that is thrown and adding it to the aggregate.

The code to be run.

Returns an exception that represents the exceptions thrown by the code passed to the or method.

Returns null if no exceptions were thrown; returns the exact exception if a single exception was thrown; returns if more than one exception was thrown.

This class is responsible for discovering the data available in an implementation of . The discovery process may not always have access to reflection (i.e., running in Resharper), so the discoverer must make a best effort to return data, but may return null when there is not enough information available (for example, if reflection is required to answer the question).

Returns the data to be used to test the theory.

This will be called during discovery, at which point the may or may not be backed by reflection (i.e., implementing ). If the data is not available because reflection is required, then you may return null to inform xUnit that the quantity of data is unknown at this point. When the tests are run, if you returned back null during discovery, then this method will be called again to retrieve the data, this time guaranteed to provide an implementation of . At this time, you must return the actual data, and returning null is not legal. The data attribute being discovered The method that is being tested/discovered The theory data (or null during discovery, if not enough information is available to enumerate the data)

Returns true if the data attribute supports enumeration during discovery; false otherwise. Data attributes with expensive computational costs and/or randomized data sets should return false.

Used by discovery, execution, and extensibility code to send messages to the runner.

Queues a message to be sent to the runner.

The message to be sent to the runner Returns true if discovery/execution should continue; false, otherwise. The return value may be safely ignored by components which are not directly responsible for discovery or execution, and this is intended to communicate to those sub-systems that that they should short circuit and stop their work as quickly as is reasonable.

Implementation of used to discover the data provided by .

A class implements this interface to participate in ordering tests for the test runner. Test case orderers are applied using the , which can be applied at the assembly, test collection, and test class level.

Orders test cases for execution.

The test cases to be ordered. The test cases in the order to be run.

Marker interface that must be implemented by test framework attributes, so that the test framework attribute discoverer can find them.

Interface to be implemented by classes which are used to discover the test framework.

Gets the type that implements to be used to discover and run tests.

The test framework attribute that decorated the assembly The test framework type

Marker interface used by attributes which provide trait data.

This interface is implemented by discoverers that provide trait values to xUnit.net v2 tests.

Gets the trait values from the trait attribute.

The trait attribute containing the trait values. The trait values.

Represents a single test case from xUnit.net v2.

Gets the exception that happened during initialization. When this is set, then the test execution should fail with this exception.

Gets the method to be run. Differs from . in that any generic argument types will have been closed based on the arguments.

Gets the timeout of the test, in milliseconds; if zero or negative, means the test case has no timeout.

Executes the test case, returning 0 or more result messages through the message sink.

The message sink used to send diagnostic messages to. The message bus to report results to. The arguments to pass to the constructor. The error aggregator to use for catching exception. The cancellation token source that indicates whether cancellation has been requested. Returns the summary of the test case run.

Interface to be implemented by classes which are used to discover tests cases attached to test methods that are attributed with (or a subclass).

Discover test cases from a test method.

The discovery options to be used. The test method the test cases belong to. The fact attribute attached to the test method. Returns zero or more test cases represented by the test method.

This interface is intended to be implemented by components which generate test collections. End users specify the desired test collection factory by applying at the assembly level. Classes which implement this interface must have a constructor that takes and .

Gets the display name for the test collection factory. This information is shown to the end user as part of the description of the test environment.

Gets the test collection for a given test class.

The test class. The test collection.

Implementation of for discovering .

Marks an assembly as a platform specific assembly for use with xUnit.net. Type references from such assemblies are allowed to use a special suffix ("My.Assembly.{Platform}"), which will automatically be translated into the correct platform-specific name ("My.Assembly.desktop", "My.Assembly.win8", etc.). This affects both extensibility points which require specifying a string-based type name and assembly, as well as serialization. In v2.1 and later, the supported platform target names include: "desktop" (for desktop and PCL tests), "dotnet" (everything else). In v2.0, the following names were also supported: "iOS-Universal" (for Xamarin test projects targeting iOS), "MonoAndroid" (for Xamarin MonoAndroid tests), "MonoTouch" (for Xamarin MonoTouch tests), "universal" (for Windows Phone 8.1 and Windows 8.1 tests), "win8" (for Windows 8 tests), "wp8" (for Windows Phone 8 Silverlight tests). For backward compatibility reasons, the v2.1 runners will support tests linked against the v2.0 execution libraries. Note that file names may be case sensitive (when running on platforms with case sensitive file systems like Linux), so ensure that your assembly file name casing is consistent, and that you use the suffixes here with the exact case shown.

Represents the statistical summary from a run of one or more tests.

The total number of tests run.

The number of failed tests.

The number of skipped tests.

The total time taken to run the tests, in seconds.

Adds a run summary's totals into this run summary.

The run summary to be added.

Decorates an implementation of that is used to determine which test framework is used to discover and run tests.

Initializes an instance of .

The fully qualified type name of the discoverer (f.e., 'Xunit.Sdk.DataDiscoverer') The name of the assembly that the discoverer type is located in, without file extension (f.e., 'xunit.execution')

The implementation of which returns the trait values for .

An attribute used to decorate classes which implement , to indicate how trait values should be discovered. The discoverer type must implement .

Initializes an instance of .

The fully qualified type name of the discoverer (f.e., 'Xunit.Sdk.TraitDiscoverer') The name of the assembly that the discoverer type is located in, without file extension (f.e., 'xunit.execution')

An attribute used to decorate classes which derive from , to indicate how test cases should be discovered.

Initializes an instance of the class.

The fully qualified type name of the discoverer (f.e., 'Xunit.Sdk.FactDiscoverer') The name of the assembly that the discoverer type is located in, without file extension (f.e., 'xunit.execution')

Indicates the default display name format for test methods.

Use a fully qualified name (namespace + class + method)

Use just the method name (without class)

Indicates the method display options for test methods.

Indicates no additional method display options.

This is the default configuration option.

Replace underscores in display names with a space.

Replace well-known monikers with their equivalent operator.

lt : < le : <= eq : = ne : != gt : > ge : >=

Replace supported escape sequences with their equivalent character. Encoding Format ASCIIX hex-digit hex-digit (ex: X2C) UnicodeU hex-digit hex-digit hex-digit hex-digit (ex: U00A9)

Replaces the period delimiter used in namespace and type references with a comma.

This option is only honored if the setting is also enabled.

Enables all method display options.

Used to decorate an assembly, test collection, or test class to allow the use of a custom .

Initializes a new instance of the class.

The type name of the orderer class (that implements ). The assembly that exists in.

Used to decorate an assembly to allow the use of a custom .

Initializes a new instance of the class.

The type name of the orderer class (that implements ). The assembly that exists in.

Used to decorate an assembly to allow the use of a custom .

Initializes an instance of .

The fully qualified type name of the test framework (f.e., 'Xunit.Sdk.XunitTestFramework') The name of the assembly that the test framework type is located in, without file extension (f.e., 'xunit.execution')

Marks a test method as being a data theory. Data theories are tests which are fed various bits of data from a data source, mapping to parameters on the test method. If the data source contains multiple rows, then the test method is executed multiple times (once with each data row). Data is provided by attributes which derive from (notably, and ).

Provides data for theories based on collection initialization syntax.

Gets the data that's currently in the collection.

Adds a row to the theory.

The values to be added.

Adds multiple rows to the theory.

The rows to be added.

Represents a set of data for a theory with a single parameter. Data can be added to the data set using the collection initializer syntax.

The parameter type.

Initializes a new isntance of the class.

The initial set of values

Initializes a new isntance of the class.

The initial set of values

Adds data to the theory data set.

The data value.

Adds multiple data items to the theory data set.

The data values.

Represents a set of data for a theory with 2 parameters. Data can be added to the data set using the collection initializer syntax.

The first parameter type. The second parameter type.

Adds data to the theory data set.

The first data value. The second data value.

Represents a set of data for a theory with 3 parameters. Data can be added to the data set using the collection initializer syntax.

The first parameter type. The second parameter type. The third parameter type.

Adds data to the theory data set.

The first data value. The second data value. The third data value.

Represents a set of data for a theory with 4 parameters. Data can be added to the data set using the collection initializer syntax.

The first parameter type. The second parameter type. The third parameter type. The fourth parameter type.

Adds data to the theory data set.

The first data value. The second data value. The third data value. The fourth data value.

Represents a set of data for a theory with 5 parameters. Data can be added to the data set using the collection initializer syntax.

The first parameter type. The second parameter type. The third parameter type. The fourth parameter type. The fifth parameter type.

Adds data to the theory data set.

The first data value. The second data value. The third data value. The fourth data value. The fifth data value.

Represents a set of data for a theory with 6 parameters. Data can be added to the data set using the collection initializer syntax.

The first parameter type. The second parameter type. The third parameter type. The fourth parameter type. The fifth parameter type. The sixth parameter type.

Adds data to the theory data set.

The first data value. The second data value. The third data value. The fourth data value. The fifth data value. The sixth data value.

Represents a set of data for a theory with 7 parameters. Data can be added to the data set using the collection initializer syntax.

The first parameter type. The second parameter type. The third parameter type. The fourth parameter type. The fifth parameter type. The sixth parameter type. The seventh parameter type.

Adds data to the theory data set.

The first data value. The second data value. The third data value. The fourth data value. The fifth data value. The sixth data value. The seventh data value.

Represents a set of data for a theory with 8 parameters. Data can be added to the data set using the collection initializer syntax.

The first parameter type. The second parameter type. The third parameter type. The fourth parameter type. The fifth parameter type. The sixth parameter type. The seventh parameter type. The eighth parameter type.

Adds data to the theory data set.

The first data value. The second data value. The third data value. The fourth data value. The fifth data value. The sixth data value. The seventh data value. The eighth data value.

Represents a set of data for a theory with 9 parameters. Data can be added to the data set using the collection initializer syntax.

Adds data to the theory data set.

The first data value. The second data value. The third data value. The fourth data value. The fifth data value. The sixth data value. The seventh data value. The eighth data value. The ninth data value.

Represents a set of data for a theory with 10 parameters. Data can be added to the data set using the collection initializer syntax.

Adds data to the theory data set.

Attribute used to decorate a test method with arbitrary name/value pairs ("traits").

Creates a new instance of the class.

The trait name The trait value

Formats value for display in assertion messages and data-driven test display names.

Gets the maximum printing depth, in terms of objects before truncation.

Gets the maximum number of values printed for collections before truncation.

Gets the maximum number of items (properties or fields) printed in an object before truncation.

Gets the maximum strength length before truncation.

Gets the ellipsis value (three middle dots, aka U+00B7).

Escapes a string for printing, attempting to most closely model the value on how you would enter the value in a C# string literal. That means control codes that are normally backslash escaped (like "\n" for newline) are represented like that; all other control codes for ASCII values under 32 are printed as "\xnn".

The string value to be escaped

Formats a value for display.

The value to be formatted The optional printing depth (1 indicates a top-level value)

Formats a type. This maps built-in C# types to their C# native name (e.g., printing "int" instead of "Int32" or "System.Int32").

The type to get the formatted name of Set to true to include the namespace; set to false for just the simple type name

Rethrows an exception object without losing the existing stack trace information

The exception to re-throw. For more information on this technique, see http://www.dotnetjunkies.com/WebLog/chris.taylor/archive/2004/03/03/8353.aspx. The remote_stack_trace string is here to support Mono.

Unwraps an exception to remove any wrappers, like .

The exception to unwrap. The unwrapped exception.

Guard class, used for guard clauses and argument validation