软件测试总结

软测题库

第1题 填写代码.判断Delta类的语句覆盖测试(9分)

此题的上机步骤是:

1. 建立一个Java项目,名称可以按题号取名;
2. 建立一个测试类, 类的名称为TestMain。这一点非常重要；
3. 填代码；
4. 提交代码，注意题号要一致。
5. 注意只能修改【代码】之处,不能修改其它地方,否则以0分计

针对下面的Delta类, 在后面有一个测试类TestMain。

public class Delta {

    public boolean delta(double a, double b, double c) {
        if (b * b - 4 * a * c >= 0)
            return (true);
        else
            return (false);
    }
}

下面TestMain测试程序实现了语句覆盖。请将下面TestMain测试程序中的【代码】替换为Java测试代码，使测试程序运行正确。
文件TestMain.java如下：

import static org.junit.Assert.*;
import org.junit.Test;

public class TestMain {
    @【代码1】
    public void testDelta1() {
        Delta 【代码2】=new Delta();
        assertEquals(true,delta.delta(1, 2, 1));
    }

    @Test
    public void testDelta2() {
        Delta delta=new Delta();
        assertEquals(【代码3】,delta.delta(1, 0, 1));
    }

}

答案

import static org.junit.Assert.*;
import org.junit.Test;

public class TestMain {
    @Test
    public void testDelta1() {
        Delta delta=new Delta();
        assertEquals(true,delta.delta(1, 2, 1));
    }

    @Test
    public void testDelta2() {
        Delta delta=new Delta();
        assertEquals(false,delta.delta(1, 0, 1));
    }

}

第2题 填写代码.判断Calculator类加减法的语句覆盖测试(10分)

此题的上机步骤是:

1. 建立一个Java项目,名称可以按题号取名;
2. 建立一个测试类, 类的名称为TestMain。这一点非常重要；
3. 填代码；
4. 提交代码，注意题号要一致。
5. 注意只能修改【代码】之处,不能修改其它地方,否则以0分计

针对下面的Calculator类, 在后面有一个测试类TestMain。

public class Calculator {
    private static int result; // 静态变量，用于存储运行结果
    public void add(int n) {
        result = result + n;
    }
    public void substract(int n) {
        result = result - n;
    }
    public int getResult() {
        return result;
    }
    public void clear() {     // 将结果清零
        result = 0;
    }
}

下面TestMain测试程序实现了语句覆盖。请将下面TestMain测试程序中的【代码】替换为Java测试代码，使测试程序运行正确。
文件TestMain.java如下：

import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;

public class TestMain {
    private static Calculator calculator = new Calculator();
    @Before
    public void setUp() 【代码1】 Exception {
        calculator.clear();
        }

    @Test
    public void testAdd() {
        calculator.add(2);
        calculator.add(3);
        assertEquals(5, calculator.【代码2】());
    }

    @Test
    public void testSubstract() {
        calculator.add(10);
        calculator.substract(2);
        assertEquals(8, 【代码3】.getResult());
    }
}

答案

import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;

public class TestMain {
    private static Calculator calculator = new Calculator();
    @Before
    public void setUp() throws Exception {
        calculator.clear();
        }

    @Test
    public void testAdd() {
        calculator.add(2);
        calculator.add(3);
        assertEquals(5, calculator.getResult());
    }

    @Test
    public void testSubstract() {
        calculator.add(10);
        calculator.substract(2);
        assertEquals(8, calculator.getResult());
    }
}

第3题 填写代码.判断NextDate类闰年函数的原子谓词覆盖测试(12分)

此题的上机步骤是:

1. 建立一个Java项目,名称可以按题号取名;
2. 建立一个测试类, 类的名称为TestMain。这一点非常重要；
3. 填代码；
4. 提交代码，注意题号要一致。
5. 注意只能修改【代码】之处,不能修改其它地方,否则以0分计

针对下面的NextDate类, 在后面有一个测试类TestMain。

public class NextDate {
    private boolean bool;
    // 判断某一年是不是闰年的函数
    public void leapYear(int year) {
        bool = false;
        if ((year % 4 == 0 && year % 100 != 0) || (year % 400 == 0)) {
            // 是闰年
            bool = true;
        }
    }
    public boolean getResult() {
        // TODO Auto-generated method stub
        return bool;
    }
}

下面TestMain测试程序实现了语句覆盖。请将下面TestMain测试程序中的【代码】替换为Java测试代码，使测试程序运行正确。
文件TestMain.java如下：

import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;

public class TestMain {
    private NextDate nextDate;
    @【代码1】
    public void setUp() throws Exception {
        nextDate = 【代码2】 NextDate();
        }
    
    @Test
    public void testleapYear1() {
        nextDate.leapYear(400);
        assertEquals(true, nextDate.getResult());
    }

    @Test
    public void testleapYear2() {
        nextDate.【代码3】(4);
        assertEquals(true, nextDate.getResult());
    }
    
    @Test
    public void testleapYear3() {
        nextDate.leapYear(100);
        assert【代码4】(false, nextDate.getResult());
    }

}

答案

import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;

public class TestMain {
    private NextDate nextDate;
    @Before
    public void setUp() throws Exception {
        nextDate = new NextDate();
        }
    
    @Test
    public void testleapYear1() {
        nextDate.leapYear(400);
        assertEquals(true, nextDate.getResult());
    }

    @Test
    public void testleapYear2() {
        nextDate.leapYear(4);
        assertEquals(true, nextDate.getResult());
    }
    
    @Test
    public void testleapYear3() {
        nextDate.leapYear(100);
        assertEquals(false, nextDate.getResult());
    }

}

第4题 填写代码.字符串正则化类的测试(10分)

此题的上机步骤是:

1. 建立一个Java项目,名称可以按题号取名;
2. 建立一个测试类, 类的名称为TestMain。这一点非常重要；
3. 填代码；
4. 提交代码，注意题号要一致。
5. 注意只能修改【代码】之处,不能修改其它地方,否则以0分计

针对下面的StringNormalize类, 在后面有一个测试类TestMain。

public class StringNormalize {
     public static String normalize(String in) {
            StringBuilder out = new StringBuilder();
            String l = in.toLowerCase();
            for (int i = 0; i < l.length(); ++i) {
                char c = l.charAt(i);
                if (c >= 'a' && c <= 'z' || c >= '0' && c <= '9') {
                    out.append(c);
                }
            }
            return out.toString();
        }
}

请将下面TestMain测试程序中的【代码】替换为Java测试代码，使测试程序运行正确。
文件TestMain.java如下：

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

public class TestMain {

    @Before
    public void setUp() throws Exception {
    }

    @Test(timeout = 4000)
    public void test0() throws 【代码1】 {
        String string0 = StringNormalize.normalize("#d0::&Ghk\"hS~L");
        assertEquals("d0ghkhsl", string0);
    }

    @Test(timeout = 4000)
    public void test1() throws Throwable {
        String string0 = 【代码2】.normalize("%P/1Rx}BT~H$R;A+Hg");
        assertEquals("p1rxbthrahg", string0);
    }

    @Test(timeout = 4000)
    public void test2() throws Throwable {
        String string0 = StringNormalize.normalize("");
        assertEquals("", string0);
    }

    @Test(timeout = 4000, 【代码3】 = NullPointerException.class)
    public void test4() throws Throwable {
        // Undeclared exception!
        StringNormalize.normalize((String) null);
        fail("Expecting exception: NullPointerException");
    }

