软件测试赛样题第 6 套

  题目1：

根据下列流程图编写程序实现相应分析处理并显示结果。返回结果“a=x：”（x为2、3或4）；其中变量x、y均须为整型。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足语句覆盖测试，每条测试数据需要在测试类中编写一个测试方法。使用assertThat中equalTo断言判断期望结果值和实际返回值是否一致。

被测试代码：

public class TM1 {
    public String tm1(int x,int y){
        int a = 0;
        if ( x>= 80 && y>60){
            if (!(x >=90 || y>= 90)){
                a = 2;
            }
        }else if (x <= 70 || y<= 70){
            a= 3;
        }else {
            a = 4;
        }
        return MessageFormat.format("a={0}",a);
    }
}

测试代码：

import org.hamcrest.CoreMatchers;
import org.junit.Test;

import static org.hamcrest.MatcherAssert.assertThat;

public class TM1Test {
    private TM1 tm1 = new  TM1();

    @Test
    public void Test01(){
        assertThat(tm1.tm1(80,80), CoreMatchers.equalTo("a=2"));
    }
    @Test
    public void Test02(){
        assertThat(tm1.tm1(70,70), CoreMatchers.equalTo("a=3"));
    }
    @Test
    public void Test03(){
        assertThat(tm1.tm1(75,75), CoreMatchers.equalTo("a=4"));
    }
}

 题目2：

根据输入的三条边值判断能组成何种三角形。三条边为变量a、b、c，范围为1≤边值≤10，不在范围内，提示“输入边值不在范围内”。不满足任意两边之和必须大于第三边，提示“输入边值不能组成三角形”。输入边值能组成三角形，只有2条边相同，显示“能组成等腰三角形”；三条边相等，显示“能组成等边三角形”；边值不满足特殊三角形显示“能组成普通三角形”。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足判定覆盖测试，每条测试数据需要在测试类中编写一个测试方法。使用assertEquals判断期望结果值和实际返回值是否一致。

被测试代码：

public class TM14 {
    public String tm14(int a,int b,int c){
        if (!(a>=1 && a<=10) || !(b>=1 && b<=10) || !(c>=1 && c<=10)){
            return "输入的边值不在范围内";
        }else if (!(a+b>c && a+c>b && c+b>a)){
            return "输入的边值不能组成三角形";
        }else if (a == b && b == c){
            return "能组成等边三角形";
        }else if ((a ==b) || (a == c) || (b == c)){
            return "能组成等腰三角形";
        }else {
            return "能组成普通三角形";
        }
    }
}

测试代码：

import org.junit.Test;

import static junit.framework.TestCase.assertEquals;

public class TM14Test {
    private TM14 tm14 = new TM14();
    @Test
    public void Test01(){
        assertEquals("输入的边值不在范围内",tm14.tm14(100,5,5));
    }
    @Test
    public void Test02(){
        assertEquals("输入的边值不能组成三角形",tm14.tm14(8,2,5));
    }
    @Test
    public void Test03(){
        assertEquals("能组成等腰三角形",tm14.tm14(6,6,7));
    }
    @Test
    public void Test04(){
        assertEquals("能组成等边三角形",tm14.tm14(6,6,6));
    }
    @Test
    public void Test05(){
        assertEquals("能组成普通三角形",tm14.tm14(3,4,5));
    }

}

 题目3：

企业根据利润提成来发放奖金。将利润金额划分6个档位来提成。

档位一：利润低于或等于10万元部分，提成10%。

档位二：利润高于10万元并且低于或等于20万元部分，提成7.5%。

档位三：利润高于20万元并且低于或等于40万元部分，提成5%。

档位四：利润高于40万元并且低于或等于60万元部分，提成3%。

档位五：利润高于60万元并且低于或等于100万元部分，提成1.5%。

档位六：利润高于100万元部分，提成1%。

编写程序根据输入的当月利润x计算出最终得到的总提成，输入利润已万为单位，x为整数。返回结果按照档次输出“总提成：y万”，y为计算的提成值。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足判定覆盖测试，每条测试数据需要在测试类中编写一个测试方法。使用assertThat中is断言判断输出文字期望结果值和实际返回值是否一致。

