前天把以前同事介绍的敏捷开发的书看完了,决定开始单元测试驱动开发TDD
2014-03-26 19:08
330 查看
ios开发的单元测试简单一些
unity的没用过,今天搜索了下,发现居然有官方工具,更新到1.22版
决定使用官方的
地址是:unit test tool
用法和注意事项
两种单元测试:
A.NUnit,官网:http://www.nunit.org:
发现一篇好文章http://confach.cnblogs.com/archive/2005/06/20/177817.aspx将NUnit的
测试静态类的(未继承MONOBehavior)
跟ios开发的xctest差不多,用attritube:[Test]表明下面的方法是个测试,命名空间是Nunit.frameword
Assert.~~~~断言~~,巴拉巴拉的什么表明测试通过没有
Assert.Pass ();
ssert.Fail ();
还有什么比较之类的方法
AreEqual相等
AreNotEual不相等
Greater大于
Less小于
IsNotNull不为空
.等等等还有好多不明白干什么的断言方法,具体列表在下面的源文件里面,请自行浏览猜测用途
第二种是Integration Test
就是可以在运行时做的单元测试
具体流程是
1.打开窗口
2.建立测试
3.设置是否断言组件(Assertions组件)通过就pass(通过任意一个之后貌似就会认为是成功了,而不是timeOut或者继续其他断言判断,也就是说后面如果有失败的就不继续测了,建议关闭)
4.设置超时时间,超过之后视为通过
5.在子物体中添加测试物体添加脚本(Assertion默认有:float,bool,vector2,3,4,renderer等判断)
6.添加断言脚本或自己写测试脚本
PS:默认的几个断言类型如果觉得不够,自己写,继承泛型类ComparerBaseGeneric<T1,T2>,重写Compare方法即可,ComparerBaseGeneric<T>则是需要一个参数的版本
当自己写单元测试脚本,
通过或失败时执行IntegrationTest.Pass (gameObject);或IntegrationTest.Fail (gameObject);即可,这个脚本需要继承Monobehavior,挂载到物体上
用上了单元测试驱动开发,顿时感觉自己对代码的信心加强了不少啊
using NUnit.Framework.Constraints;
using System;
using System.Collections;
using System.ComponentModel;
namespace NUnit.Framework
{
public class Assert
{
//
// Static Properties
//
public static int Counter
{
get
{
int result = Assert.counter;
Assert.counter = 0;
return result;
}
}
//
// Constructors
//
protected Assert ()
{
}
//
// Static Methods
//
[CLSCompliant (false)]
public static void AreEqual (uint expected, uint actual)
{
Assert.That (actual, Is.EqualTo (expected), null, null);
}
[CLSCompliant (false)]
public static void AreEqual (uint expected, uint actual, string message)
{
Assert.That (actual, Is.EqualTo (expected), message, null);
}
[CLSCompliant (false)]
public static void AreEqual (uint expected, uint actual, string message, params object[] args)
{
Assert.That (actual, Is.EqualTo (expected), message, args);
}
[CLSCompliant (false)]
public static void AreEqual (ulong expected, ulong actual)
{
Assert.That (actual, Is.EqualTo (expected), null, null);
}
[CLSCompliant (false)]
public static void AreEqual (ulong expected, ulong actual, string message)
{
Assert.That (actual, Is.EqualTo (expected), message, null);
}
[CLSCompliant (false)]
public static void AreEqual (ulong expected, ulong actual, string message, params object[] args)
{
Assert.That (actual, Is.EqualTo (expected), message, args);
}
public static void AreEqual (int expected, int actual)
{
Assert.That (actual, Is.EqualTo (expected), null, null);
}
public static void AreEqual (int expected, int actual, string message)
{
Assert.That (actual, Is.EqualTo (expected), message, null);
}
public static void AreEqual (int expected, int actual, string message, params object[] args)
{
Assert.That (actual, Is.EqualTo (expected), message, args);
}
public static void AreEqual (long expected, long actual)
{
Assert.That (actual, Is.EqualTo (expected), null, null);
}
public static void AreEqual (long expected, long actual, string message)
{
Assert.That (actual, Is.EqualTo (expected), message, null);
}
public static void AreEqual (long expected, long actual, string message, params object[] args)
{
Assert.That (actual, Is.EqualTo (expected), message, args);
}
public static void AreEqual (double expected, double? actual, double delta)
{
Assert.AssertDoublesAreEqual (expected, actual.get_Value (), delta, null, null);
}
public static void AreEqual (double expected, double? actual, double delta, string message)
{
Assert.AssertDoublesAreEqual (expected, actual.get_Value (), delta, message, null);
}
public static void AreEqual (double expected, double? actual, double delta, string message, params object[] args)
{
Assert.AssertDoublesAreEqual (expected, actual.get_Value (), delta, message, args);
}
public static void AreEqual (object expected, object actual)
{
Assert.That (actual, Is.EqualTo (expected), null, null);
}
public static void AreEqual (object expected, object actual, string message)
{
Assert.That (actual, Is.EqualTo (expected), message, null);
}
public static void AreEqual (object expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.EqualTo (expected), message, args);
}
public static void AreEqual (decimal expected, decimal actual)
{
Assert.That (actual, Is.EqualTo (expected), null, null);
}
public static void AreEqual (decimal expected, decimal actual, string message)
{
Assert.That (actual, Is.EqualTo (expected), message, null);
}
public static void AreEqual (decimal expected, decimal actual, string message, params object[] args)
{
Assert.That (actual, Is.EqualTo (expected), message, args);
}
public static void AreEqual (double expected, double actual, double delta)
{
Assert.AssertDoublesAreEqual (expected, actual, delta, null, null);
}
public static void AreEqual (double expected, double actual, double delta, string message)
{
Assert.AssertDoublesAreEqual (expected, actual, delta, message, null);
}
public static void AreEqual (double expected, double actual, double delta, string message, params object[] args)
{
Assert.AssertDoublesAreEqual (expected, actual, delta, message, args);
}
[CLSCompliant (false)]
public static void AreNotEqual (uint expected, uint actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
[CLSCompliant (false)]
public static void AreNotEqual (uint expected, uint actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
[CLSCompliant (false)]
public static void AreNotEqual (ulong expected, ulong actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
[CLSCompliant (false)]
public static void AreNotEqual (ulong expected, ulong actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotEqual (long expected, long actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
public static void AreNotEqual (long expected, long actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
[CLSCompliant (false)]
public static void AreNotEqual (uint expected, uint actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotEqual (long expected, long actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
[CLSCompliant (false)]
public static void AreNotEqual (ulong expected, ulong actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
public static void AreNotEqual (float expected, float actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
public static void AreNotEqual (float expected, float actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
public static void AreNotEqual (decimal expected, decimal actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
public static void AreNotEqual (float expected, float actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotEqual (decimal expected, decimal actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
public static void AreNotEqual (decimal expected, decimal actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotEqual (double expected, double actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotEqual (double expected, double actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
public static void AreNotEqual (object expected, object actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
public static void AreNotEqual (int expected, int actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotEqual (int expected, int actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
public static void AreNotEqual (object expected, object actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
public static void AreNotEqual (int expected, int actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
public static void AreNotEqual (double expected, double actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
public static void AreNotEqual (object expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotSame (object expected, object actual, string message)
{
Assert.That (actual, Is.Not.SameAs (expected), message, null);
}
public static void AreNotSame (object expected, object actual)
{
Assert.That (actual, Is.Not.SameAs (expected), null, null);
}
public static void AreNotSame (object expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.SameAs (expected), message, args);
}
public static void AreSame (object expected, object actual, string message)
{
Assert.That (actual, Is.SameAs (expected), message, null);
}
public static void AreSame (object expected, object actual)
{
Assert.That (actual, Is.SameAs (expected), null, null);
}
public static void AreSame (object expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.SameAs (expected), message, args);
}
protected static void AssertDoublesAreEqual (double expected, double actual, double delta, string message, object[] args)
{
if (double.IsNaN (expected) || double.IsInfinity (expected))
{
Assert.That (actual, Is.EqualTo (expected), message, args);
return;
}
Assert.That (actual, Is.EqualTo (expected).Within (delta), message, args);
}
public static void ByVal (object actual, IResolveConstraint expression, string message, params object[] args)
{
Assert.That (actual, expression, message, args);
}
public static void ByVal (object actual, IResolveConstraint expression, string message)
{
Assert.That (actual, expression, message, null);
}
public static void ByVal (object actual, IResolveConstraint expression)
{
Assert.That (actual, expression, null, null);
}
public static Exception Catch (Type expectedExceptionType, TestDelegate code, string message, params object[] args)
{
return Assert.Throws (new InstanceOfTypeConstraint (expectedExceptionType), code, message, args);
}
public static Exception Catch (Type expectedExceptionType, TestDelegate code, string message)
{
return Assert.Throws (new InstanceOfTypeConstraint (expectedExceptionType), code, message);
}
public static Exception Catch (Type expectedExceptionType, TestDelegate code)
{
return Assert.Throws (new InstanceOfTypeConstraint (expectedExceptionType), code);
}
public static Exception Catch (TestDelegate code, string message, params object[] args)
{
return Assert.Throws (new InstanceOfTypeConstraint (typeof(Exception)), code, message, args);
}
public static Exception Catch (TestDelegate code, string message)
{
return Assert.Throws (new InstanceOfTypeConstraint (typeof(Exception)), code, message);
}
public static Exception Catch (TestDelegate code)
{
return Assert.Throws (new InstanceOfTypeConstraint (typeof(Exception)), code);
}
public static T Catch<T> (TestDelegate code) where T : Exception
{
return (T)((object)Assert.Throws (new InstanceOfTypeConstraint (typeof(T)), code));
}
public static T Catch<T> (TestDelegate code, string message) where T : Exception
{
return (T)((object)Assert.Throws (new InstanceOfTypeConstraint (typeof(T)), code, message));
}
public static T Catch<T> (TestDelegate code, string message, params object[] args) where T : Exception
{
return (T)((object)Assert.Throws (new InstanceOfTypeConstraint (typeof(T)), code, message, args));
}
public static void Contains (object expected, ICollection actual, string message, params object[] args)
{
Assert.That (actual, new CollectionContainsConstraint (expected), message, args);
}
public static void Contains (object expected, ICollection actual, string message)
{
Assert.That (actual, new CollectionContainsConstraint (expected), message, null);
}
public static void Contains (object expected, ICollection actual)
{
Assert.That (actual, new CollectionContainsConstraint (expected), null, null);
}
public static void DoesNotThrow (TestDelegate code, string message, params object[] args)
{
Assert.That (code, new ThrowsNothingConstraint (), message, args);
}
public static void DoesNotThrow (TestDelegate code, string message)
{
Assert.That (code, new ThrowsNothingConstraint (), message, null);
}
public static void DoesNotThrow (TestDelegate code)
{
Assert.That (code, new ThrowsNothingConstraint (), string.Empty, null);
}
[EditorBrowsable (EditorBrowsableState.Never)]
public static bool Equals (object a, object b)
{
throw new AssertionException ("Assert.Equals should not be used for Assertions");
}
public static void Fail (string message, params object[] args)
{
if (message == null)
{
message = string.Empty;
}
else
{
if (args != null && args.Length > 0)
{
message = string.Format (message, args);
}
}
throw new AssertionException (message);
}
public static void Fail (string message)
{
Assert.Fail (message, null);
}
public static void Fail ()
{
Assert.Fail (string.Empty, null);
}
public static void False (bool condition, string message, params object[] args)
{
Assert.That (condition, Is.False, message, args);
}
public static void False (bool condition, string message)
{
Assert.That (condition, Is.False, message, null);
}
public static void False (bool condition)
{
Assert.That (condition, Is.False, null, null);
}
public static void Greater (double arg1, double arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
public static void Greater (double arg1, double arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void Greater (double arg1, double arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
public static void Greater (int arg1, int arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
public static void Greater (decimal arg1, decimal arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void Greater (decimal arg1, decimal arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
public static void Greater (IComparable arg1, IComparable arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
public static void Greater (IComparable arg1, IComparable arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void Greater (IComparable arg1, IComparable arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
public static void Greater (float arg1, float arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
public static void Greater (float arg1, float arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void Greater (float arg1, float arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Greater (ulong arg1, ulong arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
public static void Greater (long arg1, long arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
public static void Greater (long arg1, long arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void Greater (decimal arg1, decimal arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
[CLSCompliant (false)]
public static void Greater (ulong arg1, ulong arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Greater (ulong arg1, ulong arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
[CLSCompliant (false)]
public static void Greater (uint arg1, uint arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
public static void Greater (int arg1, int arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
public static void Greater (int arg1, int arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void Greater (long arg1, long arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
[CLSCompliant (false)]
public static void Greater (uint arg1, uint arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Greater (uint arg1, uint arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void GreaterOrEqual (double arg1, double arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
public static void GreaterOrEqual (double arg1, double arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
public static void GreaterOrEqual (double arg1, double arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
public static void GreaterOrEqual (decimal arg1, decimal arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
public static void GreaterOrEqual (decimal arg1, decimal arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
public static void GreaterOrEqual (decimal arg1, decimal arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
public static void GreaterOrEqual (IComparable arg1, IComparable arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
public static void GreaterOrEqual (IComparable arg1, IComparable arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
public static void GreaterOrEqual (IComparable arg1, IComparable arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
public static void GreaterOrEqual (float arg1, float arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
public static void GreaterOrEqual (float arg1, float arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
public static void GreaterOrEqual (float arg1, float arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
[CLSCompliant (false)]
public static void GreaterOrEqual (uint arg1, uint arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
[CLSCompliant (false)]
public static void GreaterOrEqual (uint arg1, uint arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
[CLSCompliant (false)]
public static void GreaterOrEqual (uint arg1, uint arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
public static void GreaterOrEqual (int arg1, int arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
public static void GreaterOrEqual (int arg1, int arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
public static void GreaterOrEqual (int arg1, int arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
[CLSCompliant (false)]
public static void GreaterOrEqual (ulong arg1, ulong arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
[CLSCompliant (false)]
public static void GreaterOrEqual (ulong arg1, ulong arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
[CLSCompliant (false)]
public static void GreaterOrEqual (ulong arg1, ulong arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
public static void GreaterOrEqual (long arg1, long arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
public static void GreaterOrEqual (long arg1, long arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
public static void GreaterOrEqual (long arg1, long arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
public static void Ignore (string message)
{
Assert.Ignore (message, null);
}
public static void Ignore ()
{
Assert.Ignore (string.Empty, null);
}
public static void Ignore (string message, params object[] args)
{
if (message == null)
{
message = string.Empty;
}
else
{
if (args != null && args.Length > 0)
{
message = string.Format (message, args);
}
}
throw new IgnoreException (message);
}
public static void Inconclusive (string message)
{
Assert.Inconclusive (message, null);
}
public static void Inconclusive ()
{
Assert.Inconclusive (string.Empty, null);
}
public static void Inconclusive (string message, params object[] args)
{
if (message == null)
{
message = string.Empty;
}
else
{
if (args != null && args.Length > 0)
{
message = string.Format (message, args);
}
}
throw new InconclusiveException (message);
}
public static void IsAssignableFrom<T> (object actual, string message, params object[] args)
{
Assert.That (actual, Is.AssignableFrom (typeof(T)), message, args);
}
public static void IsAssignableFrom<T> (object actual, string message)
{
Assert.That (actual, Is.AssignableFrom (typeof(T)), message, null);
}
public static void IsAssignableFrom<T> (object actual)
{
Assert.That (actual, Is.AssignableFrom (typeof(T)), null, null);
}
public static void IsAssignableFrom (Type expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.AssignableFrom (expected), message, args);
}
public static void IsAssignableFrom (Type expected, object actual, string message)
{
Assert.That (actual, Is.AssignableFrom (expected), message, null);
}
public static void IsAssignableFrom (Type expected, object actual)
{
Assert.That (actual, Is.AssignableFrom (expected), null, null);
}
public static void IsEmpty (string aString)
{
Assert.That (aString, new EmptyStringConstraint (), null, null);
}
public static void IsEmpty (string aString, string message)
{
Assert.That (aString, new EmptyStringConstraint (), message, null);
}
public static void IsEmpty (string aString, string message, params object[] args)
{
Assert.That (aString, new EmptyStringConstraint (), message, args);
}
public static void IsEmpty (IEnumerable collection)
{
Assert.That (collection, new EmptyCollectionConstraint (), null, null);
}
public static void IsEmpty (IEnumerable collection, string message)
{
Assert.That (collection, new EmptyCollectionConstraint (), message, null);
}
public static void IsEmpty (IEnumerable collection, string message, params object[] args)
{
Assert.That (collection, new EmptyCollectionConstraint (), message, args);
}
public static void IsFalse (bool condition)
{
Assert.That (condition, Is.False, null, null);
}
public static void IsFalse (bool condition, string message)
{
Assert.That (condition, Is.False, message, null);
}
public static void IsFalse (bool condition, string message, params object[] args)
{
Assert.That (condition, Is.False, message, args);
}
public static void IsInstanceOf (Type expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.InstanceOf (expected), message, args);
}
public static void IsInstanceOf (Type expected, object actual, string message)
{
Assert.That (actual, Is.InstanceOf (expected), message, null);
}
public static void IsInstanceOf<T> (object actual, string message, params object[] args)
{
Assert.That (actual, Is.InstanceOf (typeof(T)), message, args);
}
public static void IsInstanceOf<T> (object actual)
{
Assert.That (actual, Is.InstanceOf (typeof(T)), null, null);
}
public static void IsInstanceOf<T> (object actual, string message)
{
Assert.That (actual, Is.InstanceOf (typeof(T)), message, null);
}
public static void IsInstanceOf (Type expected, object actual)
{
Assert.That (actual, Is.InstanceOf (expected), null, null);
}
[Obsolete]
public static void IsInstanceOfType (Type expected, object actual, string message)
{
Assert.That (actual, Is.InstanceOf (expected), message, null);
}
[Obsolete]
public static void IsInstanceOfType (Type expected, object actual)
{
Assert.That (actual, Is.InstanceOf (expected), null, null);
}
[Obsolete]
public static void IsInstanceOfType (Type expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.InstanceOf (expected), message, args);
}
public static void IsNaN (double aDouble)
{
Assert.That (aDouble, Is.NaN, null, null);
}
public static void IsNaN (double aDouble, string message)
{
Assert.That (aDouble, Is.NaN, message, null);
}
public static void IsNaN (double? aDouble, string message, params object[] args)
{
Assert.That (aDouble, Is.NaN, message, args);
}
public static void IsNaN (double aDouble, string message, params object[] args)
{
Assert.That (aDouble, Is.NaN, message, args);
}
public static void IsNaN (double? aDouble)
{
Assert.That (aDouble, Is.NaN, null, null);
}
public static void IsNaN (double? aDouble, string message)
{
Assert.That (aDouble, Is.NaN, message, null);
}
public static void IsNotAssignableFrom (Type expected, object actual)
{
Assert.That (actual, Is.Not.AssignableFrom (expected), null, null);
}
public static void IsNotAssignableFrom (Type expected, object actual, string message)
{
Assert.That (actual, Is.Not.AssignableFrom (expected), message, null);
}
public static void IsNotAssignableFrom (Type expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.AssignableFrom (expected), message, args);
}
public static void IsNotAssignableFrom<T> (object actual, string message)
{
Assert.That (actual, Is.Not.AssignableFrom (typeof(T)), message, null);
}
public static void IsNotAssignableFrom<T> (object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.AssignableFrom (typeof(T)), message, args);
}
public static void IsNotAssignableFrom<T> (object actual)
{
Assert.That (actual, Is.Not.AssignableFrom (typeof(T)), null, null);
}
public static void IsNotEmpty (string aString)
{
Assert.That (aString, Is.Not.Empty, null, null);
}
public static void IsNotEmpty (IEnumerable collection, string message)
{
Assert.That (collection, Is.Not.Empty, message, null);
}
public static void IsNotEmpty (string aString, string message)
{
Assert.That (aString, Is.Not.Empty, message, null);
}
public static void IsNotEmpty (string aString, string message, params object[] args)
{
Assert.That (aString, Is.Not.Empty, message, args);
}
public static void IsNotEmpty (IEnumerable collection, string message, params object[] args)
{
Assert.That (collection, Is.Not.Empty, message, args);
}
public static void IsNotEmpty (IEnumerable collection)
{
Assert.That (collection, Is.Not.Empty, null, null);
}
public static void IsNotInstanceOf<T> (object actual, string message)
{
Assert.That (actual, Is.Not.InstanceOf (typeof(T)), message, null);
}
public static void IsNotInstanceOf<T> (object actual)
{
Assert.That (actual, Is.Not.InstanceOf (typeof(T)), null, null);
}
public static void IsNotInstanceOf<T> (object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.InstanceOf (typeof(T)), message, args);
}
public static void IsNotInstanceOf (Type expected, object actual)
{
Assert.That (actual, Is.Not.InstanceOf (expected), null, null);
}
public static void IsNotInstanceOf (Type expected, object actual, string message)
{
Assert.That (actual, Is.Not.InstanceOf (expected), message, null);
}
public static void IsNotInstanceOf (Type expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.InstanceOf (expected), message, args);
}
[Obsolete]
public static void IsNotInstanceOfType (Type expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.InstanceOf (expected), message, args);
}
[Obsolete]
public static void IsNotInstanceOfType (Type expected, object actual, string message)
{
Assert.That (actual, Is.Not.InstanceOf (expected), message, null);
}
[Obsolete]
public static void IsNotInstanceOfType (Type expected, object actual)
{
Assert.That (actual, Is.Not.InstanceOf (expected), null, null);
}
public static void IsNotNull (object anObject, string message, params object[] args)
{
Assert.That (anObject, Is.Not.Null, message, args);
}
public static void IsNotNull (object anObject, string message)
{
Assert.That (anObject, Is.Not.Null, message, null);
}
public static void IsNotNull (object anObject)
{
Assert.That (anObject, Is.Not.Null, null, null);
}
public static void IsNotNullOrEmpty (string aString, string message)
{
Assert.That (aString, new NotConstraint (new NullOrEmptyStringConstraint ()), message, null);
}
public static void IsNotNullOrEmpty (string aString)
{
Assert.That (aString, new NotConstraint (new NullOrEmptyStringConstraint ()), null, null);
}
public static void IsNotNullOrEmpty (string aString, string message, params object[] args)
{
Assert.That (aString, new NotConstraint (new NullOrEmptyStringConstraint ()), message, args);
}
public static void IsNull (object anObject, string message, params object[] args)
{
Assert.That (anObject, Is.Null, message, args);
}
public static void IsNull (object anObject)
{
Assert.That (anObject, Is.Null, null, null);
}
public static void IsNull (object anObject, string message)
{
Assert.That (anObject, Is.Null, message, null);
}
public static void IsNullOrEmpty (string aString, string message)
{
Assert.That (aString, new NullOrEmptyStringConstraint (), message, null);
}
public static void IsNullOrEmpty (string aString)
{
Assert.That (aString, new NullOrEmptyStringConstraint (), null, null);
}
public static void IsNullOrEmpty (string aString, string message, params object[] args)
{
Assert.That (aString, new NullOrEmptyStringConstraint (), message, args);
}
public static void IsTrue (bool condition, string message, params object[] args)
{
Assert.That (condition, Is.True, message, args);
}
public static void IsTrue (bool condition, string message)
{
Assert.That (condition, Is.True, message, null);
}
public static void IsTrue (bool condition)
{
Assert.That (condition, Is.True, null, null);
}
public static void Less (decimal arg1, decimal arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
public static void Less (decimal arg1, decimal arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (double arg1, double arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (decimal arg1, decimal arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Less (ulong arg1, ulong arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (long arg1, long arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Less (ulong arg1, ulong arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Less (ulong arg1, ulong arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
public static void Less (IComparable arg1, IComparable arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (float arg1, float arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
public static void Less (IComparable arg1, IComparable arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
public static void Less (IComparable arg1, IComparable arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
public static void Less (double arg1, double arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
public static void Less (double arg1, double arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
public static void Less (float arg1, float arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
public static void Less (float arg1, float arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (int arg1, int arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Less (uint arg1, uint arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (int arg1, int arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (int arg1, int arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
public static void Less (long arg1, long arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (long arg1, long arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
[CLSCompliant (false)]
public static void Less (uint arg1, uint arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
[CLSCompliant (false)]
public static void Less (uint arg1, uint arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
public static void LessOrEqual (long arg1, long arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
[CLSCompliant (false)]
public static void LessOrEqual (ulong arg1, ulong arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
[CLSCompliant (false)]
public static void LessOrEqual (ulong arg1, ulong arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
public static void LessOrEqual (int arg1, int arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void LessOrEqual (long arg1, long arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
public static void LessOrEqual (long arg1, long arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
public static void LessOrEqual (decimal arg1, decimal arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void LessOrEqual (int arg1, int arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
public static void LessOrEqual (int arg1, int arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
[CLSCompliant (false)]
public static void LessOrEqual (ulong arg1, ulong arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void LessOrEqual (decimal arg1, decimal arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
public static void LessOrEqual (decimal arg1, decimal arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
public static void LessOrEqual (double arg1, double arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
[CLSCompliant (false)]
public static void LessOrEqual (uint arg1, uint arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void LessOrEqual (IComparable arg1, IComparable arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
public static void LessOrEqual (IComparable arg1, IComparable arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
[CLSCompliant (false)]
public static void LessOrEqual (uint arg1, uint arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
public static void LessOrEqual (float arg1, float arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
public static void LessOrEqual (float arg1, float arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void LessOrEqual (double arg1, double arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void LessOrEqual (float arg1, float arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
public static void LessOrEqual (double arg1, double arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
[CLSCompliant (false)]
public static void LessOrEqual (uint arg1, uint arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
public static void LessOrEqual (IComparable arg1, IComparable arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void NotNull (object anObject)
{
Assert.That (anObject, Is.Not.Null, null, null);
}
public static void NotNull (object anObject, string message)
{
Assert.That (anObject, Is.Not.Null, message, null);
}
public static void NotNull (object anObject, string message, params object[] args)
{
Assert.That (anObject, Is.Not.Null, message, args);
}
public static void Null (object anObject)
{
Assert.That (anObject, Is.Null, null, null);
}
public static void Null (object anObject, string message)
{
Assert.That (anObject, Is.Null, message, null);
}
public static void Null (object anObject, string message, params object[] args)
{
Assert.That (anObject, Is.Null, message, args);
}
public static void Pass (string message, params object[] args)
{
if (message == null)
{
message = string.Empty;
}
else
{
if (args != null && args.Length > 0)
{
message = string.Format (message, args);
}
}
throw new SuccessException (message);
}
public static void Pass (string message)
{
Assert.Pass (message, null);
}
public static void Pass ()
{
Assert.Pass (string.Empty, null);
}
public static void ReferenceEquals (object a, object b)
{
throw new AssertionException ("Assert.ReferenceEquals should not be used for Assertions");
}
public static void That (ActualValueDelegate del, IResolveConstraint expr, string message, params object[] args)
{
Constraint constraint = expr.Resolve ();
Assert.IncrementAssertCount ();
if (!constraint.Matches (del))
{
MessageWriter messageWriter = new TextMessageWriter (message, args);
constraint.WriteMessageTo (messageWriter);
throw new AssertionException (messageWriter.ToString ());
}
}
public static void That (ActualValueDelegate del, IResolveConstraint expr, string message)
{
Assert.That (del, expr.Resolve (), message, null);
}
public static void That (ActualValueDelegate del, IResolveConstraint expr)
{
Assert.That (del, expr.Resolve (), null, null);
}
public static void That<T> (ref T actual, IResolveConstraint expression, string message, params object[] args)
{
Constraint constraint = expression.Resolve ();
Assert.IncrementAssertCount ();
if (!constraint.Matches<T> (ref actual))
{
MessageWriter messageWriter = new TextMessageWriter (message, args);
constraint.WriteMessageTo (messageWriter);
throw new AssertionException (messageWriter.ToString ());
}
}
public static void That<T> (ref T actual, IResolveConstraint expression, string message)
{
Assert.That<T> (ref actual, expression.Resolve (), message, null);
}
public static void That<T> (ref T actual, IResolveConstraint expression)
{
Assert.That<T> (ref actual, expression.Resolve (), null, null);
}
public static void That (object actual, IResolveConstraint expression, string message, params object[] args)
{
Constraint constraint = expression.Resolve ();
Assert.IncrementAssertCount ();
if (!constraint.Matches (actual))
{
MessageWriter messageWriter = new TextMessageWriter (message, args);
constraint.WriteMessageTo (messageWriter);
throw new AssertionException (messageWriter.ToString ());
}
}
public static void That (bool condition, string message)
{
Assert.That (condition, Is.True, message, null);
}
public static void That (bool condition)
{
Assert.That (condition, Is.True, null, null);
}
public static void That (TestDelegate code, IResolveConstraint constraint)
{
Assert.That (code, constraint);
}
public static void That (object actual, IResolveConstraint expression, string message)
{
Assert.That (actual, expression, message, null);
}
public static void That (object actual, IResolveConstraint expression)
{
Assert.That (actual, expression, null, null);
}
public static void That (bool condition, string message, params object[] args)
{
Assert.That (condition, Is.True, message, args);
}
public static T Throws<T> (TestDelegate code, string message, params object[] args) where T : Exception
{
return (T)((object)Assert.Throws (typeof(T), code, message, args));
}
public static Exception Throws (Type expectedExceptionType, TestDelegate code)
{
return Assert.Throws (new ExceptionTypeConstraint (expectedExceptionType), code, string.Empty, null);
}
public static T Throws<T> (TestDelegate code) where T : Exception
{
return Assert.Throws<T> (code, string.Empty, null);
}
public static T Throws<T> (TestDelegate code, string message) where T : Exception
{
return Assert.Throws<T> (code, message, null);
}
public static Exception Throws (Type expectedExceptionType, TestDelegate code, string message)
{
return Assert.Throws (new ExceptionTypeConstraint (expectedExceptionType), code, message, null);
}
public static Exception Throws (IResolveConstraint expression, TestDelegate code, string message)
{
return Assert.Throws (expression, code, message, null);
}
public static Exception Throws (IResolveConstraint expression, TestDelegate code, string message, params object[] args)
{
Exception ex = null;
try
{
code ();
}
catch (Exception ex2)
{
ex = ex2;
}
Assert.That (ex, expression, message, args);
return ex;
}
public static Exception Throws (Type expectedExceptionType, TestDelegate code, string message, params object[] args)
{
return Assert.Throws (new ExceptionTypeConstraint (expectedExceptionType), code, message, args);
}
public static Exception Throws (IResolveConstraint expression, TestDelegate code)
{
return Assert.Throws (expression, code, string.Empty, null);
}
public static void True (bool condition)
{
Assert.That (condition, Is.True, null, null);
}
public static void True (bool condition, string message)
{
Assert.That (condition, Is.True, message, null);
}
public static void True (bool condition, string message, params object[] args)
{
Assert.That (condition, Is.True, message, args);
}
}
}
unity的没用过,今天搜索了下,发现居然有官方工具,更新到1.22版
决定使用官方的
地址是:unit test tool
用法和注意事项
两种单元测试:
A.NUnit,官网:http://www.nunit.org:
发现一篇好文章http://confach.cnblogs.com/archive/2005/06/20/177817.aspx将NUnit的
测试静态类的(未继承MONOBehavior)
跟ios开发的xctest差不多,用attritube:[Test]表明下面的方法是个测试,命名空间是Nunit.frameword
Assert.~~~~断言~~,巴拉巴拉的什么表明测试通过没有
Assert.Pass ();
ssert.Fail ();
还有什么比较之类的方法
AreEqual相等
AreNotEual不相等
Greater大于
Less小于
IsNotNull不为空
.等等等还有好多不明白干什么的断言方法,具体列表在下面的源文件里面,请自行浏览猜测用途
第二种是Integration Test
就是可以在运行时做的单元测试
具体流程是
1.打开窗口
2.建立测试
3.设置是否断言组件(Assertions组件)通过就pass(通过任意一个之后貌似就会认为是成功了,而不是timeOut或者继续其他断言判断,也就是说后面如果有失败的就不继续测了,建议关闭)
4.设置超时时间,超过之后视为通过
5.在子物体中添加测试物体添加脚本(Assertion默认有:float,bool,vector2,3,4,renderer等判断)
6.添加断言脚本或自己写测试脚本
PS:默认的几个断言类型如果觉得不够,自己写,继承泛型类ComparerBaseGeneric<T1,T2>,重写Compare方法即可,ComparerBaseGeneric<T>则是需要一个参数的版本
当自己写单元测试脚本,
通过或失败时执行IntegrationTest.Pass (gameObject);或IntegrationTest.Fail (gameObject);即可,这个脚本需要继承Monobehavior,挂载到物体上
用上了单元测试驱动开发,顿时感觉自己对代码的信心加强了不少啊
using NUnit.Framework.Constraints;
using System;
using System.Collections;
using System.ComponentModel;
namespace NUnit.Framework
{
public class Assert
{
//
// Static Properties
//
public static int Counter
{
get
{
int result = Assert.counter;
Assert.counter = 0;
return result;
}
}
//
// Constructors
//
protected Assert ()
{
}
//
// Static Methods
//
[CLSCompliant (false)]
public static void AreEqual (uint expected, uint actual)
{
Assert.That (actual, Is.EqualTo (expected), null, null);
}
[CLSCompliant (false)]
public static void AreEqual (uint expected, uint actual, string message)
{
Assert.That (actual, Is.EqualTo (expected), message, null);
}
[CLSCompliant (false)]
public static void AreEqual (uint expected, uint actual, string message, params object[] args)
{
Assert.That (actual, Is.EqualTo (expected), message, args);
}
[CLSCompliant (false)]
public static void AreEqual (ulong expected, ulong actual)
{
Assert.That (actual, Is.EqualTo (expected), null, null);
}
[CLSCompliant (false)]
public static void AreEqual (ulong expected, ulong actual, string message)
{
Assert.That (actual, Is.EqualTo (expected), message, null);
}
[CLSCompliant (false)]
public static void AreEqual (ulong expected, ulong actual, string message, params object[] args)
{
Assert.That (actual, Is.EqualTo (expected), message, args);
}
public static void AreEqual (int expected, int actual)
{
Assert.That (actual, Is.EqualTo (expected), null, null);
}
public static void AreEqual (int expected, int actual, string message)
{
Assert.That (actual, Is.EqualTo (expected), message, null);
}
public static void AreEqual (int expected, int actual, string message, params object[] args)
{
Assert.That (actual, Is.EqualTo (expected), message, args);
}
public static void AreEqual (long expected, long actual)
{
Assert.That (actual, Is.EqualTo (expected), null, null);
}
public static void AreEqual (long expected, long actual, string message)
{
Assert.That (actual, Is.EqualTo (expected), message, null);
}
public static void AreEqual (long expected, long actual, string message, params object[] args)
{
Assert.That (actual, Is.EqualTo (expected), message, args);
}
public static void AreEqual (double expected, double? actual, double delta)
{
Assert.AssertDoublesAreEqual (expected, actual.get_Value (), delta, null, null);
}
public static void AreEqual (double expected, double? actual, double delta, string message)
{
Assert.AssertDoublesAreEqual (expected, actual.get_Value (), delta, message, null);
}
public static void AreEqual (double expected, double? actual, double delta, string message, params object[] args)
{
Assert.AssertDoublesAreEqual (expected, actual.get_Value (), delta, message, args);
}
public static void AreEqual (object expected, object actual)
{
Assert.That (actual, Is.EqualTo (expected), null, null);
}
public static void AreEqual (object expected, object actual, string message)
{
Assert.That (actual, Is.EqualTo (expected), message, null);
}
public static void AreEqual (object expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.EqualTo (expected), message, args);
}
public static void AreEqual (decimal expected, decimal actual)
{
Assert.That (actual, Is.EqualTo (expected), null, null);
}
public static void AreEqual (decimal expected, decimal actual, string message)
{
Assert.That (actual, Is.EqualTo (expected), message, null);
}
public static void AreEqual (decimal expected, decimal actual, string message, params object[] args)
{
Assert.That (actual, Is.EqualTo (expected), message, args);
}
public static void AreEqual (double expected, double actual, double delta)
{
Assert.AssertDoublesAreEqual (expected, actual, delta, null, null);
}
public static void AreEqual (double expected, double actual, double delta, string message)
{
Assert.AssertDoublesAreEqual (expected, actual, delta, message, null);
}
public static void AreEqual (double expected, double actual, double delta, string message, params object[] args)
{
Assert.AssertDoublesAreEqual (expected, actual, delta, message, args);
}
[CLSCompliant (false)]
public static void AreNotEqual (uint expected, uint actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
[CLSCompliant (false)]
public static void AreNotEqual (uint expected, uint actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
[CLSCompliant (false)]
public static void AreNotEqual (ulong expected, ulong actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
[CLSCompliant (false)]
public static void AreNotEqual (ulong expected, ulong actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotEqual (long expected, long actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
public static void AreNotEqual (long expected, long actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
[CLSCompliant (false)]
public static void AreNotEqual (uint expected, uint actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotEqual (long expected, long actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
[CLSCompliant (false)]
public static void AreNotEqual (ulong expected, ulong actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
public static void AreNotEqual (float expected, float actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
public static void AreNotEqual (float expected, float actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
public static void AreNotEqual (decimal expected, decimal actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
public static void AreNotEqual (float expected, float actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotEqual (decimal expected, decimal actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
public static void AreNotEqual (decimal expected, decimal actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotEqual (double expected, double actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotEqual (double expected, double actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
public static void AreNotEqual (object expected, object actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
public static void AreNotEqual (int expected, int actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotEqual (int expected, int actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
public static void AreNotEqual (object expected, object actual, string message)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, null);
}
public static void AreNotEqual (int expected, int actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
public static void AreNotEqual (double expected, double actual)
{
Assert.That (actual, Is.Not.EqualTo (expected), null, null);
}
public static void AreNotEqual (object expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.EqualTo (expected), message, args);
}
public static void AreNotSame (object expected, object actual, string message)
{
Assert.That (actual, Is.Not.SameAs (expected), message, null);
}
public static void AreNotSame (object expected, object actual)
{
Assert.That (actual, Is.Not.SameAs (expected), null, null);
}
public static void AreNotSame (object expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.SameAs (expected), message, args);
}
public static void AreSame (object expected, object actual, string message)
{
Assert.That (actual, Is.SameAs (expected), message, null);
}
public static void AreSame (object expected, object actual)
{
Assert.That (actual, Is.SameAs (expected), null, null);
}
public static void AreSame (object expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.SameAs (expected), message, args);
}
protected static void AssertDoublesAreEqual (double expected, double actual, double delta, string message, object[] args)
{
if (double.IsNaN (expected) || double.IsInfinity (expected))
{
Assert.That (actual, Is.EqualTo (expected), message, args);
return;
}
Assert.That (actual, Is.EqualTo (expected).Within (delta), message, args);
}
public static void ByVal (object actual, IResolveConstraint expression, string message, params object[] args)
{
Assert.That (actual, expression, message, args);
}
public static void ByVal (object actual, IResolveConstraint expression, string message)
{
Assert.That (actual, expression, message, null);
}
public static void ByVal (object actual, IResolveConstraint expression)
{
Assert.That (actual, expression, null, null);
}
public static Exception Catch (Type expectedExceptionType, TestDelegate code, string message, params object[] args)
{
return Assert.Throws (new InstanceOfTypeConstraint (expectedExceptionType), code, message, args);
}
public static Exception Catch (Type expectedExceptionType, TestDelegate code, string message)
{
return Assert.Throws (new InstanceOfTypeConstraint (expectedExceptionType), code, message);
}
public static Exception Catch (Type expectedExceptionType, TestDelegate code)
{
return Assert.Throws (new InstanceOfTypeConstraint (expectedExceptionType), code);
}
public static Exception Catch (TestDelegate code, string message, params object[] args)
{
return Assert.Throws (new InstanceOfTypeConstraint (typeof(Exception)), code, message, args);
}
public static Exception Catch (TestDelegate code, string message)
{
return Assert.Throws (new InstanceOfTypeConstraint (typeof(Exception)), code, message);
}
public static Exception Catch (TestDelegate code)
{
return Assert.Throws (new InstanceOfTypeConstraint (typeof(Exception)), code);
}
public static T Catch<T> (TestDelegate code) where T : Exception
{
return (T)((object)Assert.Throws (new InstanceOfTypeConstraint (typeof(T)), code));
}
public static T Catch<T> (TestDelegate code, string message) where T : Exception
{
return (T)((object)Assert.Throws (new InstanceOfTypeConstraint (typeof(T)), code, message));
}
public static T Catch<T> (TestDelegate code, string message, params object[] args) where T : Exception
{
return (T)((object)Assert.Throws (new InstanceOfTypeConstraint (typeof(T)), code, message, args));
}
public static void Contains (object expected, ICollection actual, string message, params object[] args)
{
Assert.That (actual, new CollectionContainsConstraint (expected), message, args);
}
public static void Contains (object expected, ICollection actual, string message)
{
Assert.That (actual, new CollectionContainsConstraint (expected), message, null);
}
public static void Contains (object expected, ICollection actual)
{
Assert.That (actual, new CollectionContainsConstraint (expected), null, null);
}
public static void DoesNotThrow (TestDelegate code, string message, params object[] args)
{
Assert.That (code, new ThrowsNothingConstraint (), message, args);
}
public static void DoesNotThrow (TestDelegate code, string message)
{
Assert.That (code, new ThrowsNothingConstraint (), message, null);
}
public static void DoesNotThrow (TestDelegate code)
{
Assert.That (code, new ThrowsNothingConstraint (), string.Empty, null);
}
[EditorBrowsable (EditorBrowsableState.Never)]
public static bool Equals (object a, object b)
{
throw new AssertionException ("Assert.Equals should not be used for Assertions");
}
public static void Fail (string message, params object[] args)
{
if (message == null)
{
message = string.Empty;
}
else
{
if (args != null && args.Length > 0)
{
message = string.Format (message, args);
}
}
throw new AssertionException (message);
}
public static void Fail (string message)
{
Assert.Fail (message, null);
}
public static void Fail ()
{
Assert.Fail (string.Empty, null);
}
public static void False (bool condition, string message, params object[] args)
{
Assert.That (condition, Is.False, message, args);
}
public static void False (bool condition, string message)
{
Assert.That (condition, Is.False, message, null);
}
public static void False (bool condition)
{
Assert.That (condition, Is.False, null, null);
}
public static void Greater (double arg1, double arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
public static void Greater (double arg1, double arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void Greater (double arg1, double arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
public static void Greater (int arg1, int arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
public static void Greater (decimal arg1, decimal arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void Greater (decimal arg1, decimal arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
public static void Greater (IComparable arg1, IComparable arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
public static void Greater (IComparable arg1, IComparable arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void Greater (IComparable arg1, IComparable arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
public static void Greater (float arg1, float arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
public static void Greater (float arg1, float arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void Greater (float arg1, float arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Greater (ulong arg1, ulong arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
public static void Greater (long arg1, long arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
public static void Greater (long arg1, long arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void Greater (decimal arg1, decimal arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
[CLSCompliant (false)]
public static void Greater (ulong arg1, ulong arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Greater (ulong arg1, ulong arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
[CLSCompliant (false)]
public static void Greater (uint arg1, uint arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
public static void Greater (int arg1, int arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
public static void Greater (int arg1, int arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void Greater (long arg1, long arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, args);
}
[CLSCompliant (false)]
public static void Greater (uint arg1, uint arg2)
{
Assert.That (arg1, Is.GreaterThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Greater (uint arg1, uint arg2, string message)
{
Assert.That (arg1, Is.GreaterThan (arg2), message, null);
}
public static void GreaterOrEqual (double arg1, double arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
public static void GreaterOrEqual (double arg1, double arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
public static void GreaterOrEqual (double arg1, double arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
public static void GreaterOrEqual (decimal arg1, decimal arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
public static void GreaterOrEqual (decimal arg1, decimal arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
public static void GreaterOrEqual (decimal arg1, decimal arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
public static void GreaterOrEqual (IComparable arg1, IComparable arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
public static void GreaterOrEqual (IComparable arg1, IComparable arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
public static void GreaterOrEqual (IComparable arg1, IComparable arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
public static void GreaterOrEqual (float arg1, float arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
public static void GreaterOrEqual (float arg1, float arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
public static void GreaterOrEqual (float arg1, float arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
[CLSCompliant (false)]
public static void GreaterOrEqual (uint arg1, uint arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
[CLSCompliant (false)]
public static void GreaterOrEqual (uint arg1, uint arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
[CLSCompliant (false)]
public static void GreaterOrEqual (uint arg1, uint arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
public static void GreaterOrEqual (int arg1, int arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
public static void GreaterOrEqual (int arg1, int arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
public static void GreaterOrEqual (int arg1, int arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
[CLSCompliant (false)]
public static void GreaterOrEqual (ulong arg1, ulong arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
[CLSCompliant (false)]
public static void GreaterOrEqual (ulong arg1, ulong arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
[CLSCompliant (false)]
public static void GreaterOrEqual (ulong arg1, ulong arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
public static void GreaterOrEqual (long arg1, long arg2, string message, params object[] args)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, args);
}
public static void GreaterOrEqual (long arg1, long arg2, string message)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), message, null);
}
public static void GreaterOrEqual (long arg1, long arg2)
{
Assert.That (arg1, Is.GreaterThanOrEqualTo (arg2), null, null);
}
public static void Ignore (string message)
{
Assert.Ignore (message, null);
}
public static void Ignore ()
{
Assert.Ignore (string.Empty, null);
}
public static void Ignore (string message, params object[] args)
{
if (message == null)
{
message = string.Empty;
}
else
{
if (args != null && args.Length > 0)
{
message = string.Format (message, args);
}
}
throw new IgnoreException (message);
}
public static void Inconclusive (string message)
{
Assert.Inconclusive (message, null);
}
public static void Inconclusive ()
{
Assert.Inconclusive (string.Empty, null);
}
public static void Inconclusive (string message, params object[] args)
{
if (message == null)
{
message = string.Empty;
}
else
{
if (args != null && args.Length > 0)
{
message = string.Format (message, args);
}
}
throw new InconclusiveException (message);
}
public static void IsAssignableFrom<T> (object actual, string message, params object[] args)
{
Assert.That (actual, Is.AssignableFrom (typeof(T)), message, args);
}
public static void IsAssignableFrom<T> (object actual, string message)
{
Assert.That (actual, Is.AssignableFrom (typeof(T)), message, null);
}
public static void IsAssignableFrom<T> (object actual)
{
Assert.That (actual, Is.AssignableFrom (typeof(T)), null, null);
}
public static void IsAssignableFrom (Type expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.AssignableFrom (expected), message, args);
}
public static void IsAssignableFrom (Type expected, object actual, string message)
{
Assert.That (actual, Is.AssignableFrom (expected), message, null);
}
public static void IsAssignableFrom (Type expected, object actual)
{
Assert.That (actual, Is.AssignableFrom (expected), null, null);
}
public static void IsEmpty (string aString)
{
Assert.That (aString, new EmptyStringConstraint (), null, null);
}
public static void IsEmpty (string aString, string message)
{
Assert.That (aString, new EmptyStringConstraint (), message, null);
}
public static void IsEmpty (string aString, string message, params object[] args)
{
Assert.That (aString, new EmptyStringConstraint (), message, args);
}
public static void IsEmpty (IEnumerable collection)
{
Assert.That (collection, new EmptyCollectionConstraint (), null, null);
}
public static void IsEmpty (IEnumerable collection, string message)
{
Assert.That (collection, new EmptyCollectionConstraint (), message, null);
}
public static void IsEmpty (IEnumerable collection, string message, params object[] args)
{
Assert.That (collection, new EmptyCollectionConstraint (), message, args);
}
public static void IsFalse (bool condition)
{
Assert.That (condition, Is.False, null, null);
}
public static void IsFalse (bool condition, string message)
{
Assert.That (condition, Is.False, message, null);
}
public static void IsFalse (bool condition, string message, params object[] args)
{
Assert.That (condition, Is.False, message, args);
}
public static void IsInstanceOf (Type expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.InstanceOf (expected), message, args);
}
public static void IsInstanceOf (Type expected, object actual, string message)
{
Assert.That (actual, Is.InstanceOf (expected), message, null);
}
public static void IsInstanceOf<T> (object actual, string message, params object[] args)
{
Assert.That (actual, Is.InstanceOf (typeof(T)), message, args);
}
public static void IsInstanceOf<T> (object actual)
{
Assert.That (actual, Is.InstanceOf (typeof(T)), null, null);
}
public static void IsInstanceOf<T> (object actual, string message)
{
Assert.That (actual, Is.InstanceOf (typeof(T)), message, null);
}
public static void IsInstanceOf (Type expected, object actual)
{
Assert.That (actual, Is.InstanceOf (expected), null, null);
}
[Obsolete]
public static void IsInstanceOfType (Type expected, object actual, string message)
{
Assert.That (actual, Is.InstanceOf (expected), message, null);
}
[Obsolete]
public static void IsInstanceOfType (Type expected, object actual)
{
Assert.That (actual, Is.InstanceOf (expected), null, null);
}
[Obsolete]
public static void IsInstanceOfType (Type expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.InstanceOf (expected), message, args);
}
public static void IsNaN (double aDouble)
{
Assert.That (aDouble, Is.NaN, null, null);
}
public static void IsNaN (double aDouble, string message)
{
Assert.That (aDouble, Is.NaN, message, null);
}
public static void IsNaN (double? aDouble, string message, params object[] args)
{
Assert.That (aDouble, Is.NaN, message, args);
}
public static void IsNaN (double aDouble, string message, params object[] args)
{
Assert.That (aDouble, Is.NaN, message, args);
}
public static void IsNaN (double? aDouble)
{
Assert.That (aDouble, Is.NaN, null, null);
}
public static void IsNaN (double? aDouble, string message)
{
Assert.That (aDouble, Is.NaN, message, null);
}
public static void IsNotAssignableFrom (Type expected, object actual)
{
Assert.That (actual, Is.Not.AssignableFrom (expected), null, null);
}
public static void IsNotAssignableFrom (Type expected, object actual, string message)
{
Assert.That (actual, Is.Not.AssignableFrom (expected), message, null);
}
public static void IsNotAssignableFrom (Type expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.AssignableFrom (expected), message, args);
}
public static void IsNotAssignableFrom<T> (object actual, string message)
{
Assert.That (actual, Is.Not.AssignableFrom (typeof(T)), message, null);
}
public static void IsNotAssignableFrom<T> (object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.AssignableFrom (typeof(T)), message, args);
}
public static void IsNotAssignableFrom<T> (object actual)
{
Assert.That (actual, Is.Not.AssignableFrom (typeof(T)), null, null);
}
public static void IsNotEmpty (string aString)
{
Assert.That (aString, Is.Not.Empty, null, null);
}
public static void IsNotEmpty (IEnumerable collection, string message)
{
Assert.That (collection, Is.Not.Empty, message, null);
}
public static void IsNotEmpty (string aString, string message)
{
Assert.That (aString, Is.Not.Empty, message, null);
}
public static void IsNotEmpty (string aString, string message, params object[] args)
{
Assert.That (aString, Is.Not.Empty, message, args);
}
public static void IsNotEmpty (IEnumerable collection, string message, params object[] args)
{
Assert.That (collection, Is.Not.Empty, message, args);
}
public static void IsNotEmpty (IEnumerable collection)
{
Assert.That (collection, Is.Not.Empty, null, null);
}
public static void IsNotInstanceOf<T> (object actual, string message)
{
Assert.That (actual, Is.Not.InstanceOf (typeof(T)), message, null);
}
public static void IsNotInstanceOf<T> (object actual)
{
Assert.That (actual, Is.Not.InstanceOf (typeof(T)), null, null);
}
public static void IsNotInstanceOf<T> (object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.InstanceOf (typeof(T)), message, args);
}
public static void IsNotInstanceOf (Type expected, object actual)
{
Assert.That (actual, Is.Not.InstanceOf (expected), null, null);
}
public static void IsNotInstanceOf (Type expected, object actual, string message)
{
Assert.That (actual, Is.Not.InstanceOf (expected), message, null);
}
public static void IsNotInstanceOf (Type expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.InstanceOf (expected), message, args);
}
[Obsolete]
public static void IsNotInstanceOfType (Type expected, object actual, string message, params object[] args)
{
Assert.That (actual, Is.Not.InstanceOf (expected), message, args);
}
[Obsolete]
public static void IsNotInstanceOfType (Type expected, object actual, string message)
{
Assert.That (actual, Is.Not.InstanceOf (expected), message, null);
}
[Obsolete]
public static void IsNotInstanceOfType (Type expected, object actual)
{
Assert.That (actual, Is.Not.InstanceOf (expected), null, null);
}
public static void IsNotNull (object anObject, string message, params object[] args)
{
Assert.That (anObject, Is.Not.Null, message, args);
}
public static void IsNotNull (object anObject, string message)
{
Assert.That (anObject, Is.Not.Null, message, null);
}
public static void IsNotNull (object anObject)
{
Assert.That (anObject, Is.Not.Null, null, null);
}
public static void IsNotNullOrEmpty (string aString, string message)
{
Assert.That (aString, new NotConstraint (new NullOrEmptyStringConstraint ()), message, null);
}
public static void IsNotNullOrEmpty (string aString)
{
Assert.That (aString, new NotConstraint (new NullOrEmptyStringConstraint ()), null, null);
}
public static void IsNotNullOrEmpty (string aString, string message, params object[] args)
{
Assert.That (aString, new NotConstraint (new NullOrEmptyStringConstraint ()), message, args);
}
public static void IsNull (object anObject, string message, params object[] args)
{
Assert.That (anObject, Is.Null, message, args);
}
public static void IsNull (object anObject)
{
Assert.That (anObject, Is.Null, null, null);
}
public static void IsNull (object anObject, string message)
{
Assert.That (anObject, Is.Null, message, null);
}
public static void IsNullOrEmpty (string aString, string message)
{
Assert.That (aString, new NullOrEmptyStringConstraint (), message, null);
}
public static void IsNullOrEmpty (string aString)
{
Assert.That (aString, new NullOrEmptyStringConstraint (), null, null);
}
public static void IsNullOrEmpty (string aString, string message, params object[] args)
{
Assert.That (aString, new NullOrEmptyStringConstraint (), message, args);
}
public static void IsTrue (bool condition, string message, params object[] args)
{
Assert.That (condition, Is.True, message, args);
}
public static void IsTrue (bool condition, string message)
{
Assert.That (condition, Is.True, message, null);
}
public static void IsTrue (bool condition)
{
Assert.That (condition, Is.True, null, null);
}
public static void Less (decimal arg1, decimal arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
public static void Less (decimal arg1, decimal arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (double arg1, double arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (decimal arg1, decimal arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Less (ulong arg1, ulong arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (long arg1, long arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Less (ulong arg1, ulong arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Less (ulong arg1, ulong arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
public static void Less (IComparable arg1, IComparable arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (float arg1, float arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
public static void Less (IComparable arg1, IComparable arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
public static void Less (IComparable arg1, IComparable arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
public static void Less (double arg1, double arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
public static void Less (double arg1, double arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
public static void Less (float arg1, float arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
public static void Less (float arg1, float arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (int arg1, int arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
[CLSCompliant (false)]
public static void Less (uint arg1, uint arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (int arg1, int arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (int arg1, int arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
public static void Less (long arg1, long arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThan (arg2), message, args);
}
public static void Less (long arg1, long arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
[CLSCompliant (false)]
public static void Less (uint arg1, uint arg2, string message)
{
Assert.That (arg1, Is.LessThan (arg2), message, null);
}
[CLSCompliant (false)]
public static void Less (uint arg1, uint arg2)
{
Assert.That (arg1, Is.LessThan (arg2), null, null);
}
public static void LessOrEqual (long arg1, long arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
[CLSCompliant (false)]
public static void LessOrEqual (ulong arg1, ulong arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
[CLSCompliant (false)]
public static void LessOrEqual (ulong arg1, ulong arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
public static void LessOrEqual (int arg1, int arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void LessOrEqual (long arg1, long arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
public static void LessOrEqual (long arg1, long arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
public static void LessOrEqual (decimal arg1, decimal arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void LessOrEqual (int arg1, int arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
public static void LessOrEqual (int arg1, int arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
[CLSCompliant (false)]
public static void LessOrEqual (ulong arg1, ulong arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void LessOrEqual (decimal arg1, decimal arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
public static void LessOrEqual (decimal arg1, decimal arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
public static void LessOrEqual (double arg1, double arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
[CLSCompliant (false)]
public static void LessOrEqual (uint arg1, uint arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void LessOrEqual (IComparable arg1, IComparable arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
public static void LessOrEqual (IComparable arg1, IComparable arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
[CLSCompliant (false)]
public static void LessOrEqual (uint arg1, uint arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
public static void LessOrEqual (float arg1, float arg2, string message)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, null);
}
public static void LessOrEqual (float arg1, float arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void LessOrEqual (double arg1, double arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void LessOrEqual (float arg1, float arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
public static void LessOrEqual (double arg1, double arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
[CLSCompliant (false)]
public static void LessOrEqual (uint arg1, uint arg2, string message, params object[] args)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), message, args);
}
public static void LessOrEqual (IComparable arg1, IComparable arg2)
{
Assert.That (arg1, Is.LessThanOrEqualTo (arg2), null, null);
}
public static void NotNull (object anObject)
{
Assert.That (anObject, Is.Not.Null, null, null);
}
public static void NotNull (object anObject, string message)
{
Assert.That (anObject, Is.Not.Null, message, null);
}
public static void NotNull (object anObject, string message, params object[] args)
{
Assert.That (anObject, Is.Not.Null, message, args);
}
public static void Null (object anObject)
{
Assert.That (anObject, Is.Null, null, null);
}
public static void Null (object anObject, string message)
{
Assert.That (anObject, Is.Null, message, null);
}
public static void Null (object anObject, string message, params object[] args)
{
Assert.That (anObject, Is.Null, message, args);
}
public static void Pass (string message, params object[] args)
{
if (message == null)
{
message = string.Empty;
}
else
{
if (args != null && args.Length > 0)
{
message = string.Format (message, args);
}
}
throw new SuccessException (message);
}
public static void Pass (string message)
{
Assert.Pass (message, null);
}
public static void Pass ()
{
Assert.Pass (string.Empty, null);
}
public static void ReferenceEquals (object a, object b)
{
throw new AssertionException ("Assert.ReferenceEquals should not be used for Assertions");
}
public static void That (ActualValueDelegate del, IResolveConstraint expr, string message, params object[] args)
{
Constraint constraint = expr.Resolve ();
Assert.IncrementAssertCount ();
if (!constraint.Matches (del))
{
MessageWriter messageWriter = new TextMessageWriter (message, args);
constraint.WriteMessageTo (messageWriter);
throw new AssertionException (messageWriter.ToString ());
}
}
public static void That (ActualValueDelegate del, IResolveConstraint expr, string message)
{
Assert.That (del, expr.Resolve (), message, null);
}
public static void That (ActualValueDelegate del, IResolveConstraint expr)
{
Assert.That (del, expr.Resolve (), null, null);
}
public static void That<T> (ref T actual, IResolveConstraint expression, string message, params object[] args)
{
Constraint constraint = expression.Resolve ();
Assert.IncrementAssertCount ();
if (!constraint.Matches<T> (ref actual))
{
MessageWriter messageWriter = new TextMessageWriter (message, args);
constraint.WriteMessageTo (messageWriter);
throw new AssertionException (messageWriter.ToString ());
}
}
public static void That<T> (ref T actual, IResolveConstraint expression, string message)
{
Assert.That<T> (ref actual, expression.Resolve (), message, null);
}
public static void That<T> (ref T actual, IResolveConstraint expression)
{
Assert.That<T> (ref actual, expression.Resolve (), null, null);
}
public static void That (object actual, IResolveConstraint expression, string message, params object[] args)
{
Constraint constraint = expression.Resolve ();
Assert.IncrementAssertCount ();
if (!constraint.Matches (actual))
{
MessageWriter messageWriter = new TextMessageWriter (message, args);
constraint.WriteMessageTo (messageWriter);
throw new AssertionException (messageWriter.ToString ());
}
}
public static void That (bool condition, string message)
{
Assert.That (condition, Is.True, message, null);
}
public static void That (bool condition)
{
Assert.That (condition, Is.True, null, null);
}
public static void That (TestDelegate code, IResolveConstraint constraint)
{
Assert.That (code, constraint);
}
public static void That (object actual, IResolveConstraint expression, string message)
{
Assert.That (actual, expression, message, null);
}
public static void That (object actual, IResolveConstraint expression)
{
Assert.That (actual, expression, null, null);
}
public static void That (bool condition, string message, params object[] args)
{
Assert.That (condition, Is.True, message, args);
}
public static T Throws<T> (TestDelegate code, string message, params object[] args) where T : Exception
{
return (T)((object)Assert.Throws (typeof(T), code, message, args));
}
public static Exception Throws (Type expectedExceptionType, TestDelegate code)
{
return Assert.Throws (new ExceptionTypeConstraint (expectedExceptionType), code, string.Empty, null);
}
public static T Throws<T> (TestDelegate code) where T : Exception
{
return Assert.Throws<T> (code, string.Empty, null);
}
public static T Throws<T> (TestDelegate code, string message) where T : Exception
{
return Assert.Throws<T> (code, message, null);
}
public static Exception Throws (Type expectedExceptionType, TestDelegate code, string message)
{
return Assert.Throws (new ExceptionTypeConstraint (expectedExceptionType), code, message, null);
}
public static Exception Throws (IResolveConstraint expression, TestDelegate code, string message)
{
return Assert.Throws (expression, code, message, null);
}
public static Exception Throws (IResolveConstraint expression, TestDelegate code, string message, params object[] args)
{
Exception ex = null;
try
{
code ();
}
catch (Exception ex2)
{
ex = ex2;
}
Assert.That (ex, expression, message, args);
return ex;
}
public static Exception Throws (Type expectedExceptionType, TestDelegate code, string message, params object[] args)
{
return Assert.Throws (new ExceptionTypeConstraint (expectedExceptionType), code, message, args);
}
public static Exception Throws (IResolveConstraint expression, TestDelegate code)
{
return Assert.Throws (expression, code, string.Empty, null);
}
public static void True (bool condition)
{
Assert.That (condition, Is.True, null, null);
}
public static void True (bool condition, string message)
{
Assert.That (condition, Is.True, message, null);
}
public static void True (bool condition, string message, params object[] args)
{
Assert.That (condition, Is.True, message, args);
}
}
}
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 敏捷开发 —— TDD（测试驱动开发）
- 使用IdleTest进行TDD单元测试驱动开发演练（3） 之 ASP.NET MVC
- 敏捷开发从测试驱动开始
- 使用IdleTest进行TDD单元测试驱动开发演练（2）
- 如何Vue-cli开始使用在Vue.js项目中启动TDD（测试驱动开发）
- 测试驱动开发(Test-Driven Development，简称TDD)--单元测试-->提高代码质量
- 使用IdleTest进行TDD单元测试驱动开发演练（1）
- 单元测试和测试驱动开发（TDD）杂谈
- 使用IdleTest进行TDD单元测试驱动开发演练（3） 之 ASP.NET MVC
- 如何Vue-cli开始使用在Vue.js项目中启动TDD（测试驱动开发）
- 敏捷联盟Gordon Pask奖获得者讲“测试驱动开发”（TDD）
- 驱动开发TDD介绍
- VS2010 学习笔记 WF4 (5) 加入单元测试，实现测试驱动开发（TDD）
- TDD(测试驱动开发)学习一：初识TDD
- 从今天开始学习iOS开发（iOS 7版）--介绍--教程：基础
- WinCE中nandflash驱动开发介绍
- 如何用Vue-cli在Vue.js项目中启动TDD（测试驱动开发）
- 用户故事驱动的敏捷开发 – 2. 创建backlog
- 在PHP中使用Mockery进行测试驱动开发（TDD） - 上
- 测试驱动开发中的测试，单元测试中的测试的区别