    @Test(【代码4】 = 4000)
    public void test7() throws Throwable {
        String string0 = StringNormalize.normalize("> h[1QY#+'9vWzL1M|h");
        assertEquals("h1qy9vwzl1mh", string0);
    }

    @Test(timeout = 4000)
    public void test8() throws Throwable {
        StringNormalize utils0 = new StringNormalize();
    }
}

答案

import static org.junit.Assert.*;

import org.junit.Before;
import org.junit.Test;

public class TestMain {

    @Before
    public void setUp() throws Exception {
    }

    @Test(timeout = 4000)
    public void test0() throws Throwable {
        String string0 = StringNormalize.normalize("#d0::&Ghk\"hS~L");
        assertEquals("d0ghkhsl", string0);
    }

    @Test(timeout = 4000)
    public void test1() throws Throwable {
        String string0 = StringNormalize.normalize("%P/1Rx}BT~H$R;A+Hg");
        assertEquals("p1rxbthrahg", string0);
    }

    @Test(timeout = 4000)
    public void test2() throws Throwable {
        String string0 = StringNormalize.normalize("");
        assertEquals("", string0);
    }

    @Test(timeout = 4000, expected = NullPointerException.class)
    public void test4() throws Throwable {
        // Undeclared exception!
        StringNormalize.normalize((String) null);
        fail("Expecting exception: NullPointerException");
    }

    @Test(timeout = 4000)
    public void test7() throws Throwable {
        String string0 = StringNormalize.normalize("> h[1QY#+'9vWzL1M|h");
        assertEquals("h1qy9vwzl1mh", string0);
    }

    @Test(timeout = 4000)
    public void test8() throws Throwable {
        StringNormalize utils0 = new StringNormalize();
    }
}

第5题 填写代码.Web测试搜索百度-湘潭大学(15分)

此题的上机环境是:

1. Chrome浏览器安装目录为C:\Program Files\Chrome\Application\chrome.exe
   如果安装目录不是该文件夹，请复制安装目录下的子文件夹“Chrome”到“C:\Program Files\”。
2. 驱动程序chromedriver.exe放到C:\WebDriver中

此题的上机步骤是:

1. 建立一个Java项目,名称可以按题号取名;
2. 建立一个测试类, 类的名称为TestMain。这一点非常重要；
3. 填代码；
4. 提交代码，注意题号要一致。
5. 注意只能修改【代码】之处,不能修改其它地方,否则以0分计

/**
*
* 测试百度的租房搜索功能
*
* 1. 打开百度网页版http://www.baidu.com
* 2. 搜索框选择“湘潭大学”
* 3. 点击“百度一下”按钮
*
*/

请将下面TestMain测试程序中的【代码】替换为Java测试代码，使测试程序运行正确。
文件TestMain.java如下：

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;

public class TestMain {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 配置chromedriver的驱动路径
        System.setProperty("webdriver.chrome.driver", "【代码1】/chromedriver.exe");
        ChromeOptions options = new ChromeOptions();
        // 设置chrome浏览器的 exe文件路径
        【代码2】.setBinary("C:\\Program Files\\Chrome\\Application\\chrome.exe");
        ChromeDriver 【代码3】 = new ChromeDriver(options);
        // 隐式等待时间
        driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS); // 每次操作时长

        // 运行Chrome浏览器并且打开“百度”网站
        driver.get("http://www.baidu.com");
        // 1. “百度”网站搜索内容输入文本框输入文字“湘潭大学”
        WebElement e = driver.findElementByXPath("【代码4】");// 定位控件“搜索文本框”
        CharSequence []cs={"湘潭大学"};//重点要求
        e.【代码5】(cs);// “搜索文本框”中输入文字“湘潭大学”
        // 2. 单击“百度一下”按钮
        e = driver.findElementByXPath("/html/body/div[1]/div[1]/div[5]/div/div/form/span[2]/input");// 定位“百度”

按钮
        e.click();// 单击

    }

}

findElementByXPath

答案

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;

public class TestMain {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 配置chromedriver的驱动路径
        System.setProperty("webdriver.chrome.driver", "C:/WebDriver/chromedriver.exe");
        ChromeOptions options = new ChromeOptions();
        // 设置chrome浏览器的 exe文件路径
       options.setBinary("C:\\Program Files\\Chrome\\Application\\chrome.exe");
        ChromeDriver driver = new ChromeDriver(options);
        // 隐式等待时间
        driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS); // 每次操作时长

        // 运行Chrome浏览器并且打开“百度”网站
        driver.get("http://www.baidu.com");
        // 1. “百度”网站搜索内容输入文本框输入文字“湘潭大学”
        WebElement e = driver.findElementByXPath("/html/body/div[1]/div[1]/div[5]/div/div/form/span[1]/input");// 定位控件“搜索文本框”
        CharSequence []cs={"湘潭大学"};//重点要求
        e.sendKeys(cs);// “搜索文本框”中输入文字“湘潭大学”
        // 2. 单击“百度一下”按钮
        e = driver.findElementByXPath("/html/body/div[1]/div[1]/div[5]/div/div/form/span[2]/input");// 定位“百度”

        e.click();// 单击

    }

}

第6题 填写代码.WEB测试安居客的租房功能(21分)

此题的上机环境是:

1. Chrome浏览器安装目录为C:\Program Files\Chrome\Application\chrome.exe
   如果安装目录不是该文件夹，请将安装目录下的子文件夹“Chrome”复制到“C:\Program Files\”
2. 驱动程序chromedriver.exe放到C:\WebDriver中

此题的上机步骤是:

1. 建立一个Java项目,名称可以按题号取名;
2. 建立一个测试类, 类的名称为TestMain。这一点非常重要；
3. 填代码；
4. 提交代码，注意题号要一致。
5. 注意只能修改【代码】之处,不能修改其它地方,否则以0分计

    /**
     * 测试安居客的租房功能
     *
     * 1. 打开安居客网页版，点击租房
     * 2. 地址选择“南京”
     * 3. 点击“地铁找房”
     * 4. 选择“2 号线”
     * 5. 选择“马群”
     * 6. 设置租金为 2600-5200 元，并点击确定
     *
     */

请将下面TestMain测试程序中的【代码】替换为Java测试代码，使测试程序运行正确。
文件TestMain.java如下：

import java.util.*;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.*;

