实验二 021

源代码：

 1 import java.util.Scanner;
 2 
 3 public class Commission {
 4     
 5     /*
 6      * hp：耳机 80元 mpc：手机壳 10元 cpsp：手机贴膜 8元
 7      */
 8     
 9     public static void main(String[] args) {
10         String line;
11         int hp = 0, mpc = 0, cpsp = 0;
12         String[] input = null;
13         float money = 0;
14         @SuppressWarnings("resource")
15         Scanner scanner = new Scanner(System.in);
16         while (true) {
17 
18             System.out.println("请分别输入三种手机配件的销售情况：");
19             line = scanner.nextLine();
20 
21             // 【去掉字符串前后的空格】
22             line = line.trim();
23             // 【去掉字符串中多余的空格】
24             line = line.replaceAll("\\s{1,}", " ");
25             input = line.split(" ");
26             if (Judge(input)) {
27                 // 判断是否不小于0
28                 if ((hp = Integer.parseInt(input[0])) < 0) {
29                     System.out.println("输入数量不满足要求");
30                     continue;
31                 }
32                 if ((mpc = Integer.parseInt(input[1])) < 0) {
33                     System.out.println("输入数量不满足要求");
34                     continue;
35                 }
36                 if ((cpsp = Integer.parseInt(input[2])) < 0) {
37                     System.out.println("输入数量不满足要求");
38                     continue;
39                 }
40             } else {
41                 System.out.println("输入数量不满足要求");
42                 continue;
43             }
44             money = commission(hp, mpc, cpsp);
45             System.out.println("佣金金额：" + money);
46             continue;
47         }
48     }
49 
50     // 计算佣金
51     private static float commission(int hp, int mpc, int cpsp) {
52         float commission = 0;
53         int total = hp * 80 + mpc * 10 + cpsp * 8;
54         if (total < 1000) {
55             commission = (float) (total * 0.1);
56         } else if (total <= 1800) {
57             commission = (float) (1000 * 0.1 + (total - 1000) * 0.15);
58         } else {
59             commission = (float) (1000 * 0.1 + 800 * 0.15 + (total - 1800) * 0.2);
60         }
61         return commission;
62     }
63 
64     // 判断用户输入的是不是三个整数
65     private static boolean Judge(String[] input) {
66         String number = "0123456789";
67         // 判断输入的是不是三个字符串
68         if (input.length != 3) {
69             return false;
70         }
71         // 判断三个字符串是不是纯数字且不含小数点
72         for (int i = 0; i < 3; i++) {
73             for (int j = 0; j < input[i].length(); j++) {
74 
75                 if ("+-".indexOf(String.valueOf(input[i].charAt(0))) == 1) {
76                     continue;
77                 }
78                 if (number.indexOf(input[i].charAt(j)) == -1) {
79                     return false;
80                 }
81                 // 【判断输入的字符串是否大于整型的最大数值】
82                 if (Long.parseLong(input[i]) > Integer.MAX_VALUE || input[i].length() > 10) {
83                     return false;
84                 }
85             }
86         }
87         return true;
88     }
89 }

使用Junit进行测试，一个测试用例计算一次佣金，不需要循环读取用户输入的数据，所以将源代码中main函数中while循环里的 continue改成break，以便编写测试用例。

程序图：

DD路径图：

DD路径：

19	A
68	B
72	C
73	D
75	E
78	F
82	G
28	H
32	I
36	J
54	K
55	L
56	M
57	N
59	O
61	P

所有的判断条件：

B/1、输入的字符串等于或不等于三个

E/2、第一个字符是不是 +或-

F/3、字符串里面是不是纯数字

G/4、（1）是否大于整型的最大数值：2147483647 或（2）长度是否大于10

H/5、hp是否小于0

I/6、mpc是否小于0

J/7、cpsp是否小于0

K/8、销售额<1000

L/9、1000 < 销售额 <= 1800

M/10、销售额 > 1800

测试用例：

语句覆盖、路径覆盖、判定覆盖、条件覆盖、判定/条件覆盖、组合覆盖：

