精华内容
下载资源
问答
  • 软件测试NextDate函数测试用例详解 (20页) 本资源提供全文预览,点击全文预览即可全文预览,如果喜欢文档就下载吧,查找使用更方便哦!14.90 积分NextDate函数的用例设计方法 主讲:黄老师 授课班级:软件设计班制作...

    a7f4a3f590493a1e451dd952a488fd7c.gif 软件测试NextDate函数测试用例详解

    (20页)

    a3a5151a28550017ff920ea8a459f518.gif

    本资源提供全文预览,点击全文预览即可全文预览,如果喜欢文档就下载吧,查找使用更方便哦!

    14.90 积分

    NextDate函数的用例设计方法 主讲:黄老师 授课班级:软件设计班制作者:aTool.org NextDate函数的用例设计方法 n 黑盒测试 n 等价类划分法 n 边界值分析法 n 因果图法 n 决策表法 制作者:制作者:aTool.org Page 2 等价类划分法——以输入域划分等价类 NextDate 函数包含三个变量:month(月份)、day(日期) 和 year(年),函数的输出为输入日期后一天的日期。 例如, 输入为 2007年9月 9日,则函数的输出为 2007年9月10日 。 要求输入变量 month 、 day 和 year 均为整数值,并且满足 下列条件: (1)1≤month≤12 (2)1≤day≤31 (3)1912≤year≤2050 此函数的主要特点是输入变量之间的逻辑关系比较复杂。复杂 性的来源有两个:一个是输入域的复杂性,另一个是指闰年 的规则。例如变量year和变量month取不同的值,对应的变 量day会有不同的取值范围,day值的范围可能是1~30或1~ 31,也可能是1~28或1~29。 制作者:制作者:aTool.org Page 3 等价类划分法——以输入域划分等价类 (1)简单等价类划分测试NextDate函数 有效等价类 简单等价类划分测试NextDate函数可以划分以下三种有效等价类: M1={month:1≤month≤12} D1={day:1≤day≤31} Y1={year:1912≤year≤2050} 无效等价类 若条件 (1)~(3)中任何一个条件无效,那么NextDate 函数 都会产生一个输出,指明相应的变量超出取值范围,例如 month 的值不在 1~12 范围当中。 制作者:制作者:aTool.org Page 4 等价类划分法——以输入域划分等价类 显然还存在着大量的 year 、 month 、 day 的无效组 合, NextDate 函数将这些组合统一输出为:“无效 输入日期”。其无效等价类为: M2={month:month<1} M3={month:month>12} D2={day:day<1} D3={day:day>31} Y2={year:year<1912} Y3={year:year>2050} 制作者:制作者:aTool.org Page 5 等价类划分法——以输入域划分等价类 一般等价类测试用例如表5-2所示。 表5-2 NextDate函数的一般等价类测试用例 测试 输入 期望输出 用例 month day year Test 9 9 2007 2007年9月10日 Case 1 健壮等价类测试中包含弱健壮等价类测试和强健壮等价类测试。 ? 弱健壮等价类测试 弱健壮等价类测试中的有效测试用例使用每个有效等价 类中的一个值。弱健壮等价类测试中的无效测试用例则只 包含一个无效值,其他都是有效值,即含有单缺陷假设。 如表5-3所示。 制作者:制作者:aTool.org Page 6 等价类划分法——以输入域划分等价类 输入 测试用例 期望输出 month day year Test Case 1 9 9 2007 2007年9月10日 Test Case 2 0 9 2007 month不在1~12中 Test Case 3 13 9 2007 month不在1~12中 Test Case 4 9 0 2007 day不在1~31中 Test Case 5 9 32 2007 day不在1~31中 Test Case 6 9 9 1911 year不在1912~2050中 Test Case 7 9 9 2051 year不在1912~2050中 表5-3 NextDate函数的弱健壮等价类测试用例 制作者:制作者:aTool.org Page 7 等价类划分法——以输入域划分等价类 n 强健壮等价类测试 n 强健壮等价类测试考虑了更多的无效值情况。强健壮 等价类测试中的无效测试用例可以包含多个无效值, 即含有多个缺陷假设。因为NextDate函数有三个变量, 所以对应的强健壮等价类测试用例可以包含一个无效 值,两个无效值或三个无效值。如表5-4所示。 制作者:制作者:aTool.org Page 8 等价类划分法——以输入域划分等价类 n 表5-4 NextDate函数的强健壮等价类测试用例 输入 测试用例 期望输出 month day year Test Case 1 -1 9 2007 month不在1~12中 Test Case 2 9 -1 2007 day不在1~31中 Test Case 3 9 9 1900 year不在1912~2050中 变量month、day无效 Test Case 4 -1 -1 2007 变量year有效 变量month、year无效 Test Case 5 -1 9 1900 变量day有效 变量day、year无效 Test Case 6 9 -1 1900 变量month有效 Test Case 7 -1 -1 1900 变量month、day、year无效 制作者:制作者:aTool.org Page 9 等价类划分法——以输入域划分等价类 n (2)改进等价类划分测试NextDate函数 n 在简单等价类划分测试NextDate函数中,没有考虑2月份的天数问题,也没有考虑 闰年的问题,月份只包含了30天和31天两种情况。在改进等价类划分测试 NextDate函数中,要考虑2月份天数的问题。 n 关于每个月份的天数问题,可以详细划分为以下等价类: n M1={month:month有30天} n M2={month:month有31天, 除去12月} n M3={month:month是2月} n M4={month:month是12月} n D1={day:1≤day≤27} n D2={day:day=28} n D3={day:day=29} n D4={day:day=30} n D5={day:day=31} n Y1={year:year是闰年} n Y2={year:year不是闰年} 制作者:制作者:aTool.org Page 10 等价类划分法——以输入域划分等价类 返回 n 改进等价类划分测试NextDate函数如表5-5所示。 n 表5-5 改进等价类划分法测试用例 输入 测试用例 期望输出 关 键 词: 软件测试NextDate函数测试用例详解 ppt、pptx格式 免费阅读 下载 天天文库

    4d91c43bfc72ca913299809b07b4968f.gif  天天文库所有资源均是用户自行上传分享,仅供网友学习交流,未经上传用户书面授权,请勿作他用。

    展开全文
  • (1)掌握应用黑盒测试技术进行测试用例设计。 (2)掌握对测试用例进行优化设计方法。 实验内容 日期问题 测试以下程序:该程序有三个输入变量month、day、year(month、day和year均为整数值,并且满足:1≤month≤...

    实验目的

    (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函数

    展开全文
  • 软件测试NextDate函数测试用例详解
  • 『易坊知识库摘要_Nextdate|Nextdate函数的黑盒测试』二、实验环境操作系统:Windows XP + SP2 /win7三、实验内容1、编写一个NextDate函数。2、掌握黑盒测试中的决策表测试法的基本步骤。3、使用决策表法设计测试...

    『易坊知识库摘要_Nextdate|Nextdate函数的黑盒测试』二、实验环境操作系统:Windows XP + SP2 /win7三、实验内容1、编写一个NextDate函数。2、掌握黑盒测试中的决策表测试法的基本步骤。3、使用决策表法设计测试用例,对编写的函数实施测试...

    按关键词阅读:

    测试

    黑盒

    函数

    NextDate

    1、实验四 Nextdate 函数的黑盒测试一、实验目的:掌握黑盒测试中的决策表测试法 , 并对被测程序设计测试用例 。

    二、实验环境操作系统:Windows XP + SP2 /win7三、实验内容1、编写一个NextDate函数 。

    2、掌握黑盒测试中的决策表测试法的基本步骤 。

    3、使用决策表法设计测试用例 , 对编写的函数实施测试 , 总结分析测试结果 。

    4、 实验步骤1、 编写一个NextDate函数 , 代码如下:#include int chk(int y,int m,int d)if (d31) return 0;

    else if (m12) return 0;

    else if (y2500) return 0;

    【Nextdate|Nextdate函数的黑盒测试】2、return 1;

    int isy(int y)return (y%4=0&y%100|y%400);

    int ilm(int m )return (m=4|m=6|m=9|m=11);

    int ihm(int m)return (m=1|m=3|m=5|m=7|m=8|m=10|m=12);

    int main(int argc, char* argv)int year,month,day;

    printf(Year=);

    scanf(%d,&year);

    printf(Month=);

    scanf(%d,&month);

    printf(Day=);

    scanf(%d,&day);

    if (chk(year,mont 。

    3、h,day) if (day=28&month=2&!isy(year)|(day=29&month=2&isy(year) day=1;

    month=3;

    e lse if (day=30&ilm(month)|day=31&ihm(month) day=1;

    month+;

    else day+;

    if (month12) month=1;

    +year;

    printf(Next date:%d-%d-%dn,year,month,day);

    else printf(日期不合法);

    return 0;

    2、 根据黑盒测试的决策表法设计测试用例 。

    动作桩如下: 变量day加1操作;变量day复位操作;变量month加 。

    4、1操作;变量month复位操作;变量year加1操作;条件桩如下:M1=month;

    month有30天;M2=month;

    month有31天,12月除外;M3=month;

    month是12月;M4=month;

    month是2月;D1=day:1day27;D2=day:day=28;D3=day:day=29;D4=day:day=30;D5=day:day=31;Y1=year:year是闰年;Y2=year:year不是闰年;Nextdata函数的决策表选项规则1 , 2 , 3456,7,8,91011 , 12 , 13 , 1415161718192021 , 22条件C1:month在M1M1M1M2M2 。

    5、M3M3M4M4M4M4M4M4C2:day在D1 , D2 , D3D4D5D1 , D2 , D3 , D4D5D1 , D2 , D3 , D4D5D1D2D2D3D3D4 , D5C3:year在________Y1Y2Y1Y2_复位A1:不可能A2:day加1A3:day复位A4:month加1A5:month复位A6:year加13、 根据测试用例实施测试 , 并记录测试结果 。

    测试用例MonthDayYear预期输出实际输出Test case 1-351520092009年5月16日2009年5月16日Test case 453020092009年5月31日2009年5月31日Test case 553120092009 。

    6、年6月1日2009年6月1日Test case 6-941520092009年4月16日2009年4月16日Test case 104312009不可能的输入日期2009年4月32日Test case11-14121520092009年12月16日2009年12月16日Test case 15123120092010年1月1日2010年1月1日Test case 1621520092009年2月16日2009年2月16日Test case 1722820122012年2月29日2012年2月29日Test case 1822820092009年3月1日2009年2月29日Test case 1922920122012年3月1日2012年3月1日Test case 202292009不可能的输入日期2009年3月1日Testcase 21-222302009不可能的输入日期2009年2月31日五、实验结果六、实验总结1、通过动手实验 , 对基于决策表法的测试更加了解 , 理解更加深刻 。

    2、在实验过程中复习了c语言的知识 。

    3、在实验中遇到了困难 , 经过查资料后得到了解决 。

    来源:(未知)

    【傻大方】网址:http://www.shadafang.com/a/2021/0121/0021121375.html

    标题:Nextdate|Nextdate函数的黑盒测试

    展开全文
  • 软件测试 - NextDate函数 - 测试用例详解:NextDate 函数包含三个变量:month(月份)、day(日期) 和 year(年),函数的输出为输入日期后一天的日期。 例如,输入为 2007年9月 9日,则函数的输出为 2007年9月10日 。
  • NextDate函数白盒测试

    2010-05-30 10:41:25
    NextDate函数白盒测试 自己写的 软件测试白盒文档
  • NextDate函数

    2015-04-16 23:37:33
    软件测试NextDate函数测试用例 System.DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss:ffff"); //2008年04月24 15时56分48秒 System.DateTime.Now.ToString("yyyy年MM月dd HH时mm分ss秒"); //星期二, 四月 24 ...
  • 软件测试---NextDate函数---测试用例详解 制作者:aTool.org 由于人类活动或者自然过程引起某些物质进入大气中,达到足够的浓度,滞留足够的时间,并因此导致大气环境质量下降影响人类生活的现象。 主讲:黄老师 ...

    41528d3028836879cd698677c3999917.gif软件测试---NextDate函数---测试用例详解

    制作者:aTool.org 由于人类活动或者自然过程引起某些物质进入大气中,达到足够的浓度,滞留足够的时间,并因此导致大气环境质量下降影响人类生活的现象。 主讲:黄老师 NextDate函数的用例设计方法 授课班级:软件设计班 Page 2 制作者: 制作者:aTool.org 由于人类活动或者自然过程引起某些物质进入大气中,达到足够的浓度,滞留足够的时间,并因此导致大气环境质量下降影响人类生活的现象。 NextDate函数的用例设计方法 n 黑盒测试 n等价类划分法 n边界值分析法 n因果图法 n决策表法 Page 3 制作者: 制作者:aTool.org 由于人类活动或者自然过程引起某些物质进入大气中,达到足够的浓度,滞留足够的时间,并因此导致大气环境质量下降影响人类生活的现象。 NextDate 函数包含三个变量:month(月份)、day(日期) 和 year(年),函数的输出为输入日期后一天的日期。 例如 ,输入为 2007年9月 9日,则函数的输出为 2007年9月10日 。要求输入变量 month 、 day 和 year 均为整数值,并且满 足下列条件: (1)1≤month≤12 (2)1≤day≤31 (3)1912≤year≤2050 此函数的主要特点是输入变量之间的逻辑关系比较复杂。复杂 性的来源有两个:一个是输入域的复杂性,另一个是指闰年 的规则。例如变量year和变量month取不同的值,对应的变 量day会有不同的取值范围,day值的范围可能是1~30或1~ 31,也可能是1~28或1~29。 等价类划分法——以输入域划分等价类 Page 4 制作者: 制作者:aTool.org 由于人类活动或者自然过程引起某些物质进入大气中,达到足够的浓度,滞留足够的时间,并因此导致大气环境质量下降影响人类生活的现象。 (1)简单等价类划分测试NextDate函数 有效等价类 简单等价类划分测试NextDate函数可以划分以下三种有效等价类 : M1={month:1≤month≤12} D1={day:1≤day≤31} Y1={year:1912≤year≤2050} 无效等价类 若条件 (1)~(3)中任何一个条件无效,那么NextDate 函数 都会产生一个输出,指明相应的变量超出取值范围,例如 month 的值不在 1~12 范围当中。 等价类划分法——以输入域划分等价类 Page 5 制作者: 制作者:aTool.org 由于人类活动或者自然过程引起某些物质进入大气中,达到足够的浓度,滞留足够的时间,并因此导致大气环境质量下降影响人类生活的现象。 显然还存在着大量的 year 、 month 、 day 的无效组 合, NextDate 函数将这些组合统一输出为:“无效输 入日期”。其无效等价类为: M2={month:month12} D2={day:day31} Y2={year:year2050} 等价类划分法——以输入域划分等价类 Page 6 制作者: 制作者:aTool.org 由于人类活动或者自然过程引起某些物质进入大气中,达到足够的浓度,滞留足够的时间,并因此导致大气环境质量下降影响人类生活的现象。 等价类划分法——以输入域划分等价类 一般等价类测试用例如表5-2所示。 表5-2 NextDate函数的一般等价类测试用例 测试 用例 输入 期望输出 monthdayyear Test Case 1 9920072007年9月10日 健壮等价类测试中包含弱健壮等价类测试和强健壮等价类测试。 • 弱健壮等价类测试 弱健壮等价类测试中的有效测试用例使用每个有效等价 类中的一个值。弱健壮等价类测试中的无效测试用例则只 包含一个无效值,其他都是有效值,即含有单缺陷假设。 如表5-3所示。 Page 7 制作者: 制作者:aTool.org 由于人类活动或者自然过程引起某些物质进入大气中,达到足够的浓度,滞留足够的时间,并因此导致大气环境质量下降影响人类生活的现象。 等价类划分法——以输入域划分等价类 表5-3 NextDate函数的弱健壮等价类测试用例 测试用例输入期望输出 monthdayyear Test Case 19920072007年9月10日 Test Case 2092007 month不在1~12中 Test Case 31392007month不在1~12中 Test Case 4902007day不在1~31中 Test Case 59322007day不在1~31中 Test Case 6991911 year不在1912~2050中 Test Case 7992051year不在1912~2050中 Page 8 制作者: 制作者:aTool.org 由于人类活动或者自然过程引起某些物质进入大气中,达到足够的浓度,滞留足够的时间,并因此导致大气环境质量下降影响人类生活的现象。 n 强健壮等价类测试 n 强健壮等价类测试考虑了更多的无效值情况。强健壮 等价类测试中的无效测试用例可以包含多个无效值, 即含有多个缺陷假设。因为NextDate函数有三个变量 ,所以对应的强健壮等价类测试用例可以包含一个无 效值,两个无效值或三个无效值。如表5-4所示。 等价类划分法——以输入域划分等价类 Page 9 制作者: 制作者:aTool.org 由于人类活动或者自然过程引起某些物质进入大气中,达到足够的浓度,滞留足够的时间,并因此导致大气环境质量下降影响人类生活的现象。 等价类划分法——以输入域划分等价类 n 表5-4 NextDate函数的强健壮等价类测试用例 测试用例 输入 期望输出 monthdayyear Test Case 1-192007 month不在1~12中 Test Case 29-12007day不在1~31中 Test Case 3991900 year不在1912~2050中 Test Case 4-1-12007 变量month、day无效 变量year有效 Test Case 5-191900 变量month、year无效 变量day有效 Test Case 69-11900 变量day、year无效 变量month有效 Test Case 7-1-11900变量month、day、year无效 Page 10 制作者: 制作者:aTool.org 由于人类活动或者自然过程引起某些物质进入大气中,达到足够的浓度,滞留足够的时间,并因此导致大气环境质量下降影响人类生活的现象。 n (2)改进等价类划分测试NextDate函数 n 在简单等价类划分测试NextDate函数中,没有考虑2月份的天数问题,也没有考虑 闰年的问题,月份只包含了30天和31天两种情况。在改进等价类划分测试NextDate 函数中,要考虑2月份天数的问题。 n 关于每个月份的天数问题,可以详细划分为以下等价类: n M1={month:month有30天} n M2={month:month有31天, 除去12月} n M3={month:month是2月} n M4={month:month是12月} n D

    展开全文
  • 软件测试--NextDate函数问题
  • ` 一实验目的 掌握黑盒测试中的决策表测试法并对被测程序设计测试用例 二实验环境 操作系统 Windows XP + SP2 /win7 三实验容 1编写一个 NextDate 函数 2掌握黑盒测试中的决策表测试法的基本步骤 3使用决策表法设计...
  • 一实验目的 掌握黑盒测试中的决策表测试法并对被测程序设计测试用例 二实验环境 操作系统Windows XP + SP2 /win7 三实验内容 编写一个 NextDate 函数 掌握黑盒测试中的决策表测试法的基本步骤 使用决策表法设计测试...
  • 一实验目的 掌握黑盒测试中的决策表测试法并对被测程序设计测试用例 二实验环境 操作系统Windows XP + SP2 /win7 三实验内 1编写一个 NextDate 函数 2掌握黑盒测试中的决策表测试法的基本步骤 3使用决策表法设计测试...
  • 三角形问题的等价类测试 NextDate函数的的决策表测试
  • ` 一实验目的 掌握黑盒测试中的决策表测试法并对被测程序设计测试用例 二实验环境 操作系统 Windows XP + SP2 /win7 三实验容 1编写一个 NextDate 函数 2掌握黑盒测试中的决策表测试法的基本步骤 3使用决策表法设计...
  • 道汝乘萦院 NextDate函数的用例设计方法 主讲:黄老师 授课班级:软件设计班 制作者: aTool. org 黑盒测试 等价类划分法 边界值分析法 因果图法 决策表法 制作者: aTool. org 等价类划分法以输入域划分等价类 NextDate...
  • NextDate函数的用例设计方法;NextDate 函数包含三个变量month月份day日期 和 year年函数的输出为输入日期后一天的日期 例如输入为 2007年9月 9日则函数的输出为 2007年9月10日 要求输入变量 month day 和 year 均为...
  • NextDate函数小程序

    2007-06-21 16:26:48
    有关NextDate函数的小程序,可以做为测试练习
  • 测试NextDate函数编程(c++源码)程序调试已经通过!可以作为交给老师的作业!是学习编程和相互交流的非常棒的学习资料!
  • 满意答案Sicevoise2013.11.12采纳率:53%等级:12已帮助:13187人调用系统的mktime(),获取 time_t 型日期时间,增...#include #include #include void NextDate(int *month, int *day, int *year){time_t now,next;...
  • C编写NextDate函数

    2013-10-15 14:34:59
    函数实现以下功能: 1.输入日期合法(如1993,1,5),输出下一天的日期; 2.输入日期年月日超出范围(如2004,11,32),输出‘无效输入日期’; 3.输入日期年月日均合法,但组合错误(主要指日错误如2011,2,29...
  • 编程实现:NextDate函数问题说明:输入一个日期,求从输入日期算起的第三天日期。例如,输入为2008年8月8日,则该程序的输出为2008年8月 10日。NextDate函数包含三个整数变量month、day和year,并且满足下列条件:1...
  • 测试以下程序:该程序有三个输入变量 month、day、year (month、day 和 year 均为整数值,并且满足:1 ≤ months ≤ 12、1 ≤ days ≤ 31 和 1900 ≤ year ≤ 2050),分别作为输入日期的月份、日、年份,通过...
  • 软件测试经典问题——NextDate函数

    千次阅读 2013-03-28 15:32:00
    给出今天日期(YYYY-MM-DD) 得出明天日期 c1. 1<=month<=12 c2. 1<=day<=31 c3. 0<year print("输入今天的日期 yyyy mm dd!") todaydate=[0000,0,0] tomorrowdate=[0000,0,0] ... todaydat...
  • 测试以下程序:该程序有三个输入变量 month、day、year (month、day 和 year 均为整数值,并且满足:1 ≤ months ≤ 12、1 ≤ days ≤ 31 和 1900 ≤ year ≤ 2050),分别作为输入日期的月份、日、年份,通过程序...
  • NextDate测试

    2014-09-25 22:09:18
    可以判断输入日期正确性,是NextDate函数的的具体描述
  • 利用这个函数,可以输入当天日期,然后输出先一天的日期。
  • 这是用了c语言已经数据结构的知识来写的,写下一个日期、ID的对应以及是否为闰年等等输出。
  • 利用nextdate函数测试黑盒文档的测试报告
  • NextDate.java白盒测试

    2011-05-26 17:18:04
    NextDate.java白盒测试NextDate.java白盒测试NextDate.java白盒测试NextDate.java白盒测试NextDate.java白盒测试

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,569
精华内容 17,027
关键字:

nextdate函数测试