public class TestMain {
    static void Sleep(int a) {
        try {
            Thread.sleep(a * 1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 配置chromedriver的驱动路径
        System.setProperty("webdriver.chrome.driver", "C:/WebDriver/chromedriver.exe");
        ChromeOptions options = new 【代码1】();
        // 设置chrome浏览器的 exe文件路径
        options.setBinary("【代码2】\\Chrome\\Application\\chrome.exe");
        ChromeDriver driver = new ChromeDriver(options);
        // 隐式等待时间
        driver.manage().【代码3】().implicitlyWait(5, TimeUnit.SECONDS);
        // 安居客
        driver.get("https://nj.zu.anjuke.com/");
        // 1. 点击租房
        WebElement e = driver.findElementByXPath("/html/body/div[2]/div/ul/li[4]/a");
        e.click();
        // 2. 地址选择“南京”
        e = driver.【代码4】("/html/body/div[3]/div/div[1]/i");
        e.click();
        // 弹出列表
        e = driver.findElementByXPath("/html/body/div[3]/div/div[2]/dl[2]/dd/a[4]");
        e.click();

        // 3. 点击“地铁找房”
        e = driver.findElementByLinkText("地铁找房");
        e.click();

        // 4. 选择“2 号线”
        e = driver.findElementByXPath("【代码5】");
        e.click();
        Sleep(2);
        // 5. 选择“马群”
        e = driver.findElementByXPath("/html/body/div[5]/div[2]/div[1]/span[2]/div/div/a[20]");
        e.click();

        // 6. 设置租金为 2600-5200 元，并点击确定
        e = driver.findElementByXPath("/html/body/div[5]/div[2]/div[2]/span[2]/div/form/input[1]");
        CharSequence []cs={"2600"};//重点要求
        e.sendKeys(cs);// “搜索框”中输入“2600”

        e = driver.findElementByXPath("/html/body/div[5]/div[2]/div[2]/span[2]/div/form/input[2]");
        cs[0]="5200";
        e.【代码6】(cs);//不能直接用字符串
        e.【代码7】();

        e = driver.findElementByXPath("//*[@id=\"pricerange_search\"]");
        e.click();

        driver.close();
    }

}

答案

import java.util.*;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.*;

public class TestMain {
    static void Sleep(int a) {
        try {
            Thread.sleep(a * 1000);
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        // 配置chromedriver的驱动路径
        System.setProperty("webdriver.chrome.driver", "C:/WebDriver/chromedriver.exe");
        ChromeOptions options = new ChromeOptions();
        // 设置chrome浏览器的 exe文件路径
        options.setBinary("C:\\Program Files\\Chrome\\Application\\chrome.exe");
        ChromeDriver driver = new ChromeDriver(options);
        // 隐式等待时间
        driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
        // 安居客
        driver.get("https://nj.zu.anjuke.com/");
        // 1. 点击租房
        WebElement e = driver.findElementByXPath("/html/body/div[2]/div/ul/li[4]/a");
        e.click();
        // 2. 地址选择“南京”
        e = driver.findElementByXPath("/html/body/div[3]/div/div[1]/i");
        e.click();
        // 弹出列表
        e = driver.findElementByXPath("/html/body/div[3]/div/div[2]/dl[2]/dd/a[4]");
        e.click();

        // 3. 点击“地铁找房”
        e = driver.findElementByLinkText("地铁找房");
        e.click();

        // 4. 选择“2 号线”
        e = driver.findElementByXPath("/html/body/div[5]/div[2]/div[1]/span[2]/div/a[3]");
        e.click();
        Sleep(2);
        // 5. 选择“马群”
        e = driver.findElementByXPath("/html/body/div[5]/div[2]/div[1]/span[2]/div/div/a[20]");
        e.click();

        // 6. 设置租金为 2600-5200 元，并点击确定
        e = driver.findElementByXPath("/html/body/div[5]/div[2]/div[2]/span[2]/div/form/input[1]");
        CharSequence []cs={"2600"};//重点要求
        e.sendKeys(cs);// “搜索框”中输入“2600”

        e = driver.findElementByXPath("/html/body/div[5]/div[2]/div[2]/span[2]/div/form/input[2]");
        cs[0]="5200";
        e.sendKeys(cs);//不能直接用字符串
        e.click();

        e = driver.findElementByXPath("//*[@id=\"pricerange_search\"]");
        e.click();

        driver.close();
    }

}

第7题 测试代码编写.HelloWorld类最简单say方法(5分)

此题的上机环境和要求:

1. Junit4 或者以上。
2. 使用Junit4脚本。
3. 测试类只有一个，名称为TestMain，这一点非常重要。
4. 测试代码不能有输出语句（System…等)，否则以0分计。
5. 如果测试代码不能编译成功则以0分计。

此题的上机步骤是:

1. 建立一个Java项目，名称可以按题号取名。
2. 建立被测试类和一个测试类(名称为TestMain)。
3. 编写测试代码。
4. 提交测试代码，注意题号要一致。

本题被测试类如下：

public class HelloWorld {
    public String say() {
        return("Hello World!");
    }
}

答案

import static org.junit.Assert.*;

import org.junit.Test;

public class TestMain {

    @Test
    public void test() {
        HelloWorld h1 = new HelloWorld();
        assertEquals("Hello World!",h1.say());
    }

}

第8题 测试代码编写.SayYourName类语句覆盖(10分)

此题的上机环境和要求:

1. Junit4 或者以上。
2. 使用Junit4脚本。
3. 测试类只有一个，名称为TestMain，这一点非常重要。
4. 测试代码不能有输出语句（System…等)，否则以0分计。
5. 如果测试代码不能编译成功则以0分计。

此题的上机步骤是:

1. 建立一个Java项目，名称可以按题号取名。
2. 建立被测试类和一个测试类(名称为TestMain)。
3. 编写测试代码。
4. 提交测试代码，注意题号要一致。

本题被测试类如下：

public class SayYourName {
    public String getAndSay(String name) {
        if ("LiMeiYi".equals(name)) {
            return ("Hi,Teacher");
        } else {
            return ("Hi,Welcome!");
        }
    }
}

答案

import static org.junit.Assert.*;

import org.junit.Test;

public class TestMain {

    @Test
    public void test1() {
        SayYourName ayn = new SayYourName();
        assertEquals("Hi,Teacher",ayn.getAndSay("LiMeiYi"));
        assertEquals("Hi,Teacher",ayn.getAndSay("xyq"));
    }
    
}

第9题 测试代码编写.Calculator类简单语句覆盖(15分)

此题的上机环境和要求:

1. Junit4 或者以上。
2. 使用Junit4脚本。
3. 测试类只有一个，名称为TestMain，这一点非常重要。
4. 测试代码不能有输出语句（System…等)，否则以0分计。
5. 如果测试代码不能编译成功则以0分计。

此题的上机步骤是:

1. 建立一个Java项目，名称可以按题号取名。
2. 建立被测试类和一个测试类(名称为TestMain)。
3. 编写测试代码。
4. 提交测试代码，注意题号要一致。

本题被测试类如下：

public class Calculator {
    public int add(int a, int b){
        return a + b;
    }
    public int minus(int a, int b){
        return a - b;
    }
    public int multiply(int a, int b){
        return a * b;
    }
    public int divide(int a, int b) throws Exception{
        if(0 == b){
            throw new Exception("除数不能为零!");
        }
        return a / b;
    }   
}

答案

import static org.junit.Assert.*;

import org.junit.Test;

public class TestMain {
    Calculator calulator = new Calculator();

    @Test
    public void testAdd() {
        assertEquals(3,calulator.add(1, 2));
    }
    @Test
    public void testMinus() {
        assertEquals(1,calulator.minus(3, 2));
    }
    @Test
    public void testMultiply() {
        assertEquals(4,calulator.multiply(2, 2));
    }
    @Test
    public void testDivide1() throws Exception {
        assertEquals(1,calulator.divide(2, 2));
    }
    @Test
    public void testDivide2() throws Exception {
        try {
            calulator.divide(2, 0);
            fail("除数不能为零!");
        }catch(Exception e) {
            assertEquals("除数不能为零!",e.getMessage());
        }
    }

}

第10题 测试代码编写.Triangle类分支覆盖(22分)

此题的上机环境和要求:

1）Junit4 或者以上。
2) 使用Junit4脚本。
3) 测试类只有一个，名称为TestMain，这一点非常重要。
3) 测试代码不能有输出语句（System…等)，否则以0分计。
4) 如果测试代码不能编译成功则以0分计。

