软件测试单元测试题库

一、2023年国赛赛题

题目1：任意输入2个正整数值分别存入x、y中，据此完成下述分析：若x≤0或y≤0，则提示：“输入不符合要求。”；若2值相同，则提示“可以构建圆形或正方形”；若2<|x-y|≤5，则提示“可以构建椭圆”；若|x-y|>5，则提示“可以构建矩形”；若0<|x-y|≤2,提示“可以构建长方形”。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足语句覆盖测试，每条测试数据需要在测试类中编写一个测试方法。使用assertEquals判断输入数据测试方法期望结果值和实际返回值是否一致。

程序代码：

public class Cs01 {
    public static String result;
//    判断输出
    public String cs01test(int x,int y) {
        if(x<=0||y<=0) {
            result="输入不符合要求";
        }else if(x==y) {
            result = "可以构建圆形或正方形";
        }else if(2<Math.abs(x-y)&&Math.abs(x-y)<=5) {
            result = "可以构建椭圆";
        }else if(Math.abs(x-y)>=5) {
            result = "可以构建椭矩形";
        }else {
            result ="可以构建长方形";
        }
        return result;
    }

}

测试代码：

public class TestCs01 {
    Cs01 cs01= new Cs01();
    @Test
    public void testTest1() {
    assertEquals("输入不符合要求", cs01.cs01test(5, -2));    
    }
    @Test
    public void testTest2() {
    assertEquals("可以构建圆形或正方形", cs01.cs01test(3, 3));
    }
    @Test
    public void testTest3() {
    assertEquals("可以构建椭圆", cs01.cs01test(5, 2));
    }
    @Test
    public void testTest4() {
    assertEquals("可以构建椭矩形", cs01.cs01test(10, 2));
    }
    @Test
    public void testTest5() {
    assertEquals("可以构建长方形", cs01.cs01test(5, 4));
    }

}

题目2：根据输入的年份和月份判断月份的天数。若月份不在有效范围之内，应提示：“月份输入不正确。”。月份不为2月，根据输入月份输出对应的月份天数。月份为2月，根据年份判断如为普通闰年，输出2月份正确天数；如为世纪闰年，输出2月份正确天数；不为闰年输出2月份天数。返回结果格式：“year年month月份的天数是days天。”year、month为传入的值，days为判断得到的天数值。其中变量year、month均须为正整数。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足语句覆盖测试，每条测试数据需要在测试类中编写一个测试方法。使用assertThat中equalTo断言判断返回期望结果和实际返回是否一致。

程序代码：

public class Cs02 {
    public String test(int year ,int month) {
        int days = 0;
        String result;
        if(month>=1&&month<=12) {
                      
            if(month==2) {
                //判断是否为闰年
                if(year%4==0&&year%100!=0) {
                    days=29;
                    result = year+"年"+month+"月份的天数是"+days+"天。";
                  }else {
                    if(year%400==0) {
                        days=29;
                        result = year+"年"+month+"月份的天数是"+days+"天。";
                    }else {
                        days=28;
                        result = year+"年"+month+"月份的天数是"+days+"天。";
                      }
                }
            }else {
            if(month==4||month==6||month==9||month==11) {
                days=30;
                result = year+"年"+month+"月份的天数是"+days+"天。";
            }
            else {
                days=31;
                result = year+"年"+month+"月份的天数是"+days+"天。";
               }
           }
            
            
        }else {
            result = "月份输入不正确。";
        }
        return result;
     }

}
   

测试代码：

package test;

import static org.hamcrest.MatcherAssert.*;
import static org.hamcrest.Matchers.*+;
import  org.junit.Test;

import ceshi.Cs02;

public class TestCs02 {
     
