实验二 021 林明铁

Posted mtLin

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了实验二 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

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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

测试编号

hp

mpc

cpsp

条件覆盖

预期结果

实际结果

执行路径

是否通过

10

12

33

60

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

11

21474836499

25

36

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也就简单多了。同时在写程序时尽量不要使用多个判断语句结合在一起,使用单个判断语句可以减少测试用例。

 

以上是关于实验二 021 林明铁的主要内容,如果未能解决你的问题,请参考以下文章

第4次作业类测试代码 021 林明铁

第5次作业 021 林明铁

GlobalMapper精品教程021:利用控制点校正栅格图像

实验五

[NTUSTISC pwn LAB 7]Return to libc实验(puts泄露libc中gadget片段定位)

Python_021(内置方法讲解二)