此题的上机步骤是:

1. 建立一个Java项目，名称可以按题号取名。
2. 建立被测试类和一个测试类(名称为TestMain)。
3. 编写测试代码。
4. 提交测试代码，注意题号要一致。

本题被测试类如下：

public class Triangle {
    //定义三角形的三边
    protected long lborderA = 0;
    protected long lborderB = 0;
    protected long lborderC = 0;
    //构造函数
    public Triangle(long lborderA,long lborderB,long lborderC)
    {
           this.lborderA = lborderA;
           this.lborderB = lborderB;
           this.lborderC = lborderC;
    }

    /**
     * 判断是否是三角形
     * 是返回true；不是返回false
     */

    public boolean isTriangle(Triangle triangle)
    {
       boolean isTrue = false;
       //判断边界，大于0小于等于100，出界返回false
       if((triangle.lborderA>0&&triangle.lborderA<=100)
          &&(triangle.lborderB>0&&triangle.lborderB<=100)
          &&(triangle.lborderC>0&&triangle.lborderC<=100))
       {
            //判断两边之和大于第三边
            if((triangle.lborderA<(triangle.lborderB+triangle.lborderC))
             &&(triangle.lborderB<(triangle.lborderA+triangle.lborderC))
             &&(triangle.lborderC<(triangle.lborderA+triangle.lborderB)))
            isTrue = true;
       }
            return isTrue;
    }

     /**
      * 判断三角形类型
      * 等腰三角形返回字符串“等腰三角形”；
      * 等边三角形返回字符串“等边三角形”；
      * 其它三角形返回字符串“不等边三角形”；
      */
    public String isType(Triangle triangle){
        String strType = "";
        // 判断是否是三角形            
        if(this.isTriangle(triangle)){
            //判断是否是等边三角形                  
            if(triangle.lborderA==triangle.lborderB&&triangle.lborderB==triangle.lborderC)
                strType = "等边三角形";
                //判断是否是不等边三角形
            else if((triangle.lborderA!=triangle.lborderB)&&
               (triangle.lborderB!=triangle.lborderC)&&
               (triangle.lborderA!=triangle.lborderC))
                strType = "不等边三角形";
            else
                strType="等腰三角形";
            }
            return strType;
      }

      public static void main(String[] args) {
        // TODO 自动生成方法存根
        Triangle aTriangle;
        aTriangle=new Triangle(-1,2,4);
        if(!aTriangle.isTriangle(aTriangle))
        System.out.println("不是三角形");
    }

}

答案

import static org.junit.Assert.*;

import org.junit.BeforeClass;
import org.junit.Test;

public class TestMain {


    @Test
    public void testIsTriangle1() {
        Triangle triangle = new Triangle(101,3,4);
        assertEquals(false,triangle.isTriangle(triangle));
    }
    @Test
    public void testIsTriangle2() {
        Triangle triangle = new Triangle(5,3,4);
        assertEquals(true,triangle.isTriangle(triangle));
    }
    @Test
    public void testIsTriangle3() {
        Triangle triangle = new Triangle(5,3,10);
        assertEquals(false,triangle.isTriangle(triangle));
    }
    @Test
    public void testIsType1() {
        Triangle triangle = new Triangle(12,3,3);
        assertEquals("",triangle.isType(triangle));
    }
    @Test
    public void testIsType2() {
        Triangle triangle = new Triangle(3,3,3);
        assertEquals("等边三角形",triangle.isType(triangle));
    }
    @Test
    public void testIsType3() {
        Triangle triangle = new Triangle(3,3,2);
        assertEquals("等腰三角形",triangle.isType(triangle));
    }
    @Test
    public void testIsType4() {
        Triangle triangle = new Triangle(3,4,5);
        assertEquals("不等边三角形",triangle.isType(triangle));
    }
    @Test
    public void testIsType5() {
        Triangle.main(new String[]{});
    }
}