    Cs02 cs02 = new Cs02(); 
    @Test
    public void test01() {
        assertThat(cs02.test(2000, 2), equalTo("2000年2月份的天数是29天"));
    }
    @Test
    public void test02() {
        assertThat(cs02.test(2008, 2), equalTo("2008年2月份的天数是29天"));
    }
    @Test
    public void test03() {
        assertThat(cs02.test(1900, 2), equalTo("1900年2月份的天数是28天"));
    }
    @Test
    public void test04() {
        assertThat(cs02.test(2000, 3), equalTo("2000年3月份的天数是31天"));
    }
    @Test
    public void test05() {
        assertThat(cs02.test(2000, 4), equalTo("2000年4月份的天数是30天"));
    }
    @Test
    public void test06() {
        assertThat(cs02.test(2000, 13), equalTo("月份输入不正确"));
    }
    
}

题目3：邮箱注册需要填写邮箱地址和密码。其中要求邮箱格式“登录名@主机名.域名”，登录名为5个字母，主机名固定为下面2个163、126，域名为com或com.cn。密码为6个（含6）以上数字组成。填写正确则提示“信息正确”，否则根据实际情况提示“不符合要求”（为邮箱地址或密码）。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足语句覆盖测试，每条测试数据需要在测试类中编写一个测试方法。使用assertThat中equalTo断言判断输出文字期望结果值和实际返回值是否一致。

程序代码：

public class Cs03 {
    public String  test(String add,String password) {
        //邮箱地址和密码正则表达式
        String addr = "[A-Za-z]{5}@(163|126).(com|com.cn)";
        String pass ="[0-9]{6,}";
        String result;
        if(add.matches(addr)) {
            if(password.matches(pass)) {
                result = "信息正确";
            }else {
                result = "密码不符合要求";
            }
        }else {
            result = "邮件地址不符合要求";
        }
        return result;
    }

}

测试代码：

package test;

import static org.hamcrest.MatcherAssert.*;
import static org.hamcrest.Matchers.*;
import org.junit.Test;

  
import ceshi.Cs03;

public class TestCs03 {
    Cs03 cs03 = new Cs03();
    @Test
    public void test01() {
        assertThat(cs03.test("eee", "111111"),equalTo("邮件地址不符合要求"));
    }
    
    @Test
    public void test02() {
        assertThat(cs03.test("[email protected]", "111"),equalTo("密码不符合要求"));
    }
    @Test
    public void test03() {
        assertThat(cs03.test("[email protected]", "111111"),equalTo("信息正确"));
    }

}

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

程序代码：

package ceshi;

public class Cs04 {
  String result;
  public String test(String str) {
      String  str1;
      //判断以ab开始
      if(str.startsWith("ab")) {
          str1 = str.replaceFirst("ab", "ef");
          result = "替换前缀后的字符串为:"+str1;
      }else if(str.endsWith("cd")) {
          str1 = str.replaceAll("cd", "gh");
          result = "替换cd后的字符串为:"+str1;
          
      }else {
          str1 = str.toUpperCase();
          result = "大写字母的字符串为:"+str1;
      }
      return result;
  }
}
  

测试代码：

package test; 

import static org.junit.Assert.assertEquals;

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

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

import ceshi.Cs04;

@RunWith(Parameterized.class)
public class TestCs04 {
   private Cs04 cs04 = new Cs04();
   private String str;
   private String result;
    
   @Parameters
   public static Collection Date() {
       return Arrays.asList(new Object[][]{
           {"abfdf","替换前缀后的字符串为:effdf"},
           {"cdsddscd","替换cd后的字符串为:ghsddsgh"},
           {"dfdsdf","大写字母的字符串为:DFDSDF"}
       });
       
   }
   
   public TestCs04(String str,String result) {
       this.str = str;
       this.result = result;
   }
   @Test
   public void testTest() {
       assertEquals(result, cs04.test(str));
   }
}

二、模拟题题库

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

程序代码：

public class Cs01 {
    //定义返回值
    public static String result;
    public String test(int a ,int b ) {
        if(a>9&&b>5) {
            result = "x=a*a*b的值："+(a*a*b);
    
        }else {
            if(a<0&&b<0) {
                result = "x=a-b的值："+(a-b);
            }else {
                result = "x=a+b的值："+(a+b);
            }
        }
        return result;
        
    }
    

}

