蓝桥杯单元测试挑战赛第四题（java版）

最新推荐文章于 2024-10-01 22:12:42 发布

姜姜7788

最新推荐文章于 2024-10-01 22:12:42 发布

阅读量616

点赞数 12

文章标签： java 蓝桥杯单元测试

本文链接：https://blog.csdn.net/qq_46526342/article/details/136676961

版权

本文介绍了如何使用基本路径覆盖法和简单循环覆盖法对Java代码中的GoodsService类的shoppingCart方法进行单元测试，包括针对不同场景（如购物车空、已存在商品等）设计的测试用例和测试数据的使用。

摘要由CSDN通过智能技术生成

题目链接：单元测试专项练习-第四题

题目描述：

请使用基本路径覆盖法 + 简单循环覆盖法的标准规则，对被测源代码 Goods、GoodsService 类中的 shoppingCart 方法设计单元测试用例。并在 GoodsServiceTest 类中完成单元测试代码，Datas 类中提供了测试数据。

shoppingcart代码功能：

当向购物车添加商品对象时，购物车集合列表不存在，那么系统会创建购物车集合列表，然后向购物车集合中添加商品信息，并返回商品集合列表。
当购物车集合对象为空时，可直接添加商品对象至集合列表中，然后返回商品集合列表。
当向购物车添加商品对象，而此商品已存在购物车集合对象列表中时，列表中只会对该商品的数量进行叠加，该商品的其他信息不变，完成操作后返回商品集合列表。
当向购物车添加的商品对象，并不存在商品集合列表中，则添加到购物车集合列表中，并返回商品集合列表。

源代码：

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

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类中的list2=new Arraylist（）；它在内存中是存在的，只是里面没有商品。这种情况，当用list2添加商品，没有循环直接走后面的add，是否可以理解为0次循环；另一种是Datas类中的list3 它里面有9个商品。循环1次，2次，m次，n-1次好写用例。到了循环n次就有两种情况，循环完9次后，商品存在原先list3中是一种，如果不存在例如添加g10就又会执行add操作。总共加起来是8条用例，也能通过蓝桥检测。

我的解答代码：

package cn.lanqiao;

import static org.junit.Assert.assertEquals;

import org.junit.After;
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 testShoppingCartNotExist(){
        // TODO 请填写单元测试代码
       assertEquals(Datas.g1.toString(),goodsService.shoppingCart(Datas.list1, Datas.g1).get(0).toString()); 
    }
    @Test
    public void testShoppingCartNoGoods(){
        // TODO 循环0次
        assertEquals(Datas.g2.toString(), goodsService.shoppingCart(Datas.list2,Datas.g2).get(0).toString());
    }
    @Test
    public void testShoppingCart01(){
        // TODO 循环1次
        assertEquals(4, goodsService.shoppingCart(Datas.list3, Datas.g1).get(0).getQuantity());
        
    }
    @Test
    public void testShoppingCart02(){
        // TODO 循环2次
        assertEquals(4, goodsService.shoppingCart(Datas.list3, Datas.g2).get(1).getQuantity());
        
    }
    @Test
    public void testShoppingCart04(){
        // TODO 循环m次 取值为4
        assertEquals(4, goodsService.shoppingCart(Datas.list3, Datas.g4).get(3).getQuantity());
    }
    @Test
    public void testShoppingCart08(){
        // TODO 循环n-1次，8次
        assertEquals(4, goodsService.shoppingCart(Datas.list3, Datas.g8).get(7).getQuantity());
    }
    @Test
    public void testShoppingCart09EXist(){
        // TODO 1、9次循环存在
        assertEquals(4, goodsService.shoppingCart(Datas.list3, Datas.g9).get(8).getQuantity());
    }
    @Test
    public void testShoppingCart09NotExist(){
        // TODO 2、9次循环商品不存在
        assertEquals(2, goodsService.shoppingCart(Datas.list3, Datas.g10).get(9).getQuantity());
        
    }
}