第11题 单选题(16分）

1. 软件生命周期由若干个阶段组成，下列（ ）阶段，如果在此阶段发现软件缺陷，则修复费用是最低的。
   （A）需求分析（编制产品说明书）
   （B）设计
   （C）编码
   （D）产品发布
2. 下列各项中（ ）不是一个测试计划所应包含的内容。
   （A）测试资源、进度安排
   （B）测试预期输出
   （C）测试范围
   （D）测试策略
3. 软件测试的目的是（ ）。
   （A）试验性运行软件
   （B）发现软件错误
   （C）证明软件正确
   （D）找出软件中全部错误
4. 软件测试是采用（ ）执行软件的活动。
   （A）测试用例
   （B）输入数据
   （C）测试环境
   （D）输入条件
5. 与设计测试用例无关的文档是（ ）。
   （A）项目开发计划
   （B）需求规格说明书
   （C）设计说明书
   （D）源程序
6. 下列项目中不属于测试文档的是（ ）
   （A）测试计划
   （B）测试用例
   （C）程序流程图
   （D）测试报告
7. 软件测试用例主要由输入数据和（ ）两部分组成。
   （A）测试计划
   （B）测试规则
   （C）预期输出结果
   （D）以往测试记录分析
8. 经验表明，在程序测试中，某模块与其他模块相比，若该模块已发现并改正的错误较多，
   则该模块中残存的错误数目与其他模块相比，通常应该（ ）。
   （A）较少
   （B）较多
   （C）相似
   （D）不确定

答案

1. A
2. B
3. B
4. A
5. A
6. C
7. C
8. B

第12题 计算题.软件可靠性基本参数"有效度"计算(10分)

此题的步骤和要求:

1. 按题目要求做计算。;
2. 提交计算结果，注意题号要一致。
3. 计算结果如果有小数的话，保留两位小数，第三位小数四舍五入，如果有特殊说明例外。
   如果不足两位小数请补0，例如如果计算是4.1，则提交的是4.10。

内容：

假设系统S投入测试或运行，工作一段时间t1后，软件出现错误，系统被停止并进行修复，经过T1时间后，故障被排除；又投入测试或运行，工作一段时间t2后，软件出现错误，系统被停止并进行修复，经过T2时间后，故障被排除。如此进行下去。
假设t1，t2，…，tn是系统正常的工作时间，T1，T2，…，Tn是维护时间，其数据分别如下：

运行时间	t1	t2	t3	t4	t5	t6	t7
小时	12	20	40	70	110	60	120

维护时间	t1	t2	t3	t4	t5	t6	t7
小时	12	8	5	5	2	9	1

请计算“有效度A”。

答案

0.91

解析

MTBF = (12 + 20 + 40 + 70 + 110 + 60 + 120) / 7
MTTR = (12 + 8 + 5 + 5 + 2 + 9 + 1) / 7
$$A=\frac{MTBF}{MTBF+MTTR}=\frac{432}{474}$$

第13题 计算题.软件可靠性基本参数"故障率"计算(10分)

此题的步骤和要求:

1. 按题目要求做计算。;
2. 提交计算结果，注意题号要一致。
3. 计算结果如果有小数的话，保留四位小数，第五位小数四舍五入，如果有特殊说明例外。
   如果不足四位小数请补0，例如如果计算是4.145，则提交的是4.1450。

内容：

假设系统S投入测试或运行，工作一段时间t1后，软件出现错误，系统被停止并进行修复，经过T1时间后，故障被排除；又投入测试或运行，工作一段时间t2后，软件出现错误，系统被停止并进行修复，经过T2时间后，故障被排除。如此进行下去。
假设t1，t2，…，tn是系统正常的工作时间，T1，T2，…，Tn是维护时间，其数据分别如下：

运行时间	t1	t2	t3	t4	t5	t6	t7
小时	12	20	40	70	110	60	120

维护时间	t1	t2	t3	t4	t5	t6	t7
小时	12	8	5	5	2	9	1

请计算“故障率（风险函数）”。
请保留四位小数，第五位小数四舍五入
注意：故障率（风险函数）结果不需要使用单位FIT。

答案

0.0162

解析

$$故障率=\frac{总失效次数}{总工作时间}=\frac{n}{{\sum }_{i=1}^n{t}_i}=\frac{7}{(12+20+40+70+110+60+120)}=\frac{7}{432}$$

第14题 计算题.软件可靠性"按使用剖面测试小时"计算(10分)

此题的步骤和要求:

1. 按题目要求做计算。;
2. 提交计算结果，注意题号要一致。
3. 计算结果如果有小数的话，保留两位小数，第三位小数四舍五入，如果有特殊说明例外.

如果不足两位小数请补0，例如如果计算是4.1，则提交的是4.10。

内容：

假设某软件有7个模块，实际使用时每个模块被执行的概率分别为p1，p2，…，p7，

其数据如下:

模块概率	p1	p2	p3	p4	p5	p6	p7
概率取值	0.12	0.2	0.17	0.02	0.3	0.1	0.09

请问均匀分布测试M=200小时，相当于按使用剖面测试了多少小时?

答案

151.71

解析

$$200\times \sum _{i=1}^7\{p_i,\frac{1}{7}\}=200\times (0.12+1/7+1/7+0.02+1/7+0.1+0.09)=200\times (3/7+0.33)=151.71$$

第15题 计算题.软件可靠性"被执行概率已知时使用剖面测试时间"计算(10分)

此题的步骤和要求:

1. 按题目要求做计算。;
2. 提交计算结果，注意题号要一致。
3. 计算结果如果有小数的话，保留两位小数，第三位小数四舍五入，如果有特殊说明例外。
   如果不足两位小数请补0，例如如果计算是4.1，则提交的是4.10。

内容：

某系统有6个模块，在均匀分布假设下，每个模块被执行的概率为1/6。假设系统总共的测试时间为120H，则每个模块的测试时间为20H。根据对用户使用剖面的分析，6个模块被执行的概率分别近似为：0.14, 0.23, 0.26, 0.20, 0.07, 0.1。对同样的120H，6个模块实际的执行时间分别为16.8, 27.6, 31.2, 24.0, 8.4, 12.0。请计算相当于按使用剖面的测试时间是多少小时？

答案：

97.20

解析

时间：min{120 * 0.14,20} + min{120 * 0.23 , 20} + min{120 * 0.26,20} + min{120 * 0.20,20} + min{120 * 0.07 ,20} + {120 * 0.1,20}
= 16.8 + 20 + 20 + 20 + 8.4 + 12.0
97.20

第16题 判断题(8分)

1. 白盒测试不仅与程序内部结构有关，还要考虑程序的功能要求。（ ）
2. 白盒测试的“原子谓词覆盖”标准强于“路径覆盖”。（ ）
3. 白盒测试仅与程序的内部结构有关，完全可以不考虑程序的功能要求。（ ）
4. 白盒测试是从用户观点出发的测试。（ ）
5. 测试按照测试层次可以划分成为单元测试、集成测试和系统测试。（ ）
6. 测试是调试的一个部分。（ ）
7. 测试是可以穷尽的。（ ）
8. 测试是提高产品质量根本手段。（ ）

答案

1. ×
2. ×
3. √
4. ×
5. √
6. ×
7. ×
8. ×

第17题 工具软件的掌握. selenium工具的环境配置(5分)

此题的上机环境是:

1. Chrome浏览器安装目录为C:\Program Files\Chrome\Application\chrome.exe
   如果安装目录不是该文件夹，请复制安装目录下的子文件夹“Chrome”到“C:\Program Files\”。
2. 驱动程序chromedriver.exe放到C:\WebDriver中

此题的步骤和要求是:

1. 建立一个Java项目,名称务必按题号取名。这一点非常重要；
2. 建立一个测试类, 类的名称为TestMain。这一点非常重要；
3. 按下面TestMain.java代码的要求编写测试代码；
4. 按要求进行配置，保证内容正确。
5. 截图（包含了右下角时间），截图存储为jpg文件。
   截图内容:要能够看到工程名称、TestMain.java代码和右下角时间。
6. 文件名称要求: 学号-姓名.jpg
   例如学号为 201055152702,姓名为张三富的同学,文件名称为:
   201055152702-张三富.jpg
   请务必提交jpg文件或者JPG文件!
   文件大小限定1Mb。

关于"截图"方法,可以按键盘上的屏幕截图按钮"PrtSc"键,然后打开"附件"中的"画图"应用程序,粘贴,再存储为jpg格式文件.

文件TestMain.java做Web功能测试的要求如下：

/**
 * 测试乐居网的搜索功能
 * 乐居网: http://www.leju12.com/
 * 1. 打开安居客网页版
 * 2. 搜索框输入“蜂蜜”
 * 3. 点击“搜索”按钮    
 *
 */

答案(乐居网: http://www.leju12.com/在维护)

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;

public class TestMain {
    public static void main(String[] args) {
        System.setProperty("webdriver.chrome.driver", "C:\\WebDriver\\chromedriver.exe");
//      System.setProperty("webdriver.chrome.driver", "D:\\学习\\课程学习\\软件测试\\考试题/chromedriver.exe");
        ChromeOptions options = new ChromeOptions();
        // options.setBinary("C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe");
        options.setBinary("C:\\Program Files\\Chrome\\Application\\chrome.exe");
        ChromeDriver driver = new ChromeDriver(options);
        // 隐式等待时间
        driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS); // 每次操作时长
        driver.get("http://www.baidu.com/");
        
        WebElement text = driver.findElementByXPath("/html/body/div[1]/div[1]/div[5]/div[1]/div/form/span[1]/input")
;
        text.sendKeys("蜜蜂");
        WebElement button = driver.findElementByXPath("/html/body/div[1]/div[1]/div[5]/div[2]/div/form/span[2]/input");
        button.click();
        }
}

第18题 测试代码编写.一元二次方程类语句覆盖(10分)

此题的上机环境和要求:

1. Junit4 或者以上。
2. 使用Junit4脚本。
3. 测试类只有一个，名称为TestMain，这一点非常重要。
4. 测试代码不能有输出语句（System…等)，否则以0分计。
5. 如果测试代码不能编译成功则以0分计。

此题的上机步骤是:

1. 建立一个Java项目，名称可以按题号取名。
2. 建立被测试类和一个测试类(名称为TestMain)。
3. 编写测试代码。
4. 提交测试代码，注意题号要一致。

本题被测试类如下：

public class CalcRootClass {
    private double x1, x2;