测试编号	hp	mpc	cpsp	条件覆盖	预期结果	实际结果	执行路径	是否通过
1	+5	12	10	1、true 2、true/false 3、true 4、false 5、false 6、false 7、false 8、true	控制台输出：请分别输入三种手机配件的销售情况：佣金金额：60	请分别输入三种手机配件的销售情况：输入数量不满足要求	A-B-C-D-E-D-E-F-D-E-F-G-C-D-E-F-G-H-I-J-K-L-P	否
2	123	145	125 154	1、false	请分别输入三种手机配件的销售情况：输入数量不满足要求	与预期结果一样	A-B-A	是
3	abc	abc	abc	3、false	请分别输入三种手机配件的销售情况：输入数量不满足要求	与预期结果一样	A-B-C-D-E-F-A	是
4	2147483669	12	90	4、false	请分别输入三种手机配件的销售情况：输入数量不满足要求	与预期结果一样	A-B-C-D-E-F-G-A	是
5	-23	12	30	5、false	请分别输入三种手机配件的销售情况：输入数量不满足要求	与预期结果一样	A-B-C-D-E-D-E-F-D-E-F-G-C-D-E-F-G-H-A	是
6	26	-13	60	6、false	请分别输入三种手机配件的销售情况：输入数量不满足要求	与预期结果一样	A-B-C-D-E-D-E-F-D-E-F-G-C-D-E-F-G-H-I-A	是
7	29	19	-90	7、false	请分别输入三种手机配件的销售情况：输入数量不满足要求	与预期结果一样	A-B-C-D-E-D-E-F-D-E-F-G-C-D-E-F-G-H-I-J-A	是
8	10	30	50	8、false 9、true	请分别输入三种手机配件的销售情况：佣金金额：175.0	与预期结果一样	A-B-C-D-E-D-E-F-D-E-F-G-C-D-E-F-G-H-I-J-K-M-N-P	是
9	20	30	10	9、false 10、true	请分别输入三种手机配件的销售情况：佣金金额：256.0	与预期结果一样	A-B-C-D-E-D-E-F-D-E-F-G-C-D-E-F-G-H-I-J-K-M-O-P	是

判定覆盖、判定/条件覆盖、组合覆盖：

测试编号

mpc

cpsp

条件覆盖

预期结果

实际结果

执行路径

是否通过

4.1 false

4.2 false

请分别输入三种手机配件的销售情况：

佣金金额：215.5

与预期结果一样

A-B-C-D-E-D-E-F-D-E-F-G-C-D-E-F-G-H-I-J-K-M-N-P

是

21474836499

4.1 true 4.2 true

请分别输入三种手机配件的销售情况：

输入数量不满足要求

与预期结果一样

A-B-C-D-E-F-G-A

是

条件覆盖、判定/条件覆盖、组合覆盖：

测试编号	hp	mpc	cpsp	条件覆盖	预期结果	实际结果	执行路径	是否通过
12	16	30	63	4.1 false 4.2 false	请分别输入三种手机配件的销售情况：佣金金额：276.8	与预期结果一样	A-B-C-D-E-D-E-F-D-E-F-G-C-D-E-F-G-H-I-J-K-M-O-P	是
13	00000000030	25	36	4.1 false 4.2 true	请分别输入三种手机配件的销售情况：佣金金额：447.6	请分别输入三种手机配件的销售情况：输入数量不满足要求	A-B-C-D-E-D-E-F-D-E-F-G-C-D-E-F-G-H-I-J-K-M-O-P	否
14	2147483690	30	60	4.1 true 4.2 false	请分别输入三种手机配件的销售情况：输入数量不满足要求	与预期结果一样	A-B-C-D-E-D-E-F-D-E-F-G-A	是
15	36254125696	90	33	4.1 true 4.2 true	请分别输入三种手机配件的销售情况：输入数量不满足要求	与预期结果一样	A-B-C-D-E-D-E-F-D-E-F-G-A	是

测试代码：

import static org.junit.Assert.assertEquals;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.PrintStream;
import org.junit.Test;
import procedure.Commission;

public class CommissionTest {

    public static String Out(String in) {
        InputStream ins = new ByteArrayInputStream(in.getBytes());
        System.setIn(ins);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        System.setOut(new PrintStream(baos));
        Commission.main(null);
        return baos.toString();
    }

    @Test
    public void testOne() {
        String in = "+5 12 10";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n佣金金额：60\r\n", Out(in));
    }

    @Test
    public void testTwo() {
        String in = "123 145 125 154";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n输入数量不满足要求\r\n", Out(in));
    }

    @Test
    public void testThree() {
        String in = "abc abc abc";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n输入数量不满足要求\r\n", Out(in));
    }

    @Test
    public void testFour() {
        String in = "2147483669  12 90";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n输入数量不满足要求\r\n", Out(in));
    }

    @Test
    public void testFive() {
        String in = "-23 12 30";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n输入数量不满足要求\r\n", Out(in));
    }

    @Test
    public void testSix() {
        String in = "26 -13 60";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n输入数量不满足要求\r\n", Out(in));
    }

    @Test
    public void testSeven() {
        String in = "29 19 -90";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n输入数量不满足要求\r\n", Out(in));
    }

    @Test
    public void testEight() {
        String in = "10 30 50";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n佣金金额：175.0\r\n", Out(in));
    }

    @Test
    public void testNine() {
        String in = "20 30 10";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n佣金金额：256.0\r\n", Out(in));
    }
    
    @Test
    public void testTen() {
        String in = "12 33 60";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n佣金金额：215.5\r\n", Out(in));
    }
    
