NUnit 使用

软件方法(草稿)第二章 建立模型和UML

一、简介
  NUnit是1款堪与JUnit齐名的开源的回归测试框架,供.net开发人士做单元测试之用,能够从www.nunit.org网址上免费得到,最新版本二.二.6。NUnit
贰.2.6有四个下载文件,那里用的是NUnit-贰.2.陆-net-二.0.msi。下载后双击该公文,然后按提示举行设置,那样系统中就有着NUnit环境了。
二、配置类库
  开发工具小编动用的是微软的Visual Studio.net
二零零六(以下简称vs),打开后点击菜单“文件”->“新建项目”,打开“新建项目”对话框:

<<上一章
下一章>>

图片 1

 

在该对话框中,“项目体系”我采纳的是“Visual
Basic”,假使想使用C#或者J#,请自行选用“其余语言”下的“Visual
C#”或“Visual
J#”,反正操作大致,下面也都会介绍到,但是VC就免谈了;“模板”作者选的是“控制台应用程序”,您也可以选别的“模板”,小编看的例子创制的便是“类库”;名称请自行设定,VB、C#、J#品类笔者都建了,分别起名叫NUnitVB、NUnitCS和NUnitJS,设置好后,点击“分明”按钮。此时项目虽已开立,但尚未保存,请点击“文件”->“全部封存”,打开“保存项目”对话框:

第1章 建模和UML

图片 2

 

经过“浏览”按钮设置“位置”,小编设置的是本机G:\MDZPCK\Microsoft\MySY。
  上面点击菜单“项目”->“添加引用”,打开“添加引用”对话框:

如今未有路,我们走出去,狂台风雨过天边

图片 3

《新空气的声息》;词曲:张全复、毕晓世、解承强,唱:新空气;一九九零

在“.NET”选项卡中找到组件名叫nunit.framework的一项,点击“分明”按钮,此时在品种中就能够利用NUnit类库了。
3、编写用于测试的类
  用于测试的类很简单,名称为Book,只有id和name几个属性,那五个属性将各自用于三个用例个中。
上面开首编写制定,请点击菜单“项目”->“添加类”,打开“添加新项”对话框:

粗放经营的一时已经远去

中原刚迈入改正开放时,出现了许多农家公司家,他们不用讲管理,也不用讲措施,只要胆子大学一年级些,就能获得成功。为啥?当时的市镇差不离环堵萧然,竞争分外少。农民公司家思路很简短:人人都要进食,所以开茶馆能够赚钱。将来那般的思路已经对事情未有什么帮助了,市镇竞争已经够用激烈,十家新开张的餐饮店只怕唯有一家能撑下去,所以农跨国公司业家已经很少见(连农民都更加少了)。软件开发行业也是平等,最起始的时候,会编制程序就了不可,思路也不会细小略:各样集团都要做财务,所以开发财务软件就能追求利益。以后吧?大家每想到三个“点子”,或者有上千人同时在如此想;我们要做3个东西,可能发现市镇上曾经有广大近乎的出品,你卖高价,他就卖低价,你卖低价,他简直就开源。机会驱动、粗放经营的权且已经远去,为了在能够的竞争中获取优势,软件开发组织需求从细节上晋级技能。

许多付出公司内部一再会有部分一把手,他们是项目标中流砥柱。那些“高手”在职业道路的初期做项目也是败退的,但经过在波折中穿梭积聚经验,慢慢初阶能够成功实现项目。可是,“高手”靠的是心血里面包车型大巴隐式知识,那一个知识未有通过整理,也不必然都不利,而且“高手”潜意识里出于利益的设想,并不甘于主动和豪门大快朵颐,本书希望能够讲述一些力所能及被全体团队共享的显式知识,使公司有十分的大希望在差别的品类中复制成功。

本书聚焦于两上边的技巧:须求和设计。关于要求和陈设性,开发人士可能每一天都在做,可是不是理解背后的道理吗?大家来做一些测试:

 

图片 4

此页面上的剧情必要较新本子的 Adobe Flash Player。

图片 5

 

在该对话框中,“类”模板被暗许选中,请将名称修改为Book.vb或Book.cs、Book.jsl,然后点击“添加”按钮。
  类创立后,须求修改代码,VB代码如下:
  Public Class Book
    Dim pid As String = Nothing
    Dim pname As String = Nothing

利润=需求-设计

利润=收入-开销。不管出售什么,要拿走纯利润,需求七个标准化:(壹)要卖出好价钱;(二)创造的资金要低。妙就妙在,价格和本金之间平昔不一定的计算公式,那正是翻新的重力之源。放到软件业上,作者也炮制了一个公式:

利润=需求-设计

在软件开发中,须要工作致力于化解“产品好卖”的难点,设计工作致力于消除“下降资金”的题材。二者无法相互取代。您能低本钱生产某种软件出品,但不肯定能担保它好卖。您的某种产品好卖,但万毕生产成本太高,恐怕在市集急需新型号时,不可能复用在此以前的零部件,又要投入多量人力物力去重新制作,最后照旧赚不了多少钱。

供给设计不分,利润缩水。例如从供给一向照射设计,会促成功能分解得到重新代码。若是从筹划直白找需要,会导致得到一大堆假的“必要”。

拿很久从前就有的一个类别“人体”来比喻。人体对外的效率是会走路,会跑步,会跳跃,会举重,会投掷,会游泳…。不过设计人体的内部结构时,无法从需要平昔照射到统一筹划,获得“走路子系统”、“跑步子系统”、“跳跃子系统”…。人体的“子系统”是“呼吸子系统”、“消化子系统”、“血液循环子系统”、“神经子系统”“内分泌子系统”…..。那些“子系统”湖南中国广播公司大是无法从必要一向找出来的,供给规划人士的想象力。水店老板要雇二个送水工(即租用一位肉系统),他只供给那几个工人能跑能扛就行,管她体内构造如何。同样,也无法从布署性演绎出须求――因为人有心肝脾肺肾,所以人的用例是“心管理”、“肝管理”。送水工能那样找工作吧:老董,笔者有心脏管理效率,你请笔者啊!

图片 6

图一-一 人体的必要和设计

急供给切实,设计要抽象。或许说,须求,要把产品当项目做;设计,要把品种当产品做。后边的章节笔者再逐级演讲那几个理念。

    Property id() As String
      Get
        Return pid
      End Get
      Set(ByVal Value As String)
        pid = Value
      End Set
    End Property

主导工作流

要迈向“低本钱创造好卖的各款产品”的境界,并非喊喊口号就能达成,必要静下心来,学习和实践以下依次主旨工作流中的技能:

  1. 业务建立模型――讲述组织之中各系统(人肉系统、机械系统、电脑系统…)怎么样同盟来为组织的“客户”提供劳动。新系列只可是是共青团和少先队为越来越好地满意客户,对友好的中间重新设计而买入的二个零件(和招聘一个新职工未有本质区别)。要是能学会通过作业建立模型去演绎新系统的供给,而不是拍脑袋得出需要,假的“必要变动”会大大减少。

 

  1. 需求――聚焦于待开发连串的分界,详细描述系统要卖得出去必须有所的外部表现――作用和性格。那项技术的意义在于强迫大家从“卖”的角度想想怎么着是涉众在意的、不能够改变的契约,哪些不是,严防“做”污染“卖”。需要工作流的结果――要求原则表明书是“卖”和“做”的衔接点。

  2. 分析――提炼系统内亟待封装的着力领域体制。可运转的连串必要封装各种领域的学问,在那之中唯有多少个领域(主旨域)的学识是系统能在市镇上生存的说辞。对基本领域作钻探,能够帮忙大家获得基于主旨域的复用。

  3. 设计――将焦点域知识和非主旨域知识结合,最终促成系统。说“代码正是设计”指的就是那狭义的“设计”。代码确实是布署,但代码不是分析,不是供给,不是业务建立模型。很多时候开发人士乱用“设计”那么些词,把“编码以外的有所工作”统统称为“设计”。后来又有牛人说了:代码就是布署性。这么一演绎,不就改成了:代码就是任何?