测试代码：

package test;

import static  org.hamcrest.MatcherAssert.*;

import static org.hamcrest.Matchers.*;
import org.junit.Test;

import ceshi.Cs01;

public class TestCs01 {
  //引入测试代码
    Cs01 cs01 = new Cs01();
    
    @Test
    public void test01() {
        assertThat(cs01.test(10, 6), startsWith("x=a*a*b的值：600"));
        
    }
    @Test
    public void test02() {
        assertThat(cs01.test(-2, -1), startsWith("x=a-b的值：-1"));
        
    }
    
    @Test
    public void test03() {
        assertThat(cs01.test(6, -2), startsWith("x=a+b的值：4"));
        
    }
    
    
}

题目2：根据下列流程图编写程序实现相应分析处理并显示结果。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足语句覆盖测试，测试类使用参数化测试（@Parameters）完成测试。使用assertEquals判断输入数据测试方法期望结果值和实际返回值是否一致。

程序代码：

package ceshi;

public class Cs02 {
    //定义返回值
    public static String result;
    public String test(String username,String password) {
        if(username!=""&&password!="") {
            if(username.equals("admin")&&password.equals("123")) {
                result = "登录成功";
            }else {
                if(!username.equals("admin")&&password.equals("123")) {
                    result= "请输入正确的用户名";
                }else {
                      if(username.equals("admin")&&!password.equals("123")) {
                        result = "请输入正确的密码";
                      }else{
                         result ="请输入正确的用户名和密码";
                     }
                }
            }
        }else {
            result = "用户名或密码不能为空";
        }
        return result;
    }

}

测试代码：

package test;

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

import org.hamcrest.MatcherAssert;
import org.hamcrest.Matchers;
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 ceshi.Cs02;

@RunWith(Parameterized.class)
public class TestCs02 {
    //引入测试程序
   private Cs02 cs02 = new Cs02();
   private  String result;
   private String username;
   private String password;
   
   @Parameters
   public static Collection Date() {
       return Arrays.asList(new Object[][] {
           {"","","用户名或密码不能为空"},
           {"admin","123","登录成功"},
           {"admin2","123","请输入正确的用户名"},
           {"admin","12w3","请输入正确的密码"},
           {"admeein","1dd23","请输入正确的用户名和密码"},
       });
   }
   
   public TestCs02(String username,String password,String result) {
      
       this.result = result;
       this.username =username;
       this.password = password;
       
   }
   @Test
   public void test() {
       Assert.assertEquals(cs02.test(username, password), result);
       
   }
    

}

题目3：输入一个大写字母一个小写字母。根据输入的第一个字母和周几英文单词的第一个大写字母判断是周几，如果无法根据第一个大写字母判断，则继续根据输入的第二个小写字母进行判断，最终返回正确的英文周几的单词。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足语句覆盖测试，每条测试数据需要在测试类中编写一个测试方法。使用assertEquals判断期望结果值和实际返回值是否一致。

程序代码：

package ceshi;

public class Cs03 {
    //定义返回值
    public String result="unknow";
    
    public String test(char first , char second) {
        if(first =='M') {
            result = "Monday";
        }else if(first =='T'){
            if(second =='u') {
                result ="Tuesday";
            }else if(second =='h'){
                result = "Thursday";
            }
        }else if(first =='W') {
            result ="Wednesday";
            
        }else if(first=='F') {
            result ="Friday";
        }else if(first=='S') {
            if(second =='a') {
                result ="Saturday";
            }else if(second=='u') {
                result="Sunday";
            }
        }
        
        return result;
    }

}

测试代码：

package test;

import org.junit.Assert;
import org.junit.Test;

import ceshi.Cs03;

public class TestCs03 {
    //引入测试程序
    Cs03 cs03  = new Cs03();
    
    @Test
    public void test01 (){
        Assert.assertEquals(cs03.test('M', 'l'), "Monday");
    }
    @Test
    public void test02 (){
        Assert.assertEquals(cs03.test('T', 'u'), "Tuesday");
    }

