蓝桥杯单元测试专项练习Java版

题目一：

举重比赛，需要根据性别和体重来决定是否有参赛资格，具体规则如下：

当性别为男且体重大于等于 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.java12

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

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

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 shoppingCart(List 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 list1 = null;

public static List list2 = null;

public static List 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 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 list = new ArrayList<>();

list.add(g1);

List 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 list = new ArrayList<>();

list.add(g2);

List 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 list = new ArrayList<>();

List 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 list = new ArrayList<>();

list.add(g1);

list.add(g2);

List 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 list = new ArrayList<>();

list.add(g1);

list.add(g2);

list.add(g3);

List 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 list = new ArrayList<>();

list.add(g1);

list.add(g2);

list.add(g3);

list.add(g4);

List 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 list = new ArrayList<>();

list.add(g1);

list.add(g2);

list.add(g3);

list.add(g4);

list.add(g5);

List result = goodsService.shoppingCart(list, g5);

Assert.assertNotNull(result);

Assert.assertEquals(5, result.size()); // 应添加新商品

Assert.assertEquals(g5, result.get(4));

}

}

精彩内容