图片 7

图一-贰 大旨工作流

图片 8

图一-三 宗旨工作流考虑边界

从自个儿的观看所得,以上四项技术,开发团队做得较好的是计划性(也正是完成),前面叁项都格外差,尤其是工作建立模型和剖析,未有收获丰裕的注重。很多开销共青团和少先队拍脑袋编造须要,然后直扑代码,却不知“武功在诗外”。更倒霉的是,一些支付组织以“敏捷”为名,干脆就舍弃了这几个技能的修炼。就如一名从医护人员成长起来的大夫,只控制了注射的技能,却贫乏检查、诊断、拟治疗方案…等技能,索性说:唉,反正再高明的卫生工我,也不可能一个疗程把病者治好,干脆本身也别花那么多情绪了,先随便给病号打一针看看吧,糟糕再来!

唱曲的头面人物,唱到不慢之处,吐字依然干净利落;快节奏的现代足球,职业球员的1招一式还是清清楚楚;星际争霸高手要在极长时间内成功数次操作,动作照旧层序分明。在火爆竞争的时期必要快捷应变,驾驭技术才能真敏捷。

地方的文字本人尚未涉及UML。也正是说,只要你考虑过、表明过地点这么些题材,正是在建立模型,用文件,用自造的号子来发布都得以。而且小编深信,每2个档次,我们都会考虑和表明方面那么些题材,只可是也许是无意地、不严穆地在做,以后大家要上学有意识地做,把它做出利润来。当然,使用UML是近年来1个不坏的选项。

 

    Property name() As String
      Get
        Return pname
      End Get
      Set(ByVal Value As String)
        pname = Value
      End Set
    End Property
  End Class
代码相比简单,没什么可说的啊?上面是C#代码:
  using System;
  using System.Collections.Generic;
  using System.Text;

UML简史

乘机市场馆须要的软件规模持续增大,软件的剖析规划格局一直在前行。从最起头并没有艺术,到归纳的功力分解法,再到数据流/实体关系法。进入198捌年间,面向对象分析设计(OOAD)方文学开头面临推崇,许多方外交家纷繁提议了协调的OOAD方军事学,流行度相比高的方军事学首要有:Booch、Shlaer/Mellor、Wirfs-Brock义务驱动设计、Coad/Yourdon、Rumbaugh OMT和雅各布森 OOSE。

那种百花齐放的规模带来了1个题材:各方医学有和好的壹套概念、定义和标记符号。例如以往UML中的“操作”,在分化方艺术学中的叫法有:权利(Responsibility)、服务(Service)、方法(Method)、成员函数(Member Function)…这么些细小的距离常常会造成杂乱,使开发人士无从接纳,也妨碍了面向对象分析设计方农学的加大。

Booch

Coad/Yourdon

Rumbaugh OMT

UML

图1-四不一样方经济学图形比较

一9九二年,在Rational工作的James Rumbaugh和Grady Booch起首集合OMT和Booch方法。随后,Ivar Jacobson带着他的OOSE方经济学也投入了Rational公司,一同加入那项工作。他们三人被称作“3友”(three amigo)。那项工作导致了相当大的撞击,因为以前,各类方文学的维护者觉得未有要求废弃本人早已选择的表示法来接受联合的表示法。

一9九8年,三友开头与James Odell、Peter Coad、大卫 哈雷尔等源于别的店铺的方外交家同盟,吸纳了他们的名堂精华。199七年二月,全部提议被统10%壹套提出书提交给OMG。1997年二月,OMG全员平等通过UML,并选用为行业内部。从二零零五年起,UML被ISO吸收接纳为正规,UML一.4.二即ISO/IEC 19471,UML二.一.二即ISO/IEC 一九伍零五。

UML诞生时,马丁 Fowler就作了之类预测:

你应当运用UML吗?一个字:是!旧的面向对象符号正在快捷地消失。它们还会残留在UML稳固前出版的书方面,但新的书、小说等等将会整整以UML作为标志。即使你正在使用旧的标志,你就应该在一九九7年间转移到UML。假设您刚刚初叶采纳建立模型符号,你就该一直攻读UML。

――马丁 Fowler著,easehawking译,面向对象分析和设计技术,《非程序员》第陆期,200一。英文原作在网络春日搜索不到。

岁月过去十多年了,UML不断前进,在象征法上已经获得了克制。随便打开一本现在出版的软件开发书,里面倘诺波及建立模型,使用的号子基本都以UML,固然在纸上随便画个草图,样子也是UML的指南。各样主流的费用平台也逐条添加了UML建立模型的效劳。OMG还和种种行业标准组织如DMTF、HL7等缔盟,用UML表明行业标准。

别的,以UML为关键,掀起了一股普及软件工程的狂潮,在UML出现后的几年,不但有关建模的新书数量暴增,包蕴CMM/CMMI、敏捷进度等软件进程立异书籍数量也应运而生了大开间增加。制定UML标准的剧中人物(OMG)、根据标准构建建立模型工具的角色(UML工具厂商)、使用UML工具开发软件的角色(开发职员)这三种剧中人物的退出,也致使建立模型工具的多寡和花色出现了爆炸性的滋长。而以前的数据流等艺术一直不曾象面向对象分析设计艺术1致,出现UML那样的集合表示法,从而带动大批量图书和工具的发生。

最起先一堆UML书籍,基本上是方外交家所写。最近几年,以“UML”为题的新书大多为大学教材或普及性教材。那并不是说UML已经不重大,而是未有须要再去强调,大旨不再是“要不要UML”,而是要不要建立模型、如何建立模型。

依照UMLChina的总括,UML相关工具最多时达16捌种,经过市集的洗礼,现在还在更新的还有近百种。有钱买贵的,没钱就买便宜的还是用免费、开源的。

参考链接

UML新闻:http://www.umlchina.com/News/News.htm