    @Test
    public void test03 (){
        Assert.assertEquals(cs03.test('T', 'h'), "Thursday");
    }

    @Test
    public void test04 (){
        Assert.assertEquals(cs03.test('W', 'l'), "Wednesday");
    }

    @Test
    public void test05 (){
        Assert.assertEquals(cs03.test('F', 'l'), "Friday");
    }

    @Test
    public void test06 (){
        Assert.assertEquals(cs03.test('S', 'a'), "Saturday");
    }

    @Test
    public void test07 (){
        Assert.assertEquals(cs03.test('S', 'u'), "Sunday");
    }
}

题目4：进行系统注册时通常需要输入用户名和密码，其中用户名要求由8个字母组成、密码由6个（含6）以上数字组成。满足要求，则提示“注册成功”，否则根据实际情况提示“不符合要求”（为用户名或密码）。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足语句覆盖测试，每条测试数据需要在测试类中编写一个测试方法。使用assertThat中containsString断言判断输出文字期望结果值和实际返回值是否一致。

程序代码：

package ceshi;

public class Cs04 {
    //定义返回值
    public String result;
    
    public String test(String username,String password) {
        String user = "[a-zA-Z]{8}";
        String  pass = "[0-9]{6,}";
         if(username.matches(user)&&password.matches(pass)) {
             result = "登录成功";
         }else {
             if(!username.matches(user)&&password.matches(pass)) {
                 result = "用户名不符合要求";
             }else if(username.matches(user)&&!password.matches(pass)) {
                 result = "密码不符合要求";
             }
         }
        return result;
        
    }

}

测试代码：

package test;

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

import static org.hamcrest.MatcherAssert.*;
import static org.hamcrest.Matchers.*;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.Parameterized;
import org.junit.runners.Parameterized.Parameters;

import ceshi.Cs04;

@RunWith(Parameterized.class)
public class TestCs04 {
    
    //引入测试程序
    private Cs04 cs04 = new Cs04();
    private String username;
    private String password;
    private String result;
    
    @Parameters
    public static Collection Date() {
        return Arrays.asList(new Object[][] {
            {"asdfasdf","123456","登录成功"},
            {"asdf","123456","用户名不符合要求"},
            {"asdfasdf","12345","密码不符合要求"}
        });
    }
    
    public TestCs04(String username,String password,String result) {
        this.username =username;
        this.password =password;
        this.result = result;
    }
    
    @Test
    public void test() {
        assertThat(cs04.test(username, password),containsString(result));
    }
 
}

题目5：企业根据利润提成来发放奖金。将利润金额划分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断言判断输出文字期望结果值和实际返回值是否一致。

程序代码：

package ceshi;

public class Cs01 {
  //定义返回值
    public static String result;
    public static double y;
    public String test(int x) {
        if(x<=10) {
            y = x*0.1;
        result = "总提成："+y+"万";
        }else if(10<x&&x<=20) {
            y=((x-10)*0.075)+(10*0.1);
            result = "总提成："+y+"万";
        }else if(20<x&&x<=40) {
            y = (((x-20)*0.05)+(10*0.075)+(10*0.1));
            result = "总提成："+y+"万";
        }else if(40<x&&x<=60) {
            y =(((x-40)*0.03)+(20*0.05)+(10*0.075)+(10*0.1));
            result = "总提成："+y+"万";
        }else if(60<x&&x<=100) {
            y = ((x-60)*0.015+20*0.03+20*0.05+10*0.075+10*0.1);
            result = "总提成："+y+"万";
        }else {
            y = ((x-100)*0.1+40*0.015+20*0.03+20*0.05+10*0.075+10*0.1);
            result = "总提成："+y+"万";
        }
        return result;
    }
}

测试代码：

package test;

import static org.hamcrest.MatcherAssert.*;

import static org.hamcrest.Matchers.*;
import org.junit.Test;

import ceshi.Cs01;

