精华内容
下载资源
问答
  • (五)判定表驱动法定义:判定表是分析和表达多逻辑条件下执行不同操作的情况的工具。优点:能够将复杂的问题按照各种可能的情况全部列举出来,简明并避免遗漏。因此,利用判定表能够设计出完整的测试用例集合。在...

    (五)判定表驱动法

    定义:判定表是分析和表达多逻辑条件下执行不同操作的情况的工具。

    优点:能够将复杂的问题按照各种可能的情况全部列举出来,简明并避免遗漏。因此,利用判定表能够设计出完整的测试用例集合。在一些数据处理问题当中,某些操作的实施依赖于多个逻辑条件的组合,即:针对不同逻辑条件的组合值,分别执行不同的操作。判定表适合于处理这类问题。

    阅读指南,判定表:

     

    1

    2

    3

    4

    5

    6

    7

    8

    问题

    觉得疲倦吗?

    Y

    Y

    Y

    Y

     

     

     

     

    感兴趣吗?

    Y

    Y

     

     

    Y

    Y

     

     

    糊涂吗?

    Y

     

    Y

     

    Y

     

    Y

     

    建议

    重读

     

     

     

     

    Y

     

     

     

    继续

     

     

     

     

     

    Y

     

     

    跳下一章

     

     

     

     

     

     

    Y

    Y

    休息

    Y

    Y

    Y

    Y

     

     

     

     

     

    判定表由四部分组成,如下图:

     1)        条件桩(Condition Stub):列出了问题的所有条件。通常认为列出的条件的次序无关紧要。

    2)        动作桩(Action Stub):列出了问题规定可能采取的操作。这些操作的排列顺序没有约束。

    3)        条件项(Condition Entry):列出针对它左列条件的取值。在所有可能情况下的真假值。

    4)        动作项(Action Entry):列出在条件项的各种取值情况下应该采取的动作。

    规则及规则合并:

    1)  规则:任何一个条件组合的特定取值及其相应要执行的操作称为规则。在判定表中贯穿条件项和动作项的一列就是一条规则。显然判定表中列出多少组条件取值,也就有多少条规则,既条件项和动作项有多少列。

    2)  化简:就是规则合并有两条或多条规则具有相同的动作,并且其条件项之间存在着极为相似的关系。

    合并举例:

    1)        如下图左端,两规则动作项一样,条件项类似,在1、2条件项分别去Y、N时,无论条件3取何值,都执行同一操作。即要执行的动作与条件3无关。于是可合并。“-”表示与取值无关

     

    2)        与上类似,下图中,无关条件项“-”可包含其他条件项取值,具有相同动作的规则可合并。

     

    3)        化简后的读书指南判定表

     

    1

    2

    3

    4

    问题

    觉得疲倦吗?

    -

    -

    Y

    N

    感兴趣吗?

    Y

    Y

    N

    N

    糊涂吗?

    Y

    N

    -

    -

    建议

    重读

    X

     

     

     

    继续

     

    X

     

     

    跳下一章

     

     

     

    X

    休息

     

     

    X

     

    判定表建立步骤:

    1)  确定规则的个数。假如有n个条件,每个条件有两个取值(0,1),故2n种规则。

    2)  列出所有的条件桩和动作桩

    3)  填入条件项

    4)  填入动作项,等到初始判定表

    5)  简化,合并相似规则(相同动作)

     

    实例1,机器维修

    问题要求:“。。。。。。对功率大于50马力的机器,维修记录不全或已运行10以上的机器,应给予优先的维修处理。。。。。。”,这里假定,“维修记录不全”和“优先维修处理”均已在别处有更严格的定义。请建立判定表。

    解答:

    1、确定规则的个数:这里有3个条件,每个条件有两个取值,故应有2*2*2=8种规则。

    2、列出所有的条件桩和动作桩:

    条件

    功率大于50马力吗?

    维修记录不全吗?

    运行超过10年吗?

    动作

    进行优先处理

    3、填入条件项。可从最后1行条件项开始,逐行向上填满。

    4、填入动作桩和动作项。这样便得到如下图的初始判定表

     

     

     

     

     

     

     

     

     

     

    条件

     

    1

    2

    3

    4

    5

    6

    7

    8

    功率大于50马力吗?

    Y

    Y

    Y

    Y

    N

    N

    N

    N

    维修记录不全吗?

    Y

    Y

    N

    N

    Y

    Y

    N

    N

    运行超过10年吗?

    Y

    N

    Y

    N

    Y

    N

    Y

    N

    工作

    进行优先处理

    X

    X

    X

     

    X

     

    X

     

    作其它处理

     

     

     

    X

     

    X

     

    X

    5、

    初始判定表化简。合并相似规则后得到

     

     

     

     

     

     

     

    条件

     

    1

    2

    3

    4

    5

    功率大于50马力吗?

    Y

    Y

    Y

    N

    N

    维修记录不全吗?

    Y

    N

    N

    -

    -

    运行超过10年吗?

    -

    Y

    N

    Y

    N

    工作

    进行优先处理

    X

    X

     

    X

    X

    作其它处理

     

     

    X

     

    X

     

    实例2,NextData函数的精简决策表

    M1={月份, 每月有30天}

    M2={月份, 每月有31天}

    M3={月份, 2月}                 有29=512条规则

    D1={日期,1~28}                 12月末31日和其它31

    D2={日期,29}                    日月份的31日处理不同

    D3={日期,30}                    平年2月28日处理不同

    D4={日期,31}                    于2月27日

    Y1 ={年:年是闰年}

    Y2 ={年:年不是闰年}

    改进为:

    M1={月份: 每月有30天}

    M2={月份: 每月有31天, 12月除外}

    M4={月份:12月}

    M3={月份: 2月}

    D1={日期:1<=日期<=27}

    D2={日期:28}

    D3={日期:29}

    D4={日期:30}

    D5={日期:31}

    Y1 ={年:年是闰年}

    Y2 ={年:年不是闰年}

    输入变量间存在大量逻辑关系的NextData决策表

     

     

    3.     用决策表测试法测试以下程序:该程序有三个输入变量month、day、year(month、day和year均为整数值,并且满足:1≤month≤12和1≤day≤31),分别作为输入日期的月份、日、年份,通过程序可以输出该输入日期在日历上隔一天的日期。

    例如,输入为2004年11月29日,则该程序的输出为2000年12月1日。

    1)    分析各种输入情况,列出为输入变量month、day、year划分的有效等价类。

    2)    分析程序规格说明,结合以上等价类划分的情况给出问题规定的可能采取的操作(即列出所有的动作桩)。

    3)    根据(1)和(2),画出简化后的决策表。

    案例分析如下:

    Ø  month变量的有效等价类:

    M1: {month=4,6,9,11}              M2: {month=1,3,5,7,8,10}

    M3: {month=12                       }M4: {month=2}

    Ø  day变量的有效等价类:

    D1:{1≤day≤26}                        D2: {day=27}                D3: {day=28}               D4: {day=29}                             D5: {day=30}                D6: {day=31}

    Ø  year变量的有效等价类:

    Y1: {year是闰年}                       Y2:  {year不是闰年}

    4)    考虑各种有效的输入情况,程序中可能采取的操作有以下六种:

    a1: day+2                                 a2: day=2                     a3: day=1

    a4: month+1                            a5: month=1                a6: year+1 

    4.     判定表在功能测试中的应用

    1)    一些软件的功能需求可用判定表表达得非常清楚,在检验程序的功能时判定表也就成为一个不错的工具。如果一个软件的规格说明指出:

    Ø  当条件1和条件2满足,并且条件3和条件4不满足,或者当条件1、3和条件4满足时,要执行操作1。

    Ø  在任一个条件都不满足时,要执行操作2。

    Ø  在条件1不满足,而条件4被满足时,要执行操作3。 根据规格说明得到如下判定表:

    这里,判定表只给出了16种规则中的8种。事实上,除这8条以外的一些规则是指当不能满足指定的条件,执行3种操作时,要执行1个默许的操作。在没必要时,判定表通常可略去这些规则。但如果用判定表来设计测试用例,就必须列出这些默许规则(如下表)。

    规则5

    规则6

    规则7

    规则8

    条件1

    -

    N

    Y

    Y

    条件2

    -

    Y

    Y

    N

    条件3

    Y

    N

    N

    N

    条件4

    N

    N

    Y

    -

    默许操作

    x

    x

    x

    x

    默许的规则 

    2)    判定表的优点和缺点

    Ø  优点:它能把复杂的问题按各种可能的情况一一列举出来,简明而易于理解,也可避免遗漏。

    Ø  缺点:不能表达重复执行的动作,例如循环结构。

    3)    B. Beizer 指出了适合使用判定表设计测试用例的条件:

    Ø  规格说明以判定表形式给出,或很容易转换成判定表。

    Ø  条件的排列顺序不会也不影响执行哪些操作。

    Ø  规则的排列顺序不会也不影响执行哪些操作。

    Ø  每当某一规则的条件已经满足,并确定要执行的操作后,不必检验别的规则。

    Ø  如果某一规则得到满足要执行多个操作,这些操作的执行顺序无关紧要。

    B. Beizer提出这5个必要条件的目的是为了使操作的执行完全依赖于条件的组合。其实对于某些不满足这几条的判定表,同样可以借以设计测试用例,只不过尚需增加其它的测试用例罢了。

     

    展开全文
  • 测试用例设计方法-判定表驱动法

    千次阅读 2017-09-16 19:03:00
    判定表驱动法 定义:判定表是分析和表达多逻辑条件下执行不同操作的情况的工具。 优点:能够将复杂的问题按照各种可能的情况全部列举出来,简明并避免遗漏。因此,利用判定表能够设计出完整的测试用例集合。在一些...

    判定表驱动法

    定义:判定表是分析和表达多逻辑条件下执行不同操作的情况的工具。

    优点:能够将复杂的问题按照各种可能的情况全部列举出来,简明并避免遗漏。因此,利用判定表能够设计出完整的测试用例集合。在一些数据处理问题当中,某些操作的实施依赖于多个逻辑条件的组合,即:针对不同逻辑条件的组合值,分别执行不同的操作。判定表适合于处理这类问题。

    阅读指南,判定表:

     

    1

    2

    3

    4

    5

    6

    7

    8

    问题

    觉得疲倦吗?

    Y

    Y

    Y

    Y

     

     

     

     

    感兴趣吗?

    Y

    Y

     

     

    Y

    Y

     

     

    糊涂吗?

    Y

     

    Y

     

    Y

     

    Y

     

    建议

    重读

     

     

     

     

    Y

     

     

     

    继续

     

     

     

     

     

    Y

     

     

    跳下一章

     

     

     

     

     

     

    Y

    Y

    休息

    Y

    Y

    Y

    Y

     

     

     

     

     

    判定表由四部分组成,如下图:

     1)        条件桩(Condition Stub):列出了问题的所有条件。通常认为列出的条件的次序无关紧要。

    2)        动作桩(Action Stub):列出了问题规定可能采取的操作。这些操作的排列顺序没有约束。

    3)        条件项(Condition Entry):列出针对它左列条件的取值。在所有可能情况下的真假值。

    4)        动作项(Action Entry):列出在条件项的各种取值情况下应该采取的动作。

    规则及规则合并:

    1)  规则:任何一个条件组合的特定取值及其相应要执行的操作称为规则。在判定表中贯穿条件项和动作项的一列就是一条规则。显然判定表中列出多少组条件取值,也就有多少条规则,既条件项和动作项有多少列。

    2)  化简:就是规则合并有两条或多条规则具有相同的动作,并且其条件项之间存在着极为相似的关系。

    合并举例:

    1)        如下图左端,两规则动作项一样,条件项类似,在1、2条件项分别去Y、N时,无论条件3取何值,都执行同一操作。即要执行的动作与条件3无关。于是可合并。“-”表示与取值无关

     

    2)        与上类似,下图中,无关条件项“-”可包含其他条件项取值,具有相同动作的规则可合并。

     

    3)        

    3)        化简后的读书指南判定表

     

    1

    2

    3

    4

    问题

    觉得疲倦吗?

    -

    -

    Y

    N

    感兴趣吗?

    Y

    Y

    N

    N

    糊涂吗?

    Y

    N

    -

    -

    建议

    重读

    X

     

     

     

    继续

     

    X

     

     

    跳下一章

     

     

     

    X

    休息

     

     

    X

     

    判定表建立步骤:

    1)  确定规则的个数。假如有n个条件,每个条件有两个取值(0,1),故2n种规则。

    2)  列出所有的条件桩和动作桩

    3)  填入条件项

    4)  填入动作项,等到初始判定表

    5)  简化,合并相似规则(相同动作)

     

    实例1,机器维修

    问题要求:“。。。。。。对功率大于50马力的机器,维修记录不全或已运行10以上的机器,应给予优先的维修处理。。。。。。”,这里假定,“维修记录不全”和“优先维修处理”均已在别处有更严格的定义。请建立判定表。

    解答:

    1、确定规则的个数:这里有3个条件,每个条件有两个取值,故应有2*2*2=8种规则。

    2、列出所有的条件桩和动作桩:

    条件

    功率大于50马力吗?

    维修记录不全吗?

    运行超过10年吗?

    动作

    进行优先处理

    3、填入条件项。可从最后1行条件项开始,逐行向上填满。

    4、填入动作桩和动作项。这样便得到如下图的初始判定表

     

     

     

     

     

     

     

     

     

     

    条件

     

    1

    2

    3

    4

    5

    6

    7

    8

    功率大于50马力吗?

    Y

    Y

    Y

    Y

    N

    N

    N

    N

    维修记录不全吗?

    Y

    Y

    N

    N

    Y

    Y

    N

    N

    运行超过10年吗?

    Y

    N

    Y

    N

    Y

    N

    Y

    N

    工作

    进行优先处理

    X

    X

    X

     

    X

     

    X

     

    作其它处理

     

     

     

    X

     

    X

     

    X

    5、

    初始判定表化简。合并相似规则后得到

     

     

     

     

     

     

     

    条件

     

    1

    2

    3

    4

    5

    功率大于50马力吗?

    Y

    Y

    Y

    N

    N

    维修记录不全吗?

    Y

    N

    N

    -

    -

    运行超过10年吗?

    -

    Y

    N

    Y

    N

    工作

    进行优先处理

    X

    X

     

    X

    X

    作其它处理

     

     

    X

     

    X

     

    实例2,NextData函数的精简决策表

    M1={月份, 每月有30天}

    M2={月份, 每月有31天}

    M3={月份, 2月}                 有29=512条规则

    D1={日期,1~28}                 12月末31日和其它31

    D2={日期,29}                    日月份的31日处理不同

    D3={日期,30}                    平年2月28日处理不同

    D4={日期,31}                    于2月27日

    Y1 ={年:年是闰年}

    Y2 ={年:年不是闰年}

    改进为:

    M1={月份: 每月有30天}

    M2={月份: 每月有31天, 12月除外}

    M4={月份:12月}

    M3={月份: 2月}

    D1={日期:1<=日期<=27}

    D2={日期:28}

    D3={日期:29}

    D4={日期:30}

    D5={日期:31}

    Y1 ={年:年是闰年}

    Y2 ={年:年不是闰年}

    输入变量间存在大量逻辑关系的NextData决策表

     

     

    3.     用决策表测试法测试以下程序:该程序有三个输入变量month、day、year(month、day和year均为整数值,并且满足:1≤month≤12和1≤day≤31),分别作为输入日期的月份、日、年份,通过程序可以输出该输入日期在日历上隔一天的日期。

    例如,输入为2004年11月29日,则该程序的输出为2000年12月1日。

    1)    分析各种输入情况,列出为输入变量month、day、year划分的有效等价类。

    2)    分析程序规格说明,结合以上等价类划分的情况给出问题规定的可能采取的操作(即列出所有的动作桩)。

    3)    根据(1)和(2),画出简化后的决策表。

    案例分析如下:

    Ø  month变量的有效等价类:

    M1: {month=4,6,9,11}              M2: {month=1,3,5,7,8,10}

    M3: {month=12                       }M4: {month=2}

    Ø  day变量的有效等价类:

    D1:{1≤day≤26}                        D2: {day=27}                D3: {day=28}               D4: {day=29}                             D5: {day=30}                D6: {day=31}

    Ø  year变量的有效等价类:

    Y1: {year是闰年}                       Y2:  {year不是闰年}

    4)    考虑各种有效的输入情况,程序中可能采取的操作有以下六种:

    a1: day+2                                 a2: day=2                     a3: day=1

    a4: month+1                            a5: month=1                a6: year+1 

    4.     判定表在功能测试中的应用

    1)    一些软件的功能需求可用判定表表达得非常清楚,在检验程序的功能时判定表也就成为一个不错的工具。如果一个软件的规格说明指出:

    Ø  当条件1和条件2满足,并且条件3和条件4不满足,或者当条件1、3和条件4满足时,要执行操作1。

    Ø  在任一个条件都不满足时,要执行操作2。

    Ø  在条件1不满足,而条件4被满足时,要执行操作3。 根据规格说明得到如下判定表:

    这里,判定表只给出了16种规则中的8种。事实上,除这8条以外的一些规则是指当不能满足指定的条件,执行3种操作时,要执行1个默许的操作。在没必要时,判定表通常可略去这些规则。但如果用判定表来设计测试用例,就必须列出这些默许规则(如下表)。

    规则5

    规则6

    规则7

    规则8

    条件1

    -

    N

    Y

    Y

    条件2

    -

    Y

    Y

    N

    条件3

    Y

    N

    N

    N

    条件4

    N

    N

    Y

    -

    默许操作

    x

    x

    x

    x

    默许的规则 

    2)    判定表的优点和缺点

    Ø  优点:它能把复杂的问题按各种可能的情况一一列举出来,简明而易于理解,也可避免遗漏。

    Ø  缺点:不能表达重复执行的动作,例如循环结构。

    3)    B. Beizer 指出了适合使用判定表设计测试用例的条件:

    Ø  规格说明以判定表形式给出,或很容易转换成判定表。

    Ø  条件的排列顺序不会也不影响执行哪些操作。

    Ø  规则的排列顺序不会也不影响执行哪些操作。

    Ø  每当某一规则的条件已经满足,并确定要执行的操作后,不必检验别的规则。

    Ø  如果某一规则得到满足要执行多个操作,这些操作的执行顺序无关紧要。

    B. Beizer提出这5个必要条件的目的是为了使操作的执行完全依赖于条件的组合。其实对于某些不满足这几条的判定表,同样可以借以设计测试用例,只不过尚需增加其它的测试用例罢了。

     

    展开全文
  • 实验目的 (1)掌握应用黑盒测试技术进行测试用例设计。 (2)掌握对测试用例进行优化设计方法。 实验内容 日期问题 测试以下程序:该程序有三个输入变量month、day...(1)划分等价类,按照等价类划分设计测试用例;

    实验目的

    (1)掌握应用黑盒测试技术进行测试用例设计。
    (2)掌握对测试用例进行优化设计方法。

    实验内容

    日期问题
    测试以下程序:该程序有三个输入变量month、day、year(month、day和year均为整数值,并且满足:1≤month≤12、1≤day≤31和1900≤year≤2050),分别作为输入日期的月份、日、年份,通过程序可以输出该输入日期在日历上隔一天的日期。例如,输入为2004 年11月30日,则该程序的输出为2004年12月1日。
    (1)划分等价类
    (2)按照等价类划分法设计测试用例;
    (3)按照边界值分析法设计测试用例;
    (4)按照判定表驱动法设计测试用例。
    (5)编写nextDate函数;
    (6)掌握Junit4的用法,使用Junit4测试nextDate函数。
    JUnit4是JUnit框架有史以来的最大改进,其主要目标便是利用Java5的Annotation特性简化测试用例的编写。
    掌握Junit4定义的一些常见Annotations:

    org.junit.Test 
    org.junit.Before
    org.junit.After
    org.junit.BeforeClass
    org.junit.AfterClass
    org.junit.Ignore
    org.junit.runner.RunWith
    org.junit.runners.Suite.SuiteClasses
    org.junit.runners.Parameterized.Parameters
    

    实验要求

    (1)根据题目要求编写测试用例;
    (2)准备nextDate函数,使用Junit4测试执行测试;
    (3)实验结果要求给出测试用例集测试效果比较。
    (4)撰写实验报告。

    实验过程

    (1)根据题目要求编写测试用例

    划分等价类并编号

    输入数据有效等价类无效等价类
    (1) 1900到2050内的闰年整数(10) year<1900
    (2) 1900到2050内的平年整数(11) year>2050
    (12) 其他输入
    (3) 1,3,5,7,8,10,12内的整数(13) month<1
    (4) 4,6,9,11内的整数(14) 12<month
    (5) 2(15) 其他输入
    (6) 1~28(16) day<1
    (7) 29(17) year为闰年 month=2时,29<day
    (8) 30(18) year为非闰年 month=2时,28<day
    (9) 31(19) month=1,3,5,7,8,10,12时,31<day
    (20) month=4,6,9,11时,30<day
    (21) day>31
    (22) 其他输入

    按照等价类划分法设计测试用例

    1)为有效等价类设计测试用例

    序号测试数据期望结果覆盖范围
    12016 2 29下一天是2016年3月1日!(1)(5)(7)
    22017 1 28下一天是2017年1月29日!(2)(3)(6)
    32017 1 31下一天是2017年2月1日!(2)(3)(9)
    42017 4 30下一天是2017年5月1日!(2)(4)(8)
    52017 12 31下一天是2018年1月1日!(2)(3)(9)

    2)为每一个无效等价类至少设计一个测试用例

    序号输入数据期望结果覆盖范围
    61899 3 1年的值不在指定范围之内(10)
    72051 3 1年的值不在指定范围之内(11)
    8205% 3 1无效的输入日期!(12)
    91901 -1 1月的值不在指定范围之内(13)
    101901 13 1月的值不在指定范围之内(14)
    111901 1% 1无效的输入日期!(15)
    121901 1 -1日的值不在指定范围之内(16)
    132016 2 30日的值不在指定范围之内(17)
    142017 2 29日的值不在指定范围之内(18)
    152017 3 32日的值不在指定范围之内(19)
    162017 4 31日的值不在指定范围之内(20)
    172017 4 32日的值不在指定范围之内(21)
    182017 4 3%无效的输入日期!(22)

    按照边界值分析法设计测试用例

    测试用例monthdayYear针对的有效类期望输出
    17101889(1)(2)年的值不在指定范围内
    27101900(1)(2)19000711
    37101901(1)(2)19010711
    47102049(1)(2)20490711
    57102050(1)(2)20500711
    67102051(1)(2)年的值不在指定范围内
    70102019(3)~(6)月的值不在指定范围内
    81102019(3)~(6)20190111
    92102019(3)~(6)20190211
    1011102019(3)~(6)20191111
    1112102019(3)~(6)20191211
    1213102019(3)~(6)月的值不在指定范围内
    132272019(5)(7)~(9)20190228
    142282019(5)(7)~(9)20190301
    152292019(5)(7)~(9)日的值不在指定范围内
    162282020(5)(7)~(9)20200229
    172292020(5)(7)~(9)20200301
    182302020(5)(7)~(9)日的值不在指定范围内
    191302019(3)(9)(10)20190131
    201312019(3)(9)(10)20190201
    211322019(3)(9)(10)日的值不在指定范围内
    224302019(4)(9)(10)20190501
    234312019(4)(9)(10)日的值不在指定范围内
    244322019(4)(9)(10)日的值不在指定范围内

    按照判定表驱动法设计测试用例

    条件桩

    M 1 = m o n t h : 这 个 月 有 30 天 M_1={month:这个月有30天} M1=month:30
    M 2 = m o n t h : 这 个 月 有 31 天 , 除 了 12 月 M_2={month:这个月有31天,除了12月} M2=month:3112
    M 3 = m o n t h : 这 个 月 是 12 月 M_3={month:这个月是12月} M3=month:12
    M 4 = m o n t h : 这 个 月 是 2 月 M_4={month:这个月是2月} M4=month:2
    D 1 = d a y : 1 ≤ d a y ≤ 27 D_1={day:1≤day≤27} D1=day:1day27
    D 2 = d a y : d a y = 28 D_2={day:day=28} D2=day:day=28
    D 3 = d a y : d a y = 29 D_3={day:day=29} D3=day:day=29
    D 4 = d a y : d a y = 30 D_4={day:day=30} D4=day:day=30
    D 5 = d a y : d a y = 31 D_5={day:day=31} D5=day:day=31
    Y 1 = y e a r : y e a r 是 闰 年 Y_1={year:year是闰年} Y1=year:year
    Y 2 = y e a r : y e a r 不 是 闰 年 Y_2={year:year不是闰年} Y2=year:year

    动作桩

    A 0 : 不 可 能 A_0:不可能 A0
    A 1 : d a y + 1 A_1:day+1 A1:day+1
    A 2 : d a y 复 位 A_2:day复位 A2:day
    A 3 : m o n t h + 1 A_3:month+1 A3:month+1
    A 4 : m o n t h 复 位 A_4:month复位 A4:month
    A 5 : y e a r + 1 A_5:year+1 A5:year+1

    判断表

    规则12345678910111213141516171819202122
    条件:
    C 1 : m o n t h 是 C_1:month是 C1:month M 1 M_1 M1 M 1 M_1 M1 M 1 M_1 M1 M 1 M_1 M1 M 1 M_1 M1 M 2 M_2 M2 M 2 M_2 M2 M 2 M_2 M2 M 2 M_2 M2 M 2 M_2 M2 M 3 M_3 M3 M 3 M_3 M3 M 3 M_3 M3 M 3 M_3 M3 M 3 M_3 M3 M 4 M_4 M4 M 4 M_4 M4 M 4 M_4 M4 M 4 M_4 M4 M 4 M_4 M4 M 4 M_4 M4 M 4 M_4 M4
    C 2 : d a y 是 C_2:day是 C2:day D 1 D_1 D1 D 2 D_2 D2 D 3 D_3 D3 D 4 D_4 D4 D 5 D_5 D5 D 1 D_1 D1 D 2 D_2 D2 D 3 D_3 D3 D 4 D_4 D4 D 5 D_5 D5 D 1 D_1 D1 D 2 D_2 D2 D 3 D_3 D3 D 4 D_4 D4 D 5 D_5 D5 D 1 D_1 D1 D 2 D_2 D2 D 2 D_2 D2 D 3 D_3 D3 D 3 D_3 D3 D 4 D_4 D4 D 5 D_5 D5
    C 3 : y e a r 是 C_3:year是 C3:year − - − - − - − - − - − - − - − - − - − - − - − - − - − - − - − - Y 1 Y_1 Y1 Y 2 Y_2 Y2 Y 1 Y_1 Y1 Y 2 Y_2 Y2 − - − -
    动作:
    A 0 = 不 可 能 A_0=不可能 A0= √ \surd √ \surd √ \surd √ \surd
    A 1 : d a y + 1 A_1:day+1 A1:day+1 √ \surd √ \surd √ \surd √ \surd √ \surd √ \surd √ \surd √ \surd √ \surd √ \surd √ \surd √ \surd √ \surd
    A 2 : d a y 复 位 A_2:day复位 A2:day √ \surd √ \surd √ \surd √ \surd √ \surd
    A 3 : m o n t h + 1 A_3:month+1 A3:month+1 √ \surd √ \surd √ \surd √ \surd
    A 4 : m o n t h 复 位 A_4:month复位 A4:month √ \surd
    A 5 : y e a r + 1 A_5:year+1 A5:year+1 √ \surd

    简化判断表

    规则1
    2
    3
    456
    7
    8
    9
    1011
    12
    13
    14
    15161718192021
    22
    条件:
    C 1 : m o n t h 是 C_1:month是 C1:month M 1 M_1 M1 M 1 M_1 M1 M 1 M_1 M1 M 2 M_2 M2 M 2 M_2 M2 M 3 M_3 M3 M 3 M_3 M3 M 4 M_4 M4 M 4 M_4 M4 M 4 M_4 M4 M 4 M_4 M4 M 4 M_4 M4 M 4 M_4 M4
    C 2 : d a y 是 C_2:day是 C2:day D 1 D_1 D1
    D 2 D_2 D2
    D 3 D_3 D3
    D 4 D_4 D4 D 5 D_5 D5 D 1 D_1 D1
    D 2 D_2 D2
    D 3 D_3 D3
    D 4 D_4 D4
    D 5 D_5 D5 D 1 D_1 D1
    D 2 D_2 D2
    D 3 D_3 D3
    D 4 D_4 D4
    D 5 D_5 D5 D 1 D_1 D1 D 2 D_2 D2 D 2 D_2 D2 D 3 D_3 D3 D 4 D_4 D4 D 4 D_4 D4
    D 5 D_5 D5
    C 3 : y e a r 是 C_3:year是 C3:year − - − - − - − - − - − - − - − - Y 1 Y_1 Y1 Y 2 Y_2 Y2 Y 1 Y_1 Y1 Y 2 Y_2 Y2 − -
    动作:
    A 0 = 不 可 能 A_0=不可能 A0= √ \surd √ \surd √ \surd
    A 1 : d a y + 1 A_1:day+1 A1:day+1 √ \surd √ \surd √ \surd √ \surd √ \surd
    A 2 : d a y 复 位 A_2:day复位 A2:day √ \surd √ \surd √ \surd √ \surd √ \surd
    A 3 : m o n t h + 1 A_3:month+1 A3:month+1 √ \surd √ \surd √ \surd √ \surd
    A 4 : m o n t h 复 位 A_4:month复位 A4:month √ \surd
    A 5 : y e a r + 1 A_5:year+1 A5:year+1 √ \surd

    设计测试用例

    测试用例monthdayyear期望输出
    1~3916201920190917
    4930201920191001
    59312019日的值不在指定范围内
    6~9116201920190117
    10131201920190201
    11~141216201920191217
    151231201920200101
    16216201920190217
    17228201920190301
    18228202020200229
    19229202020200301
    202292019日的值不在指定范围内
    21,222302019日的值不在指定范围内

    (2)编写nextDate函数,使用Junit4测试执行测试

    被测代码

    package io.shentuzhigang.demo.blackbox;
    
    import java.util.regex.Pattern;
    
    /**
     * @author ShenTuZhiGang
     * @version 1.0.0
     * @date 2021-05-06 15:43
     */
    public class Date {
        private static final Pattern pattern = Pattern.compile("^[-\\+]?[\\d]*$");
    
        public static String nextDate(String s_year, String s_month, String s_day) {
            //检测是否存在无效字符
            if (!(isInteger(s_year) && isInteger(s_month) && isInteger(s_day))) {
                return "无效的输入日期!";
            }
            //将字符串转为int
            int year = Integer.parseInt(s_year);
            int month = Integer.parseInt(s_month);
            int day = Integer.parseInt((s_day));
            boolean flag = false;
            if (year < 1900 || year > 2050) {
                return ("年的值不在指定范围之内");
            } else if (month > 12 || month < 1) {
                return ("月的值不在指定范围之内");
            } else if (day > 31 || day < 1) {
                return ("日的值不在指定范围之内");
            }
    
            switch (month) {
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                    if (day == 31) {
                        day = 1;
                        month = month + 1;
                    } else {
                        day = day + 1;
                    }
                    break;
                case 4:
                case 6:
                case 9:
                case 11:
                    if (day == 30) {
                        day = 1;
                        month = month + 1;
                    } else if (day == 31) {
                        flag = true;
                    } else {
                        day = day + 1;
                    }
                    break;
                case 12:
                    if (day == 31) {
                        day = 1;
                        month = 1;
                        year = year + 1;
                    } else {
                        day = day + 1;
                    }
                    break;
                case 2: {
                    if (((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)) {
                        // 闰年
                        if (day == 29) {
                            day = 1;
                            month = 3;
                        } else if (day < 29) {
                            day = day + 1;
                        } else {
                            flag = true;
                            // day超过29
                        }
                    } else {
                        //非闰年
                        if (day == 28) {
                            day = 1;
                            month = 3;
                        } else if (day < 28) {
                            day = day + 1;
                        } else {
                            flag = true;
                        }
                    }
    
                }
                break;
                default:
            }
    
            if (year > 2050) {
                return ("年的值不在指定范围之内");
            } else if (flag) {
                return ("日的值不在指定范围之内");
            } else {
                return ("下一天是" + year + "年" + month + "月" + day + "日!");
            }
        }
    
        /**
         * 判断输入字符串是否是整数型
         *
         * @param str
         * @return
         */
        public static boolean isInteger(String str) {
            return pattern.matcher(str).matches();
        }
    }
    
    
    package io.shentuzhigang.demo.test.blackbox;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStreamReader;
    
    
    public class Exp2 {
    
    
        public static void main(String[] args) throws IOException {
            // TODO Auto-generated method stub
            int year, month, day;
            BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
            System.out.println("输入年:");
            year = Integer.parseInt(br.readLine());
            System.out.println("输入月:");
            month = Integer.parseInt(br.readLine());
            System.out.println("输入日:");
            day = Integer.parseInt(br.readLine());
            String nextday = Exp2.nextDate(year, month, day);
            System.out.println("下一天为" + nextday);
        }
    
        public static String nextDate(int y, int m, int d) {
            int year, month, day;
            year = y;
            month = m;
            day = d;
            String result = new String();
    
            switch (month) {
                case 1:
                case 3:
                case 5:
                case 7:
                case 8:
                case 10:
                    if (day == 31) {
                        day = 1;
                        month = month + 1;
                    } else
                        day = day + 1;
                    break;
                case 4:
                case 6:
                case 9:
                case 11:
                    if (day == 30) {
                        day = 1;
                        month = month + 1;
                    } else if (day == 31) {
                        System.out.println("无效输入日期!");
                        //continue;
                    } else
                        day = day + 1;
                    break;
                case 12:
                    if (day == 31) {
                        day = 1;
                        month = 1;
                        year = year + 1;
                    } else if (day < 31) {
                        day = day + 1;
                    }
                    break;
                case 2: {
                    if (day == 28)
                        if (((year % 4 == 0 && year % 100 != 0) || year % 400 == 0)) {
                            day = 29;
                        } else {
                            day = 1;
                            month = 3;
                        }
                    else if (day == 29) {
                        day = 1;
                        month = 3;
                    } else if (day < 28) {
                        day = day + 1;
                    } else {
                        //System.out.println("无效输入日期!");
                        result = "无效输入日期!";
                        //continue;
                    }
                }
                break;
                default:
            }
    
            if (year >= 1900 && year <= 2050 && month <= 12 && month >= 1
                    && day <= 31 && day >= 1) {
                //System.out.println("下一天是" + year + "年" + month + "月" + day	+ "日!");
                StringBuilder months = new StringBuilder();
                StringBuilder days = new StringBuilder();
                if (month < 10)
                    months = months.append(0).append(month);
                else
                    months = months.append(month);
                if (day < 10)
                    days = days.append(0).append(day);
                else
                    days = days.append(day);
                StringBuilder resultB = new StringBuilder().append(year).append(months).append(days);
                result = resultB.toString();
            } else if (year < 1900 || year > 2050) {
                //System.out.println("年的值不在指定范围内");
                result = "年的值不在指定范围内";
            } else if (month > 12 || month < 1) {
                //System.out.println("月的值不在指定范围内");
                result = "月的值不在指定范围内";
            } else if (day > 31 || day < 1) {
                //System.out.println("日的值不在指定范围内");
                result = "日的值不在指定范围内";
            } else result = null;
            return result;
        }
    }
    
    
    

    测试过程

    等价类划分法

    测试类
    package io.shentuzhigang.demo.blackbox;
    
    import org.junit.Assert;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.junit.runners.Parameterized;
    import org.junit.runners.Parameterized.Parameters;
    
    import java.util.Arrays;
    import java.util.Collection;
    
    /**
     * @author ShenTuZhiGang
     * @version 1.0.0
     * @date 2021-05-06 15:43
     */
    @RunWith(Parameterized.class)
    public class DateTests {
        private String input1;
        private String input2;
        private String input3;
        private String expected;
    
        @Parameters
        public static Collection<?> prepareData(){
            String [][] object = {
                    // 有效等价类
                    {"2016","2","29","下一天是2016年3月1日!"},
                    {"2017","1","28","下一天是2017年1月29日!"},
                    {"2017","1","31","下一天是2017年2月1日!"},
                    {"2017","4","30","下一天是2017年5月1日!"},
                    // 无效等价类
                    {"1899","3","1","年的值不在指定范围之内"},
                    {"2051","3","1","年的值不在指定范围之内"},
                    {"205%","3","1","无效的输入日期!"},
                    {"1901","-1","1","月的值不在指定范围之内"},
                    {"1901","13","1","月的值不在指定范围之内"},
                    {"1901","1%","1","无效的输入日期!"},
                    {"1901","1","-1","日的值不在指定范围之内"},
                    {"2016","2","30","日的值不在指定范围之内"},
                    {"2017","2","29","日的值不在指定范围之内"},
                    {"2017","3","32","日的值不在指定范围之内"},
                    {"2017","4","31","日的值不在指定范围之内"},
                    {"2017","4","32","日的值不在指定范围之内"},
                    {"2017","4","3%","无效的输入日期!"}
            };
            return Arrays.asList(object);
        }
        public DateTests(String input1,String input2,String input3,String expected){
            this.input1 = input1;
            this.input2 = input2;
            this.input3 = input3;
            this.expected = expected;
    
        }
        @Test
        public void testDate(){
            String result = Date.nextDate(input1,input2,input3);
            Assert.assertEquals(expected,result);
        }
    }
    
    
    
    测试结果

    在这里插入图片描述

    边界值分析法

    测试类
    package io.shentuzhigang.demo.test.blackbox;
    
    import org.junit.Assert;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.junit.runners.Parameterized;
    
    import java.util.Arrays;
    import java.util.Collection;
    
    /**
     * @author ShenTuZhiGang
     * @version 1.0.0
     * @date 2021-05-13 14:55
     */
    @RunWith(Parameterized.class)
    public class DateBoundaryTests {
        private int input1;
        private int input2;
        private int input3;
        private String expected;
    
        @Parameterized.Parameters
        public static Collection<?> prepareData(){
            Object [][] object = {
                    //年
                    {1889, 7, 10, "年的值不在指定范围内"},
                    {1900, 7, 10, "19000711"},
                    {1901, 7, 10, "19010711"},
                    {2049, 7, 10, "20490711"},
                    {2050, 7, 10, "20500711"},
                    {2051, 7, 10, "年的值不在指定范围内"},
                    //月
                    {2019, 0, 10, "月的值不在指定范围内"},
                    {2019, 1, 10, "20190111"},
                    {2019, 2, 10, "20190211"},
                    {2019, 11, 10, "20191111"},
                    {2019, 12, 10, "20191211"},
                    {2019, 13, 10, "月的值不在指定范围内"},
                    //日
                    {2019, 2, 27, "20190228"},
                    {2019, 2, 28, "20190301"},
                    {2019, 2, 29, "日的值不在指定范围内"},
                    {2020, 2, 28, "20200229"},
                    {2020, 2, 29, "20200301"},
                    {2020, 2, 30, "日的值不在指定范围内"},
    
                    {2019, 1, 30, "20190131"},
                    {2019, 1, 31, "20190201"},
                    {2019, 1, 32, "日的值不在指定范围内"},
                    {2019, 4, 30, "20190501"},
                    {2019, 4, 31, "日的值不在指定范围内"},
                    {2019, 4, 32, "日的值不在指定范围内"},
                    
            };
            return Arrays.asList(object);
        }
        public DateBoundaryTests(int input1,int input2,int input3,String expected){
            this.input1 = input1;
            this.input2 = input2;
            this.input3 = input3;
            this.expected = expected;
    
        }
        @Test
        public void testDate(){
            String result = Exp2.nextDate(input1,input2,input3);
            Assert.assertEquals(expected, result);
        }
    }
    
    
    测试结果

    在这里插入图片描述

    判定表驱动法

    测试类
    package io.shentuzhigang.demo.test.blackbox;
    
    import org.junit.Assert;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.junit.runners.Parameterized;
    
    import java.util.Arrays;
    import java.util.Collection;
    
    /**
     * @author ShenTuZhiGang
     * @version 1.0.0
     * @date 2021-05-13 14:59
     */
    @RunWith(Parameterized.class)
    public class DateDecisionTests {
        private int input1;
        private int input2;
        private int input3;
        private String expected;
    
        @Parameterized.Parameters
        public static Collection<?> prepareData(){
            Object [][] object = {
                    {2019, 9, 16, "20190917"},
                    {2019, 9, 30, "20191001"},
                    {2019, 9, 31, "日的值不在指定范围内"},
                    {2019, 1, 16, "20190117"},
                    {2019, 1, 31, "20190201"},
                    {2019, 12, 16, "20191217"},
                    {2019, 12, 31, "20200101"},
                    {2019, 2, 16, "20190217"},   //7
                    {2019, 2, 28, "20190301"},    //8
                    {2020, 2, 28, "20200229"},
                    {2020, 2, 29, "20200301"},
                    {2019, 2, 29, "日的值不在指定范围内"},   //11
                    {2019, 2, 30, "日的值不在指定范围内"},
            };
            return Arrays.asList(object);
        }
        public DateDecisionTests(int input1,int input2,int input3,String expected){
            this.input1 = input1;
            this.input2 = input2;
            this.input3 = input3;
            this.expected = expected;
    
        }
        @Test
        public void testDate(){
            String result = Exp2.nextDate(input1,input2,input3);
            Assert.assertEquals(expected, result);
        }
    }
    
    
    测试结果

    在这里插入图片描述

    缺陷分析

    1. 用例?发生故障的原因是程序先判断day为29就变为3月1日,而不先判断是否为闰年,于是用例?的输出结果为2007-3-1而不是无效输入日期。
    2. 用例?发生故障的原因是程序没有先判断接收的三个参数是否在指定范围内,而是先根据month进行数据处理,再判断处理后的参数是否在指定范围内,用例?的参数因为month为3所以直接day+1由0变成1再判断day在指定范围内,所以用例?的输出结果为1998-3-1而不是日的值不在指定范围内。

    心得与体会

    (1)掌握应用黑盒测试技术进行测试用例设计。
    (2)掌握对测试用例进行优化设计方法。
    (3)能用Junit实施参数化测试

    参考文章

    使用等价类划分法以及Junit的参数化测试,测试nextDate函数
    使用边界值分析法与判定表驱动法设计测试用例,测试nextDate函数

    展开全文
  • (七)判定表驱动法

    千次阅读 2015-04-14 14:41:14
    2.1 判定表了解 1)定义: 判定表也称决策表,是分析和表达逻辑条件下执行不同操作的情况下的工具。它能够将复杂的问题按照各种可能的情况全部列举出来,简明并避免遗漏,设计出完成的测试用例集合。 2)组成: ...

    2.1  判定表了解

    1)定义:

    判定表也称决策表,是分析和表达逻辑条件下执行不同操作的情况下的工具。它能够将复杂的问题按照各种可能的情况全部列举出来,简明并避免遗漏,设计出完成的测试用例集合。

    2)组成:

    1) 条件桩(Condition Stub):列出了问题得所有条件。通常认为列出的条件的次序无关紧要。

    2) 动作桩(Action Stub):列出了问题规定可能采取的操作。这些操作的排列顺序没有约束。

    3) 条件项(Condition Entry):列出针对它左列条件的取值。在所有可能情况下的真假值。

    4) 动作项(Action Entry):列出在条件项的各种取值情况下应该采取的动作。

    3)合并规则:

    1) 规则:任何一个条件组合的特定取值及其相应要执行的操作称为规则。在判定表中贯穿条件项和动作项的一列就是一条规则。显然,判定表中列出多少组条件取值,也就有多少条规则,既条件项和动作项有多少列。

    2) 化简:就是规则合并有两条或多条规则具有相同的动作,并且其条件项之间存在着极为相似的关系。

    4)判定表的建立步骤:

    1) 确定规则的个数。假如有n个条件,每个条件有两个取值(0,1),故2的n次方种规则。

    2) 列出所有的条件桩和动作桩

    3) 填入条件项的取值

    4) 填入动作项的取值,得到初始判定表

    5) 简化,合并相似规则(相同动作)

    2.2  引用的例子

    例子:打印机是否能打印出来正确的内容,有多个因素影响,包括驱动程序、纸张、墨粉等。(为了简化问题,不考虑中途断电、卡纸等因素的影响)

    1)列出条件桩和动作桩

    条件桩:

    (1) 驱动程序是否正确?

    (2) 是否有纸张?

    (3) 是否有墨粉?

    动作桩:(动作桩有两种:打印内容和不同的错误提示,并且假定:优先警告缺纸,然后警告没有墨粉,最后警告驱动程序不对。)

    (1) 打印内容

    (2) 提示驱动程序不对

    (3) 提示没有纸张

    (4) 提示没有墨粉

     

    2)生成初始化的判定表


    注:

    输入条件项,即上述每个条件的值分别取“是(Y)”和“否(N)”,可以简化表示为1和0。

    3)优化的判定表


    注:

    如果动作结果一样,对于某些因素取“1”或“0”没有影响,即以“—”表示,并合并。

    优化的判定表就可以设计测试用例,每一列代表一条测试用例。

    判定表的优/缺点:

    优点:把复杂的问题按各种可能的情况一一列举,简明而易于理解,也避免遗漏。

    缺点:不能表达重复执行的动作,如循环结构。判定表不能很好的伸缩。如有n个条件的判定表有2的n次方个规则。


    2.3  LMS应用的例子

    这里引用测试模板添加需要具体什么条件为例子。


    Ø 用例的审核与不审核:


    Ø 模板的发布与不发布:


    Ø 在模板列表中显示的已发布的测试模板:


    Ø 已经审核的用例,并且模板已经发布了,才能显示:



    添加的用例模板,还需要在用例列表中,审核对应模块下的用例,发布测试用例模板后,才能在测试模板中添加数据,如果用例没有审核,那么就会有如下的提示:

      

    添加的测试模板,如果产品型号不存在或是研发审批未完成则不能添加成功,如下图所示:

     

    测试用例模板,不仅需要审核对应模块下的用例,还需发布该测试用例模板,才能在测试模板中添加数据。

    添加数据时,产品型号是要存在的,并且还需研发审批通过,这里先不考虑用户和客户输入的条件,只考虑产品型号的存在问题,不考虑审批的情况。

     

    1)列出条件桩和动作桩

    条件桩:

    (1) 测试模板是否审核?

    (2) 测试用例模板是否发布?

    (3) 产品型号是否存在?

    动作桩:(因为提示未审核用例,需要发布才能知道该提示)

    (1) 提示用例未审核

    (2) 显示测试用例模板

    (3) 提示产品型号不存在

    (4) 成功添加测试模板

     

    2)生成初始化的判定表

    因为是3个条件桩,所以共有2*2*2=8条规则



    分析:

    1.先确定动作(4)的情况,是1时,所有的条件都需要满足,都是1的时候,其余情况都是0

    2.确定条件(2)是1时,动作(2)必须是1----1.2.5.6),否则都取0--3.4.7.8

    3.根据业务需求,只要条件(2)不发布,即是0的时候,那么动作(1)和(3)都是0------3.4.7.8

    4.根据业务需求,只要条件(2)是1,那么条件(1)是1的时候,动作(1)是0

    5根据业务需求,只要条件(2)是1,那么条件(3)是1的时候,动作(2)是0

    3)优化的判定表

    注意:

    如果动作(结果)一样,对于某些因素取“1”或“0”没有影响,即以“—”表示,并合并。

    把出现一样的结果化简,根据判定表,我们可以得到1256都是单一的结果,所以不用化简;3478的结果是一样的,可以化简。


    展开全文
  • 决策表法(判定表驱动法):是分析和表达多逻辑条件下执行不同操作的情况的工具,能够将复杂的问题按照各种可能的情况全部列举出来,简明并避免遗漏。 错误推测法 :依靠经验和直觉猜测程序中可能存在的各种错误,从而...
  • 判定表驱动法 概述:判定表是分析和表达多逻辑条件下执行不同操作的情况的工具。又称“决策表”,是一种呈表格状的图形工具,适用于描述处理判断条件较多且条件又相互组合、有多种决策方案的情况。精确而简洁描述...
  • 一、判定表 判定表定义: 是分析和表达多逻辑条件下执行不同操作的情况的工具。 判定表作用: 判定表是分析和表达多逻辑条件下执行不同操作的情况的工具。 判定表通常由四部分组成 : 条件桩 动作桩 条件项 ...
  • 判定表驱动法0 目录3 黑盒测试3.1 判定表驱动法3.1.1课堂重点3.1.2测试与作业4 下一章 0 目录 3 黑盒测试 3.1 判定表驱动法 3.1.1课堂重点 3.1.2测试与作业 判定表中一个特定的...
  • 判定表是分析和表达多逻辑条件下执行不同操作的工具。它能够将复杂的问题按照各种可能的情况全部列举出来。因此,利用判定表能够设计出完整的测试用例集合。在一些数据处理问题当中,某些操作的实施依赖于多个逻辑...
  • 1.判定表的简介 判定表是黑盒测试的方法之一,判定表是把作为条件的所有输入的各种组合值以及对应输出值都罗列出来而形成的表格。它能够将复杂的问题按照各种可能的情况全部列举出来,简明并避免遗漏。 因此,利用...
  •  判定表是分析和表达多逻辑条件下执行不同操作的情况的工具    a、可配合因果图后期使用;    b、适合于多逻辑条件下的组合分析;    掌握判定表的结构:        1)...
  • 需求 日期问题 测试以下程序:该程序有三个输入变量 month、day、year (month、day 和 year 均为整数值,并且满足:1 ≤ months ≤ 12、1 ≤ days ≤ 31 和 1900 ≤ ...(2) 判定表驱动法设计测试用例。 实现 一、边界值
  • 黑盒测试用例设计--判定表驱动法

    千次阅读 2017-08-01 13:18:43
    判定表驱动法 基本思路:对多个条件的组合进行分析,从而设计测试用例来覆盖各种组合。   判定表:是分析和表达多逻辑条件下执行不同操作的情况下的工具。   判定表5个概念:  条件桩:问题的输入条件列出...
  • 【黑盒测试用例设计】测试方法之判定表驱动法 原理:针对不同逻辑条件的组合值,分别执行不同的操作。 定义:判定表是分析和表达多逻辑条件下执行不同操作的情况的工具。 判定表的优点 能够将复杂的问题按照各种...
  • 边界值分析: 选择测试用例的原则: 1.如果规定了值的范围,则应选取刚好等于,略大于,略小于端点的值 2.如果规定了值得个数,则用最大个数,最小个数和比最大个数、最小个数多一个和少一个的数作为测试数据...
  • 判定表驱动分析方法

    千次阅读 2013-12-31 11:01:06
    1.定义:判定表是分析和表达多逻辑条件下执行不同操作的情况的工具。 2.判定表的优点 能够将复杂的问题按照各种可能的情况全部列举出来,简明并避免遗漏。因此,利用判定表能够设计出完整的测试用例集合。 在一些...
  • 今天上课上了黑盒测试,但无奈课本无判定表驱动法,特意自己总结一份笔记记录,以后复习有东西可看。 判定表驱动法是黑盒测试中使用的方法之一,在其中,判定表主要组成成分为: 条件桩 条件项 动作桩 动作...
  • 这里以一个《软件评测师教程》上面的例子为例,来说明和演示因果图和判定表驱动法设计设计用例的过程与方法。该实例描述具体如下。 1. 需求规格描述 有一个处理单价为1元5角钱的盒装饮料的自动售货机软件。若投入...
  • 判定表驱动法的应用 判定表的优点: a. 能够将复杂的问题按照各种可能的情况全部列举出来,简明并避免遗漏。因此,利用判定表能够设计出完整的测试用例集合。 b. 在一些数据处理问题当中,某些操作的实施依赖于多个...
  • 1.判定表驱动分析 在之前介绍的因果图分析也用到了判定表,但是没有详细介绍。判定表又称决策表,它是分析和表达多逻辑条件下执行不同操作的情况的工具。在黑盒测试中,基于判定表的测试是最具有逻辑性、最严格...
  • 黑盒测试技术 不考虑程序内部的结构与特性,只根据程序功能或程序的外部特性设计测试用例 黑盒测试主要发现的错误 功能不正确或遗漏 ...等价类划分 把程序的所有可能的输入数据...
  • 案例实战—直角三角形试用等价类划分、边界值分析和因果图加判定表驱动法为三角形问题中的直角三角形设计测试用例。假定三边边长a、b和c均为1到100之间的正整数,其中整数的要求通过数据类型控制。直角三角形问题...
  • 5.判定表驱动方法 前面因果图方法中已经用到了判定表。判定表是分析和表达多逻辑条件下执行不同操作的情况的工具。在程序设计中可作为编写程序的辅助工具。把复杂的逻辑关系和多种条件组合的情况表达得较明确。 ...
  • 因果图和判定表

    万次阅读 2018-08-12 22:45:53
    上一篇文章中介绍了等价类和边界值,接下来我们就来学习一下因果图和判定表,这两种方法在软件测试中是非常重要的工具,这两个东西理论也是很绕口,特别是因果图,砖家给的方法我看起来也很困,所以我们就不要按照砖...
  • 什么是判定表法

    2021-07-22 21:05:06
    判定表是分析和表达多逻辑条件下执行不同操作的情况的工具 判定表的优点:能够将复杂的问题按照各种可能的情况全部列举出来,简明并避 免遗漏。因此,利用判定表能够设计出完整的测试用例集合。 在一些数据...
  • 黑盒测试方法等价类划分法边界值分析法错误推测法因果图法判定表驱动法正交试验设计法功能图法场景法 等价类划分法 把程序的说有输入看成一个大集合,在这个大集合中又可以划分出许多小的集合,而同一个小集合中的...
  • --------------------健壮性最强,考虑情况最全面### Decision Tables 决策表,又称判定表法 ###* 前言* 一、认识决策表* 二、例题* * * 例题一* 例题二* 例题三* 例题四* 例题五* 例题六* 总结------------------...
  • 表驱动法

    千次阅读 2019-03-25 23:06:51
    表驱动法: 一种编程模式,从表里面查找信息而不使用逻辑语句(if、case)。事实上,凡是能通过逻辑语句来选择的事物,都可以通过查表来选择。对简单的情况而言,使用简单的逻辑语句更为容易和直白,但随着逻辑链的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,757
精华内容 3,502
关键字:

判定表驱动法

友情链接: libxors3d.dll.rar