UML工具大全:http://www.umlchina.com/Tools/Newindex1.htm

 

  namespace NUnitCS
  {
    public class Book
    {
      private string pid = null;
      private string pname = null;

各工作流中的UML

UML今后的版本是二.四,包罗的图形如图1-陆所示,一共1四种(泛化树上的叶结点)。

图片 9

图一-五 UML贰.四图片,依照UML2.4专业重新绘制

莫不你看了会说,哇,这么多图,学起来用起来多复杂啊。其实,UML像一个工具箱,里面各样工具都有。您只供给从那些工具箱中甄选对你的档次项目合适的工具用上就足以,并不须要“完整地”使用UML。不只是UML,对编制程序语言也同等的。很四人说“小编用Java”,其实只是用Java的一小部分,而且十分短日子内只用这一小部分就够了。

时常有学员问:潘先生,能否给3个案例,完完整整地履行了方方面面UML?那是一种误解,那样的案例不该有。有局地建立模型工具自带的案例模型会招致误解,一个模子里把具有的UML图都给用上了,但这是工具厂商出于显示其工具建立模型能力的目的而提供的,不可当真。

各工作流能够选取的UML成分以及引入用法如图一-7所示。

工作流

思考焦点

可选UML元素

推荐UML元素

业务建模

组织内系统之间

用例图、类图、序列图、活动图

用例图、类图、序列图

需求

系统边界

用例图、序列图、状态图、活动图、文档

用例图、文档

分析

系统内核心域

类图、序列图、状态图、活动图、通信图、包图

类图、序列图、状态图

设计

系统内各域之间

类图、序列图、状态图、活动图、通信图、组件图、部署图、时间图、组合结构图、包图

不画,代码即设计

图1-6 推荐的UML用法

特定类型的项目,能够按须要丰硕图形,那或多或少后文再描述。

      public string id
      {
        get
        {
          return pid;
        }

宗旨共识上的联系

许多开发人士并不喜欢用UML,更欣赏在白板上画个自造的草图,似流程图非流程图,似类图非类图,然后说“来,小编给大家讲讲!”。那样的做法有3个壮烈的“优点”――因为怎么画都是对的,关于那些草图的解释权归“作者”全数,同事也不佳批评自身,项目要正视于“笔者”头脑中的隐式知识――假若“小编”不“给大家讲讲”,我们就玩不转了。那一点,在有必然阅历、但又窘迫项指标胜败承担主要义务的“高手”身上表现更明了。

但是,那样的做法更像是想经过形式上的难看来遮掩内容上的猥琐。动乱时代,地历史学家在牛棚中用马粪纸做数学推理,不表示就足以因为演算工具简陋就能够允许本人胡乱使用标志和概念;过去的小说家群未有电脑,不意味小说家能够自由写错别字犯语法错误。开发职员故意选拔简陋的方式为简陋的始末开脱,就像同小说家故意采用不佳的纸来掩盖自身文字功力不足的谜底,并不是好现象。

就像数学符号背后蕴藏着数学的着力共识,伍线谱背后饱含着主导乐理一样,UML背后暗含的是对于软件建模的一些宗旨共同的认识。那几个标记幼园的孩儿都会画,但骨子里的共同的认识供给一定的教练和上学才能操纵。在主旨共同的认识上挂钩,效用会高得多,无效的低品位龃龉也会少得多,背后的脓包也会强制性流露来。开发职员倘诺习惯于画“草图”,用“模块”、“个性”等词汇含糊不清地球表面明思想,在审慎建立模型思维的追问之下,往往会衰退,揭发许多事先并没有想到的题材。

图片 10

图1-7 符号背后的中坚共同的认识

直面1个棋局,下一步怎么走?在业余棋手看来随地都是正确答案,在工作棋手眼里,答案唯有两二种,因为事情棋手针对一些主干的技艺形成了共同的认识,大大裁减了思维中的浪费。

        set
        {
          pid = value;
        }
      }

主意和经过

本书讲的是措施(技能),不强调现实某一种进程。拿足球打比方,本书探究的是射门、控球、传接、抢截、定位球、协作的技能,不商量战术,更不钻探更衣间团结、俱乐部运行和俱乐部文化。

公司执行进度立异不难流于格局,根源往往就在于技能的缺少。假设把改良的宗旨先放在技术上,开发职员技能进步了,适用什么样的进度自然就浮出水面,未有需求去里丑捧心某进度。或许说,技能升高了,更能适应分裂的经过。

重重时候方法和经过不时被歪曲,现在平常说“敏捷方法”,其实“敏捷”是经过(家族)。之所以造成这些误会,可能和MartinFowler把她介绍敏捷进程家族的小提及名字为“新方历史学(The New
Methodology)”有关。另叁个广泛的误会来自罗Bert C. 马丁的书《敏捷软件开发-原则、方法与实践》,书中最首要讲的是面向对象设计的部分方法(原理、原则和情势),那么些方式毫无罗Bert C.
马丁首先提议,而且和飞速进度未有早晚涉及,可是,平日会有开发职员误解面向对象设计的那几个思想是便捷人员提出来的。

自作者刚起先为付出团队提供服务时,有三次和贰个付出集团的经营调换,COO说“大家用的是面向进程方法”。小编一初阶认真,认为一旦能成就用面向进度方法,从社团级、系统级到模块级层层分解也不错的。后来发现,老总所说的“面向进度方法”其实是轻易的效益分解,也等于未有办法。

接近的现象还有:开发团队首席执行官说“我们今后选择的是高效进度”,稍为深切了然一下,多半会发现其实她所说的“敏捷进程”正是未有经过。

未有办法不等于面向进度方法,未有经过不对等敏捷进程。面向进度是成熟的方历史学,真正的迅猛进度也是很严肃的历程。不要让“面向进程”、“敏捷”成为偷懒的怜惜所。

还有2个常听到的偷懒珍视所是“软件开发是措施”。软件开发是或不是艺术,笔者不掌握,然则本身的眼光是,固然软件开发到了极高境界真的是方法,大概也不是大家近日有资格谈的。围棋下到很高境界,也有宇宙流、暴力流、大巴流…,但连基本棋理都不曾控制的初学者也胡思乱下妄谈“流派”就不正好了。音乐大师一张画卖到上千万欧元,某人一看,哟,怎么歪歪扭扭的和自己外孙子画的大多呀,孙子,咱也别辛苦学这几个绘画技法了,胡乱画吧,没准哪一天你的画也能卖一千万法郎啊!

      public string name
      {
        get
        {
          return pname;
        }

案例介绍

在开班进入艺术的探赜索隐从前,照例需求先说一下案例项目是何等,本书给出多个:

案例壹:某国软件开发工具厂商AoiSora
System为了在炎黄加大其出品的开发工具,委托中华夏族民共和国的一家软件咨询公司――优马神州公司不定期举行与开发工具相关的免费技术讲座。技术讲座的对象听众为软件开发职员,每期讲座会约请一名产业界著名技术专家庭教育授。讲座已经设置了二十多期,优马神州集团的新兵对现状不顺心了,他梦想有1对转移……

案例2:徐运光是一家软件公司的技巧首席营业官,外甥度岁上初级中学,外甥“小升初”的伟业使得徐运光对初级中学学校,初级中学教授的各个新闻分外关怀。在相连上网收集素材的进度中,他只顾到了2个状态:初中等教育师的家常工作肩负分外重,而且看起来未有好的电脑系统扶助。徐运光想:能还是不能够为初级中学等教育师的一般性工作做1些软件?要是有戏的话,干脆本人开个公司来做?自个儿也四十了,该做一些谈得来的业务了……

首先个案例是个“项目”,源点于客户的渴求;第三个案例是个“产品”,源点于开发职员萌生的想法。

        set
        {
          pname = value;
        }
      }
    }
  }
也没怎么可说的呢?下面是J#代码:
  package NUnitJS;

模型的团协会

建立模型的历程中,大家在分化的工作流使用了1些UML元素,怎样来组织它们?在此以前方的图1-6得以知晓,工作流和所用的UML元素不是各类对应的。模型可以依据UML成分的系列组织,也得以遵照工作流来公司。本书推荐的模型社团办法是按工作流协会,如下图:

图片 11

图1-8 推荐做法――按工作流组织模型