public class TestCs01 {
    //引入程序
    Cs01 cs01 = new Cs01();
    
    @Test
    public void test01() {
        assertThat(cs01.test(8),is("总提成：0.8万"));
    }
    @Test
    public void test02() {
        assertThat(cs01.test(15),is("总提成：1.375万"));
    }
    @Test
    public void test03() {
        assertThat(cs01.test(25),is("总提成：2.0万"));
    }
    @Test
    public void test04() {
        assertThat(cs01.test(45),is("总提成：2.9万"));
    }
    @Test
    public void test05() {
        assertThat(cs01.test(65),is("总提成：3.425万"));
    }
    

}

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

程序代码：

package ceshi;

public class Cs02 {
      //定义返回值
    public static String result;
    public String test(int x,int y) {
        if(x>=80&&y>=60) {
            if(x>=90||y>=90) {
                
            }else {
                result = "a=2";
            }
        }else {
            if(x<=70||y<=70) {
                result = "a=3";
            }else {
                result = "a=4";
            }
        
        }
        return result;
    }
}

测试代码：

package test;

import static org.hamcrest.MatcherAssert.*;
import static org.hamcrest.Matchers.*;
import org.hamcrest.Matchers;
import org.junit.Test;

import ceshi.Cs02;

public class TestCs02 {
    //引入程序
    Cs02  cs02 = new Cs02();
    @Test
     public void test01() {
        assertThat(cs02.test(80, 80), equalTo("a=2"));
     }
    
    @Test
     public void test02() {
        assertThat(cs02.test(70, 70), equalTo("a=3"));
     }
    @Test
     public void test03() {
        assertThat(cs02.test(75, 90), equalTo("a=4"));
     }
}

题目7：填写快递单时通常需要确定接收人的姓名、手机号和地址。其中要求手机号是 11 位数字字符，地址为字母开头的 10个（含10）以内字母或字母数字共同组成。填写正确则提示“OK”，否则根据实际情况提示“不符合要求”（为手机号或地址）,退出。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足判定覆盖测试，每条测试数据需要在测试类中编写一个测试方法。使用assertThat中equalTo断言判断输出文字期望结果值和实际返回值是否一致。

程序代码：

package ceshi;

public class Cs03 {
    //定义返回值
    public static String result;
    
    public String test(String name ,String phone,String address) {
        String p = "[0-9]{11}";
        String a ="[a-zA-Z]{1}[a-zA-Z0-9]{0,9}";
        if(phone.matches(p)&&address.matches(a)) {
            result = "OK";
        }else if(!phone.matches(p)&&address.matches(a)) {
            result = "手机号不符合要求";
        }else if(phone.matches(p)&&!address.matches(a)) {
            result = "地址不符合要求";
        }
        return result;
    }

}

测试代码：

package test;

import static org.hamcrest.MatcherAssert.*;
import static org.hamcrest.Matchers.*;

import org.junit.Test;

import ceshi.Cs03;

public class TestCs03 {
    //引入程序
    Cs03 cs03 = new Cs03();
    @Test
    public void test01 () {
        assertThat(cs03.test("BOb","12345678910", "S555dd"), equalTo("OK"));
    }
    @Test
    public void test02 () {
        assertThat(cs03.test("BOb","2345678910", "S555dd"), equalTo("手机号不符合要求"));
    }
    @Test
    public void test03 () {
        assertThat(cs03.test("BOb","12345678910", "555fdd"), equalTo("地址不符合要求"));
    }

}

题目8：根据下列流程图编写程序实现相应处理，执行j=10x-y返回文字“j1=：”和计算值，执行j=(x-y)(10⁵%7)返回文字“j2=：”和计算值，执行j=y*log(x+10)返回文字“j3=：”和计算值。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足判定覆盖测试，每条测试数据需要在测试类中编写一个测试方法。使用assertThat中startsWith断言判断输出文字结果开头期望结果值和实际返回值是否一致。

程序代码：

package ceshi;

