蓝桥杯单元测试专项练习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.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

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<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));
    }

}

标签：蓝桥杯

本文转载自: https://blog.csdn.net/weixin_44117248/article/details/135896490
版权归原作者 weixin_44117248 所有，如有侵权，请联系我们删除。

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

题目一：

题目要求

判分标准

题目二：

题目要求

判分标准

题目三：

题目要求

判分标准

题目四

题目要求

判分标准

发表评论

“蓝桥杯单元测试专项练习Java版”的评论:

关于作者

overfit同步小助手

相关阅读

文章导航