本书提供了2个空手的EA模型(http://www.umlchina.com/training/myproject.rar),模型中曾经依据图一-八的不2诀要建好了包,并且添加了有的构造型(Stereotype)。小编建议直接从本书提供的空域模型开头做,安份守己填空即可。您在熟悉驾驭本书的建模技能今后,假使体会出对您的品类更合理的团组织措施,能够抛弃本书所推荐的主意。若是您日常选用的工具不是EA,而是MagicDraw、StarUML、VP-UML等,也足以自行根据图1-八的措施组织模型。UML工具(包涵EA)一般都会预置①些模板,提出先无视它们。

其它一种常见的模子社团办公室法是按视图来组织,如图一-玖。在此此前Rational
罗丝缺省的团体章程正是这么,最早先自个儿也是如此做的,可是后来发现开发职员不难出难题的地点不是用什么样图,而是当前在做怎么样。开发人士的合计日常跳来跳去,无意识地改变切磋范围,思索的边界一会在系统里头,一会在待开发系列的边际,1会跳到系统里面类的涉及,一会又细到有些操作内部的代码。

图片 12

图1-九 不推荐――按视图协会模型

 

  public class Book
  {
    private String pid = null;
    private String pname = null;

此页面上的剧情须要较新本子的 Adobe Flash Player。

图片 13

 

 

 

 

 

 

    /** @property */
    public void set_id(String value)
    {
      pid = value;
    }
    /** @property */
    public String get_id()
    {
      return pid;
    }

    /** @property */
    public void set_name(String value)
    {
      pname = value;
    }
    /** @property */
    public String get_name()
    {
      return pname;
    }
  }
能够看来,J#代码与VB和C#代码有些差异,因为J#的语法是从Java衍变过来的,所以其天性在概念时被拆成了set_XXX和get_XXX那样的四个格局。但仅有set_XXX和get_XXX那样的七个主意还不够,还亟需接纳@property指令进行认证。纵然用不用@property指令在调用时也没怎么分别,但您可以品味将变量pid和pname更名称叫id和name,重新编译;而后再将@property指令去掉,再重复编译。真的分化。
从那之后,用于测试的类编排成功了。
肆、编写测试用例
  那里只用了二个类进行测试,名叫BookTest,在此以前那样的类可能供给后续NUnit.Framework.TestCase类,但现行反革命只须求对此类应用TestFixture属性进行标识即可,而无须继承了。BookTest类包蕴多少个用例,分别对相应类的testId和testName方法,即每种方法达成了贰个测试用例。注意,在NUnit中,这一个用来落到实处测试用例的点子有三种手段举办标识:三个是以testXXX的格式来定名,3个是应用Test属性进行标识。其它,BookTest还有Init和Dispose那多少个办法,并各自使用SetUp和TearDown属性来展开标识,前者在各样测试方法起头在此之前实施,多用来做初叶化;后者在各样测试方法完结之后执行,多用来清理能源。注意,那多个艺术的称呼并不曾什么范围,但无法不用SetUp和TearDown属性进行标识。其它,NUnit还提供了TestFixtureSetUp和TestFixtureTearDown属性,效能与SetUp和TearDown类似,但前者是在全数用例执行从前做开头化、之后做清理,而后者是在各样用例执行从前做开端化、之后做清理。上面起头工编织制BookTest。
  点击菜单“项目”->“添加类”,打开“添加新项”对话框,将名称改为BookTest.vb或BookTest.cs、BookTest.jsl,然后点击“添加”按钮成立该类。修改代码,VB代码如下:
  Imports NUnit.Framework

  <TestFixture()> _
  Public Class BookTest
    Dim bo As Book = Nothing

    <SetUp()> _
    Public Sub Init()
      Console.WriteLine(“测试初阶!”)
      bo = New Book
      Console.WriteLine(“book对象被开始化!”)
    End Sub

    <Test()> _
    Public Sub testId()
      bo.id = “00一” ‘设置id属性的值为
      ’使用Assert查看id属性的值是或不是为
      Assert.AreEqual(“001”, bo.id)
      Console.WriteLine(“id属性被测试!”)
    End Sub

    <Test()> _
    Public Sub testName()
      bo.name = “ASP” ‘设置name属性的值为ASP
      ’使用Assert查看name属性的值是还是不是为JSP,那是个自然出现错误的测试
      Assert.AreEqual(“JSP”, bo.name)
      Console.WriteLine(“name属性被测试!”)
    End Sub

    <TearDown()> _
    Public Sub Dispose()
      Console.WriteLine(“book对象将被清理!”)
      bo = Nothing
      Console.WriteLine(“测试截止!”)
    End Sub
  End Class
此地Init和Dispose方法没什么好说的,正是实施了对book对象的初阶化和清理,可是testId和testName供给说Bellamy下。前者是在对bo的id属性举行测试,首先赋值为”00一”,然后利用Assert的AreEqual方法查看id属性中存放的值是还是不是是期待的值,由于自己的期待值也是”001”,所以进行后这一个用例应该是成功的;后者则是对bo的name属性实行测试,也是第三赋值为”ASP”,然后接纳Assert的AreEqual方法查看其值是还是不是是期待的,由于自个儿尤其将期待值设定为素有不只怕的”JSP”,因而这么些用例执行后会出现3个荒唐。但请留意,由于自家是专程要让测试出现错误,所以将期待值设定成了不容许的值,假若您是测试人士,请千万不要这么做,不然假使其余地方导致了错误,很简单给本人造成不供给的难为。
  上边不难介绍一下上方用到的静态类NUnit.Framework.Assert。该类重要涵盖十多少个措施:
  一.AreEqual()和AreNotEqual()方法,用来查看七个目的的值是不是等于或不等,与对象相比中利用的Equals()方法类似。
  二.AreSame()和AreNot山姆e()方法,用来比较多个指标的引用是不是等于或不等,类似于通过“Is”或“==”相比八个指标。
  三.Contains()方法,用来查阅对象是还是不是在汇聚中,集合类型应与System.Collections.IList包容。示例:
    Dim o As New Object
    Dim al As New ArrayList
    al.Add(o)
    Assert.Contains(o, al)
  4.Greater()和Less()方法,用来相比五个数值的深浅,前者约等于过量号(>),后者也等于小于号(<)。
  伍.IsInstanceOfType()和IsNotInstanceOfType()方法,用来判定指标是或不是匹配于内定项目。示例:
    Dim t As Type = New Object().GetType
    Dim s As String = “”
    Assert.IsInstanceOfType(t, s)
是因为Object是.net中全部类型的基类,String类型包容于Object,因而这一个示例是力所能及运行通过的。而下边那个示例运转将是失利的:
    Dim t As Type = New ArrayList().GetType
    Dim s As String = “”
    Assert.IsInstanceOfType(t, s)
  6.IsAssignableFrom()和IsNotAssignableFrom()方法,用来判断目的是不是是钦赐类型的实例。示例:
    Dim t As Type = New Object().GetType
    Dim s As String = “”
    Assert.IsAssignableFrom(t, s)
其一示例与事先的言传身教是同壹的,但由于字符串s不是Object类型的,由此不恐怕运维通过。而上边那个实例能够运转通过:
    Dim t As Type = New String(“”).GetType
    Dim s As String = “”
    Assert.IsAssignableFrom(t, s)
  7.IsFalse()和IsTrue()方法,用来查看变量是是不是为false或true,假使IsFalse()查看的变量的值是false则测试成功,要是是true则退步,IsTrue()与之相反。
  八.IsNull()和IsNotNull()方法,用来查看对象是或不是为空和不为空。
  九.IsEmpty()和IsNotEmpty()方法,用来判定字符串或集合是或不是为空白或尚未成分,在那之中集合类型应与ICollection兼容。
  拾.IsNaN()方法,用来判断内定的值是不是不是数字。
  1一.Fail()方法,意为退步,用来抛出荒唐。笔者个人认为有八个用途:首先是在测试驱动开发中,由于测试用例都以在被测试的类以前编写,而写成时又不知道其科学与否,此时就足以选择Fail方法抛出荒谬举办效仿;其次是抛出意外的谬误,比如要测试的剧情是从数据库中读取的数据是或不是正确,而致使错误的原故却是数据库连接战败。
  1二.Ignore()方法,意为忽略,用来忽略后续代码的实施,用途可以参考Fail()方法。
除此以外,NUnit还提供了三个专用于字符串的静态类NUnit.Framework.
StringAssert,该类主要含有伍个主意:
  1.Contains()方法,用来查阅钦赐的第3个字符串中是不是含有了第二个字符串。
  二.StartsWith ()和EndsWith
()方法,分别用来查看内定的率先个字符串是还是不是位于第三个字符串的伊始和末段。
  三.AreEqualIgnoringCase()方法,用来比较多个字符串是还是不是等于。
  下边再看一下C#代码:
  using System;
  using System.Collections.Generic;
  using System.Text;
  using NUnit.Framework;

  namespace NUnitCS
  {
    [TestFixture]
    public class BookTest
    {
      Book book = null;

      [SetUp]
      public void Init()
      {
        Console.WriteLine(“测试起始!”);
        book = new Book();
        Console.WriteLine(“book对象被开头化!”);
      }

      [Test]
      public void testId()
      {
        book.id = “00一”; //设置id属性的值为
        //使用Assert查看id属性的值是还是不是为
        Assert.AreEqual(“001”, book.id);
        Console.WriteLine(“id属性被测试!”);
      }

      [Test]
      public void testName()
      {
        book.name = “ASP”; //设置name属性的值为ASP
        //使用Assert查看name属性的值是不是为JSP,那是个自然出现错误的测试
        Assert.AreEqual(“JSP”, book.name);
        Console.WriteLine(“name属性被测试!”);
      }

      [TearDown]
      public void Dispose()
      {
        Console.WriteLine(“book对象将被清理!”);
        book = null;
        Console.WriteLine(“测试结束!”);
      }
    }
  }
没什么好说的啊?下边看J#代码:
  package NUnitJS;

  import System.*;
  import NUnit.Framework.*;

  /** @attribute TestFixture() */
  public class BookTest
  {
    Book book = null;

    /** @attribute SetUp() */
    public void Init()
    {
      Console.WriteLine(“测试开首!”);
      book = new Book();
      Console.WriteLine(“book对象被初始化!”);
    }

    /** @attribute Test() */
    public void testId()
    {
      book.set_id(“00一”); //设置id属性的值为00一
      //使用Assert查看id属性的值是不是为00一
      Assert.AreEqual(“001”, book.get_id());
      Console.WriteLine(“id属性被测试!”);
    }

    /** @attribute Test() */
    public void testName()
    {
      book.set_id(“ASP”); //设置name属性的值为ASP
      //使用Assert查看name属性的值是还是不是为JSP,那是个肯定出现谬误的测试
      Assert.AreEqual(“JSP”, book.get_name());
      Console.WriteLine(“name属性被测试!”);
    }

    /** @attribute TearDown() */
    public void Dispose()
    {
      Console.WriteLine(“book对象将被清理!”);
      book = null;
      Console.WriteLine(“测试甘休!”);
    }
  }
改好后,点击菜单“调节和测试”->“运维调节和测试”或按F伍键运营程序。等等,main函数里头好象一句代码也没写过吗啊?没有错,一句也没写,可是你照做就足以了。在探望黑屏一闪之后,编码工作形成。
五、运行NUnit
  编码实现后,就足以运用NUnit测试了。NUnit有二种界面,1种是命令行的,一种是可视化的,小编动用的就是后者。点击“开头”菜单->“全体程序”->“NUnit-Net-2.0
贰.2.六”->“NUnit-Gui”,打开NUnit的可视化界面:

图片 14

点击菜单“File”->“Open”,打开刚才运营生成的可执行文件:

图片 15

此刻就足以选拔BookTest类对Book类进行测试了。请首先选取testId,点击“Run”按钮,运维结果如下图:

图片 16

testId前的灰点变绿,而且进度条显示为绿条,这标志运维成功。下边再选择BookTest,点击“Run”按钮,运维结果如下图:

图片 17

testId前的点照旧是栗褐,但testName前的点是庚寅革命,而且进程条呈现为红条,那标志testName中留存不当。但是那一个荒唐是测度之内的,假若不想见到,能够在vs大校testName()方法中的”JSP”改成”ASP”,然后再一次运转。此时无须重新起动NUnit,NUnit会自动加载重新编排好的公文。此时再运营BookTest,进程条已不是革命,而是黄铜色了。
NUnit二.0详细使用办法

前①段时间,有人问作者在.NET里什么进展TDD开发.那个难点促使本人想对NUnit做叁个详细的介绍.因为大家我们都知情NUnit是在.NET实行TDD的利器.

      
借使你早已领悟许多有关NUnit的采取,请提出本人的不规则之处和建议某些提议,使本文尤其完善.倘诺你对NUnit还不是很驾驭的话,笔者建议你依然阅读一下.

     本文分为以下一些:

1. TDD的简介

首先什么是TDD呢?Kent 贝克在他的<<测试驱动开发
>>(Addison-WesleyProfessional,2003)一书中,使用下边3个条件来定义TDD:

·        除非你有3个告负的自动测试,永远不要写一单行代码.

·        阻止重复

      
小编想首先个规格是显眼的.在未曾失利的自动测试下就毫无写代码.因为测试是置于在代码必须知足的须要中.假设没有要求,就一贯不要求完成任陈峰西.所以这些标准阻止大家去达成那1个并未有测试和在化解方案中不要求的效率.

其次个原则表达了在一个先后中,不应有包罗重复的代码.如果代码重复,小编想这正是倒霉的软件设计的象征.随着时间的流逝,它会对先后造成不雷同的难题,并且使代码变丰盛混乱
,因为大家经常不会记得重复代码的地点.借使发现代码重复,笔者想大家应有及时删除代码重复.其实那就涉嫌到重构了.在那里作者就不多讲了.

相似的话,测试分为贰种档次,一是程序员本身的测试,其余一种是客户的测试.关于客户测试,作者引入一个Corolla的框架,相当正确。在那里,大家讲的TDD便是程序员测试.那么怎么样是程序员测试呢?小编以为便是我们常说的单元测试.既然是单元测试,在.NET里势必会用到1些工具,如今最出名大概正是自个儿就要介绍的NUnit了,

2.NUnit的介绍

NUnit是叁个单元测试框架,专门针对于.NET来写的.其实在前头有
JUnit(Java),CPPUnit(C++),他们都以xUnit的一员.最初,它是从JUnit而来.今后的本子是二.2.接下来自个儿所用的都以依据那些版本.

NUnit最初是由James W. Newkirk, 亚历克斯ei A. Vorontsov 和Philip A. Craig,
后来支付协会逐步庞大起来.在支付进程中, Kent Beck 和埃里克h
Gamma四人牛人也提供了众多帮助.看来对于NUnit还真是下了一番马力了.J

 NUnit是xUnit家族种的第6个主打产品,完全由C#言语来编排,并且编写时丰富利用了许多.NET的特点,比如反射,客户属性等等.

 最珍视的某个是它适合于全体.NET语言.

      假若您还不曾下载,能够到http://www.nunit.org/去下载.

2.1 NUnit的介绍

   Ok,上边正式上课NUnit.在教师从前,看看几张图纸:

     图片 18

图一  NUnit运营的功力

图片 19
                     图二   NUnit运营的其它3个功能

      
从中大家得以非常简单发现,右侧是个情景条,图壹是革命的,图2是暗褐的.为何会那样呢?因为倘若具有测试案例运营成功,就为驼灰,反之假使有2个不成事,则为松石绿,但也有暗黑的.左面包车型地铁工作域内则是大家写的每2个单元测试.

通过上边的图形,笔者想你对NUnit有个总的精通了.

接下去依然分为3个部分,1是NUnit的布局,别的1些就是它的中央概念.

先是熟习一下NUnit GUI的布局.

让大家更进一步看一下测试运转器窗口的布局。在左侧面板的中间,能够见见测试进度条。进程条的水彩反映了测试执行的处境:

绿色 描述近日所举办的测试都因此

黄色 意味有个别测试忽略,不过此间未有难倒

红色 表示有波折

底层的景况条表示上面包车型大巴情事:

状态.表达了后唐运作测试的情形。当全数测试完了时,状态成为Completed.运维测试中,状态是Running:
<test-name> (<test-name>是正在周转的测试名称)。

Test
Cases
证实加载的程序集中测试案例的总个数。那也是测试树里叶子节点的个数。

Tests Run 已经做到的测试个数。

Failures  到如今甘休,所有测试中败诉的个数.

Time  展现运转测试时间(以秒计)

File主菜单有以下内容:

New
Project
同意你成立二个新工程。工程是二个测试程序集的联谊。那种体制让你共青团和少先队多少个测试程序集,并把她们作为三个组比较。

Open 加载贰个新的测试程序集,或3个从前保存的NUnit工程文件。

Close闭馆今后加载的测试程序集或未来加载的NUnit工程。

Save
保存未来的Nunit工程到二个文书。倘使正工作单个程序集,本菜单项允许你创造二个新的NUnit工程,并把它保存在文件里。

Save As允许你将现有NUnit工程看成二个文件保留。

Reload
强制重载现有测试程序集或NUnit工程。NUnit-Gui自动监测现加载的测试程序集的变通。

当程序集变化时,测试运转珍视新加载测试程序集。(当测试正运维时,今后加载的测试程序集不会重新加载。在测试运转之间测试程序集仅能够重新加载。3个忠告:要是测试程序集正视别的二个程序集,测试运行器不会考查任何借助的主次集。对测试运转器来说,强制叁个重载使全数依靠的次序集变化可知。

Recent Files 
表达多少个方今在NUnit中加载的测试程序集或NUnit工程(这些列表在Windows注册表,由各类用户维护,因而只要你共享你的PC,你仅看到您的测试)。近期程序集的数量能够利用Options菜单项修改,能够访问Tool主菜单。

Exit退出。

 View菜单有以下内容:

Expand1斑斑增加现在树中所选节点

Collapse 折叠未来树中挑选的节点

Expand All递归扩张树中所选节点后的有所节点

Collapse All递归折叠树中所选节点后的装有节点

Expand Fixtures增添树中拥有表示测试fixture的节点。

Collapse Fixtures 折叠树中具有代表测试fixture的节点。

Properties 展现树中现所选节点的天性。

Tools 菜单由这一个项:

Save Results as XML用作1XML文书保留运营测试的结果。

Options让你定制NUnit的行为。

现行看望右手,你已经纯熟Run按钮和进程条。那里还有二个紧跟Run按钮的Stop按钮:点击那些按钮会停下执行正运维的测试。进度条上面是一个文书窗口,在它下面,由以下多少个标签:

Errors and Failures
窗口呈现失利的测试。在我们的事例里,这几个窗口是空。

 Tests Not Run 窗口体现未有拿走实施的测试。

Console.Error
窗口浮现运转测试爆发的失实消息。那么些此音讯是应用程序代码应用Console.Error输出流能够输出的。

Console.Out窗口体现运转测试打字与印刷到Console.Error输出流的文件新闻。

 

二.二 壹些常用属性

       
接下去,笔者将讲述那么些框架如何使用.同时也关乎到有的卓殊关键的概念,作者想其客户属性是万分首要的.在NUnit里,有以下两种属性:

  • Test Fixture
  • Test

下边作者将对各类特性壹壹讲解.

TestFixtureAttribute

    本属性标记三个类富含测试,当然setup和teardown方法可有可无.(关于setup
和teardown方法在背后介绍)

    做为八个测试的类,那一个类还有局部限量

  • 总得是Public,否则NUnit看不到它的存在.
  • 它必须有七个缺省的构造函数,不然是NUnit不会组织它.
  • 构造函数应该未有别的副作用,因为NUnit在运营时通常会协会这一个类数十次,假如就算构造函数要什么副功效的话,那不是乱了.

举个例子

 
  1  using System;
 2  using NUnit.Framework;
 3  namespace MyTest.Tests
 4{
 5
 6  [TestFixture]
 7  public class PriceFixture
 8  {
 9    // 
10  }
11}
12 
 

TestAttribute

   
Test属性用来标记一个类(已经标记为TestFixture)的有个别方法是能够测试的.为了和原先的本子向后卓殊,头伍个字符(“test”)忽略大小写.
(参看http://nunit.org/test.html)

那么些测试方法能够定义为:

       
 public void MethodName() 

   
从位置能够看出,这么些方式未有别的参数,其实测试方法必须未有参数.假设大家定义方法不对的话,这一个措施不会现出在测试方法列表中.也正是说在NUnit的界面左边的工作域内,看不到这个方法.再有某个就是以此法子不回去任何参数,并且必须为Public.

   例如:

 
  1using System;
 2using NUnit.Framework;
 3
 4namespace MyTest.Tests
 5{
 6  [TestFixture]
 7  public class SuccessTests
 8  {
 9    [Test] public void Test1()
10    { /**//*  */ }
11  }
12}
13
14 

一般来说,有了上面两个属性,你可以做基本的事情了.

另外,我们再对如何进行比较做一个描述。

在NUnit中,用Assert(断言)进行比较,Assert是一个类,它包括以下方法:
AreEqual,AreSame,Equals, Fail,Ignore,IsFalse,IsNotNull,
具体请参看NUnit的文档。

3.如何在.NET中应用NUnit

  作者将举个例子,一步一步演示怎么样去行使NUnit.

第三步.为测试代码创设3个Visual Studio工程。

在Microsoft Visual Studio .NET中,让我们初叶创办3个新的工程。选择Visual
C#工程看成工程项目,Class
Library作为模板。将工程命名称为NUnitQuickStart.图肆-壹是叁个叙述本步骤的Visual
Studio .NET。

 图片 20
                            图 四-一: 创制第陆个NUnit工程

第3步.扩大一个NUnit框架引用

在Microsoft Visual Studio
.NET里创设那一个例牛时,你需求扩展多个nunit.framework.dll引用,如下:

在Solution Explorer右击引用,然后选取增多引用

   nunit.framework组件,在Add Reference对话框中按Select和OK按钮。

图4-2 描述了那步:

 图片 21
图 四-2: 扩充2个 nunit.framework.dll 引用到工程

第3步.为工程加3个类.

为工程加叁个NumbersFixture类。那里是其一事例的代码。

 1图片 22using System; 
 2图片 23using NUnit.Framework; 
 3图片 24  
 4图片 25namespace NUnitQuickStart 
 5图片 26图片 27图片 28
 6图片 29            [TestFixture] 
 7图片 30            public class NumersFixture 
 8图片 31图片 32            图片 33
 9图片 34                        [Test] 
10图片 35                        public void AddTwoNumbers() 
11图片 36图片 37                        图片 38
12图片 39                                    int a=1; 
13图片 40                                    int b=2; 
14图片 41                                    int sum=a+b; 
15图片 42                                    Assert.AreEqual(sum,3); 
16图片 43                        } 
17图片 44            } 
18图片 45}
19图片 46