public class Cs04 {
    //定义返回值
    public static String result;
    public static double j;
    public String test(int x,int y) {
      if(x>=60&&y<=35) {
          j = 10*x-y;
          result = "j1="+j;
      }else {
          if(x==25&&y>50){
              j = y*Math.log(x+10);
              result = "j2="+j;
          }else {
              j = (x-y)*(Math.pow(10, 5));
              result = "j3="+j;
          }
      }
      return result;
        
    }

}

测试代码：

package test;

import static org.hamcrest.MatcherAssert.*;
import static org.hamcrest.Matchers.*;
import org.junit.Test;

import ceshi.Cs04;

public class TestCs04 {
    //引入程序
    Cs04 cs04 = new Cs04();
    @Test
    public void test01() {
        assertThat(cs04.test(70, 30), startsWith("j1=670.0"));
    }
    @Test
    public void test02() {
        assertThat(cs04.test(25, 100), startsWith("j2=355.53480614894136"));
    }
    @Test
    public void test03() {
        assertThat(cs04.test(2, 1), startsWith("j3=100000.0"));
    }

}

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

程序代码：

package ceshi;

public class Cs05 {
 //定义返回值
    public static String result;
    public String test(int a,int b,int c) {
        if(1<=a&&a<=10&&1<=b&&b<=10&&1<=c&&c<=10) {
            if((a+b)<=c||(a+c)<=b||(b+c)<=a) {
                result = "输入边值不能组成三角形";
            }else {
                if(a==b||b==c||a==c) {
                    result = "能组成等腰三角形";
                }else if(a==b&&a==c&&b==c){
                    result = "能组成等边三角形";
                }else {
                    result = "能组成普通三角形";
                }
            }
        }else {
            result = "输入边值不在范围内";
        }
        return result;
    }
}

测试代码：

package test;

import static org.junit.Assert.assertEquals;

import org.junit.Test;

import ceshi.Cs05;

public class TestCs05 {
    //引入测试程序
    Cs05 cs05 = new Cs05();
    
   @Test
   public void test01() {
     assertEquals(cs05.test(11, 11,11), "输入边值不在范围内");  
   }
   @Test
   public void test02() {
     assertEquals(cs05.test(1,1,1), "输入边值不能组成三角形");  
   }
   @Test
   public void test03() {
     assertEquals(cs05.test(2,2,1), "能组成等腰三角形");  
   } @Test
   public void test04() {
     assertEquals(cs05.test(5,5,5), "能组成等边三角形");  
   } @Test
   public void test05() {
     assertEquals(cs05.test(2,3,4), "能组成普通三角形");  
   }
}

题目10：根据下列流程图编写程序实现相应处理，程序根据两个输入参数iRecordNum和IType计算x的值并返回。编写程序代码，使用JUnit框架编写测试类对编写的程序代码进行测试，测试类中设计最少的测试数据满足基路径覆盖测试，每条测试数据需要在测试类中编写一个测试方法。使用assertEquals断言判断输出结果期望结果值和实际返回值是否一致。

程序代码：

package ceshi;

public class Cs06 {
  //定义返回值
    
    public int test(int iRecordNum,int IType) {
        int x=0;
        int y =0;
        while(iRecordNum-->0) {
            if(IType==0) {
                x = y+2;
                break;
            }else if(IType ==1) {
                x =y+10;
            }else {
                x= y+20;
            }
        }
        return x;
    }
}

测试代码：

package test;

import static org.junit.Assert.assertEquals;

import org.junit.Test;

import ceshi.Cs06;

public class TestCs06 {
  //引入测试程序
    Cs06 cs06 = new Cs06();
    
    @Test
    public void test01() {
        assertEquals(0,cs06.test(0, 0));
    }
    @Test
    public void test02() {
        assertEquals(2,cs06.test(10, 0));
    }
    @Test
    public void test03() {
        assertEquals(10,cs06.test(10, 1));
    }
    @Test
    public void test04() {
        assertEquals(20,cs06.test(10, 2));
    }
}