    public String CalcFun(double a, double b, double c) {
        double mid = 0;
        String st = "";
        if (a != 0) {
            mid = b * b - 4 * a * c;
            if (mid > 0) {
                x1 = (-b + Math.sqrt(mid)) / (2 * a);
                x2 = (-b - Math.sqrt(mid)) / (2 * a);
                st += ("二个实根\n");
            } else {
                if (mid == 0) {
                    x1 = -b / (2 * a);
                    x2=x1;
                    st += ("一个二重实根\n");
                } else {
                    x1 = -b / (2 * a);
                    x2 = Math.sqrt(-mid) / (2 * a);
                    st += ("二个复根,实部和虚部分别为\n");
                }
            }
            st = st + "x1=" + x1 + ",x2=" + x2 + "\n";
        }
        return st;
    }
}

答案

import static org.junit.Assert.assertEquals;

import org.junit.Before;
import org.junit.Test;

public class TestMain {
    CalcRootClass crc;
    @Before
    public void setUp() throws Exception {
        crc = new CalcRootClass();
    }

    @Test
    public void test() {
        assertEquals("二个实根\nx1=3.0,x2=1.0\n",crc.CalcFun(1,-4,3));
        assertEquals("一个二重实根\nx1=-1.0,x2=-1.0\n",crc.CalcFun(2,4,2));
        assertEquals("二个复根,实部和虚部分别为\nx1=-0.4,x2=0.2\n",crc.CalcFun(5,4,1));
    }

}

或

import static org.junit.Assert.assertEquals;

import org.junit.Before;
import org.junit.Test;

public class TestMain {
    CalcRootClass crc;
    @Before
    public void setUp() throws Exception {
        crc = new CalcRootClass();
    }

    @Test
    public void test1() {
        assertEquals("二个实根\nx1=3.0,x2=1.0\n",crc.CalcFun(1,-4,3));
    }
    @Test
    public void test2() {
        assertEquals("一个二重实根\nx1=-1.0,x2=-1.0\n",crc.CalcFun(2,4,2));
    }
    @Test
    public void test3() {
        assertEquals("二个复根,实部和虚部分别为\nx1=-0.4,x2=0.2\n",crc.CalcFun(5,4,1));
    }

}

第19题 测试代码编写.一元二次方程分支覆盖(10分)

此题的上机环境和要求:

1. Junit4 或者以上。
2. 使用Junit4脚本。
3. 测试类只有一个，名称为TestMain，这一点非常重要。
4. 测试代码不能有输出语句（System…等)，否则以0分计。
5. 如果测试代码不能编译成功则以0分计。

此题的上机步骤是:

1. 建立一个Java项目，名称可以按题号取名。
2. 建立被测试类和一个测试类(名称为TestMain)。
3. 编写测试代码。
4. 提交测试代码，注意题号要一致。

本题被测试类如下：

public class CalcRootClass {
    private double x1, x2;

    public String CalcFun(double a, double b, double c) {
        double mid = 0;
        String st = "";
        if (a != 0) {
            mid = b * b - 4 * a * c;
            if (mid > 0) {
                x1 = (-b + Math.sqrt(mid)) / (2 * a);
                x2 = (-b - Math.sqrt(mid)) / (2 * a);
                st += ("二个实根\n");
            } else {
                if (mid == 0) {
                    x1 = -b / (2 * a);
                    x2=x1;
                    st += ("一个二重实根\n");
                } else {
                    x1 = -b / (2 * a);
                    x2 = Math.sqrt(-mid) / (2 * a);
                    st += ("二个复根,实部和虚部分别为\n");
                }
            }
            st = st + "x1=" + x1 + ",x2=" + x2 + "\n";
        }
        return st;
    }
}

答案

import static org.junit.Assert.assertEquals;

import org.junit.Before;
import org.junit.Test;

public class TestMain {
    CalcRootClass crc;
    @Before
    public void setUp() throws Exception {
        crc = new CalcRootClass();
    }

    @Test
    public void test1() {
        assertEquals("",crc.CalcFun(0,1,2));
        
    }
    @Test
    public void test2() {
        assertEquals("二个实根\nx1=3.0,x2=1.0\n",crc.CalcFun(1,-4,3));
    }
    @Test
    public void test3() {
        assertEquals("一个二重实根\nx1=-1.0,x2=-1.0\n",crc.CalcFun(2,4,2));
    }
    @Test
    public void test4() {
        assertEquals("二个复根,实部和虚部分别为\nx1=-0.4,x2=0.2\n",crc.CalcFun(5,4,1));
    }

}

附加作业(1)-购物车WEB测试

测试类名称是TestMain。

测试网站：

https://sahitest.com/demo/training/login.htm

1. 用下列用户登录

用户名：test

密码：secret

2. 单击 "login"按钮，出现"All available books"表单界面

3. 请对界面的每个控件都进行一次测试。

答案

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;

public class TestMain {
    public static void main(String[] args) {
        System.setProperty("webdriver.chrome.driver", "D:\\学习\\课程学习\\软件测试\\考试题\\chromedriver.exe");
        ChromeOptions options = new ChromeOptions();
        options.setBinary("C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe");
        ChromeDriver driver = new ChromeDriver(options);
        driver.manage().timeouts().implicitlyWait(5,TimeUnit.SECONDS);
        driver.get("https://sahitest.com/demo/training/login.htm");
        CharSequence username[] = {"test"};
        CharSequence password[] = {"secret"};
        CharSequence coreJava1[] = {"9"};
        CharSequence ruby1[] = {"999"};
        CharSequence python1[] = {"99"};
        CharSequence total1[] = {"123456789"};
        WebElement user = driver.findElementByXPath("/html/body/center/div/form/table/tbody/tr[1]/td[2]/input");
        user.sendKeys(username);
        WebElement pwd = driver.findElementByXPath("/html/body/center/div/form/table/tbody/tr[2]/td[2]/input");
        pwd.sendKeys(password);
        WebElement login = driver.findElementByCssSelector(".test .button");
        login.click();
        WebElement coreJava = driver.findElementByXPath("/html/body/center/form/div/table/tbody/tr[2]/td[4]/input");
        coreJava.sendKeys(coreJava1);
        WebElement ruby = driver.findElementByXPath("/html/body/center/form/div/table/tbody/tr[2]/td[4]/input");
        ruby.sendKeys(ruby1);
        WebElement python = driver.findElementByXPath("//*[@id=\"listing\"]/tbody/tr[3]/td[4]/input");
        python.sendKeys(python1);
        WebElement addBtn = driver.findElementByXPath("//*[@id=\"listing\"]/tbody/tr[4]/td[4]/input");
        addBtn.click();
        WebElement total = driver.findElementByXPath("//*[@id=\"total\"]");
        total.sendKeys(total1);
        WebElement clearBtn = driver.findElementByXPath("/html/body/center/form/div/input[2]");
        clearBtn.sendKeys(total1);
        WebElement logout = driver.findElementByXPath("/html/body/center/form/div/input[3]");
        logout.click();
        
    }
}

附加作业(2)-用户注册WEB测试

测试类名称是TestMain。

测试网站：

https://sahitest.com/demo/training/register.htm

1. 进入用户注册。

2. 请对此用户注册界面的每个控件都进行一次测试，包括“提示”信息的测试。

答案

import java.util.concurrent.TimeUnit;

import org.openqa.selenium.Alert;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;
import org.openqa.selenium.chrome.ChromeOptions;
public class TestMain {