第四步.建立你的Visual Studio 工程,使用NUnit-Gui测试

从程序->NUnit二.二开拓NUnit-gui,加载本本工程编写翻译的先后集.

为了在Visual Studio
.NET中自行运转NUnit-Gui,你须要建立NUnit-Gui作为你的开发银行程序:

在 Solution Explorer里右击你的NunitQuickStart工程。

在弹出菜单中选取属性。

在呈现的对话框的左侧,点击Configuration Properties夹

选料出未来Configuration Properties夹下的Debugging。

在性质框左侧的Start Action部分,采纳下拉框的Program作为Debug Mode值。

按Apply按钮

设置nunit-gui.exe ** 用作Start
Application。,你既能够键入nunit-gui.exe的全路径,也可利用浏览按钮来指向它。

图4-3 支持描述本步骤:
图片 47图片 48  图片 49

图 肆-3:将NUnit-Gui 作为工程的测试运营器

第5步.编写翻译运维测试.

 以后编写翻译solution。成功编写翻译后,初叶应用程序。NUnit-Gui测试运行器出现。当您首先次起初NUnit-Gui,它开辟时未有测试加载。从File菜单选取Oprn,浏览NUnitQuickStart.dll的路线。当您加载了测试的程序集,测试运行器为加载的次序集的测试发生3个凸现的显现。在例子中,测试程序集仅有贰个测试,测试程序集的结构如图四-四所示:

 图片 50
 图 四-四: 测试程序集的测试在 NUnit-Gui中的视图