    @Test
    public void testEleven() {
        String in = "21474836499 25 36";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n输入数量不满足要求\r\n", Out(in));
    }
    @Test
    public void testTwelev() {
        String in = "16 30 63";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n佣金金额：276.8\r\n", Out(in));
    }
    
    @Test
    public void testThirteen() {
        String in = "00000000030 25 36";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n佣金金额：447.6\r\n", Out(in));
    }
    
    @Test
    public void testFourteen() {
        String in = "2147483690 30 60";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n输入数量不满足要求\r\n", Out(in));
    }
    
    @Test
    public void testFifteen() {
        String in = "36254125696 90 33";
        assertEquals("请分别输入三种手机配件的销售情况：\r\n输入数量不满足要求\r\n", Out(in));
    }
}

测试结果：

测试小结：

1、当输入的数字前面带上正负号时，无法判断数值大小是否在int的整数范围内。

2、当输入的数字前面添加多个0，无法判断数值大小是否在int的整数范围内。

代码修改（以/**/注释的为所需要添加的代码）：

import java.util.Scanner;

public class Commission {

    /*
     * hp：耳机 80元 mpc：手机壳 10元 cpsp：手机贴膜 8元
     */

    public static void main(String[] args) {
        String line;
        int hp = 0, mpc = 0, cpsp = 0;
        String[] input = null;
        float money = 0;
        @SuppressWarnings("resource")
        Scanner scanner = new Scanner(System.in);
        while (true) {

            System.out.println("请分别输入三种手机配件的销售情况：");
            line = scanner.nextLine();

            // 【去掉字符串前后的空格】
            line = line.trim();
            // 【去掉字符串中多余的空格】
            line = line.replaceAll("\\s{1,}", " ");
            input = line.split(" ");
            if (Judge(input)) {
                // 判断是否不小于0
                if ((hp = Integer.parseInt(input[0])) < 0) {
                    System.out.println("输入数量不满足要求");
                    continue;
                }
                if ((mpc = Integer.parseInt(input[1])) < 0) {
                    System.out.println("输入数量不满足要求");
                    continue;
                }
                if ((cpsp = Integer.parseInt(input[2])) < 0) {
                    System.out.println("输入数量不满足要求");
                    continue;
                }
            } else {
                System.out.println("输入数量不满足要求");
                continue;
            }
            money = commission(hp, mpc, cpsp);
            System.out.println("佣金金额：" + money);
            continue;
        }
    }

    // 计算佣金
    private static float commission(int hp, int mpc, int cpsp) {
        float commission = 0;
        int total = hp * 80 + mpc * 10 + cpsp * 8;
        if (total < 1000) {
            commission = (float) (total * 0.1);
        } else if (total <= 1800) {
            commission = (float) (1000 * 0.1 + (total - 1000) * 0.15);
        } else {
            commission = (float) (1000 * 0.1 + 800 * 0.15 + (total - 1800) * 0.2);
        }
        return commission;
    }

    // 判断用户输入的是不是三个整数
    private static boolean Judge(String[] input) {
        String number = "0123456789";
        // 判断输入的是不是三个字符串
        if (input.length != 3) {
            return false;
        }
        // 判断三个字符串是不是纯数字且不含小数点
        for (int i = 0; i < 3; i++) {
            for (int j = 0; j < input[i].length(); j++) {

                /* char类型的“+-”和String类型的“+-”是不一样的
                 * 替换："+-".indexOf(String.valueOf(input[i].charAt(0))) == 1 
                 * 第一种：
                 * "+".equals(String.valueOf(input[i].charAt(0))) || "-".equals(String.valueOf(input[i].charAt(0))) 
                 * 第二种：
                 * Character characterAdd = '+'; Character characterSubtract = '-';
                 * characterAdd.equals(input[i].charAt(0))) || characterSubtract.equals(input[i].charAt(0)))
                 */
                if ("+-".indexOf(String.valueOf(input[i].charAt(0))) == 1) {
                    /*
                     * if ("+".equals(String.valueOf(input[i].charAt(0)))) {
                     *         input[i].substring(1); 
                     * }
                     */
                    continue;
                }
                if (number.indexOf(input[i].charAt(j)) == -1) {
                    return false;
                }
                // 【判断输入的字符串是否大于整型的最大数值】
                /*
                 * input[i] = input[i].replaceFirst("^0*", "");
                 */
                if (Long.parseLong(input[i]) > Integer.MAX_VALUE || input[i].length() > 10) {
                    return false;
                }
            }
        }
        return true;
    }
}

测试总结：

　　在测试前可以按照程序的正确流程写出所有的判断语句，然后根据测试技术结合程序的判断语句写出测试用例可以增加测试的覆盖率，找出程序的BUG也就简单多了。同时在写程序时尽量不要使用多个判断语句结合在一起，使用单个判断语句可以减少测试用例。

posted on 2017-04-13 16:28 VioletGlass 阅读(354) 评论(0) 编辑收藏举报