From 221942b67d9879b3f65d8abdc2640f53699bbb2b Mon Sep 17 00:00:00 2001 From: "Eugene.Petrenko" Date: Wed, 13 Jul 2011 18:35:20 +0400 Subject: [PATCH] add nunit.framework dll --- .../lib/nunit/nunit.framework.dll | Bin 0 -> 139264 bytes .../lib/nunit/nunit.framework.xml | 10407 ++++++++++++++++ 2 files changed, 10407 insertions(+) create mode 100644 nuget-extensions/lib/nunit/nunit.framework.dll create mode 100644 nuget-extensions/lib/nunit/nunit.framework.xml diff --git a/nuget-extensions/lib/nunit/nunit.framework.dll b/nuget-extensions/lib/nunit/nunit.framework.dll new file mode 100644 index 0000000000000000000000000000000000000000..6856e51ef08a8e681896c3a84ccbeea8975d5947 GIT binary patch literal 139264 zcmeFad7KB(&AnIt4Lfh083Ga+FOAwUQ_1PBm9LfCggq+@r2m|eO+;Bmc#Vq48UYbeQ4rA=QQ>=@b8b~vRrkb*yx;f7M}C>xb=G_C zx#uo*>(;Hk4?f?x#uyKOAAV@e-T39d>5{HHSq^e@_r1+#b;DC*?@r8oYV7P2POS7S zDwmEgANi@CqmMlKPnC{2c497<9cNX~+Qpce3DR0#nb9>o1V;d70W8O{})1%m{jic8+_@#Bkx2WB?68rgUjsP9_!eb7~HT??$0IvSZ z6%q1pXXrhMSJ2y%R9qyT?wF-kUlmY2NsQF^6;{Ohe2GvwDnK9>diG z&pqeW`?h=HoUTXaZ}{z>ZTa8>Uwi+A$p`PX=reErWziF7Uv%HY?-XudwoS{|o?7(& z(Q~FSi_20g5;I_9Neo5nT z2Rnsf#$-_#w}jj2>>zHdJ=1I2Cne4PFc@HKz~U5I!BT4T`J4fAmys+gwF8;|AdyY= z_c)5r>rbfzleM+ddoQTN~520Efglve1P%olov@t2fc<)5VEsU|( zL!i%dDxC}rS)Q*8e*JNN2BR&pX5o~#PVBf9fnXV z&88xavoYP@n#!jlEi&s!DN?R)T($1u8^#(7DRr>FQ-%)~m5WFUn^=GO$ldB8=Y^3o z99O(h=(nPNTW5JTKs}^cp28MFbvn;QQ$%-?cdt(kq6@`&6s@b!3}a zG7Vno_`vniVbMpxkk6&oYzG#`b9Q2PYRwJ-(3V;=-3P?xVj?f9n=(rnozR*q9-CSN zGgZ7=u3f(Zc z(1YZ9lkS|`m{!VpCw}13$f@Ui@ZpDwYWIq!)$3jA^G(He z^++b2DQ!s4Wjg0JWt30d*1r~A8!9)IE1HJhtsK|uEFdDJ*OPK^9)rHCHR>(TotK>7 zIXCO1LfJLCO+}3968Ga#Lm6q!*JqM*o6@Ndyj(;7tJ+5Qf=&!cb#*SF(x=y{br(dB zYF(geUy=EUXO4tk42Lnj$&G+EX8M<>&(Dh8skw?VZ|^Yo#6~9_%B%?yZi|pX5tGL9U z3?ij3p5c`5L{H)d{V)(ejv)Nrb*SHJKX2y?J-%+4zYq#$VdQlrm@yFu=7X+weVFpK z*zUS9J%||fifK%Mc%ku7?b|U8K(Iyo_9`E;wEeZ^tLfXTyw$$l^49I!eSY;J#{%@U zM2ZjnISMookD3h45eOj=*w!)B@$nFOF!XtSBlWlQ+}%*Ajp=-M-&N@nVlG=ubckZ` z`?{@fDJLZHEg{jZcA>+dZfH;*nR61tM4CT3=R}Di6w^zj#slY^gq)5+%4iHnVrRV1 zD>e`c+2E-S6Cyl>LOixC=;}jdAyms#i0}{!@gy`axHY7Q(0|Bd?SYi)xs^U31i$g8 zuT6iK!7teY3XBTM4@ySihK4>GfqGOht8)i2L1C}2gqpe}IubvwmWNV;pXhWHPPLtE z`y|)QK|EkE2-=O~_PK5`rNh_YrVz_#iyOPC%a`1W#?jY;tDAU*K@$Hl!eZX$xv7rp zQ|OX0LQsO^BG6CNxgVP7+adK#2+oMb&1MlELc$Y?bz&Lo{QbAFj;V@iQ$JuHMbpww z;R|$v+AEF;wF?^qlfWw^v6WD*t&@Eosb4~3WG19e~Jcf2U9DN;!hp7*OfVvS}dotgiDo$ukwx%v`OfSizJFrtT z4kRg7SJ5eUwBn*Y)tYKe%4~+TCo!^;U2?`iKEfHG4H?y&xqLB+I-Fw+lyT{$RQ>~o zgaA{m1?QcZnkVC14oX@Ztb8gn_i`0(2y*$>0F7KMo`^b6!1Srw|c9+X~OE^?16%Jg^QE zc&L+j$3)$aw|fv&NsU!Z*BEW6>c;fc%O%=Ew{#_RxY4aT<=^t(}IUggv zM;>jl8!d*+nEUWYZUDRNicCmVdq@ycT*!$_b!S6j2tv}U4VX}GuW_By2nQk3%Q|q_ zFUUF)T3V?oVNxX&DkVZn$7I;2e;WP5sFh5rOxr`>0PCbQR+UmG#yEo+H`;dTT559! z=*+%cc@vZ&RltaY&K{F(lh(DY0q|oE&c1;4*_aNd>Cj@(@G(s@Kxv&1=-@B z<%0qgoWWWyTt_knk!-eDET2@D3|7{%vcd^q#nKjhkuZt91DSz{O9?Wui{^xPGU!IP{FlJ}%HWo+66f_w zzbSbK{iZ8%sxg;z{Q{_*?bFavVJdu)@BbMrfj77lei%Zq-7$OPwHmhP5doj>X_~Ca+e_N1j*mRW{XI)RE}OraI^Cf_e`Yrix>HWmnTy zPC(TJ1+(aL^eR>&>Si2B>{`G2nl6VXhC;P0z8h;yKVS&cvHGr|r;GC1?P=fT7{m(u zakS+n7%H^W!uZ*gl7%t2sj=AVlrWFZmN1}mo@g&$e8w2=)iTX@2!u+iNTX>{~>uNeh>7(vYh>Z@QnpUq-fp7o6-;p1Dq5-K^1 zK{Zvv5SwjJ7Du-x1=r-HGlgG(fU4$=7`mX`+T%fFmf6Ktk6 zUBbjOYhL7x3X|LH1gtz)rB*`9TbC5p#<5H+?FADA2Q@x%f0;l`Mqc>^a1|~U9F)=@bKwu%5wsfXiKb$AM#_w3R%d`xe!($nd7X`G ziy5&W&@b1H%&76WBSn#c%Aj<%zbV>sadk+%8+KC>w4fFCg! zzJ$ReypX|+=TAWgCg*GyY9Ri`mAdWh-kHmiFqw!13rwsip7? zT$05jtiRy54^!Z`@r$}fKPt_aMsEsB0;4HZ&**)`=)FQl)8;PNto@xcKn}@HGm}WB z`a{F&$z;{zUie)YGq^7`+n&QIe>#+dw)1A>ftw2WrE_q9@&;{$QRCCx!e0YrZuK$K z;H*G`_J;XAG+WJl{rHpX!C$r29o#R-S>tg_I0~WJYC7EA&5-16ygNn4_TkvS_fpbAFs>{4fd8L&N)b$9!0O|hkE;NWUVrlYhSE^`e! z{}5KI_3L%D8s4P{+un#nR!yp*^d3Cho^%H2{l08#GXDWbUPPlXa;0bOe5Ljam1{8( z>UO3f%O_VXsB|nad20H@4?jdNk=BOR&`KLcVWzdgZ)%-bM1p(J!x^)q^b>eb1lJ6@ zX8eujHU6<~XX966(f16@z(lawE&rAwD3hn+C`4o~847rMQ6mxsW(ida)5mSd*28fJ z^9I+ffPNZd%KL&)!E`>0duv+>XqTO-@{u4YN~fxr-ee~PT4g{kpGd8iz~DrwRrquf zCMqPHDt{s1Psw9aX||(K-os!|AMA0YzaKmRg2B>^I|y%hC>V!;#$t!Y7tAGBO8aZA z3grFj+D@$m2@@dFf&Uq>+RtrhHr$!F=k#>~PB5mQzEF*&>2!wN$&(%#`)Ekb*oR)m zOr$&}ypzyXsaZQhi(B}!_E4~+&8kn8Fon*V&c@Wn+iPrdal7uKgoZ{kWvz{lilE$+)I%dOIgQN|{R(G%T12P>~&~5i5?& zXVHhE&D*h7@~g&tJIdnIWo%ssUB=QXeILio=R3C~lC-`@2 z^a1-V;fJ%xQ@W1UT7I;`>hePdUc#a=h;Hdd{1&hilAN@}EsaphAa!V4bj-HC?scmh zp#5%XOh^M3l`mmS=US0tj)$JfQcsdusSBK90=j?ZE(o`DL)D%tOG=)jAo2><)Y3?> zVW&V%8PZw?n{bk9(V|Z-u^(-&1Ule2H;O7=HZzRmaINKl&2wq03HXKU@zU z6|w<+z|jEx*bLc1t`g=ZHMWdaTZE1=(dvdR#JDAly|@o_2B_8#5s8seDCZU-S@;{v zq#erRd&z&!Ba798$B1d@ttU_^7fBTZeF;84z`YRrh5=$_?N|nZ&|G~4c#yBpgK-8G zVw}aW+n>^lZDYWHlRLmD|eG&9FmYPX}{9Td#BN9_E*V){gyue z-_Vc$H}ucc(xdj>TgN`egXX^`;ZH0In^lcuKNYHj)l?C$gB)~d-MWSGRZ)~r^S89h z9K>Uofx4OhRuV()i?%%5z*d_6l_o=m`lj{GC=%&>YI0zK%- zV|p;LmU3kS9`xcLfoEr{=c%CV7e@5-z(2}UjqyqyX5R;xor_&-0(}?N=u@7MzB
jGx_)XGKVSL!mZ7A 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 s;idf~4WfA}|OOnpsbG<<@nYpjdJ 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 K#)0=F2mTF_u(`ni literal 0 HcmV?d00001 diff --git a/nuget-extensions/lib/nunit/nunit.framework.xml b/nuget-extensions/lib/nunit/nunit.framework.xml new file mode 100644 index 0000000..c98e5ad --- /dev/null +++ b/nuget-extensions/lib/nunit/nunit.framework.xml @@ -0,0 +1,10407 @@ + + + + nunit.framework + + + + + Attribute used to apply a category to a test + + + + + The name of the category + + + + + Construct attribute for a given category based on + a name. The name may not contain the characters ',', + '+', '-' or '!'. However, this is not checked in the + constructor since it would cause an error to arise at + as the test was loaded without giving a clear indication + of where the problem is located. The error is handled + in NUnitFramework.cs by marking the test as not + runnable. + + The name of the category + + + + Protected constructor uses the Type name as the name + of the category. + + + + + The name of the category + + + + + Used to mark a field for use as a datapoint when executing a theory + within the same fixture that requires an argument of the field's Type. + + + + + Used to mark an array as containing a set of datapoints to be used + executing a theory within the same fixture that requires an argument + of the Type of the array elements. + + + + + Attribute used to provide descriptive text about a + test case or fixture. + + + + + Construct the attribute + + Text describing the test + + + + Gets the test description + + + + + Enumeration indicating how the expected message parameter is to be used + + + + Expect an exact match + + + Expect a message containing the parameter string + + + Match the regular expression provided as a parameter + + + Expect a message that starts with the parameter string + + + + ExpectedExceptionAttribute + + + + + + Constructor for a non-specific exception + + + + + Constructor for a given type of exception + + The type of the expected exception + + + + Constructor for a given exception name + + The full name of the expected exception + + + + Gets or sets the expected exception type + + + + + Gets or sets the full Type name of the expected exception + + + + + Gets or sets the expected message text + + + + + Gets or sets the user message displayed in case of failure + + + + + Gets or sets the type of match to be performed on the expected message + + + + + Gets the name of a method to be used as an exception handler + + + + + ExplicitAttribute marks a test or test fixture so that it will + only be run if explicitly executed from the gui or command line + or if it is included by use of a filter. The test will not be + run simply because an enclosing suite is run. + + + + + Default constructor + + + + + Constructor with a reason + + The reason test is marked explicit + + + + The reason test is marked explicit + + + + + Attribute used to mark a test that is to be ignored. + Ignored tests result in a warning message when the + tests are run. + + + + + Constructs the attribute without giving a reason + for ignoring the test. + + + + + Constructs the attribute giving a reason for ignoring the test + + The reason for ignoring the test + + + + The reason for ignoring a test + + + + + Abstract base for Attributes that are used to include tests + in the test run based on environmental settings. + + + + + Constructor with no included items specified, for use + with named property syntax. + + + + + Constructor taking one or more included items + + Comma-delimited list of included items + + + + Name of the item that is needed in order for + a test to run. Multiple itemss may be given, + separated by a comma. + + + + + Name of the item to be excluded. Multiple items + may be given, separated by a comma. + + + + + The reason for including or excluding the test + + + + + PlatformAttribute is used to mark a test fixture or an + individual method as applying to a particular platform only. + + + + + Constructor with no platforms specified, for use + with named property syntax. + + + + + Constructor taking one or more platforms + + Comma-deliminted list of platforms + + + + CultureAttribute is used to mark a test fixture or an + individual method as applying to a particular Culture only. + + + + + Constructor with no cultures specified, for use + with named property syntax. + + + + + Constructor taking one or more cultures + + Comma-deliminted list of cultures + + + + Marks a test to use a combinatorial join of any argument data + provided. NUnit will create a test case for every combination of + the arguments provided. This can result in a large number of test + cases and so should be used judiciously. This is the default join + type, so the attribute need not be used except as documentation. + + + + + PropertyAttribute is used to attach information to a test as a name/value pair.. + + + + + Construct a PropertyAttribute with a name and string value + + The name of the property + The property value + + + + Construct a PropertyAttribute with a name and int value + + The name of the property + The property value + + + + Construct a PropertyAttribute with a name and double value + + The name of the property + The property value + + + + Constructor for derived classes that set the + property dictionary directly. + + + + + Constructor for use by derived classes that use the + name of the type as the property name. Derived classes + must ensure that the Type of the property value is + a standard type supported by the BCL. Any custom + types will cause a serialization Exception when + in the client. + + + + + Gets the property dictionary for this attribute + + + + + Default constructor + + + + + Marks a test to use pairwise join of any argument data provided. + NUnit will attempt too excercise every pair of argument values at + least once, using as small a number of test cases as it can. With + only two arguments, this is the same as a combinatorial join. + + + + + Default constructor + + + + + Marks a test to use a sequential join of any argument data + provided. NUnit will use arguements for each parameter in + sequence, generating test cases up to the largest number + of argument values provided and using null for any arguments + for which it runs out of values. Normally, this should be + used with the same number of arguments for each parameter. + + + + + Default constructor + + + + + Summary description for MaxTimeAttribute. + + + + + Construct a MaxTimeAttribute, given a time in milliseconds. + + The maximum elapsed time in milliseconds + + + + RandomAttribute is used to supply a set of random values + to a single parameter of a parameterized test. + + + + + ValuesAttribute is used to provide literal arguments for + an individual parameter of a test. + + + + + Abstract base class for attributes that apply to parameters + and supply data for the parameter. + + + + + Gets the data to be provided to the specified parameter + + + + + The collection of data to be returned. Must + be set by any derived attribute classes. + We use an object[] so that the individual + elements may have their type changed in GetData + if necessary. + + + + + Construct with one argument + + + + + + Construct with two arguments + + + + + + + Construct with three arguments + + + + + + + + Construct with an array of arguments + + + + + + Get the collection of values to be used as arguments + + + + + Construct a set of doubles from 0.0 to 1.0, + specifying only the count. + + + + + + Construct a set of doubles from min to max + + + + + + + + Construct a set of ints from min to max + + + + + + + + Get the collection of values to be used as arguments + + + + + RangeAttribute is used to supply a range of values to an + individual parameter of a parameterized test. + + + + + Construct a range of ints using default step of 1 + + + + + + + Construct a range of ints specifying the step size + + + + + + + + Construct a range of longs + + + + + + + + Construct a range of doubles + + + + + + + + Construct a range of floats + + + + + + + + RepeatAttribute may be applied to test case in order + to run it multiple times. + + + + + Construct a RepeatAttribute + + The number of times to run the test + + + + RequiredAddinAttribute may be used to indicate the names of any addins + that must be present in order to run some or all of the tests in an + assembly. If the addin is not loaded, the entire assembly is marked + as NotRunnable. + + + + + Initializes a new instance of the class. + + The required addin. + + + + Gets the name of required addin. + + The required addin name. + + + + Summary description for SetCultureAttribute. + + + + + Construct given the name of a culture + + + + + + Summary description for SetUICultureAttribute. + + + + + Construct given the name of a culture + + + + + + Attribute used to mark a class that contains one-time SetUp + and/or TearDown methods that apply to all the tests in a + namespace or an assembly. + + + + + SetUpFixtureAttribute is used to identify a SetUpFixture + + + + + Attribute used to mark a static (shared in VB) property + that returns a list of tests. + + + + + Attribute used to identify a method that is called + immediately after each test is run. The method is + guaranteed to be called, even if an exception is thrown. + + + + + Adding this attribute to a method within a + class makes the method callable from the NUnit test runner. There is a property + called Description which is optional which you can provide a more detailed test + description. This class cannot be inherited. + + + + [TestFixture] + public class Fixture + { + [Test] + public void MethodToTest() + {} + + [Test(Description = "more detailed description")] + publc void TestDescriptionMethod() + {} + } + + + + + + Descriptive text for this test + + + + + TestCaseAttribute is used to mark parameterized test cases + and provide them with their arguments. + + + + + The ITestCaseData interface is implemented by a class + that is able to return complete testcases for use by + a parameterized test method. + + NOTE: This interface is used in both the framework + and the core, even though that results in two different + types. However, sharing the source code guarantees that + the various implementations will be compatible and that + the core is able to reflect successfully over the + framework implementations of ITestCaseData. + + + + + Gets the argument list to be provided to the test + + + + + Gets the expected result + + + + + Gets the expected exception Type + + + + + Gets the FullName of the expected exception + + + + + Gets the name to be used for the test + + + + + Gets the description of the test + + + + + Gets a value indicating whether this is ignored. + + true if ignored; otherwise, false. + + + + Gets the ignore reason. + + The ignore reason. + + + + Construct a TestCaseAttribute with a list of arguments. + This constructor is not CLS-Compliant + + + + + + Construct a TestCaseAttribute with a single argument + + + + + + Construct a TestCaseAttribute with a two arguments + + + + + + + Construct a TestCaseAttribute with a three arguments + + + + + + + + Gets the list of arguments to a test case + + + + + Gets or sets the expected result. + + The result. + + + + Gets a list of categories associated with this test; + + + + + Gets or sets the category associated with this test. + May be a single category or a comma-separated list. + + + + + Gets or sets the expected exception. + + The expected exception. + + + + Gets or sets the name the expected exception. + + The expected name of the exception. + + + + Gets or sets the expected message of the expected exception + + The expected message of the exception. + + + + Gets or sets the type of match to be performed on the expected message + + + + + Gets or sets the description. + + The description. + + + + Gets or sets the name of the test. + + The name of the test. + + + + Gets or sets the ignored status of the test + + + + + Gets or sets the ignored status of the test + + + + + Gets the ignore reason. + + The ignore reason. + + + + FactoryAttribute indicates the source to be used to + provide test cases for a test method. + + + + + Construct with the name of the factory - for use with languages + that don't support params arrays. + + An array of the names of the factories that will provide data + + + + Construct with a Type and name - for use with languages + that don't support params arrays. + + The Type that will provide data + The name of the method, property or field that will provide data + + + + The name of a the method, property or fiend to be used as a source + + + + + A Type to be used as a source + + + + + [TestFixture] + public class ExampleClass + {} + + + + + Default constructor + + + + + Construct with a object[] representing a set of arguments. + In .NET 2.0, the arguments may later be separated into + type arguments and constructor arguments. + + + + + + Descriptive text for this fixture + + + + + Gets and sets the category for this fixture. + May be a comma-separated list of categories. + + + + + Gets a list of categories for this fixture + + + + + The arguments originally provided to the attribute + + + + + Gets or sets a value indicating whether this should be ignored. + + true if ignore; otherwise, false. + + + + Gets or sets the ignore reason. May set Ignored as a side effect. + + The ignore reason. + + + + Get or set the type arguments. If not set + explicitly, any leading arguments that are + Types are taken as type arguments. + + + + + Attribute used to identify a method that is + called before any tests in a fixture are run. + + + + + Attribute used to identify a method that is called after + all the tests in a fixture have run. The method is + guaranteed to be called, even if an exception is thrown. + + + + + Adding this attribute to a method within a + class makes the method callable from the NUnit test runner. There is a property + called Description which is optional which you can provide a more detailed test + description. This class cannot be inherited. + + + + [TestFixture] + public class Fixture + { + [Test] + public void MethodToTest() + {} + + [Test(Description = "more detailed description")] + publc void TestDescriptionMethod() + {} + } + + + + + + WUsed on a method, marks the test with a timeout value in milliseconds. + The test will be run in a separate thread and is cancelled if the timeout + is exceeded. Used on a method or assembly, sets the default timeout + for all contained test methods. + + + + + Construct a TimeoutAttribute given a time in milliseconds + + The timeout value in milliseconds + + + + Marks a test that must run in the STA, causing it + to run in a separate thread if necessary. + + On methods, you may also use STAThreadAttribute + to serve the same purpose. + + + + + Construct a RequiresSTAAttribute + + + + + Marks a test that must run in the MTA, causing it + to run in a separate thread if necessary. + + On methods, you may also use MTAThreadAttribute + to serve the same purpose. + + + + + Construct a RequiresMTAAttribute + + + + + Marks a test that must run on a separate thread. + + + + + Construct a RequiresThreadAttribute + + + + + Construct a RequiresThreadAttribute, specifying the apartment + + + + + ValueSourceAttribute indicates the source to be used to + provide data for one parameter of a test method. + + + + + Construct with the name of the factory - for use with languages + that don't support params arrays. + + The name of the data source to be used + + + + Construct with a Type and name - for use with languages + that don't support params arrays. + + The Type that will provide data + The name of the method, property or field that will provide data + + + + The name of a the method, property or fiend to be used as a source + + + + + A Type to be used as a source + + + + + AttributeExistsConstraint tests for the presence of a + specified attribute on a Type. + + + + + The Constraint class is the base of all built-in constraints + within NUnit. It provides the operator overloads used to combine + constraints. + + + + + The IConstraintExpression interface is implemented by all + complete and resolvable constraints and expressions. + + + + + Return the top-level constraint for this expression + + + + + + Static UnsetObject used to detect derived constraints + failing to set the actual value. + + + + + The actual value being tested against a constraint + + + + + The display name of this Constraint for use by ToString() + + + + + Argument fields used by ToString(); + + + + + The builder holding this constraint + + + + + Construct a constraint with no arguments + + + + + Construct a constraint with one argument + + + + + Construct a constraint with two arguments + + + + + Sets the ConstraintBuilder holding this constraint + + + + + Write the failure message to the MessageWriter provided + as an argument. The default implementation simply passes + the constraint and the actual value to the writer, which + then displays the constraint description and the value. + + Constraints that need to provide additional details, + such as where the error occured can override this. + + The MessageWriter on which to display the message + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Test whether the constraint is satisfied by an + ActualValueDelegate that returns the value to be tested. + The default implementation simply evaluates the delegate + but derived classes may override it to provide for delayed + processing. + + An ActualValueDelegate + True for success, false for failure + + + + Test whether the constraint is satisfied by a given reference. + The default implementation simply dereferences the value but + derived classes may override it to provide for delayed processing. + + A reference to the value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + Default override of ToString returns the constraint DisplayName + followed by any arguments within angle brackets. + + + + + + Returns the string representation of this constraint + + + + + This operator creates a constraint that is satisfied only if both + argument constraints are satisfied. + + + + + This operator creates a constraint that is satisfied if either + of the argument constraints is satisfied. + + + + + This operator creates a constraint that is satisfied if the + argument constraint is not satisfied. + + + + + Returns a DelayedConstraint with the specified delay time. + + The delay in milliseconds. + + + + + Returns a DelayedConstraint with the specified delay time + and polling interval. + + The delay in milliseconds. + The interval at which to test the constraint. + + + + + The display name of this Constraint for use by ToString(). + The default value is the name of the constraint with + trailing "Constraint" removed. Derived classes may set + this to another name in their constructors. + + + + + Returns a ConstraintExpression by appending And + to the current constraint. + + + + + Returns a ConstraintExpression by appending And + to the current constraint. + + + + + Returns a ConstraintExpression by appending Or + to the current constraint. + + + + + Class used to detect any derived constraints + that fail to set the actual value in their + Matches override. + + + + + Constructs an AttributeExistsConstraint for a specific attribute Type + + + + + + Tests whether the object provides the expected attribute. + + A Type, MethodInfo, or other ICustomAttributeProvider + True if the expected attribute is present, otherwise false + + + + Writes the description of the constraint to the specified writer + + + + + AttributeConstraint tests that a specified attribute is present + on a Type or other provider and that the value of the attribute + satisfies some other constraint. + + + + + Abstract base class used for prefixes + + + + + The base constraint + + + + + Construct given a base constraint + + + + + + Constructs an AttributeConstraint for a specified attriute + Type and base constraint. + + + + + + + Determines whether the Type or other provider has the + expected attribute and if its value matches the + additional constraint specified. + + + + + Writes a description of the attribute to the specified writer. + + + + + Writes the actual value supplied to the specified writer. + + + + + Returns a string representation of the constraint. + + + + + BasicConstraint is the abstract base for constraints that + perform a simple comparison to a constant value. + + + + + Initializes a new instance of the class. + + The expected. + The description. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + NullConstraint tests that the actual value is null + + + + + Initializes a new instance of the class. + + + + + TrueConstraint tests that the actual value is true + + + + + Initializes a new instance of the class. + + + + + FalseConstraint tests that the actual value is false + + + + + Initializes a new instance of the class. + + + + + NaNConstraint tests that the actual value is a double or float NaN + + + + + Test that the actual value is an NaN + + + + + + + Write the constraint description to a specified writer + + + + + + BinaryConstraint is the abstract base of all constraints + that combine two other constraints in some fashion. + + + + + The first constraint being combined + + + + + The second constraint being combined + + + + + Construct a BinaryConstraint from two other constraints + + The first constraint + The second constraint + + + + AndConstraint succeeds only if both members succeed. + + + + + Create an AndConstraint from two other constraints + + The first constraint + The second constraint + + + + Apply both member constraints to an actual value, succeeding + succeeding only if both of them succeed. + + The actual value + True if the constraints both succeeded + + + + Write a description for this contraint to a MessageWriter + + The MessageWriter to receive the description + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + OrConstraint succeeds if either member succeeds + + + + + Create an OrConstraint from two other constraints + + The first constraint + The second constraint + + + + Apply the member constraints to an actual value, succeeding + succeeding as soon as one of them succeeds. + + The actual value + True if either constraint succeeded + + + + Write a description for this contraint to a MessageWriter + + The MessageWriter to receive the description + + + + CollectionConstraint is the abstract base class for + constraints that operate on collections. + + + + + Construct an empty CollectionConstraint + + + + + Construct a CollectionConstraint + + + + + + Determines whether the specified enumerable is empty. + + The enumerable. + + true if the specified enumerable is empty; otherwise, false. + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Protected method to be implemented by derived classes + + + + + + + CollectionItemsEqualConstraint is the abstract base class for all + collection constraints that apply some notion of item equality + as a part of their operation. + + + + + Construct an empty CollectionConstraint + + + + + Construct a CollectionConstraint + + + + + + Flag the constraint to use the supplied IComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied Comparison object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IEqualityComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IEqualityComparer object. + + The IComparer object to use. + Self. + + + + Compares two collection members for equality + + + + + Return a new CollectionTally for use in making tests + + The collection to be included in the tally + + + + Flag the constraint to ignore case and return self. + + + + + EmptyCollectionConstraint tests whether a collection is empty. + + + + + Check that the collection is empty + + + + + + + Write the constraint description to a MessageWriter + + + + + + UniqueItemsConstraint tests whether all the items in a + collection are unique. + + + + + Check that all items are unique. + + + + + + + Write a description of this constraint to a MessageWriter + + + + + + CollectionContainsConstraint is used to test whether a collection + contains an expected object as a member. + + + + + Construct a CollectionContainsConstraint + + + + + + Test whether the expected item is contained in the collection + + + + + + + Write a descripton of the constraint to a MessageWriter + + + + + + CollectionEquivalentCOnstraint is used to determine whether two + collections are equivalent. + + + + + Construct a CollectionEquivalentConstraint + + + + + + Test whether two collections are equivalent + + + + + + + Write a description of this constraint to a MessageWriter + + + + + + CollectionSubsetConstraint is used to determine whether + one collection is a subset of another + + + + + Construct a CollectionSubsetConstraint + + The collection that the actual value is expected to be a subset of + + + + Test whether the actual collection is a subset of + the expected collection provided. + + + + + + + Write a description of this constraint to a MessageWriter + + + + + + CollectionOrderedConstraint is used to test whether a collection is ordered. + + + + + Construct a CollectionOrderedConstraint + + + + + Modifies the constraint to use an IComparer and returns self. + + + + + Modifies the constraint to use an IComparer<T> and returns self. + + + + + Modifies the constraint to use a Comparison<T> and returns self. + + + + + Modifies the constraint to test ordering by the value of + a specified property and returns self. + + + + + Test whether the collection is ordered + + + + + + + Write a description of the constraint to a MessageWriter + + + + + + Returns the string representation of the constraint. + + + + + + If used performs a reverse comparison + + + + + CollectionTally counts (tallies) the number of + occurences of each object in one or more enumerations. + + + + + Construct a CollectionTally object from a comparer and a collection + + + + + Try to remove an object from the tally + + The object to remove + True if successful, false if the object was not found + + + + Try to remove a set of objects from the tally + + The objects to remove + True if successful, false if any object was not found + + + + The number of objects remaining in the tally + + + + + ComparisonAdapter class centralizes all comparisons of + values in NUnit, adapting to the use of any provided + IComparer, IComparer<T> or Comparison<T> + + + + + Returns a ComparisonAdapter that wraps an IComparer + + + + + Returns a ComparisonAdapter that wraps an IComparer<T> + + + + + Returns a ComparisonAdapter that wraps a Comparison<T> + + + + + Compares two objects + + + + + Gets the default ComparisonAdapter, which wraps an + NUnitComparer object. + + + + + Construct a ComparisonAdapter for an IComparer + + + + + Compares two objects + + + + + + + + Construct a default ComparisonAdapter + + + + + ComparisonAdapter<T> extends ComparisonAdapter and + allows use of an IComparer<T> or Comparison<T> + to actually perform the comparison. + + + + + Construct a ComparisonAdapter for an IComparer<T> + + + + + Compare a Type T to an object + + + + + Construct a ComparisonAdapter for a Comparison<T> + + + + + Compare a Type T to an object + + + + + Abstract base class for constraints that compare values to + determine if one is greater than, equal to or less than + the other. + + + + + The value against which a comparison is to be made + + + + + If true, less than returns success + + + + + if true, equal returns success + + + + + if true, greater than returns success + + + + + The predicate used as a part of the description + + + + + ComparisonAdapter to be used in making the comparison + + + + + Initializes a new instance of the class. + + The value against which to make a comparison. + if set to true less succeeds. + if set to true equal succeeds. + if set to true greater succeeds. + String used in describing the constraint. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Modifies the constraint to use an IComparer and returns self + + + + + Modifies the constraint to use an IComparer<T> and returns self + + + + + Modifies the constraint to use a Comparison<T> and returns self + + + + + Tests whether a value is greater than the value supplied to its constructor + + + + + Initializes a new instance of the class. + + The expected value. + + + + Tests whether a value is greater than or equal to the value supplied to its constructor + + + + + Initializes a new instance of the class. + + The expected value. + + + + Tests whether a value is less than the value supplied to its constructor + + + + + Initializes a new instance of the class. + + The expected value. + + + + Tests whether a value is less than or equal to the value supplied to its constructor + + + + + Initializes a new instance of the class. + + The expected value. + + + + Delegate used to delay evaluation of the actual value + to be used in evaluating a constraint + + + + + ConstraintBuilder maintains the stacks that are used in + processing a ConstraintExpression. An OperatorStack + is used to hold operators that are waiting for their + operands to be reognized. a ConstraintStack holds + input constraints as well as the results of each + operator applied. + + + + + Initializes a new instance of the class. + + + + + Appends the specified operator to the expression by first + reducing the operator stack and then pushing the new + operator on the stack. + + The operator to push. + + + + Appends the specified constraint to the expresson by pushing + it on the constraint stack. + + The constraint to push. + + + + Sets the top operator right context. + + The right context. + + + + Reduces the operator stack until the topmost item + precedence is greater than or equal to the target precedence. + + The target precedence. + + + + Resolves this instance, returning a Constraint. If the builder + is not currently in a resolvable state, an exception is thrown. + + The resolved constraint + + + + Gets a value indicating whether this instance is resolvable. + + + true if this instance is resolvable; otherwise, false. + + + + + OperatorStack is a type-safe stack for holding ConstraintOperators + + + + + Initializes a new instance of the class. + + The builder. + + + + Pushes the specified operator onto the stack. + + The op. + + + + Pops the topmost operator from the stack. + + + + + + Gets a value indicating whether this is empty. + + true if empty; otherwise, false. + + + + Gets the topmost operator without modifying the stack. + + The top. + + + + ConstraintStack is a type-safe stack for holding Constraints + + + + + Initializes a new instance of the class. + + The builder. + + + + Pushes the specified constraint. As a side effect, + the constraint's builder field is set to the + ConstraintBuilder owning this stack. + + The constraint. + + + + Pops this topmost constrait from the stack. + As a side effect, the constraint's builder + field is set to null. + + + + + + Gets a value indicating whether this is empty. + + true if empty; otherwise, false. + + + + Gets the topmost constraint without modifying the stack. + + The topmost constraint + + + + ConstraintExpression represents a compound constraint in the + process of being constructed from a series of syntactic elements. + + Individual elements are appended to the expression as they are + reognized. Once an actual Constraint is appended, the expression + returns a resolvable Constraint. + + + + + ConstraintExpressionBase is the abstract base class for the + generated ConstraintExpression class, which represents a + compound constraint in the process of being constructed + from a series of syntactic elements. + + NOTE: ConstraintExpressionBase is aware of some of its + derived classes, which is an apparent violation of + encapsulation. Ideally, these classes would be a + single class, but they must be separated in order to + allow parts to be generated under .NET 1.x and to + provide proper user feedback in syntactically + aware IDEs. + + + + + The ConstraintBuilder holding the elements recognized so far + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class passing in a ConstraintBuilder, which may be pre-populated. + + The builder. + + + + Returns a string representation of the expression as it + currently stands. This should only be used for testing, + since it has the side-effect of resolving the expression. + + + + + + Appends an operator to the expression and returns the + resulting expression itself. + + + + + Appends a self-resolving operator to the expression and + returns a new ResolvableConstraintExpression. + + + + + Appends a constraint to the expression and returns that + constraint, which is associated with the current state + of the expression being built. + + + + + Initializes a new instance of the class. + + + + + Initializes a new instance of the + class passing in a ConstraintBuilder, which may be pre-populated. + + The builder. + + + + Returns a new PropertyConstraintExpression, which will either + test for the existence of the named property on the object + being tested or apply any following constraint to that property. + + + + + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + + + + + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + + + + + Returns the constraint provided as an argument - used to allow custom + custom constraints to easily participate in the syntax. + + + + + Returns the constraint provided as an argument - used to allow custom + custom constraints to easily participate in the syntax. + + + + + Returns a constraint that tests two items for equality + + + + + Returns a constraint that tests that two references are the same object + + + + + Returns a constraint that tests whether the + actual value is greater than the suppled argument + + + + + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + + + + + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + + + + + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is a collection containing the same elements as the + collection supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is a subset of the collection supplied as an argument. + + + + + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + + + + + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + + + + + Returns a new ContainsConstraint. This constraint + will, in turn, make use of the appropriate second-level + constraint, depending on the type of the actual argument. + This overload is only used if the item sought is a string, + since any other type implies that we are looking for a + collection member. + + + + + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + + + + + Returns a constraint that tests whether the path provided + is the same as an expected path after canonicalization. + + + + + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + + + + + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + + + + + Returns a constraint that tests whether the actual value falls + within a specified range. + + + + + Returns a ConstraintExpression that negates any + following constraint. + + + + + Returns a ConstraintExpression that negates any + following constraint. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if at least one of them succeeds. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them fail. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Length property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Count property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Message property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the InnerException property of the object being tested. + + + + + With is currently a NOP - reserved for future use. + + + + + Returns a constraint that tests for null + + + + + Returns a constraint that tests for True + + + + + Returns a constraint that tests for False + + + + + Returns a constraint that tests for NaN + + + + + Returns a constraint that tests for empty + + + + + Returns a constraint that tests whether a collection + contains all unique items. + + + + + Returns a constraint that tests whether an object graph is serializable in binary format. + + + + + Returns a constraint that tests whether an object graph is serializable in xml format. + + + + + Returns a constraint that tests whether a collection is ordered + + + + + Helper class with properties and methods that supply + a number of constraints used in Asserts. + + + + + Returns a new PropertyConstraintExpression, which will either + test for the existence of the named property on the object + being tested or apply any following constraint to that property. + + + + + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + + + + + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + + + + + Returns a constraint that tests two items for equality + + + + + Returns a constraint that tests that two references are the same object + + + + + Returns a constraint that tests whether the + actual value is greater than the suppled argument + + + + + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + + + + + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + + + + + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is a collection containing the same elements as the + collection supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is a subset of the collection supplied as an argument. + + + + + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + + + + + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + + + + + Returns a new ContainsConstraint. This constraint + will, in turn, make use of the appropriate second-level + constraint, depending on the type of the actual argument. + This overload is only used if the item sought is a string, + since any other type implies that we are looking for a + collection member. + + + + + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that fails if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that fails if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that fails if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + + + + + Returns a constraint that fails if the actual + value matches the pattern supplied as an argument. + + + + + Returns a constraint that tests whether the path provided + is the same as an expected path after canonicalization. + + + + + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + + + + + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + + + + + Returns a constraint that tests whether the actual value falls + within a specified range. + + + + + Returns a ConstraintExpression that negates any + following constraint. + + + + + Returns a ConstraintExpression that negates any + following constraint. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if at least one of them succeeds. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them fail. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Length property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Count property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Message property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the InnerException property of the object being tested. + + + + + Returns a constraint that tests for null + + + + + Returns a constraint that tests for True + + + + + Returns a constraint that tests for False + + + + + Returns a constraint that tests for NaN + + + + + Returns a constraint that tests for empty + + + + + Returns a constraint that tests whether a collection + contains all unique items. + + + + + Returns a constraint that tests whether an object graph is serializable in binary format. + + + + + Returns a constraint that tests whether an object graph is serializable in xml format. + + + + + Returns a constraint that tests whether a collection is ordered + + + + + The ConstraintOperator class is used internally by a + ConstraintBuilder to represent an operator that + modifies or combines constraints. + + Constraint operators use left and right precedence + values to determine whether the top operator on the + stack should be reduced before pushing a new operator. + + + + + The precedence value used when the operator + is about to be pushed to the stack. + + + + + The precedence value used when the operator + is on the top of the stack. + + + + + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + + + + + + The syntax element preceding this operator + + + + + The syntax element folowing this operator + + + + + The precedence value used when the operator + is about to be pushed to the stack. + + + + + The precedence value used when the operator + is on the top of the stack. + + + + + PrefixOperator takes a single constraint and modifies + it's action in some way. + + + + + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + + + + + + Returns the constraint created by applying this + prefix to another constraint. + + + + + + + Negates the test of the constraint it wraps. + + + + + Constructs a new NotOperator + + + + + Returns a NotConstraint applied to its argument. + + + + + Abstract base for operators that indicate how to + apply a constraint to items in a collection. + + + + + Constructs a CollectionOperator + + + + + Represents a constraint that succeeds if all the + members of a collection match a base constraint. + + + + + Returns a constraint that will apply the argument + to the members of a collection, succeeding if + they all succeed. + + + + + Represents a constraint that succeeds if any of the + members of a collection match a base constraint. + + + + + Returns a constraint that will apply the argument + to the members of a collection, succeeding if + any of them succeed. + + + + + Represents a constraint that succeeds if none of the + members of a collection match a base constraint. + + + + + Returns a constraint that will apply the argument + to the members of a collection, succeeding if + none of them succeed. + + + + + Represents a constraint that simply wraps the + constraint provided as an argument, without any + further functionality, but which modifes the + order of evaluation because of its precedence. + + + + + Constructor for the WithOperator + + + + + Returns a constraint that wraps its argument + + + + + Abstract base class for operators that are able to reduce to a + constraint whether or not another syntactic element follows. + + + + + Operator used to test for the presence of a named Property + on an object and optionally apply further tests to the + value of that property. + + + + + Constructs a PropOperator for a particular named property + + + + + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + + + + + + Gets the name of the property to which the operator applies + + + + + Operator that tests for the presence of a particular attribute + on a type and optionally applies further tests to the attribute. + + + + + Construct an AttributeOperator for a particular Type + + The Type of attribute tested + + + + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + + + + + Operator that tests that an exception is thrown and + optionally applies further tests to the exception. + + + + + Construct a ThrowsOperator + + + + + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + + + + + Abstract base class for all binary operators + + + + + Reduce produces a constraint from the operator and + any arguments. It takes the arguments from the constraint + stack and pushes the resulting constraint on it. + + + + + + Abstract method that produces a constraint by applying + the operator to its left and right constraint arguments. + + + + + Gets the left precedence of the operator + + + + + Gets the right precedence of the operator + + + + + Operator that requires both it's arguments to succeed + + + + + Construct an AndOperator + + + + + Apply the operator to produce an AndConstraint + + + + + Operator that requires at least one of it's arguments to succeed + + + + + Construct an OrOperator + + + + + Apply the operator to produce an OrConstraint + + + + + ContainsConstraint tests a whether a string contains a substring + or a collection contains an object. It postpones the decision of + which test to use until the type of the actual argument is known. + This allows testing whether a string is contained in a collection + or as a substring of another string using the same syntax. + + + + + Initializes a new instance of the class. + + The expected. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Flag the constraint to use the supplied IComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied Comparison object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IEqualityComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IEqualityComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to ignore case and return self. + + + + + Applies a delay to the match so that a match can be evaluated in the future. + + + + + Creates a new DelayedConstraint + + The inner constraint two decorate + The time interval after which the match is performed + If the value of is less than 0 + + + + Creates a new DelayedConstraint + + The inner constraint two decorate + The time interval after which the match is performed + The time interval used for polling + If the value of is less than 0 + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for if the base constraint fails, false if it succeeds + + + + Test whether the constraint is satisfied by a delegate + + The delegate whose value is to be tested + True for if the base constraint fails, false if it succeeds + + + + Test whether the constraint is satisfied by a given reference. + Overridden to wait for the specified delay period before + calling the base constraint with the dereferenced value. + + A reference to the value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a MessageWriter. + + The writer on which the actual value is displayed + + + + Returns the string representation of the constraint. + + + + + EmptyDirectoryConstraint is used to test that a directory is empty + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + EmptyConstraint tests a whether a string or collection is empty, + postponing the decision about which test is applied until the + type of the actual argument is known. + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + EqualConstraint is able to compare an actual value with the + expected value provided in its constructor. Two objects are + considered equal if both are null, or if both have the same + value. NUnit has special semantics for some object types. + + + + + If true, strings in error messages will be clipped + + + + + NUnitEqualityComparer used to test equality. + + + + + Initializes a new instance of the class. + + The expected value. + + + + Flag the constraint to use a tolerance when determining equality. + + Tolerance value to be used + Self. + + + + Flag the constraint to use the supplied IComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied Comparison object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IEqualityComparer object. + + The IComparer object to use. + Self. + + + + Flag the constraint to use the supplied IEqualityComparer object. + + The IComparer object to use. + Self. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write a failure message. Overridden to provide custom + failure messages for EqualConstraint. + + The MessageWriter to write to + + + + Write description of this constraint + + The MessageWriter to write to + + + + Display the failure information for two collections that did not match. + + The MessageWriter on which to display + The expected collection. + The actual collection + The depth of this failure in a set of nested collections + + + + Displays a single line showing the types and sizes of the expected + and actual collections or arrays. If both are identical, the value is + only shown once. + + The MessageWriter on which to display + The expected collection or array + The actual collection or array + The indentation level for the message line + + + + Displays a single line showing the point in the expected and actual + arrays at which the comparison failed. If the arrays have different + structures or dimensions, both values are shown. + + The MessageWriter on which to display + The expected array + The actual array + Index of the failure point in the underlying collections + The indentation level for the message line + + + + Flag the constraint to ignore case and return self. + + + + + Flag the constraint to suppress string clipping + and return self. + + + + + Flag the constraint to compare arrays as collections + and return self. + + + + + Switches the .Within() modifier to interpret its tolerance as + a distance in representable values (see remarks). + + Self. + + Ulp stands for "unit in the last place" and describes the minimum + amount a given value can change. For any integers, an ulp is 1 whole + digit. For floating point values, the accuracy of which is better + for smaller numbers and worse for larger numbers, an ulp depends + on the size of the number. Using ulps for comparison of floating + point results instead of fixed tolerances is safer because it will + automatically compensate for the added inaccuracy of larger numbers. + + + + + Switches the .Within() modifier to interpret its tolerance as + a percentage that the actual values is allowed to deviate from + the expected value. + + Self + + + + Causes the tolerance to be interpreted as a TimeSpan in days. + + Self + + + + Causes the tolerance to be interpreted as a TimeSpan in hours. + + Self + + + + Causes the tolerance to be interpreted as a TimeSpan in minutes. + + Self + + + + Causes the tolerance to be interpreted as a TimeSpan in seconds. + + Self + + + + Causes the tolerance to be interpreted as a TimeSpan in milliseconds. + + Self + + + + Causes the tolerance to be interpreted as a TimeSpan in clock ticks. + + Self + + + + EqualityAdapter class handles all equality comparisons + that use an IEqualityComparer, IEqualityComparer<T> + or a ComparisonAdapter. + + + + + Compares two objects, returning true if they are equal + + + + + Returns an EqualityAdapter that wraps an IComparer. + + + + + Returns an EqualityAdapter that wraps an IEqualityComparer. + + + + + Returns an EqualityAdapter that wraps an IEqualityComparer<T>. + + + + + Returns an EqualityAdapter that wraps an IComparer<T>. + + + + + Returns an EqualityAdapter that wraps a Comparison<T>. + + + + Helper routines for working with floating point numbers + + + The floating point comparison code is based on this excellent article: + http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm + + + "ULP" means Unit in the Last Place and in the context of this library refers to + the distance between two adjacent floating point numbers. IEEE floating point + numbers can only represent a finite subset of natural numbers, with greater + accuracy for smaller numbers and lower accuracy for very large numbers. + + + If a comparison is allowed "2 ulps" of deviation, that means the values are + allowed to deviate by up to 2 adjacent floating point values, which might be + as low as 0.0000001 for small numbers or as high as 10.0 for large numbers. + + + + + Compares two floating point values for equality + First floating point value to be compared + Second floating point value t be compared + + Maximum number of representable floating point values that are allowed to + be between the left and the right floating point values + + True if both numbers are equal or close to being equal + + + Floating point values can only represent a finite subset of natural numbers. + For example, the values 2.00000000 and 2.00000024 can be stored in a float, + but nothing inbetween them. + + + This comparison will count how many possible floating point values are between + the left and the right number. If the number of possible values between both + numbers is less than or equal to maxUlps, then the numbers are considered as + being equal. + + + Implementation partially follows the code outlined here: + http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/ + + + + + Compares two double precision floating point values for equality + First double precision floating point value to be compared + Second double precision floating point value t be compared + + Maximum number of representable double precision floating point values that are + allowed to be between the left and the right double precision floating point values + + True if both numbers are equal or close to being equal + + + Double precision floating point values can only represent a limited series of + natural numbers. For example, the values 2.0000000000000000 and 2.0000000000000004 + can be stored in a double, but nothing inbetween them. + + + This comparison will count how many possible double precision floating point + values are between the left and the right number. If the number of possible + values between both numbers is less than or equal to maxUlps, then the numbers + are considered as being equal. + + + Implementation partially follows the code outlined here: + http://www.anttirt.net/2007/08/19/proper-floating-point-comparisons/ + + + + + + Reinterprets the memory contents of a floating point value as an integer value + + + Floating point value whose memory contents to reinterpret + + + The memory contents of the floating point value interpreted as an integer + + + + + Reinterprets the memory contents of a double precision floating point + value as an integer value + + + Double precision floating point value whose memory contents to reinterpret + + + The memory contents of the double precision floating point value + interpreted as an integer + + + + + Reinterprets the memory contents of an integer as a floating point value + + Integer value whose memory contents to reinterpret + + The memory contents of the integer value interpreted as a floating point value + + + + + Reinterprets the memory contents of an integer value as a double precision + floating point value + + Integer whose memory contents to reinterpret + + The memory contents of the integer interpreted as a double precision + floating point value + + + + Union of a floating point variable and an integer + + + The union's value as a floating point variable + + + The union's value as an integer + + + The union's value as an unsigned integer + + + Union of a double precision floating point variable and a long + + + The union's value as a double precision floating point variable + + + The union's value as a long + + + The union's value as an unsigned long + + + + MessageWriter is the abstract base for classes that write + constraint descriptions and messages in some form. The + class has separate methods for writing various components + of a message, allowing implementations to tailor the + presentation as needed. + + + + + Construct a MessageWriter given a culture + + + + + Method to write single line message with optional args, usually + written to precede the general failure message. + + The message to be written + Any arguments used in formatting the message + + + + Method to write single line message with optional args, usually + written to precede the general failure message, at a givel + indentation level. + + The indentation level of the message + The message to be written + Any arguments used in formatting the message + + + + Display Expected and Actual lines for a constraint. This + is called by MessageWriter's default implementation of + WriteMessageTo and provides the generic two-line display. + + The constraint that failed + + + + Display Expected and Actual lines for given values. This + method may be called by constraints that need more control over + the display of actual and expected values than is provided + by the default implementation. + + The expected value + The actual value causing the failure + + + + Display Expected and Actual lines for given values, including + a tolerance value on the Expected line. + + The expected value + The actual value causing the failure + The tolerance within which the test was made + + + + Display the expected and actual string values on separate lines. + If the mismatch parameter is >=0, an additional line is displayed + line containing a caret that points to the mismatch point. + + The expected string value + The actual string value + The point at which the strings don't match or -1 + If true, case is ignored in locating the point where the strings differ + If true, the strings should be clipped to fit the line + + + + Writes the text for a connector. + + The connector. + + + + Writes the text for a predicate. + + The predicate. + + + + Writes the text for an expected value. + + The expected value. + + + + Writes the text for a modifier + + The modifier. + + + + Writes the text for an actual value. + + The actual value. + + + + Writes the text for a generalized value. + + The value. + + + + Writes the text for a collection value, + starting at a particular point, to a max length + + The collection containing elements to write. + The starting point of the elements to write + The maximum number of elements to write + + + + Abstract method to get the max line length + + + + + Static methods used in creating messages + + + + + Static string used when strings are clipped + + + + + Returns the representation of a type as used in NUnitLite. + This is the same as Type.ToString() except for arrays, + which are displayed with their declared sizes. + + + + + + + Converts any control characters in a string + to their escaped representation. + + The string to be converted + The converted string + + + + Return the a string representation for a set of indices into an array + + Array of indices for which a string is needed + + + + Get an array of indices representing the point in a collection or + array corresponding to a single int index into the collection. + + The collection to which the indices apply + Index in the collection + Array of indices + + + + Clip a string to a given length, starting at a particular offset, returning the clipped + string with ellipses representing the removed parts + + The string to be clipped + The maximum permitted length of the result string + The point at which to start clipping + The clipped string + + + + Clip the expected and actual strings in a coordinated fashion, + so that they may be displayed together. + + + + + + + + + Shows the position two strings start to differ. Comparison + starts at the start index. + + The expected string + The actual string + The index in the strings at which comparison should start + Boolean indicating whether case should be ignored + -1 if no mismatch found, or the index where mismatch found + + + + The Numerics class contains common operations on numeric values. + + + + + Checks the type of the object, returning true if + the object is a numeric type. + + The object to check + true if the object is a numeric type + + + + Checks the type of the object, returning true if + the object is a floating point numeric type. + + The object to check + true if the object is a floating point numeric type + + + + Checks the type of the object, returning true if + the object is a fixed point numeric type. + + The object to check + true if the object is a fixed point numeric type + + + + Test two numeric values for equality, performing the usual numeric + conversions and using a provided or default tolerance. If the tolerance + provided is Empty, this method may set it to a default tolerance. + + The expected value + The actual value + A reference to the tolerance in effect + True if the values are equal + + + + Compare two numeric values, performing the usual numeric conversions. + + The expected value + The actual value + The relationship of the values to each other + + + + NUnitComparer encapsulates NUnit's default behavior + in comparing two objects. + + + + + Compares two objects + + + + + + + + Returns the default NUnitComparer. + + + + + NUnitEqualityComparer encapsulates NUnit's handling of + equality tests between objects. + + + + + If true, all string comparisons will ignore case + + + + + If true, arrays will be treated as collections, allowing + those of different dimensions to be compared + + + + + If non-zero, equality comparisons within the specified + tolerance will succeed. + + + + + Comparison object used in comparisons for some constraints. + + + + + Compares two objects for equality. + + + + + Helper method to compare two arrays + + + + + Method to compare two DirectoryInfo objects + + first directory to compare + second directory to compare + true if equivalent, false if not + + + + Returns the default NUnitEqualityComparer + + + + + Gets and sets a flag indicating whether case should + be ignored in determining equality. + + + + + Gets and sets a flag indicating that arrays should be + compared as collections, without regard to their shape. + + + + + Gets and sets an external comparer to be used to + test for equality. It is applied to members of + collections, in place of NUnit's own logic. + + + + + Gets and sets a tolerance used to compare objects of + certin types. + + + + + Gets the list of failure points for the last Match performed. + + + + + PathConstraint serves as the abstract base of constraints + that operate on paths and provides several helper methods. + + + + + The expected path used in the constraint + + + + + The actual path being tested + + + + + Flag indicating whether a caseInsensitive comparison should be made + + + + + Construct a PathConstraint for a give expected path + + The expected path + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Returns true if the expected path and actual path match + + + + + Returns the string representation of this constraint + + + + + Canonicalize the provided path + + + The path in standardized form + + + + Test whether two paths are the same + + The first path + The second path + Indicates whether case should be ignored + + + + + Test whether one path is under another path + + The first path - supposed to be the parent path + The second path - supposed to be the child path + Indicates whether case should be ignored + + + + + Test whether one path is the same as or under another path + + The first path - supposed to be the parent path + The second path - supposed to be the child path + + + + + Modifies the current instance to be case-insensitve + and returns it. + + + + + Modifies the current instance to be case-sensitve + and returns it. + + + + + Summary description for SamePathConstraint. + + + + + Initializes a new instance of the class. + + The expected path + + + + Test whether the constraint is satisfied by a given value + + The expected path + The actual path + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + SubPathConstraint tests that the actual path is under the expected path + + + + + Initializes a new instance of the class. + + The expected path + + + + Test whether the constraint is satisfied by a given value + + The expected path + The actual path + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + SamePathOrUnderConstraint tests that one path is under another + + + + + Initializes a new instance of the class. + + The expected path + + + + Test whether the constraint is satisfied by a given value + + The expected path + The actual path + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Predicate constraint wraps a Predicate in a constraint, + returning success if the predicate is true. + + + + + Construct a PredicateConstraint from a predicate + + + + + Determines whether the predicate succeeds when applied + to the actual value. + + + + + Writes the description to a MessageWriter + + + + + NotConstraint negates the effect of some other constraint + + + + + Initializes a new instance of the class. + + The base constraint to be negated. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for if the base constraint fails, false if it succeeds + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a MessageWriter. + + The writer on which the actual value is displayed + + + + AllItemsConstraint applies another constraint to each + item in a collection, succeeding if they all succeed. + + + + + Construct an AllItemsConstraint on top of an existing constraint + + + + + + Apply the item constraint to each item in the collection, + failing if any item fails. + + + + + + + Write a description of this constraint to a MessageWriter + + + + + + SomeItemsConstraint applies another constraint to each + item in a collection, succeeding if any of them succeeds. + + + + + Construct a SomeItemsConstraint on top of an existing constraint + + + + + + Apply the item constraint to each item in the collection, + succeeding if any item succeeds. + + + + + + + Write a description of this constraint to a MessageWriter + + + + + + NoItemConstraint applies another constraint to each + item in a collection, failing if any of them succeeds. + + + + + Construct a SomeItemsConstraint on top of an existing constraint + + + + + + Apply the item constraint to each item in the collection, + failing if any item fails. + + + + + + + Write a description of this constraint to a MessageWriter + + + + + + PropertyExistsConstraint tests that a named property + exists on the object provided through Match. + + Originally, PropertyConstraint provided this feature + in addition to making optional tests on the vaue + of the property. The two constraints are now separate. + + + + + Initializes a new instance of the class. + + The name of the property. + + + + Test whether the property exists for a given object + + The object to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. + + The writer on which the actual value is displayed + + + + Returns the string representation of the constraint. + + + + + + PropertyConstraint extracts a named property and uses + its value as the actual value for a chained constraint. + + + + + Initializes a new instance of the class. + + The name. + The constraint to apply to the property. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + Returns the string representation of the constraint. + + + + + + RangeConstraint tests whethe two values are within a + specified range. + + + + + Initializes a new instance of the class. + + From. + To. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Modifies the constraint to use an IComparer and returns self. + + + + + Modifies the constraint to use an IComparer<T> and returns self. + + + + + Modifies the constraint to use a Comparison<T> and returns self. + + + + + ResolvableConstraintExpression is used to represent a compound + constraint being constructed at a point where the last operator + may either terminate the expression or may have additional + qualifying constraints added to it. + + It is used, for example, for a Property element or for + an Exception element, either of which may be optionally + followed by constraints that apply to the property or + exception. + + + + + Create a new instance of ResolvableConstraintExpression + + + + + Create a new instance of ResolvableConstraintExpression, + passing in a pre-populated ConstraintBuilder. + + + + + Resolve the current expression to a Constraint + + + + + Appends an And Operator to the expression + + + + + Appends an Or operator to the expression. + + + + + ReusableConstraint wraps a resolved constraint so that it + may be saved and reused as needed. + + + + + Construct a ReusableConstraint + + The constraint or expression to be reused + + + + Conversion operator from a normal constraint to a ReusableConstraint. + + The original constraint to be wrapped as a ReusableConstraint + + + + + Returns the string representation of the constraint. + + A string representing the constraint + + + + Resolves the ReusableConstraint by returning the constraint + that it originally wrapped. + + A resolved constraint + + + + SameAsConstraint tests whether an object is identical to + the object passed to its constructor + + + + + Initializes a new instance of the class. + + The expected object. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + BinarySerializableConstraint tests whether + an object is serializable in binary format. + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + Returns the string representation + + + + + BinarySerializableConstraint tests whether + an object is serializable in binary format. + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + Returns the string representation of this constraint + + + + + StringConstraint is the abstract base for constraints + that operate on strings. It supports the IgnoreCase + modifier for string operations. + + + + + The expected value + + + + + Indicates whether tests should be case-insensitive + + + + + Constructs a StringConstraint given an expected value + + The expected value + + + + Modify the constraint to ignore case in matching. + + + + + EmptyStringConstraint tests whether a string is empty. + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + NullEmptyStringConstraint tests whether a string is either null or empty. + + + + + Constructs a new NullOrEmptyStringConstraint + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + SubstringConstraint can test whether a string contains + the expected substring. + + + + + Initializes a new instance of the class. + + The expected. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + StartsWithConstraint can test whether a string starts + with an expected substring. + + + + + Initializes a new instance of the class. + + The expected string + + + + Test whether the constraint is matched by the actual value. + This is a template method, which calls the IsMatch method + of the derived class. + + + + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + EndsWithConstraint can test whether a string ends + with an expected substring. + + + + + Initializes a new instance of the class. + + The expected string + + + + Test whether the constraint is matched by the actual value. + This is a template method, which calls the IsMatch method + of the derived class. + + + + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + RegexConstraint can test whether a string matches + the pattern provided. + + + + + Initializes a new instance of the class. + + The pattern. + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True for success, false for failure + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + ThrowsConstraint is used to test the exception thrown by + a delegate by applying a constraint to it. + + + + + Initializes a new instance of the class, + using a constraint to be applied to the exception. + + A constraint to apply to the caught exception. + + + + Executes the code of the delegate and captures any exception. + If a non-null base constraint was provided, it applies that + constraint to the exception. + + A delegate representing the code to be tested + True if an exception is thrown and the constraint succeeds, otherwise false + + + + Converts an ActualValueDelegate to a TestDelegate + before calling the primary overload. + + + + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + Returns the string representation of this constraint + + + + + Get the actual exception thrown - used by Assert.Throws. + + + + + ThrowsNothingConstraint tests that a delegate does not + throw an exception. + + + + + Test whether the constraint is satisfied by a given value + + The value to be tested + True if no exception is thrown, otherwise false + + + + Converts an ActualValueDelegate to a TestDelegate + before calling the primary overload. + + + + + + + Write the constraint description to a MessageWriter + + The writer on which the description is displayed + + + + Write the actual value for a failing constraint test to a + MessageWriter. The default implementation simply writes + the raw value of actual, leaving it to the writer to + perform any formatting. + + The writer on which the actual value is displayed + + + + Modes in which the tolerance value for a comparison can + be interpreted. + + + + + The tolerance was created with a value, without specifying + how the value would be used. This is used to prevent setting + the mode more than once and is generally changed to Linear + upon execution of the test. + + + + + The tolerance is used as a numeric range within which + two compared values are considered to be equal. + + + + + Interprets the tolerance as the percentage by which + the two compared values my deviate from each other. + + + + + Compares two values based in their distance in + representable numbers. + + + + + The Tolerance class generalizes the notion of a tolerance + within which an equality test succeeds. Normally, it is + used with numeric types, but it can be used with any + type that supports taking a difference between two + objects and comparing that difference to a value. + + + + + Constructs a linear tolerance of a specdified amount + + + + + Constructs a tolerance given an amount and ToleranceMode + + + + + Tests that the current Tolerance is linear with a + numeric value, throwing an exception if it is not. + + + + + Returns an empty Tolerance object, equivalent to + specifying an exact match. + + + + + Gets the ToleranceMode for the current Tolerance + + + + + Gets the value of the current Tolerance instance. + + + + + Returns a new tolerance, using the current amount as a percentage. + + + + + Returns a new tolerance, using the current amount in Ulps. + + + + + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of days. + + + + + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of hours. + + + + + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of minutes. + + + + + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of seconds. + + + + + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of milliseconds. + + + + + Returns a new tolerance with a TimeSpan as the amount, using + the current amount as a number of clock ticks. + + + + + Returns true if the current tolerance is empty. + + + + + TypeConstraint is the abstract base for constraints + that take a Type as their expected value. + + + + + The expected Type used by the constraint + + + + + Construct a TypeConstraint for a given Type + + + + + + Write the actual value for a failing constraint test to a + MessageWriter. TypeConstraints override this method to write + the name of the type. + + The writer on which the actual value is displayed + + + + ExactTypeConstraint is used to test that an object + is of the exact type provided in the constructor + + + + + Construct an ExactTypeConstraint for a given Type + + The expected Type. + + + + Test that an object is of the exact type specified + + The actual value. + True if the tested object is of the exact type provided, otherwise false. + + + + Write the description of this constraint to a MessageWriter + + The MessageWriter to use + + + + InstanceOfTypeConstraint is used to test that an object + is of the same type provided or derived from it. + + + + + Construct an InstanceOfTypeConstraint for the type provided + + The expected Type + + + + Test whether an object is of the specified type or a derived type + + The object to be tested + True if the object is of the provided type or derives from it, otherwise false. + + + + Write a description of this constraint to a MessageWriter + + The MessageWriter to use + + + + AssignableFromConstraint is used to test that an object + can be assigned from a given Type. + + + + + Construct an AssignableFromConstraint for the type provided + + + + + + Test whether an object can be assigned from the specified type + + The object to be tested + True if the object can be assigned a value of the expected Type, otherwise false. + + + + Write a description of this constraint to a MessageWriter + + The MessageWriter to use + + + + AssignableToConstraint is used to test that an object + can be assigned to a given Type. + + + + + Construct an AssignableToConstraint for the type provided + + + + + + Test whether an object can be assigned to the specified type + + The object to be tested + True if the object can be assigned a value of the expected Type, otherwise false. + + + + Write a description of this constraint to a MessageWriter + + The MessageWriter to use + + + + Thrown when an assertion failed. + + + + + The error message that explains + the reason for the exception + + + The error message that explains + the reason for the exception + The exception that caused the + current exception + + + + Serialization Constructor + + + + + Thrown when an assertion failed. + + + + + + + The error message that explains + the reason for the exception + The exception that caused the + current exception + + + + Serialization Constructor + + + + + Thrown when a test executes inconclusively. + + + + + The error message that explains + the reason for the exception + + + The error message that explains + the reason for the exception + The exception that caused the + current exception + + + + Serialization Constructor + + + + + Thrown when an assertion failed. + + + + + + + The error message that explains + the reason for the exception + The exception that caused the + current exception + + + + Serialization Constructor + + + + + Delegate used by tests that execute code and + capture any thrown exception. + + + + + The Assert class contains a collection of static methods that + implement the most common assertions used in NUnit. + + + + + We don't actually want any instances of this object, but some people + like to inherit from it to add other static methods. Hence, the + protected constructor disallows any instances of this object. + + + + + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + + + + + + + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + + + + + + + Helper for Assert.AreEqual(double expected, double actual, ...) + allowing code generation to work consistently. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Throws a with the message and arguments + that are passed in. This allows a test to be cut short, with a result + of success returned to NUnit. + + The message to initialize the with. + Arguments to be used in formatting the message + + + + Throws a with the message and arguments + that are passed in. This allows a test to be cut short, with a result + of success returned to NUnit. + + The message to initialize the with. + + + + Throws a with the message and arguments + that are passed in. This allows a test to be cut short, with a result + of success returned to NUnit. + + + + + Throws an with the message and arguments + that are passed in. This is used by the other Assert functions. + + The message to initialize the with. + Arguments to be used in formatting the message + + + + Throws an with the message that is + passed in. This is used by the other Assert functions. + + The message to initialize the with. + + + + Throws an . + This is used by the other Assert functions. + + + + + Throws an with the message and arguments + that are passed in. This causes the test to be reported as ignored. + + The message to initialize the with. + Arguments to be used in formatting the message + + + + Throws an with the message that is + passed in. This causes the test to be reported as ignored. + + The message to initialize the with. + + + + Throws an . + This causes the test to be reported as ignored. + + + + + Throws an with the message and arguments + that are passed in. This causes the test to be reported as inconclusive. + + The message to initialize the with. + Arguments to be used in formatting the message + + + + Throws an with the message that is + passed in. This causes the test to be reported as inconclusive. + + The message to initialize the with. + + + + Throws an . + This causes the test to be reported as Inconclusive. + + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint expression to be applied + The actual value to test + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint expression to be applied + An ActualValueDelegate returning the value to be tested + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint expression to be applied + An ActualValueDelegate returning the value to be tested + The message that will be displayed on failure + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + An ActualValueDelegate returning the value to be tested + A Constraint expression to be applied + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display if the condition is false + Arguments to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display if the condition is false + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + + + + Asserts that the code represented by a delegate throws an exception + that satisfies the constraint provided. + + A TestDelegate to be executed + A ThrowsConstraint used in the test + + + + Verifies that a delegate throws a particular exception when called. + + A constraint to be satisfied by the exception + A TestSnippet delegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate throws a particular exception when called. + + A constraint to be satisfied by the exception + A TestSnippet delegate + The message that will be displayed on failure + + + + Verifies that a delegate throws a particular exception when called. + + A constraint to be satisfied by the exception + A TestSnippet delegate + + + + Verifies that a delegate throws a particular exception when called. + + The exception Type expected + A TestSnippet delegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate throws a particular exception when called. + + The exception Type expected + A TestSnippet delegate + The message that will be displayed on failure + + + + Verifies that a delegate throws a particular exception when called. + + The exception Type expected + A TestSnippet delegate + + + + Verifies that a delegate throws a particular exception when called. + + Type of the expected exception + A TestSnippet delegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate throws a particular exception when called. + + Type of the expected exception + A TestSnippet delegate + The message that will be displayed on failure + + + + Verifies that a delegate throws a particular exception when called. + + Type of the expected exception + A TestSnippet delegate + + + + Verifies that a delegate throws an exception when called + and returns it. + + A TestDelegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate throws an exception when called + and returns it. + + A TestDelegate + The message that will be displayed on failure + + + + Verifies that a delegate throws an exception when called + and returns it. + + A TestDelegate + + + + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + + The expected Exception Type + A TestDelegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + + The expected Exception Type + A TestDelegate + The message that will be displayed on failure + + + + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + + The expected Exception Type + A TestDelegate + + + + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + + The expected Exception Type + A TestDelegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + + The expected Exception Type + A TestDelegate + The message that will be displayed on failure + + + + Verifies that a delegate throws an exception of a certain Type + or one derived from it when called and returns it. + + The expected Exception Type + A TestDelegate + + + + Verifies that a delegate does not throw an exception + + A TestSnippet delegate + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Verifies that a delegate does not throw an exception. + + A TestSnippet delegate + The message that will be displayed on failure + + + + Verifies that a delegate does not throw an exception. + + A TestSnippet delegate + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display in case of failure + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display in case of failure + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + + + + Asserts that a condition is false. If the condition is true the method throws + an . + + The evaluated condition + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that a condition is false. If the condition is true the method throws + an . + + The evaluated condition + The message to display in case of failure + + + + Asserts that a condition is false. If the condition is true the method throws + an . + + The evaluated condition + + + + Asserts that a condition is false. If the condition is true the method throws + an . + + The evaluated condition + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that a condition is false. If the condition is true the method throws + an . + + The evaluated condition + The message to display in case of failure + + + + Asserts that a condition is false. If the condition is true the method throws + an . + + The evaluated condition + + + + Verifies that the object that is passed in is not equal to null + If the object is null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the object that is passed in is not equal to null + If the object is null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + + + + Verifies that the object that is passed in is not equal to null + If the object is null then an + is thrown. + + The object that is to be tested + + + + Verifies that the object that is passed in is not equal to null + If the object is null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the object that is passed in is not equal to null + If the object is null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + + + + Verifies that the object that is passed in is not equal to null + If the object is null then an + is thrown. + + The object that is to be tested + + + + Verifies that the object that is passed in is equal to null + If the object is not null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the object that is passed in is equal to null + If the object is not null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + + + + Verifies that the object that is passed in is equal to null + If the object is not null then an + is thrown. + + The object that is to be tested + + + + Verifies that the object that is passed in is equal to null + If the object is not null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the object that is passed in is equal to null + If the object is not null then an + is thrown. + + The object that is to be tested + The message to display in case of failure + + + + Verifies that the object that is passed in is equal to null + If the object is not null then an + is thrown. + + The object that is to be tested + + + + Verifies that the double that is passed in is an NaN value. + If the object is not NaN then an + is thrown. + + The value that is to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the double that is passed in is an NaN value. + If the object is not NaN then an + is thrown. + + The value that is to be tested + The message to display in case of failure + + + + Verifies that the double that is passed in is an NaN value. + If the object is not NaN then an + is thrown. + + The value that is to be tested + + + + Verifies that the double that is passed in is an NaN value. + If the object is not NaN then an + is thrown. + + The value that is to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the double that is passed in is an NaN value. + If the object is not NaN then an + is thrown. + + The value that is to be tested + The message to display in case of failure + + + + Verifies that the double that is passed in is an NaN value. + If the object is not NaN then an + is thrown. + + The value that is to be tested + + + + Assert that a string is empty - that is equal to string.Empty + + The string to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Assert that a string is empty - that is equal to string.Empty + + The string to be tested + The message to display in case of failure + + + + Assert that a string is empty - that is equal to string.Empty + + The string to be tested + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing ICollection + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing ICollection + The message to display in case of failure + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing ICollection + + + + Assert that a string is not empty - that is not equal to string.Empty + + The string to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Assert that a string is not empty - that is not equal to string.Empty + + The string to be tested + The message to display in case of failure + + + + Assert that a string is not empty - that is not equal to string.Empty + + The string to be tested + + + + Assert that an array, list or other collection is not empty + + An array, list or other collection implementing ICollection + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Assert that an array, list or other collection is not empty + + An array, list or other collection implementing ICollection + The message to display in case of failure + + + + Assert that an array, list or other collection is not empty + + An array, list or other collection implementing ICollection + + + + Assert that a string is either null or equal to string.Empty + + The string to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Assert that a string is either null or equal to string.Empty + + The string to be tested + The message to display in case of failure + + + + Assert that a string is either null or equal to string.Empty + + The string to be tested + + + + Assert that a string is not null or empty + + The string to be tested + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Assert that a string is not null or empty + + The string to be tested + The message to display in case of failure + + + + Assert that a string is not null or empty + + The string to be tested + + + + Asserts that an object may be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object may be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + + + + Asserts that an object may be assigned a value of a given Type. + + The expected Type. + The object under examination + + + + Asserts that an object may be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object may be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + + + + Asserts that an object may be assigned a value of a given Type. + + The expected Type. + The object under examination + + + + Asserts that an object may not be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object may not be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + + + + Asserts that an object may not be assigned a value of a given Type. + + The expected Type. + The object under examination + + + + Asserts that an object may not be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object may not be assigned a value of a given Type. + + The expected Type. + The object under examination + The message to display in case of failure + + + + Asserts that an object may not be assigned a value of a given Type. + + The expected Type. + The object under examination + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + + + + Asserts that an object is an instance of a given type. + + The expected Type + The object being examined + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + The message to display in case of failure + + + + Asserts that an object is not an instance of a given type. + + The expected Type + The object being examined + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are equal. If they are not, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an is + thrown. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an is + thrown. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + The message to display in case of failure + + + + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an is + thrown. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + + + + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an is + thrown. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an is + thrown. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + The message to display in case of failure + + + + Verifies that two doubles are equal considering a delta. If the + expected value is infinity then the delta value is ignored. If + they are not equal then an is + thrown. + + The expected value + The actual value + The maximum acceptable difference between the + the expected and the actual + + + + Verifies that two objects are equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are not equal an is thrown. + + The value that is expected + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two objects are equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are not equal an is thrown. + + The value that is expected + The actual value + The message to display in case of failure + + + + Verifies that two objects are equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are not equal an is thrown. + + The value that is expected + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + The message to display in case of failure + + + + Verifies that two values are not equal. If they are equal, then an + is thrown. + + The expected value + The actual value + + + + Verifies that two objects are not equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are equal an is thrown. + + The value that is expected + The actual value + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that two objects are not equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are equal an is thrown. + + The value that is expected + The actual value + The message to display in case of failure + + + + Verifies that two objects are not equal. Two objects are considered + equal if both are null, or if both have the same value. NUnit + has special semantics for some object types. + If they are equal an is thrown. + + The value that is expected + The actual value + + + + Asserts that two objects refer to the same object. If they + are not the same an is thrown. + + The expected object + The actual object + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that two objects refer to the same object. If they + are not the same an is thrown. + + The expected object + The actual object + The message to display in case of failure + + + + Asserts that two objects refer to the same object. If they + are not the same an is thrown. + + The expected object + The actual object + + + + Asserts that two objects do not refer to the same object. If they + are the same an is thrown. + + The expected object + The actual object + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that two objects do not refer to the same object. If they + are the same an is thrown. + + The expected object + The actual object + The message to display in case of failure + + + + Asserts that two objects do not refer to the same object. If they + are the same an is thrown. + + The expected object + The actual object + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than the second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + The message to display in case of failure + + + + Verifies that the first value is greater than or equal tothe second + value. If it is not, then an + is thrown. + + The first value, expected to be greater + The second value, expected to be less + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + The message to display in case of failure + + + + Verifies that the first value is less than or equal to the second + value. If it is not, then an + is thrown. + + The first value, expected to be less + The second value, expected to be greater + + + + Asserts that an object is contained in a list. + + The expected object + The list to be examined + The message to display in case of failure + Array of objects to be used in formatting the message + + + + Asserts that an object is contained in a list. + + The expected object + The list to be examined + The message to display in case of failure + + + + Asserts that an object is contained in a list. + + The expected object + The list to be examined + + + + Gets the number of assertions executed so far and + resets the counter to zero. + + + + + AssertionHelper is an optional base class for user tests, + allowing the use of shorter names for constraints and + asserts and avoiding conflict with the definition of + , from which it inherits much of its + behavior, in certain mock object frameworks. + + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. Works + identically to + + A Constraint to be applied + The actual value to test + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. Works + identically to + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. Works + identically to + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint expression to be applied + An ActualValueDelegate returning the value to be tested + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint expression to be applied + An ActualValueDelegate returning the value to be tested + The message that will be displayed on failure + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + An ActualValueDelegate returning the value to be tested + A Constraint expression to be applied + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an assertion exception on failure. + + A Constraint to be applied + The actual value to test + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . Works Identically to + . + + The evaluated condition + The message to display if the condition is false + Arguments to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . Works Identically to + . + + The evaluated condition + The message to display if the condition is false + + + + Asserts that a condition is true. If the condition is false the method throws + an . Works Identically to . + + The evaluated condition + + + + Asserts that the code represented by a delegate throws an exception + that satisfies the constraint provided. + + A TestDelegate to be executed + A ThrowsConstraint used in the test + + + + Returns a ListMapper based on a collection. + + The original collection + + + + + Provides static methods to express the assumptions + that must be met for a test to give a meaningful + result. If an assumption is not met, the test + should produce an inconclusive result. + + + + + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + + + + + + + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + + + + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + The actual value to test + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + The actual value to test + The message that will be displayed on failure + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + The actual value to test + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + An ActualValueDelegate returning the value to be tested + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + An ActualValueDelegate returning the value to be tested + The message that will be displayed on failure + + + + Apply a constraint to an actual value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + An ActualValueDelegate returning the value to be tested + A Constraint expression to be applied + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + The actual value to test + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + The actual value to test + The message that will be displayed on failure + + + + Apply a constraint to a referenced value, succeeding if the constraint + is satisfied and throwing an InconclusiveException on failure. + + A Constraint expression to be applied + The actual value to test + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display if the condition is false + Arguments to be used in formatting the message + + + + Asserts that a condition is true. If the condition is false the method throws + an . + + The evaluated condition + The message to display if the condition is false + + + + Asserts that a condition is true. If the condition is false the + method throws an . + + The evaluated condition + + + + Asserts that the code represented by a delegate throws an exception + that satisfies the constraint provided. + + A TestDelegate to be executed + A ThrowsConstraint used in the test + + + + A set of Assert methods operationg on one or more collections + + + + + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + + + + + + + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + + + + + + + Asserts that all items contained in collection are of the type specified by expectedType. + + IEnumerable containing objects to be considered + System.Type that all objects in collection must be instances of + + + + Asserts that all items contained in collection are of the type specified by expectedType. + + IEnumerable containing objects to be considered + System.Type that all objects in collection must be instances of + The message that will be displayed on failure + + + + Asserts that all items contained in collection are of the type specified by expectedType. + + IEnumerable containing objects to be considered + System.Type that all objects in collection must be instances of + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that all items contained in collection are not equal to null. + + IEnumerable containing objects to be considered + + + + Asserts that all items contained in collection are not equal to null. + + IEnumerable containing objects to be considered + The message that will be displayed on failure + + + + Asserts that all items contained in collection are not equal to null. + + IEnumerable of objects to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Ensures that every object contained in collection exists within the collection + once and only once. + + IEnumerable of objects to be considered + + + + Ensures that every object contained in collection exists within the collection + once and only once. + + IEnumerable of objects to be considered + The message that will be displayed on failure + + + + Ensures that every object contained in collection exists within the collection + once and only once. + + IEnumerable of objects to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + + + + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + If comparer is not null then it will be used to compare the objects. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The IComparer to use in comparing objects from each IEnumerable + + + + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + + + + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + If comparer is not null then it will be used to compare the objects. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The IComparer to use in comparing objects from each IEnumerable + The message that will be displayed on failure + + + + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that expected and actual are exactly equal. The collections must have the same count, + and contain the exact same objects in the same order. + If comparer is not null then it will be used to compare the objects. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The IComparer to use in comparing objects from each IEnumerable + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + + + + Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + + + + Asserts that expected and actual are equivalent, containing the same objects but the match may be in any order. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that expected and actual are not exactly equal. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + + + + Asserts that expected and actual are not exactly equal. + If comparer is not null then it will be used to compare the objects. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The IComparer to use in comparing objects from each IEnumerable + + + + Asserts that expected and actual are not exactly equal. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + + + + Asserts that expected and actual are not exactly equal. + If comparer is not null then it will be used to compare the objects. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The IComparer to use in comparing objects from each IEnumerable + The message that will be displayed on failure + + + + Asserts that expected and actual are not exactly equal. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that expected and actual are not exactly equal. + If comparer is not null then it will be used to compare the objects. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The IComparer to use in comparing objects from each IEnumerable + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that expected and actual are not equivalent. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + + + + Asserts that expected and actual are not equivalent. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + + + + Asserts that expected and actual are not equivalent. + + The first IEnumerable of objects to be considered + The second IEnumerable of objects to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that collection contains actual as an item. + + IEnumerable of objects to be considered + Object to be found within collection + + + + Asserts that collection contains actual as an item. + + IEnumerable of objects to be considered + Object to be found within collection + The message that will be displayed on failure + + + + Asserts that collection contains actual as an item. + + IEnumerable of objects to be considered + Object to be found within collection + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that collection does not contain actual as an item. + + IEnumerable of objects to be considered + Object that cannot exist within collection + + + + Asserts that collection does not contain actual as an item. + + IEnumerable of objects to be considered + Object that cannot exist within collection + The message that will be displayed on failure + + + + Asserts that collection does not contain actual as an item. + + IEnumerable of objects to be considered + Object that cannot exist within collection + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that superset is not a subject of subset. + + The IEnumerable superset to be considered + The IEnumerable subset to be considered + + + + Asserts that superset is not a subject of subset. + + The IEnumerable superset to be considered + The IEnumerable subset to be considered + The message that will be displayed on failure + + + + Asserts that superset is not a subject of subset. + + The IEnumerable superset to be considered + The IEnumerable subset to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Asserts that superset is a subset of subset. + + The IEnumerable superset to be considered + The IEnumerable subset to be considered + + + + Asserts that superset is a subset of subset. + + The IEnumerable superset to be considered + The IEnumerable subset to be considered + The message that will be displayed on failure + + + + Asserts that superset is a subset of subset. + + The IEnumerable superset to be considered + The IEnumerable subset to be considered + The message that will be displayed on failure + Arguments to be used in formatting the message + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing IEnumerable + The message to be displayed on failure + Arguments to be used in formatting the message + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing IEnumerable + The message to be displayed on failure + + + + Assert that an array,list or other collection is empty + + An array, list or other collection implementing IEnumerable + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing IEnumerable + The message to be displayed on failure + Arguments to be used in formatting the message + + + + Assert that an array, list or other collection is empty + + An array, list or other collection implementing IEnumerable + The message to be displayed on failure + + + + Assert that an array,list or other collection is empty + + An array, list or other collection implementing IEnumerable + + + + Assert that an array, list or other collection is ordered + + An array, list or other collection implementing IEnumerable + The message to be displayed on failure + Arguments to be used in formatting the message + + + + Assert that an array, list or other collection is ordered + + An array, list or other collection implementing IEnumerable + The message to be displayed on failure + + + + Assert that an array, list or other collection is ordered + + An array, list or other collection implementing IEnumerable + + + + Assert that an array, list or other collection is ordered + + An array, list or other collection implementing IEnumerable + A custom comparer to perform the comparisons + The message to be displayed on failure + Arguments to be used in formatting the message + + + + Assert that an array, list or other collection is ordered + + An array, list or other collection implementing IEnumerable + A custom comparer to perform the comparisons + The message to be displayed on failure + + + + Assert that an array, list or other collection is ordered + + An array, list or other collection implementing IEnumerable + A custom comparer to perform the comparisons + + + + Static helper class used in the constraint-based syntax + + + + + Creates a new SubstringConstraint + + The value of the substring + A SubstringConstraint + + + + Creates a new CollectionContainsConstraint. + + The item that should be found. + A new CollectionContainsConstraint + + + + Summary description for DirectoryAssert + + + + + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + + + + + + + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + + + + + + + We don't actually want any instances of this object, but some people + like to inherit from it to add other static methods. Hence, the + protected constructor disallows any instances of this object. + + + + + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A directory containing the value that is expected + A directory containing the actual value + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A directory containing the value that is expected + A directory containing the actual value + The message to display if directories are not equal + + + + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A directory containing the value that is expected + A directory containing the actual value + + + + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A directory path string containing the value that is expected + A directory path string containing the actual value + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A directory path string containing the value that is expected + A directory path string containing the actual value + The message to display if directories are not equal + + + + Verifies that two directories are equal. Two directories are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A directory path string containing the value that is expected + A directory path string containing the actual value + + + + Asserts that two directories are not equal. If they are equal + an is thrown. + + A directory containing the value that is expected + A directory containing the actual value + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Asserts that two directories are not equal. If they are equal + an is thrown. + + A directory containing the value that is expected + A directory containing the actual value + The message to display if directories are not equal + + + + Asserts that two directories are not equal. If they are equal + an is thrown. + + A directory containing the value that is expected + A directory containing the actual value + + + + Asserts that two directories are not equal. If they are equal + an is thrown. + + A directory path string containing the value that is expected + A directory path string containing the actual value + The message to display if directories are equal + Arguments to be used in formatting the message + + + + Asserts that two directories are not equal. If they are equal + an is thrown. + + A directory path string containing the value that is expected + A directory path string containing the actual value + The message to display if directories are equal + + + + Asserts that two directories are not equal. If they are equal + an is thrown. + + A directory path string containing the value that is expected + A directory path string containing the actual value + + + + Asserts that the directory is empty. If it is not empty + an is thrown. + + A directory to search + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Asserts that the directory is empty. If it is not empty + an is thrown. + + A directory to search + The message to display if directories are not equal + + + + Asserts that the directory is empty. If it is not empty + an is thrown. + + A directory to search + + + + Asserts that the directory is empty. If it is not empty + an is thrown. + + A directory to search + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Asserts that the directory is empty. If it is not empty + an is thrown. + + A directory to search + The message to display if directories are not equal + + + + Asserts that the directory is empty. If it is not empty + an is thrown. + + A directory to search + + + + Asserts that the directory is not empty. If it is empty + an is thrown. + + A directory to search + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Asserts that the directory is not empty. If it is empty + an is thrown. + + A directory to search + The message to display if directories are not equal + + + + Asserts that the directory is not empty. If it is empty + an is thrown. + + A directory to search + + + + Asserts that the directory is not empty. If it is empty + an is thrown. + + A directory to search + The message to display if directories are not equal + Arguments to be used in formatting the message + + + + Asserts that the directory is not empty. If it is empty + an is thrown. + + A directory to search + The message to display if directories are not equal + + + + Asserts that the directory is not empty. If it is empty + an is thrown. + + A directory to search + + + + Asserts that path contains actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + Arguments to be used in formatting the message + + + + Asserts that path contains actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + + + + Asserts that path contains actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + + + + Asserts that path contains actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + Arguments to be used in formatting the message + + + + Asserts that path contains actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + + + + Asserts that path contains actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + + + + Asserts that path does not contain actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + Arguments to be used in formatting the message + + + + Asserts that path does not contain actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + + + + Asserts that path does not contain actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + + + + Asserts that path does not contain actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + Arguments to be used in formatting the message + + + + Asserts that path does not contain actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + The message to display if directory is not within the path + + + + Asserts that path does not contain actual as a subdirectory or + an is thrown. + + A directory to search + sub-directory asserted to exist under directory + + + + Summary description for FileAssert. + + + + + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + + + + + + + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + + + + + + + We don't actually want any instances of this object, but some people + like to inherit from it to add other static methods. Hence, the + protected constructor disallows any instances of this object. + + + + + Verifies that two Streams are equal. Two Streams are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + The expected Stream + The actual Stream + The message to display if Streams are not equal + Arguments to be used in formatting the message + + + + Verifies that two Streams are equal. Two Streams are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + The expected Stream + The actual Stream + The message to display if objects are not equal + + + + Verifies that two Streams are equal. Two Streams are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + The expected Stream + The actual Stream + + + + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A file containing the value that is expected + A file containing the actual value + The message to display if Streams are not equal + Arguments to be used in formatting the message + + + + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A file containing the value that is expected + A file containing the actual value + The message to display if objects are not equal + + + + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + A file containing the value that is expected + A file containing the actual value + + + + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + The path to a file containing the value that is expected + The path to a file containing the actual value + The message to display if Streams are not equal + Arguments to be used in formatting the message + + + + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + The path to a file containing the value that is expected + The path to a file containing the actual value + The message to display if objects are not equal + + + + Verifies that two files are equal. Two files are considered + equal if both are null, or if both have the same value byte for byte. + If they are not equal an is thrown. + + The path to a file containing the value that is expected + The path to a file containing the actual value + + + + Asserts that two Streams are not equal. If they are equal + an is thrown. + + The expected Stream + The actual Stream + The message to be displayed when the two Stream are the same. + Arguments to be used in formatting the message + + + + Asserts that two Streams are not equal. If they are equal + an is thrown. + + The expected Stream + The actual Stream + The message to be displayed when the Streams are the same. + + + + Asserts that two Streams are not equal. If they are equal + an is thrown. + + The expected Stream + The actual Stream + + + + Asserts that two files are not equal. If they are equal + an is thrown. + + A file containing the value that is expected + A file containing the actual value + The message to display if Streams are not equal + Arguments to be used in formatting the message + + + + Asserts that two files are not equal. If they are equal + an is thrown. + + A file containing the value that is expected + A file containing the actual value + The message to display if objects are not equal + + + + Asserts that two files are not equal. If they are equal + an is thrown. + + A file containing the value that is expected + A file containing the actual value + + + + Asserts that two files are not equal. If they are equal + an is thrown. + + The path to a file containing the value that is expected + The path to a file containing the actual value + The message to display if Streams are not equal + Arguments to be used in formatting the message + + + + Asserts that two files are not equal. If they are equal + an is thrown. + + The path to a file containing the value that is expected + The path to a file containing the actual value + The message to display if objects are not equal + + + + Asserts that two files are not equal. If they are equal + an is thrown. + + The path to a file containing the value that is expected + The path to a file containing the actual value + + + + GlobalSettings is a place for setting default values used + by the framework in performing asserts. + + + + + Default tolerance for floating point equality + + + + + Helper class with properties and methods that supply + a number of constraints used in Asserts. + + + + + Returns a new PropertyConstraintExpression, which will either + test for the existence of the named property on the object + being tested or apply any following constraint to that property. + + + + + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + + + + + Returns a new AttributeConstraint checking for the + presence of a particular attribute on an object. + + + + + Returns a new CollectionContainsConstraint checking for the + presence of a particular object in the collection. + + + + + Returns a ConstraintExpression that negates any + following constraint. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if at least one of them succeeds. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them fail. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Length property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Count property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the Message property of the object being tested. + + + + + Returns a new ConstraintExpression, which will apply the following + constraint to the InnerException property of the object being tested. + + + + + Interface implemented by a user fixture in order to + validate any expected exceptions. It is only called + for test methods marked with the ExpectedException + attribute. + + + + + Method to handle an expected exception + + The exception to be handled + + + + Helper class with properties and methods that supply + a number of constraints used in Asserts. + + + + + Returns a constraint that tests two items for equality + + + + + Returns a constraint that tests that two references are the same object + + + + + Returns a constraint that tests whether the + actual value is greater than the suppled argument + + + + + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is greater than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + + + + + Returns a constraint that tests whether the + actual value is less than or equal to the suppled argument + + + + + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + + + + + Returns a constraint that tests whether the actual + value is of the exact type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is of the type supplied as an argument or a derived type. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is assignable from the type supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is a collection containing the same elements as the + collection supplied as an argument. + + + + + Returns a constraint that tests whether the actual value + is a subset of the collection supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + + + + + Returns a constraint that tests whether the path provided + is the same as an expected path after canonicalization. + + + + + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + + + + + Returns a constraint that tests whether the path provided + is the same path or under an expected path after canonicalization. + + + + + Returns a constraint that tests whether the actual value falls + within a specified range. + + + + + Returns a ConstraintExpression that negates any + following constraint. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + + + + + Returns a constraint that tests for null + + + + + Returns a constraint that tests for True + + + + + Returns a constraint that tests for False + + + + + Returns a constraint that tests for NaN + + + + + Returns a constraint that tests for empty + + + + + Returns a constraint that tests whether a collection + contains all unique items. + + + + + Returns a constraint that tests whether an object graph is serializable in binary format. + + + + + Returns a constraint that tests whether an object graph is serializable in xml format. + + + + + Returns a constraint that tests whether a collection is ordered + + + + + The Iz class is a synonym for Is intended for use in VB, + which regards Is as a keyword. + + + + + The List class is a helper class with properties and methods + that supply a number of constraints used with lists and collections. + + + + + List.Map returns a ListMapper, which can be used to map + the original collection to another collection. + + + + + + + ListMapper is used to transform a collection used as an actual argument + producing another collection to be used in the assertion. + + + + + Construct a ListMapper based on a collection + + The collection to be transformed + + + + Produces a collection containing all the values of a property + + The collection of property values + + + + + Randomizer returns a set of random values in a repeatable + way, to allow re-running of tests if necessary. + + + + + Get a randomizer for a particular member, returning + one that has already been created if it exists. + This ensures that the same values are generated + each time the tests are reloaded. + + + + + Get a randomizer for a particular parameter, returning + one that has already been created if it exists. + This ensures that the same values are generated + each time the tests are reloaded. + + + + + Construct a randomizer using a random seed + + + + + Construct a randomizer using a specified seed + + + + + Return an array of random doubles between 0.0 and 1.0. + + + + + + + Return an array of random doubles with values in a specified range. + + + + + Return an array of random ints with values in a specified range. + + + + + Get a random seed for use in creating a randomizer. + + + + + The SpecialValue enum is used to represent TestCase arguments + that cannot be used as arguments to an Attribute. + + + + + Null represents a null value, which cannot be used as an + argument to an attriute under .NET 1.x + + + + + Basic Asserts on strings. + + + + + The Equals method throws an AssertionException. This is done + to make sure there is no mistake by calling this function. + + + + + + + override the default ReferenceEquals to throw an AssertionException. This + implementation makes sure there is no mistake in calling this function + as part of Assert. + + + + + + + Asserts that a string is found within another string. + + The expected string + The string to be examined + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string is found within another string. + + The expected string + The string to be examined + The message to display in case of failure + + + + Asserts that a string is found within another string. + + The expected string + The string to be examined + + + + Asserts that a string is not found within another string. + + The expected string + The string to be examined + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string is found within another string. + + The expected string + The string to be examined + The message to display in case of failure + + + + Asserts that a string is found within another string. + + The expected string + The string to be examined + + + + Asserts that a string starts with another string. + + The expected string + The string to be examined + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string starts with another string. + + The expected string + The string to be examined + The message to display in case of failure + + + + Asserts that a string starts with another string. + + The expected string + The string to be examined + + + + Asserts that a string does not start with another string. + + The expected string + The string to be examined + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string does not start with another string. + + The expected string + The string to be examined + The message to display in case of failure + + + + Asserts that a string does not start with another string. + + The expected string + The string to be examined + + + + Asserts that a string ends with another string. + + The expected string + The string to be examined + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string ends with another string. + + The expected string + The string to be examined + The message to display in case of failure + + + + Asserts that a string ends with another string. + + The expected string + The string to be examined + + + + Asserts that a string does not end with another string. + + The expected string + The string to be examined + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string does not end with another string. + + The expected string + The string to be examined + The message to display in case of failure + + + + Asserts that a string does not end with another string. + + The expected string + The string to be examined + + + + Asserts that two strings are equal, without regard to case. + + The expected string + The actual string + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that two strings are equal, without regard to case. + + The expected string + The actual string + The message to display in case of failure + + + + Asserts that two strings are equal, without regard to case. + + The expected string + The actual string + + + + Asserts that two strings are not equal, without regard to case. + + The expected string + The actual string + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that two strings are Notequal, without regard to case. + + The expected string + The actual string + The message to display in case of failure + + + + Asserts that two strings are not equal, without regard to case. + + The expected string + The actual string + + + + Asserts that a string matches an expected regular expression pattern. + + The regex pattern to be matched + The actual string + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string matches an expected regular expression pattern. + + The regex pattern to be matched + The actual string + The message to display in case of failure + + + + Asserts that a string matches an expected regular expression pattern. + + The regex pattern to be matched + The actual string + + + + Asserts that a string does not match an expected regular expression pattern. + + The regex pattern to be used + The actual string + The message to display in case of failure + Arguments used in formatting the message + + + + Asserts that a string does not match an expected regular expression pattern. + + The regex pattern to be used + The actual string + The message to display in case of failure + + + + Asserts that a string does not match an expected regular expression pattern. + + The regex pattern to be used + The actual string + + + + The TestCaseData class represents a set of arguments + and other parameter info to be used for a parameterized + test case. It provides a number of instance modifiers + for use in initializing the test case. + + Note: Instance modifiers are getters that return + the same instance after modifying it's state. + + + + + The argument list to be provided to the test + + + + + The expected result to be returned + + + + + The expected exception Type + + + + + The FullName of the expected exception + + + + + The name to be used for the test + + + + + The description of the test + + + + + A dictionary of properties, used to add information + to tests without requiring the class to change. + + + + + If true, indicates that the test case is to be ignored + + + + + The reason for ignoring a test case + + + + + Initializes a new instance of the class. + + The arguments. + + + + Initializes a new instance of the class. + + The argument. + + + + Initializes a new instance of the class. + + The first argument. + The second argument. + + + + Initializes a new instance of the class. + + The first argument. + The second argument. + The third argument. + + + + Sets the expected result for the test + + The expected result + A modified TestCaseData + + + + Sets the expected exception type for the test + + Type of the expected exception. + The modified TestCaseData instance + + + + Sets the expected exception type for the test + + FullName of the expected exception. + The modified TestCaseData instance + + + + Sets the name of the test case + + The modified TestCaseData instance + + + + Sets the description for the test case + being constructed. + + The description. + The modified TestCaseData instance. + + + + Applies a category to the test + + + + + + + Applies a named property to the test + + + + + + + + Applies a named property to the test + + + + + + + + Applies a named property to the test + + + + + + + + Ignores this TestCase. + + + + + + Ignores this TestCase, specifying the reason. + + The reason. + + + + + Gets the argument list to be provided to the test + + + + + Gets the expected result + + + + + Gets the expected exception Type + + + + + Gets the FullName of the expected exception + + + + + Gets the name to be used for the test + + + + + Gets the description of the test + + + + + Gets a value indicating whether this is ignored. + + true if ignored; otherwise, false. + + + + Gets the ignore reason. + + The ignore reason. + + + + Gets a list of categories associated with this test. + + + + + Gets the property dictionary for this test + + + + + Provide the context information of the current test + + + + + Constructs a TestContext using the provided context dictionary + + A context dictionary + + + + Get the current test context. This is created + as needed. The user may save the context for + use within a test, but it should not be used + outside the test for which it is created. + + + + + Gets a TestAdapter representing the currently executing test in this context. + + + + + Gets a ResultAdapter representing the current result for the test + executing in this context. + + + + + Gets the current directory for this TestContext + + + + + TestAdapter adapts a Test for consumption by + the user test code. + + + + + Constructs a TestAdapter for this context + + The context dictionary + + + + The name of the test. + + + + + The FullName of the test + + + + + The properties of the test. + + + + + ResultAdapter adapts a TestResult for consumption by + the user test code. + + + + + Construct a ResultAdapter for a context + + The context holding the result + + + + The TestState of current test. This maps to the ResultState + used in nunit.core and is subject to change in the future. + + + + + The TestStatus of current test. This enum will be used + in future versions of NUnit and so is to be preferred + to the TestState value. + + + + + The ResultState enum indicates the result of running a test + + + + + The result is inconclusive + + + + + The test was not runnable. + + + + + The test has been skipped. + + + + + The test has been ignored. + + + + + The test succeeded + + + + + The test failed + + + + + The test encountered an unexpected exception + + + + + The test was cancelled by the user + + + + + The TestStatus enum indicates the result of running a test + + + + + The test was inconclusive + + + + + The test has skipped + + + + + The test succeeded + + + + + The test failed + + + + + Helper class with static methods used to supply constraints + that operate on strings. + + + + + Returns a constraint that succeeds if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that fails if the actual + value contains the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that fails if the actual + value starts with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that fails if the actual + value ends with the substring supplied as an argument. + + + + + Returns a constraint that succeeds if the actual + value matches the Regex pattern supplied as an argument. + + + + + Returns a constraint that fails if the actual + value matches the pattern supplied as an argument. + + + + + Returns a ConstraintExpression, which will apply + the following constraint to all members of a collection, + succeeding if all of them succeed. + + + + + TextMessageWriter writes constraint descriptions and messages + in displayable form as a text stream. It tailors the display + of individual message components to form the standard message + format of NUnit assertion failure messages. + + + + + Prefix used for the expected value line of a message + + + + + Prefix used for the actual value line of a message + + + + + Length of a message prefix + + + + + Construct a TextMessageWriter + + + + + Construct a TextMessageWriter, specifying a user message + and optional formatting arguments. + + + + + + + Method to write single line message with optional args, usually + written to precede the general failure message, at a givel + indentation level. + + The indentation level of the message + The message to be written + Any arguments used in formatting the message + + + + Display Expected and Actual lines for a constraint. This + is called by MessageWriter's default implementation of + WriteMessageTo and provides the generic two-line display. + + The constraint that failed + + + + Display Expected and Actual lines for given values. This + method may be called by constraints that need more control over + the display of actual and expected values than is provided + by the default implementation. + + The expected value + The actual value causing the failure + + + + Display Expected and Actual lines for given values, including + a tolerance value on the expected line. + + The expected value + The actual value causing the failure + The tolerance within which the test was made + + + + Display the expected and actual string values on separate lines. + If the mismatch parameter is >=0, an additional line is displayed + line containing a caret that points to the mismatch point. + + The expected string value + The actual string value + The point at which the strings don't match or -1 + If true, case is ignored in string comparisons + If true, clip the strings to fit the max line length + + + + Writes the text for a connector. + + The connector. + + + + Writes the text for a predicate. + + The predicate. + + + + Write the text for a modifier. + + The modifier. + + + + Writes the text for an expected value. + + The expected value. + + + + Writes the text for an actual value. + + The actual value. + + + + Writes the text for a generalized value. + + The value. + + + + Writes the text for a collection value, + starting at a particular point, to a max length + + The collection containing elements to write. + The starting point of the elements to write + The maximum number of elements to write + + + + Write the generic 'Expected' line for a constraint + + The constraint that failed + + + + Write the generic 'Expected' line for a given value + + The expected value + + + + Write the generic 'Expected' line for a given value + and tolerance. + + The expected value + The tolerance within which the test was made + + + + Write the generic 'Actual' line for a constraint + + The constraint for which the actual value is to be written + + + + Write the generic 'Actual' line for a given value + + The actual value causing a failure + + + + Gets or sets the maximum line length for this writer + + + + + Helper class with properties and methods that supply + constraints that operate on exceptions. + + + + + Creates a constraint specifying the exact type of exception expected + + + + + Creates a constraint specifying the exact type of exception expected + + + + + Creates a constraint specifying the type of exception expected + + + + + Creates a constraint specifying the type of exception expected + + + + + Creates a constraint specifying an expected exception + + + + + Creates a constraint specifying an exception with a given InnerException + + + + + Creates a constraint specifying an expected TargetInvocationException + + + + + Creates a constraint specifying an expected TargetInvocationException + + + + + Creates a constraint specifying an expected TargetInvocationException + + + + + Creates a constraint specifying that no exception is thrown + + + + -- 2.23.3