按Run按钮。树的节点变为乳白,而且测试运转器窗口上的进程条变绿,水晶色代表成功通过。

 

四.别样的有的基本概念

   下面的例证介绍了骨干的NUnit特性和功用. TestFixture, Test, 和
Assert是三个最基本的表征,大家得以用那么些特征开始展览程序员测试了.不过1对时候,你以为那三个远远不够,比如有个别时候打开贰个数据库连接多次,有未有只让它开辟三次的艺术吗?假使作者想把测试分类,应该怎么着贯彻啊?倘若自个儿想忽视有个别测试,又应当怎样去做到吗?不用担心,NUnit已经有诸如此类的功效了.

上面我们壹1作出回答.

SetUp/TearDown 属性

在早先时期给的test fixture定义里,我们说test
fixture的测试是1组符合规律运维时能源.在测试成功之后,或是在测试执行种,或是释放或解除在此以前,那一个健康运维时财富在1分明的法子上大概必要获得和初步化.NUnit使用1个附加的习性:SetUp
TearDown,就支持那种健康的初阶化/清除.我们地点的事例来叙述这几个成效.让大家扩展乘法.

 1图片 51using System; 
 2图片 52using NUnit.Framework; 
 3图片 53  
 4图片 54namespace NUnitQuickStart 
 5图片 55图片 56图片 57
 6图片 58            [TestFixture] 
 7图片 59            public class NumersFixture 
 8图片 60图片 61            图片 62
 9图片 63                        [Test] 