被测试代码：

import java.text.MessageFormat;

public class TM7 {
    public String tm7(int x){
        if (x > 100){
            return MessageFormat.format("总提成{0}万",
                    ((x-100)*0.01)+(40*0.015)+(20*0.03)+(20*0.05)+(10*0.075)+10*0.1);
        }else if (x >60 && x<= 100){
            return MessageFormat.format("总提成{0}万",
                    ((x - 60)*0.015)+(20*0.03)+(20*0.05)+(10*0.075)+10*0.1);
        } else if (x >40 && x<= 60) {
            return MessageFormat.format("总提成{0}万",
                    ( (x-40) * 0.03) + (20 * 0.05) + (10 * 0.075) + 10 * 0.1);
        }else if (x >20 && x<= 40) {
            return MessageFormat.format("总提成{0}万",
                    ((x=20) * 0.05) + (10 * 0.075) + 10 * 0.1);
        }else if (x >10 && x<= 20) {
            return MessageFormat.format("总提成{0}万",
                    ((x-10) * 0.075) + 10 * 0.1);
        }else {
            return MessageFormat.format("总提成{0}万",
                    (x>0? x:0)*0.1);
        }
    }
}

测试代码：

import org.junit.Test;

import static org.hamcrest.CoreMatchers.is;
import static org.hamcrest.MatcherAssert.assertThat;

public class TM7Test {
    private TM7 tm7 = new TM7();

    @Test
    public void Test01() {
        assertThat(tm7.tm7(10), is("总提成1万"));
    }

    @Test
    public void Test02() {
        assertThat(tm7.tm7(20),is("总提成1.75万"));
    }

    @Test
    public void Test03() {
        assertThat(tm7.tm7(40), is("总提成2.75万"));
    }

    @Test
    public void Test04() {
        assertThat(tm7.tm7(60), is("总提成3.35万"));
    }

    @Test
    public void Test05() {
        assertThat(tm7.tm7(100), is("总提成3.95万"));
    }

    @Test
    public void Test06() {
        assertThat(tm7.tm7(120), is("总提成4.15万"));
    }
}

 题目4：

输入小写的字符串。如字符串前缀为ab开头，则将前缀ab替换为ef并打印出替换后字符串，返回文字“替换前缀后的字符串为:”和替换后字符串值；如后缀为cd并且前缀不为ab，替换字符串中所有cd为gh并打印出替换后字符串，返回文字“替换cd后的字符串为:”和替换后字符串值；否则全部字母大写输出，返回文字“大写字母的字符串为:”和转换后的字符串值。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足条件覆盖测试，测试类使用参数化测试（@Parameters）完成测试。使用assertEquals判断期望结果值和实际返回值是否一致。

被测试代码：

public class TM4 {
    public String tm4(String str) {
        if (str.matches("ab.*")){
            return "替换前缀后的字符串为:".concat(str.replaceFirst("ab","ef"));
        }else if (str.matches(".*cd")){
            return "替换cd后的字符串为:".concat(str.substring(0,str.length()-2)+"gh");
        }else {
            return "大写字符的字符串是".concat(str.toUpperCase());
        }
    }
}

测试代码：

import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;

import java.util.Arrays;
import java.util.Collection;

import static junit.framework.TestCase.assertEquals;

@RunWith(Parameterized.class)
public class TM4Test {
   private TM4 tm4 = new TM4();
   private String str;
   private String result;

   public TM4Test(String str,String result){
       this.str = str;
       this.result = result;
   }
   @Parameterized.Parameters
   public static Collection parm(){
        return Arrays.asList(new Object[][]{
           {"abcdef","替换前缀后的字符串为:efcdef"},
           {"cdcdcd","替换cd后的字符串为:cdcdgh"},
           {"wrwr","大写字符的字符串是WRWR"}
       });
    }

    @Test
    public void Test01(){
        assertEquals(result,tm4.tm4(str));
    }
}