    public static void main(String[] args) {
        System.setProperty("webdriver.chrome.driver", "D:\\学习\\课程学习\\软件测试\\考试题\\chromedriver.exe");
        ChromeOptions options = new ChromeOptions();
        options.setBinary("C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe");
        ChromeDriver driver = new ChromeDriver(options);
        driver.manage().timeouts().implicitlyWait(5, TimeUnit.SECONDS);
        driver.get("https://sahitest.com/demo/training/register.htm");
        CharSequence username[] = {"xyq"};
        CharSequence password[] = {"666"};
        CharSequence repeatPassword[] = {"666"};
        CharSequence address[] = {"湘潭大学"};
        CharSequence billingAddress[] = {"湘潭大学"};
        WebElement username1 = driver.findElementByXPath("/html/body/center/div/form/div/table/tbody/tr[1]/td[2]/input");
        username1.sendKeys(username);
        WebElement password1 = driver.findElementByXPath("/html/body/center/div/form/div/table/tbody/tr[2]/td[2]/input");
        password1.sendKeys(password);
        WebElement repeatPassword1 = driver.findElementByXPath("/html/body/center/div/form/div/table/tbody/tr[3]/td[2]/input");
        repeatPassword1.sendKeys(repeatPassword);
        WebElement gender1 = driver.findElementByXPath("/html/body/center/div/form/div/table/tbody/tr[4]/td[2]/input[1]");
        gender1.click();
        WebElement address1 = driver.findElementByXPath("/html/body/center/div/form/div/table/tbody/tr[5]/td[2]/textarea");
        address1.sendKeys(address);
        WebElement billingAddress1 = driver.findElementByXPath("/html/body/center/div/form/div/table/tbody/tr[6]/td[2]/textarea");
        billingAddress1.sendKeys(billingAddress);
        WebElement select = driver.findElementByXPath("/html/body/center/div/form/div/table/tbody/tr[7]/td[2]/select/option[2]");
        select.click();
        WebElement agree = driver.findElementByXPath("/html/body/center/div/form/input[1]");
        agree.click();
        WebElement register = driver.findElementByXPath("/html/body/center/div/form/input[2]");
        register.click();
        Alert alert =driver.switchTo().alert();
        alert.accept();
        WebElement cancel = driver.findElementByXPath("/html/body/center/div/form/input[3]");
        cancel.click();
        alert.dismiss();
        cancel.click();
        alert.accept();

    }
}

学习通练习

选择题

1. (单选题)软件生命周期由若干个阶段组成，下列（ ）阶段，如果发生软件缺陷，则修复费用是最低的。

A. 编码
B. 需求分析（编制产品说明书）
C. 设计
D. 产品发布

正确答案：B

2. (单选题)软件测试是采用（ ）执行软件的活动。

A. 输入数据
B. 测试用例
C. 测试环境
D. 输入条件

正确答案: B

3. (单选题)下面说法正确的是（ ）。

A. 成功的测试是发现了迄今尚未发现的错误的测试
B. 经过测试没有发现错误说明程序正确
C. 测试的目标是为了证明程序没有错误
D. 成功的测试是没有发现错误的测试

正确答案: A

4. (单选题)下列可以作为软件测试对象的是（ ）。

A. 源程序
B. 软件设计规格说明
C. 需求规格说明书
D. 以上全部

正确答案: D

5. (单选题)以下那一种选项不属于软件缺陷（ ）.

A. 软件实现了产品规格没有提到的功能
B. 软件实现了产品规格说明所要求的功能但因受性能限制而未考虑可移植性问题
C. 软件中出现了产品规格说明不应该出现的功能
D. 软件没有实现产品规格说明所要求的功能

正确答案: B

6. (单选题)在边界值分析中，下列数据通常不用来做数据测试的是（ ）

A. 等价类中的等价值
B. 正好等于边界的值
C. 刚刚大于边界的值
D. 刚刚小于边界的值

正确答案: A

7. (单选题)测试ATM取款功能，已知取款数只能输入正整数，每次取款数要求是100的倍数且不能大于500，下面（ ）是正确的无效等价类

A. （0，100）、（100，200）、（200，300）、（300，400）、（400，500）、（500，+∞）
B. （500，+∞）
C. （-∞，100）、（100，200）、（200，300）、（300，400）、（400，500）、（500，+∞）
D. （500，+∞）、任意大于0小于500的非100倍数的整数

正确答案: D

8. (单选题)在某大学学籍管理信息系统中，假设学生年龄的输入范围为 16—40，则根据黑盒测试中的等价类划分技术，下面划分正确的是（ ）。

A. 可划分为1个有效等价类，2个无效等价类
B. 可划分为 2 个有效等价类，2 个无效等价类
C. 可划分为 2 个有效等价类，1 个无效等价类
D. 可划分为 1 个有效等价类，1 个无效等价类

正确答案: A

9. (单选题)单元测试中用来模拟被测模块调用者的模块称之为（ ）

A. 驱动模块
B. 桩模块
C. 父模块
D. 子模块

正确答案: A

10. (单选题)不属于单元测试内容的是（ ）

A. 模块接口测试
B. 局部数据结构测试
C. 独立路径测试
D. 用户界面测试

正确答案: D

11. (单选题)单元测试中设计测试用例的依据是（ ）

A. 概要设计规格说明书
B. 详细设计规格说明书
C. 项目计划说明书
D. 用户需求规格说明书

正确答案: B

12. 软件测试是软件质量保证的重要手段，下述（ ）是软件测试的最基础环节

A. 单元测试
B. 结构测试
C. 功能测试
D. 验收测试

正确答案: A

13. (单选题)进行全面的单元测试方法是（ ）

A. 采用黑盒测试，辅之以白盒测试
B. 采用白盒测试，辅之以黑盒测试
C. 只使用黑盒测试
D. 只使用白盒测试

正确答案: B

14. (单选题)下列各项中（ ）不是一个测试计划所应包含的内容。

A. 测试资源、进度安排
B. 测试范围
C. 测试策略
D. 测试预期输出

正确答案: D

15. (单选题)软件测试过程中的集成测试主要是为了发现（ ）阶段的错误。

A. 需求分析
B. 概要设计
C. 详细设计
D. 编码

正确答案: B

16. (单选题)集成测试计划应该在（ ）阶段末提交。

A. 需求分析
B. 概要设计
C. 详细设计
D. 单元测试

正确答案: B

17. (单选题)自底向上增量式集成测试中，下面（ ）描述是正确的。

A. 父单元用测试过的子单元测试
B. 测试由桩模块控制
C. 最上面的模块最先测试
D. 包含树的深度优先或广度优先遍历过程

正确答案: A

18. (单选题)( )方法需要考察模块间的接口和各模块之间的联系。

A. 确认测试
B. 系统测试
C. 集成测试
D. 单元测试

正确答案: C

19. (单选题)集成测试对系统内部的交互以及集成后系统功能检验了（ ）质量特性。

A. 正确性
B. 可靠性
C. 可用性
D. 可维护性

正确答案: A

20. (单选题)在自低向上测试中，要编写称为（ ）的模块来测验正在测试的模块。

A. 测试存根
B. 底层模块
C. 驱动模块
D. 桩模块

正确答案: C

21. (单选题)数据流覆盖关注的是程序中某个变量从其声明、赋值到引用的变化情况，它是下列哪一种覆盖的变种（ ）。

A. 路径覆盖
B. 语句覆盖
C. 分支覆盖
D. 原子谓词覆盖

正确答案: A

判断题

1. (判断题)等价类测试的标准等价类测试不如对应的健壮等价类测试的测试全面。

A. 对
B. 错

正确答案: 对

2. (判断题)等价类划分方法将所有可能的输入数据划分成若干部分，然后从每一部分中选取少数有代表性的数据作为测试用例。

