题目一:
举重比赛,需要根据性别和体重来决定是否有参赛资格,具体规则如下:
-
当性别为男且体重大于等于 54 公斤时,可参加男子组比赛,否则无资格参赛。
-
当性别为女且体重大于等于 46 公斤时,可参加女子组比赛,否则无资格参赛。
-
当性别既不是男也不是女时,系统显示性别异常。
题目要求
- 请使用基本路径覆盖法设计 5 条测试用例,使被测代码的基本路径覆盖率达到 100% 。
- 请使用 Java 语言对应的单元测试框架 JUnit 编写测试代码。
- 测试代码请直接在提供的类文件 WeightliftingTest.java 中编写。
- 在测试中用到的断言 Assert 类务必使用 org.junit 包中的 Assert。
- 请不要修改所提供的文件名称,否则将会判 0 分。
判分标准
满分为 30 分,具体判分细则如下:
- 代码规范:5 分
- 测试用例覆盖率:25 分
- 运行结果: 如果运行不成功,则扣除全部测试用例覆盖率分数,但不影响代码规范得分。
被测类文件:Weightlifting.java
package cn.lanqiao;
/**
* 本类主要功能描述:
* 1、性别既不是男也不是女,则显示性别异常
* 2、性别为男,体重大于等于54公斤,显示可参加男子组比赛,否则无资格参赛
* 3、性别为女,体重大于等于46公斤,显示可参加女子组比赛,否则无资格参赛
*/
public class Weightlifting {
/**
* 根据性别和体重确认是否可以参赛
* @param sex 性别
* @param weight 体重
* @return 是否可以参赛
*/
public String divide(String sex, int weight){
String result = null;
if("男".equals(sex)){
if(weight >= 54){
result = "可参加男子组比赛";
}else{
result = "无资格参赛";
}
}else if("女".equals(sex)){
if(weight >= 46){
result = "可参加女子组比赛";
}else{
result = "无资格参赛";
}
}else{
result = "性别异常";
}
return result;
}
}
- 测试类文件:WeightliftingTest.java
package cn.lanqiao;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
/**
* 1. 请使用基本路径覆盖法对被测源代码 Weightlifting 类中的 divide 方法设计 5 条单元测试用例。
* 2. 请在下方 WeightliftingTest 类中填写单元测试代码内容。
* 3. 在测试中用到的断言 Assert 类务必使用 org.junit 包中的 Assert 。
*/
public class WeightliftingTest {
// 声明被测类
private Weightlifting weightlifting;
@Before
public void setUp(){
// 创建被测类对象
weightlifting = new Weightlifting();
}
@After
public void tearDown(){
// 释放被测类对象
weightlifting = null;
}
@Test
public void test01(){
Assert.assertEquals("可参加男子组比赛", weightlifting.divide("男", 55));
}
@Test
public void test02(){
Assert.assertEquals("无资格参赛", weightlifting.divide("男", 53));
}
@Test
public void test03(){
Assert.assertEquals("可参加女子组比赛", weightlifting.divide("女", 47));
}
@Test
public void test04(){
Assert.assertEquals("无资格参赛", weightlifting.divide("女", 45));
}
@Test
public void test05(){
Assert.assertEquals("性别异常", weightlifting.divide("其他", 60));
}
}
题目二:
通过输入的 a、b、c 三个整数,对它们进行从小到大的排序,具体规则如下:
-
当 a 大于等于 b,且 c 大于 a 时,显示 “bac”,若 c 小于 a,且 c 大于 b时,显示 “bca”,否则显示 “cba”;
-
当 a 小于 b,且 c 大于 b 时,显示 “abc”,若 c 小于 b,且 c 大于 a 时,显示 “acb”,否则显示 “cab”。
题目要求
- 请使用基本路径覆盖法设计 6 条测试用例,使被测代码的基本路径覆盖率达到 100% 。
- 请使用 Java 语言对应的单元测试框架 JUnit 编写测试代码。
- 测试代码请直接在提供的类文件 NumberSortTest.java 中编写。
- 在测试中用到的断言 Assert 类务必使用 org.junit 包中的 Assert。
- 请不要修改所提供的文件名称,否则将会判 0 分。
判分标准
满分为 30 分,具体判分细则如下:
- 代码规范:5 分
- 测试用例覆盖率:25 分
- 运行结果: 如果运行不成功,则扣除全部测试用例覆盖率分数,但不影响代码规范得分。
被测类文件:NumberSort.java
package cn.lanqiao;
/**
* 本类主要功能描述:
* 1、当 a 大于等于 b,且 c 大于 a 时,显示 “bac”,若 c 小于 a,且 c 大于 b时,显示 “bca”,否则显示 “cba”;
* 2、当 a 小于 b,且 c 大于 b 时,显示 “abc”,若 c 小于 b,且 c 大于 a 时,显示 “acb”,否则显示 “cab”。
*/
public class NumberSort {
/**
* 根据输入的三个整数进行从小到大排序
* @param a 整型数值
* @param b 整型数值
* @param c 整型数值
* @return 排序顺序
*/
public String sort(int a,int b,int c){
if(a >= b){
if(c > a){
return "bac";
}else{
if(c > b){
return "bca";
}else{
return "cba";
}
}
}else{
if(c > b){
return "abc";
}else{
if(c > a){
return "acb";
}else{
return "cab";
}
}
}
}
}
- 测试类文件:NumberSortTest.java
package cn.lanqiao;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
/**
* 1. 请使用基本路径覆盖法对被测源代码 NumberSort 类中的 sort 方法设计 6 条单元测试用例。
* 2. 请在下方 NumberSortTest 类中填写单元测试代码内容。
* 3. 在测试中用到的断言 Assert 类务必使用 org.junit 包中的 Assert 。
*/
public class NumberSortTest {
// 声明被测类
private NumberSort numberSort;
@Before
public void setUp(){
// 创建被测类实例
numberSort = new NumberSort();
}
@After
public void tearDown(){
// 释放被测类实例
numberSort = null;
}
@Test
public void test01(){
Assert.assertEquals("bac", numberSort.sort(3, 2, 13));
}
@Test
public void test02(){
Assert.assertEquals("bca", numberSort.sort(3, 1, 2));
}
@Test
public void test03(){
Assert.assertEquals("cba", numberSort.sort(3, 2, 1));
}
@Test
public void test04(){
Assert.assertEquals("abc", numberSort.sort(1, 2, 3));
}
@Test
public void test05(){
Assert.assertEquals("acb", numberSort.sort(1, 3, 2));
}
@Test
public void test06(){
Assert.assertEquals("cab", numberSort.sort(2, 3, 1));
}
}
题目三:
界面获取用户名信息,要求字符串长度必须在 3 ~ 12 位之间,为了显示样式的美观性,根据获取的字符串,以及限定的最小长度(3)和最大长度(12)进行处理,具体规则如下:
- 字符串不能为 null,否则无法进行处理,因此当为 null 时,返回 “字符串不能为空”。
- 字符串要求的长度是参数提供的最小长度 ~ 最大长度位,会对获取的字符串进行去除前后空格的处理,当去除空格后长度依然不满足要求时,会返回 “字符串长度必须在最小长度 ~ 最大长度位”。例如:字符串长度必须在3~12位。
- 对于长度小于最大长度位的字符串,会在字符串后面添加空格补全,直到长度为最大长度位后处理结束,并返回处理后的字符串。
题目要求
- 请使用简单循环覆盖法设计 6 条测试用例,使被测代码的判定循环覆盖率达到 100% 。
- 请使用 Java 语言对应的单元测试框架 JUnit 编写测试代码。
- 测试代码请直接在提供的类文件 UtilsTest.java 中编写。
- 在测试中用到的断言 Assert 类务必使用 org.junit 包中的 Assert。
- 请不要修改所提供的文件名称,否则将会判 0 分。
判分标准
满分为 30 分,具体判分细则如下:
- 代码规范:5 分
- 测试用例覆盖率:25 分
- 运行结果: 如果运行不成功,则扣除全部测试用例覆盖率分数,但不影响代码规范得分。
- 被测类文件:Utils.java
package cn.lanqiao;
/**
* 本类为工具类,主要功能描述:
* 1、字符串不能为 null,否则无法进行处理,因此当为 null 时,返回 “字符串不能为空”。
* 2、字符串要求的长度是参数提供的最小长度 ~ 最大长度位,会对获取的字符串进行去除前后空格的处理,当去除空格后长度依然不满足要求时,会返回 “字符串长度必须在最小长度 ~ 最大长度位”。
* 3、对于长度小于最大长度位的字符串,会在字符串后面添加空格补全,直到长度为最大长度位后处理结束,并返回处理后的字符串。
*/
public class Utils {
/**
* 对字符串长度进行处理,为达到最大长度时,用空格补全
* @param message 字符串
* @param min 最小长度
* @param max 最大长度
* @return 处理后的信息
*/
public static String stringStyle(String message, int min, int max){
String result = null;
// 字符串不能为空
if(message != null){
// 去除字符串前后空格
message = message.trim();
// 获取字符串长度
int length = message.length();
if(length >=min && length <= max){
result = message;
// 当长度为达到最大长度时,用空格补全
for (int i = 0; i < max-length; i++) {
result += " ";
}
}else{
result = "字符串长度必须在"+min+"~"+max+"位";
}
}else{
result = "字符串不能为空";
}
return result;
}
}
- 测试类文件:UtilsTest.java
- 12
package cn.lanqiao;
import static org.junit.Assert.*;
import static org.hamcrest.MatcherAssert.assertThat;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
/**
* 1. 请使用简单循环覆盖法对被测源代码 Utils 类中的 stringStyle 方法设计 6 条单元测试用例。
* 2. 请在下方 UtilsTest 类中填写单元测试代码内容。
* 3. 在测试中用到的断言 Assert 类务必使用 org.junit 包中的 Assert 。
*/
public class UtilsTest {
private Utils utils;
@Before
public void setUp(){
utils = new Utils();
}
@After
public void tearDown(){
// 释放被测类实例
utils = null;
}
@Test
public void testStringStyle01(){
// TODO 请填写单元测试代码
Assert.assertEquals("abc ", utils.stringStyle("abc", 3, 12));
}
@Test
public void testStringStyle02(){
// TODO 请填写单元测试代码
Assert.assertEquals("abcd ", utils.stringStyle("abcd", 3, 12));
}
@Test
public void testStringStyle03(){
// TODO 请填写单元测试代码
Assert.assertEquals("abcdef ", utils.stringStyle("abcdef", 3, 12));
}
@Test
public void testStringStyle04(){
// TODO 请填写单元测试代码
Assert.assertEquals("abcdefghij ", utils.stringStyle("abcdefghij", 3, 12));
}
@Test
public void testStringStyle05(){
// TODO 请填写单元测试代码
Assert.assertEquals("abcdefghijk ", utils.stringStyle("abcdefghijk", 3, 12));
}
@Test
public void testStringStyle06(){
// TODO 请填写单元测试代码
Assert.assertEquals("abcdefghijkl", utils.stringStyle("abcdefghijkl", 3, 12));
}
}
题目四
某管理系统中,其中一个业务逻辑接口中实现了商品管理模块中的购物车功能,现根据输入的集合列表和商品对象两个参数实现了购物车添加功能,实现逻辑如下:
- 当向购物车添加商品对象时,购物车集合列表不存在,那么系统会创建购物车集合列表,然后向购物车集合中添加商品信息,并返回商品集合列表。
- 当购物车集合对象为空时,可直接添加商品对象至集合列表中,然后返回商品集合列表。
- 当向购物车添加商品对象,而此商品已存在购物车集合对象列表中时,列表中只会对该商品的数量进行叠加,该商品的其他信息不变,完成操作后返回商品集合列表。
- 当向购物车添加的商品对象,并不存在商品集合列表中,则添加到购物车集合列表中,并返回商品集合列表。
题目要求
- 请使用基本路径覆盖法 + 简单循环覆盖法设计测试用例,使被测代码的路径和循环覆盖率达到 100% 。
- 请使用 Java 语言对应的单元测试框架 JUnit 编写测试代码。
- 测试代码请直接在提供的类文件 GoodsServiceTest.java 中编写。
- 在测试中用到的断言 Assert 类务必使用 org.junit 包中的 Assert。
- 请不要修改所提供的文件名称,否则将会判 0 分。
🌼 注意:请使用测试数据类文件中提供的测试数据
判分标准
满分为 30 分,具体判分细则如下:
- 代码规范:5 分
- 测试用例覆盖率:25 分
- 运行结果: 如果运行不成功,则扣除全部测试用例覆盖率分数,但不影响代码规范得分。
被测类文件:Goods.java文章来源:https://www.toymoban.com/news/detail-825851.html
package cn.lanqiao;
/**
* 商品实体类
*/
public class Goods {
// 商品编号
private int id;
// 商品名称
private String name;
// 商品类别
private String type;
// 商品价格
private double price;
// 商品数量
private int quantity;
/**
* 无参
*/
public Goods() {
}
/**
* 全参
* @param id 编号
* @param name 名称
* @param type 类别
* @param price 价格
* @param quantity 数量
*/
public Goods(int id, String name, String type, double price, int quantity) {
this.id = id;
this.name = name;
this.type = type;
this.price = price;
this.quantity = quantity;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
public int getQuantity() {
return quantity;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
@Override
public String toString() {
return "Goods [id=" + id + ", name=" + name + ", type=" + type + ", price=" + price + ", quantity=" + quantity + "]";
}
}
GoodsService.java文章来源地址https://www.toymoban.com/news/detail-825851.html
package cn.lanqiao;
import java.util.ArrayList;
import java.util.List;
/**
* 商品管理模块业务逻辑类,本类主要功能描述:
* 1、当向购物车添加商品对象时,购物车集合列表不存在,那么系统会创建购物车集合列表,然后向购物车集合中添加商品信息,并返回商品集合列表。
* 2、当购物车集合对象为空时,可直接添加商品对象至集合列表中,然后返回商品集合列表。
* 3、当向购物车添加商品对象,而此商品已存在购物车集合对象列表中时,列表中只会对该商品的数量进行叠加,该商品的其他信息不变,完成操作后返回商品集合列表。
* 4、当向购物车添加的商品对象,并不存在商品集合列表中,则添加到购物车集合列表中,并返回商品集合列表。
*/
public class GoodsService{
/**
* 商品加入购物车
* @param list 购物车列表
* @param goods 商品信息
* @return 购物车列表
*/
public List<Goods> shoppingCart(List<Goods> list, Goods goods) {
// 当购物车为 null
if(list == null){
// 创建购物车集合对象
list = new ArrayList<>();
// 添加商品信息
list.add(goods);
}else{
boolean flag = false;
for (Goods goods2 : list) {
// 当购物车中已存在商品和添加的商品一致时,商品数量进行叠加
if(goods2.getId() == goods.getId()){
goods2.setQuantity(goods2.getQuantity()+goods.getQuantity());
flag = true;
break;
}
}
// 当添加的商品对象不存在与购物车中时,将商品对象存储到购物车集合列表中
if(!flag){
list.add(goods);
}
}
return list;
}
}
- 测试数据类文件:Datas.java
package cn.lanqiao;
import java.util.ArrayList;
import java.util.List;
/**
* 测试数据
*/
public class Datas {
// 声明集合对象
public static List<Goods> list1 = null;
public static List<Goods> list2 = null;
public static List<Goods> list3 = null;
// 提供商品信息
public static Goods g1 = new Goods(1, "手机", "华为", 3000, 2);
public static Goods g2 = new Goods(2, "手机", "oppo", 2800, 2);
public static Goods g3 = new Goods(3, "手机", "小米", 1800, 2);
public static Goods g4 = new Goods(4, "手机", "vivo", 2600, 2);
public static Goods g5 = new Goods(5, "手机", "荣耀", 1300, 2);
public static Goods g6 = new Goods(6, "手机", "华为", 6000, 2);
public static Goods g7 = new Goods(7, "手机", "oppo", 3800, 2);
public static Goods g8 = new Goods(8, "手机", "小米", 2000, 2);
public static Goods g9 = new Goods(9, "手机", "vivo", 3100, 2);
public static Goods g10 = new Goods(10, "手机", "荣耀", 1700, 2);
static {
list2 = new ArrayList<>();
list3 = new ArrayList<>();
list3.add(g1);
list3.add(g2);
list3.add(g3);
list3.add(g4);
list3.add(g5);
list3.add(g6);
list3.add(g7);
list3.add(g8);
list3.add(g9);
}
}
- 测试类文件:GoodsServiceTest.java
package cn.lanqiao;
import java.util.ArrayList;
import java.util.List;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
/**
* 1. 请使用简单循环覆盖法对被测源代码 Goods 和 GoodsService 类中的 shoppingCart 方法设计单元测试用例。
* 2. 请在下方 GoodsServiceTest 类中填写单元测试代码内容。
* 3. 请使用 Datas 类中提供的集合对象和商品对象的数据进行测试。
* 4. 在测试中用到的断言 Assert 类务必使用 org.junit 包中的 Assert 。
*/
public class GoodsServiceTest {
// 声明被测类
private GoodsService goodsService;
@Before
public void setUp(){
// 创建被测类实例
goodsService = new GoodsService();
}
@After
public void tearDown(){
// 释放被测类实例
goodsService = null;
}
@Test
public void testShoppingCart01(){
GoodsService goodsService = new GoodsService();
Goods g1 = new Goods(11, "Phone", "Brand", 1000, 1);
List<Goods> result = goodsService.shoppingCart(null, g1);
Assert.assertNotNull(result);
Assert.assertEquals(1, result.size());
Assert.assertEquals(g1, result.get(0));
}
@Test
public void testShoppingCart02(){
// TODO 请填写单元测试代码
GoodsService goodsService = new GoodsService();
Goods g1 = new Goods(12, "Phone", "Brand", 1000, 1);
List<Goods> list = new ArrayList<>();
list.add(g1);
List<Goods> result = goodsService.shoppingCart(list, g1);
Assert.assertNotNull(result);
Assert.assertEquals(1, result.size());
Assert.assertEquals(2, result.get(0).getQuantity()); // 数量应增加
}
@Test
public void testShoppingCart03(){
// TODO 请填写单元测试代码
GoodsService goodsService = new GoodsService();
Goods g1 = new Goods(13, "Phone", "Brand", 1000, 1);
Goods g2 = new Goods(14, "Tablet", "Brand", 1500, 1); // Different ID
List<Goods> list = new ArrayList<>();
list.add(g2);
List<Goods> result = goodsService.shoppingCart(list, g1);
Assert.assertNotNull(result);
Assert.assertEquals(2, result.size()); // 应添加新商品
Assert.assertEquals(g1, result.get(1));
}
@Test
public void testShoppingCart04(){
// TODO 请填写单元测试代码
GoodsService goodsService = new GoodsService();
Goods g1 = new Goods(1, "Phone", "Brand", 1000, 1);
List<Goods> list = new ArrayList<>();
List<Goods> result = goodsService.shoppingCart(list, g1);
Assert.assertNotNull(result);
Assert.assertEquals(1, result.size());
Assert.assertEquals(g1, result.get(0));
}
@Test
public void testShoppingCart05(){
// TODO 请填写单元测试代码
GoodsService goodsService = new GoodsService();
Goods g1 = new Goods(13, "Phone", "Brand", 1000, 1);
Goods g2 = new Goods(14, "Tablet", "Brand", 1500, 1); // Different ID
List<Goods> list = new ArrayList<>();
list.add(g1);
list.add(g2);
List<Goods> result = goodsService.shoppingCart(list, g2);
Assert.assertNotNull(result);
Assert.assertEquals(2, result.size()); // 应添加新商品
Assert.assertEquals(g2, result.get(1));
}
@Test
public void testShoppingCart06(){
// TODO 请填写单元测试代码
GoodsService goodsService = new GoodsService();
Goods g1 = new Goods(13, "Phone", "Brand", 1000, 1);
Goods g2 = new Goods(14, "Tablet", "Brand", 1500, 1); // Different ID
Goods g3 = new Goods(15, "Tablet", "Brand", 1500, 1);
List<Goods> list = new ArrayList<>();
list.add(g1);
list.add(g2);
list.add(g3);
List<Goods> result = goodsService.shoppingCart(list, g3);
Assert.assertNotNull(result);
Assert.assertEquals(3, result.size()); // 应添加新商品
Assert.assertEquals(g3, result.get(2));
}
@Test
public void testShoppingCart07(){
// TODO 请填写单元测试代码
GoodsService goodsService = new GoodsService();
Goods g1 = new Goods(13, "Phone", "Brand", 1000, 1);
Goods g2 = new Goods(14, "Tablet", "Brand", 1500, 1); // Different ID
Goods g3 = new Goods(15, "Tablet", "Brand", 1500, 1);
Goods g4 = new Goods(16, "Tablet", "Brand", 1500, 1);
List<Goods> list = new ArrayList<>();
list.add(g1);
list.add(g2);
list.add(g3);
list.add(g4);
List<Goods> result = goodsService.shoppingCart(list, g4);
Assert.assertNotNull(result);
Assert.assertEquals(4, result.size()); // 应添加新商品
Assert.assertEquals(g4, result.get(3));
}
@Test
public void testShoppingCart08(){
// TODO 请填写单元测试代码
GoodsService goodsService = new GoodsService();
Goods g1 = new Goods(13, "Phone", "Brand", 1000, 1);
Goods g2 = new Goods(14, "Tablet", "Brand", 1500, 1); // Different ID
Goods g3 = new Goods(15, "Tablet", "Brand", 1500, 1);
Goods g4 = new Goods(16, "Tablet", "Brand", 1500, 1);
Goods g5 = new Goods(17, "Tablet", "Brand", 1500, 1);
List<Goods> list = new ArrayList<>();
list.add(g1);
list.add(g2);
list.add(g3);
list.add(g4);
list.add(g5);
List<Goods> result = goodsService.shoppingCart(list, g5);
Assert.assertNotNull(result);
Assert.assertEquals(5, result.size()); // 应添加新商品
Assert.assertEquals(g5, result.get(4));
}
}
到了这里,关于蓝桥杯单元测试专项练习Java版的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!