10图片 64                        public void AddTwoNumbers() 
11图片 65图片 66                        图片 67
12图片 68                                    int a=1; 
13图片 69                                    int b=2; 
14图片 70                                    int sum=a+b; 
15图片 71                                    Assert.AreEqual(sum,3); 
16图片 72                        } 
17图片 73                        [Test] 
18图片 74                        public void MultiplyTwoNumbers() 
19图片 75图片 76                        图片 77
20图片 78                                    int a = 1; 
21图片 79                                    int b = 2; 
22图片 80                                    int product = a * b; 
23图片 81                                    Assert.AreEqual(2, product); 
24图片 82                        } 
25图片 83  
26图片 84            } 
27图片 85
28图片 86

  
大家密切一看,不对,有再次的代码,如何去除重复的代码呢?大家得以领取那么些代码到二个单独的点子,然后标志这些办法为SetUp
属性,那样三个测试方法能够共享对操作数的初叶化了,那里是改变后的代码: 

 1图片 87using System; 
 2图片 88using NUnit.Framework; 
 3图片 89  
 4图片 90namespace NUnitQuickStart 
 5图片 91图片 92图片 93
 6图片 94            [TestFixture] 
 7图片 95            public class NumersFixture 
 8图片 96图片 97            图片 98
 9图片 99                        private int a; 
10图片 100                        private int b; 
11图片 101                        [SetUp] 
12图片 102                        public void InitializeOperands() 
13图片 103图片 104                        图片 105
14图片 106                                    a = 1; 
15图片 107                                    b = 2; 
16图片 108                        } 
17图片 109  
18图片 110                        [Test] 
19图片 111                        public void AddTwoNumbers() 
20图片 112图片 113                        图片 114
21图片 115                                    int sum=a+b; 
22图片 116                                    Assert.AreEqual(sum,3); 
23图片 117                        } 
24图片 118                        [Test] 
25图片 119                        public void MultiplyTwoNumbers() 
26图片 120图片 121                        图片 122
27图片 123                                    int product = a * b; 
28图片 124                                    Assert.AreEqual(2, product); 
29图片 125                        } 
30图片 126  
31图片 127            } 
32图片 128
33图片 129

   这样NUnit将在执行每个测试前执行标记SetUp属性的方法.
在本例中就是执行InitializeOperands()方法.记住,这里这个方法必须为
public,不然就会有以下错误:
Invalid Setup or TearDown method signature

ExpectedException

那里是3个注解这么些只要的测试.有的时候,我们明白一点操作会有出色出现,例如,
在实例中加进除法,有些操作被0除,抛出的不得了和.NET文书档案描述的一样.参看以下源代码.

 1[Test]
2[ExpectedException(typeof(DivideByZeroException))]
3public void DivideByZero()
4{
5   int zero = 0;
6   int infinity = a/zero;
7   Assert.Fail("Should have gotten an exception");
8}
9 

   除了[Test]天性之外, DivideByZero主意有此外三个客户属性:
ExpectedException.在那些天性里,你能够在推行进度中抓获你希望的要命类型,例如在本例正是DivideByZeroException.借使这一个法子在未有抛出希望十分的气象下完了了,那些测试失利.使用那天性情帮忙大家写程序员测试证明边界条件(Boundary
Conditions).

Ignore 属性

  
由于各类原因,有壹部分测试我们不想运维.当然,这么些原因只怕包蕴你认为那一个测试还不曾完毕,这几个测试正在重构之中,这一个测试的须要不是太显然.但你有不想损坏测试,不然进度条可是深藕红的哟.怎么做?使用Ignore属性.你能够有限支撑测试,但又不运营它们.让我们标记MultiplyTwoNumbers测试方法为Ignore属性:

 1[Test]
2[Ignore("Multiplication is ignored")]
3public void MultiplyTwoNumbers()
4{
5   int product = a * b;
6   Assert.AreEqual(2, product);
7} 

   运维测试,现在发出了下边包车型客车出口(在图五-一来得):

 图片 130
图 5-壹: 在1个程序员测试中利用 Ignore属性

  
Ignore性情能够附加到三个单身的测试方法,也得以叠加到全方位测试类(TestFixture).若是Ignore特性附加到TestFixture,有着在fixture的测试都被忽略.

TestFixtureSetUp/TestFixtureTearDown

  
有时,1组测试须要的能源太昂贵.例如,数据库连接恐怕是三个根本能源,在3个test
fixture的每一种测试中,打开/关闭数据库连接大概非常慢.那就是自家在发轫波及的难点.怎样缓解?NUnit有1对近似于前方议论的SetUp/TearDown的属性:
TestFixtureSetUp/TestFixtureTearDown.正如他们名字证明的等同,那个属性用来标记为全方位test
fixture开首化/释放财富方法1遍的方法.

   例如,要是您想为全部test