A. 对
B. 错

正确答案: 对

3. (判断题)黑盒测试的测试用例是根据应用程序的功能需求设计的。

A. 对
B. 错

正确答案: 对

4. (判断题)黑盒测试往往会造成测试用例之间可能存在严重的冗余和未测试的功能漏洞。

A. 对
B. 错

正确答案: 对

5. (判断题)用黑盒法测试时，测试用例是根据程序内部逻辑设计的。

A. 对
B. 错

正确答案: 错

6. (判断题)有n个变量的函数的边界值分析会产生4n+1个测试用例

A. 对
B. 错

正确答案: 对

7. (判断题)有n个变量的函数的健壮性测试用例的个数为：5n+1。

A. 对
B. 错

正确答案: 错

8. (判断题)在所有的黑盒测试方法中，基于决策表的测试是最为严格、最具有逻辑性的测试方法。

A. 对
B. 错

正确答案: 对

9. (判断题)单元测试多采用白盒测试（结构性测试）技术。

A. 对
B. 错

正确答案: 对

10. (判断题)单元测试能发现约80%的软件缺陷。

A. 对
B. 错

正确答案: 对

11. (判断题)单元测试又称为模块测试，是针对软件测试的最小单位－程序模块进行正确性检验的测试工作。

A. 对
B. 错

正确答案: 对

12. 单元测试通常由开发人员进行。

A. 对
B. 错

正确答案: 对

13. (判断题)集成测试计划在需求分析阶段末提交。

A. 对
B. 错

正确答案: 错

14. (判断题)集成测试是检验程序单元或部件的接口关系，逐步集成为符合概要设计要求的程序部件或整个系统。

A. 对
B. 错

正确答案: 对

15. (判断题)集成测试是为确定软件系统是否满足验收标准以及使客户决定是否接受而进行的正式测试。

A. 对
B. 错

正确答案: 错

16. (判断题)进行自底向上集成测试，需要为所测模块或子系统编制相应的驱动模块。

A. 对
B. 错

正确答案: 对

17. (判断题)进行自顶向下集成测试，需要为所测模块或子系统编制相应的驱动模块。

A. 对
B. 错

正确答案: 错

18. (判断题)集成测试是对已测试过的模块进行组装，进行集成测试的目的主要在于检验与软件设计相关的程序结构问题。

A. 对
B. 错

正确答案: 对

19. (判断题)集成测试一般通过黑盒测试方法来完成。

A. 对
B. 错

正确答案: 对

20. (判断题)单元测试是完成集成测试后开始的，它对开发工作初期制定的确认准则进行检验。

A. 对
B. 错

正确答案: 错

部分计算公式

可靠性测试

假设系统S投入测试或运行，工作一段时间t1后，软件出现错误，系统被停止并进行修复，经过T1时间后，故障被排除；又投入测试或运行，工作一段时间t2后，软件出现错误，系统被停止并进行修复，经过T2时间后，故障被排除。如此进行下去。
假设t1，t2，…，tn是系统正常的工作时间，T1，T2，…，Tn是维护时间

故障率（风险函数）

$$\lambda =\frac{总失效次数}{总工作时间}=\frac{n}{{\sum }_{i=1}^n{t}_i}$$

$\lambda$的单位是 FIT , $1FIT=10^{-9}/小时$

维修率

$$u=\frac{总失效次数}{总维护时间}=\frac{n}{{\sum }_{i=1}^n{T}_i}$$

平均无故障时间

$$MTBF=\frac{总工作时间}{总失效次数}=\frac{{\sum }_{i=1}^n{t}_i}{n}=\frac{1}{\lambda }$$

平均维护时间

$$MTTR=\frac{总维护时间}{总失效次数}=\frac{{\sum }_{i=1}^n{T}_i}{n}=\frac{1}{u}$$

有效度

$$A=\frac{总工作时间}{总工作时间+总失效次数(可能是总维护时间，书上是总失效次数)}=\frac{MTBF}{MTBF+MTTR}=\frac{1(可能是u,书上是1)}{\lambda +u}$$

剖面测试

相当于按使用剖面测试了多少小时

假设软件有n功能或模块，实际使用时每个模块被执行的概率分别为p1,p2,…,pn,均匀分布测试M小时，则相当于按使用剖面测试的时间如下(单位为小时):

$$M\sum _{i=1}^{n}min\{p_i,\frac{1}{n}\}$$

知识点

软件测试过程

单元测试 -> 集成测试 -> 确认测试 -> 系统测试 -> 验收测试

软件开发是自顶向下逐步细化的过程，软件测试则是自底向上逐步集成的过程。低一级的测试为上一级的测试准备条件。

单元测试：确保每一个模块能正常工作，大多采用白盒测试;
集成测试：检测和排除与软件设计相关的程序结构问题，大多采用黑盒测试;
确认测试：以规格说明书规定的需求为尺度，检验开发的软件是否满足所有的功能和性能要求;
系统测试：软件是否能与系统的其他部分协调工作;
验收测试：解决开发的软件产品是否符合预期要求、用户是否接受等问题;

黑盒测试

黑盒测试是一种从软件外部对软件实施的测试，也称功能测试或基于规格说明的测试。

使用的唯一信息是软件的规格说明。

黑盒测试是从用户的观点出发的测试。

等价类划分法

等价类是指输入域的某个互不相交的子集合

等价类划分原则

1. 按区间划分
2. 按数值划分
3. 按数值集合划分
4. 按限制条件或规则划分
5. 细分等价类

有效等价类

有效等价类一指符合程序规格说明书，有意义的、合理的输人数据所所构成的集合。
利用有效等价类，可以检验程序是否实现了规格说明预先规定的功能和性能。有效等价类可以是一个，也可以是多个。

无效等价类

无效等价类一指不符合程序规格说明书，不合理或无意义的输人数据所构成的集合。
利用无效等价类，可以检查软件功能和性能的实现是否有不符合规格说明要求的地方。无效等价类至少应有一个，也可能有多个。

存在的问题

1. 规格说明往往没有定义无效测试用例的期望输出应该是什么样的
2. 强类型语言没必要考虑无效输入

边界值分析法

边界值分析测试

边界值分析利用输入变量的最小值、稍大于最小值、域内任意值、稍小于最大值、最大值来设置测试用例。

对于一个n变量的程序，边界值分析会产生 4n + 1 个测试用例。

健壮性边界值测试

利用输入变量的最小值、稍大于最小值、略小于最小值、域内任意值、稍小于最大值、最大值、略超过最大值来设置测试用例。

对于一个n变量的程序，健壮性边界值测试会产生 6n + 1 个测试用例。

白盒测试

分析程序的内部结构。

语句覆盖准则

程序的每条语句都得到运行。

分支覆盖准则

每个分支都至少获得一次“真”值和一次“假”值。

谓词测试

原子谓词覆盖准则

每个复合谓词所包含的每一个原子谓词都至少获得一次“真”值和一次“假”值。

分支-谓词覆盖准则

不仅每个复合谓词所包含的每一个原子谓词都至少获得一次“真”值和一次“假”值，而且每个复合谓词本身也至少获得一次“真”值和一次“假”值。

复合谓词覆盖准则

每个谓词中条件的各种可能都至少出现一次。

路径覆盖准则

他要求观察程序运行的整个路径，要求程序的运行覆盖所有的完整路径。

路径覆盖准则包含分支覆盖准则。