fixture的测试共享相同的数据库连接对象,大家得以写三个开拓数据库连接的法子,标记为TestFixtureSetUp属性,编写别的二个关闭数据库连接的秘籍,标记为TestFixtureTearDown属性.那里是描述这么些的例子.

  1using NUnit.Framework;
 2
 3[TestFixture]
 4public class DatabaseFixture
 5{
 6   [TestFixtureSetUp]
 7   public void OpenConnection()
 8   {
 9      //open the connection to the database
10   }
11 
12   [TestFixtureTearDown]
13   public void CloseConnection()
14   {
15      //close the connection to the database
16   }
17   
18   [SetUp]
19   public void CreateDatabaseObjects()
20   {
21      //insert the records into the database table
22   }
23 
24   [TearDown]
25   public void DeleteDatabaseObjects()
26   {
27      //remove the inserted records from the database table
28   }
29 
30   [Test]
31   public void ReadOneObject()
32   {
33      //load one record using the open database connection
34   }
35 
36   [Test]
37   public void ReadManyObjects()
38   {
39      //load many records using the open database connection
40   }
41}
42
43 

Test Suite

*   Test Suite*是test case或其他test suite的集合.
合成(Composite),方式描述了test case和test suite之间的关系.

 参考来自NUnit的关于Suite的代码

Suite Attribute

 1图片 131namespace NUnit.Tests
 2图片 132图片 133图片 134{
 3图片 135using System;
 4图片 136  using NUnit.Framework;
 5图片 137 
 6图片 138
 7图片 139
 8图片 140  public class AllTests
 9图片 141图片 142  图片 143{
10图片 144    [Suite]
11图片 145    public static TestSuite Suite
12图片 146图片 147    图片 148{
13图片 149      get
14图片 150图片 151      图片 152{
15图片 153        TestSuite suite = new TestSuite(“All Tests”);
16图片 154        suite.Add(new OneTestCase());
17图片 155        suite.Add(new Assemblies.AssemblyTests());
18图片 156        suite.Add(new AssertionTest());
19图片 157        return suite;
20图片 158      }
21图片 159    }
22图片 160  }
23图片 161
24图片 162

Category属性

 对于测试来说,你有个别时候供给将之分类,此属性正好正是用来缓解那些难点的。

 你能够选拔你须求周转的测试类目录,也足以选用除了这个目录之外的测试都能够运转。在命令行环境里
/include
和/exclude来落成。在GUI环境下,就更简约了,选用左侧工作域里的Catagories
Tab,选用Add和Remove既能够了。

在地方的事例上做了有个别考订,代码如下:

  1using System; 
 2using NUnit.Framework; 
 3  
 4namespace NUnitQuickStart 
 5{ 
 6            [TestFixture] 
 7            public class NumersFixture 
 8            { 
 9                        private int a; 
10                        private int b; 
11                        [SetUp] 
12                        public  void InitializeOperands() 
13                        { 
14                                    a = 1; 
15                                    b = 2; 
16                        } 
17  
18                        [Test] 
19                        [Category("Numbers")] 
20                        public void AddTwoNumbers() 
21                        { 
22                                    int sum=a+b; 
23                                    Assert.AreEqual(sum,3); 
24                        } 
25                        
26                        [Test] 
27                [Category("Exception")] 
28                        [ExpectedException(typeof(DivideByZeroException))] 
29                        public void DivideByZero() 
30                        { 
31                                    int zero = 0; 
32                                    int infinity = a/zero; 
33                                    Assert.Fail("Should have gotten an exception"); 
34                        } 
35                        [Test] 
36                        [Ignore("Multiplication is ignored")] 
37                        [Category("Numbers")] 
38                        public void MultiplyTwoNumbers() 
39                        { 
40                                    int product = a * b; 
41                                    Assert.AreEqual(2, product); 
42                        } 
43  
44               } 
45 
        NUnit-GUI界面如图5-2:



图5-2:使用Catagories属性的界面

Explicit属性

本属性忽略2个test和test fixture,直到它们显式的精选执行。即使test和test
fixture在实践的进度中被察觉,就马虎他们。所以,那样一来进度条展现为原野绿,因为有test或test
fixture忽略了。

 例如:

  

 1图片 163
 2图片 164                        [Test,Explicit] 
 3图片 165                        [Category(“Exception”)] 
 4图片 166                        [ExpectedException(typeof(DivideByZeroException))] 
 5图片 167                        public void DivideByZero() 
 6图片 168图片 169                        图片 170
 7图片 171                                    int zero = 0; 
 8图片 172                                    int infinity = a/zero; 
 9图片 173                                    Assert.Fail(“Should have gotten an exception”); 
10图片 174                        }
11图片 175

    为何会规划成那样吧?原因是Ingore属性忽略了某些test或test
fixture,那么他们你再想调用执行是不容许的。那么万一有1天笔者想调用被忽视的test或test
fixture怎么做,就用Explicit属性了。笔者想那正是内部的原委吧。

Expected Exception属性

  期望在运作时抛出叁个希望的非凡,假诺是,则测试通过,不然不通过。

参照上面包车型大巴事例:

 1图片 176[Test] 
 2图片 177[ExpectedException(typeofInvalidOperationException))] 
 3图片 178public void ExpectAnException() 
 4图片 179图片 180 图片 181
 5图片 182   int zero = 0; 
 6图片 183   int infinity = a/zero; 
 7图片 184   Assert.Fail(“Should have gotten an exception”); 
 8图片 185                       
 9图片 186 } 
10图片 187

   
在本测试中,应该抛出DivideByZeroException,不过希望的是InvalidOperationException,所以不能够透过。
要是我们将[ExpectedException(typeof(InvalidOperationException))]改为[ExpectedException(typeof(DivideByZeroException))],本测试通过。

5 . 测试生命周期合约

   假使记得test
case的概念,在那之中四个属性是测试的独立性或隔开性.SetUp/TearDown主意提供高达测试隔绝性的目标.SetUp保障共享的财富在每种测试运营前科学初阶化,TearDown担保未有运营测试发生的残存副成效.
TestFixtureSetUp/TestFixtureTearDown相同提供平等的指标,不过却在test
fixture范围里,我们刚刚描述的剧情结合了测试框架的周转时容器(test
runner)和你写的测试时期的生命周期合约(life-cycle contract).

  
为了描述这几个合同,大家写三个简单的测试来证实如何办法调用了,怎么合适调用的.那里是代码:

  1using System;
 2using NUnit.Framework;
 3[TestFixture]
 4public class LifeCycleContractFixture
 5{
 6   [TestFixtureSetUp]
 7   public void FixtureSetUp()
 8   {
 9      Console.Out.WriteLine("FixtureSetUp");
10   }
11 
12   [TestFixtureTearDown]
13   public void FixtureTearDown()
14   {
15      Console.Out.WriteLine("FixtureTearDown");
16   }
17   
18   [SetUp]
19   public void SetUp()
20   {
21      Console.Out.WriteLine("SetUp");
22   }
23
24   [TearDown]
25   public void TearDown()
26   {
27      Console.Out.WriteLine("TearDown");
28   }
29 
30   [Test]
31   public void Test1()
32   {
33      Console.Out.WriteLine("Test 1");
34   }
35
36   [Test]
37   public void Test2()
38   {
39      Console.Out.WriteLine("Test 2");
40   }
41
42}
43
44 

   当编写翻译和平运动转那么些测试,能够在System.Console窗口看到上边包车型地铁出口:

 FixtureSetUp
SetUp
Test 1
TearDown
SetUp
Test 2
TearDown
FixtureTearDown

   可以观望, SetUp/TearDown艺术调用在种种测试方法的前后.
整个fixture调用3次TestFixtureSetUp/TestFixtureTearDown方法.

  作者:Milestone

 下载:
一)NUnit的运用文书档案 下载 2)本问的PDF版
下载

3)源代码 下载 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图