Java 如何为基于字符串条件从数组中筛选元素的方法编写测试

我有一个

Car

类，其类别字段为

String

：

public class Car {

     private String category;

     public Car(String category) {
         this.category = category;
     }

     public String getCategory() {
         return category;
     }

     public void setCategory(String category) {
         this.category = category;
     }
}

我有一种方法，它根据

字符串
使用
包含（）
方法从数组中过滤出元素，只保留跑车。我知道这是个坏主意，只是想写我的第一个单元测试。你能帮我弄清楚从哪里开始吗。一般来说，测试循环过滤逻辑的最佳实践是什么

private List<Car> filterOutEverythingExceptSportCars(List<Car> cars) {
    List<Car> filteredCarsList = new ArrayList<>();

    for (int i = 0; i < cars.size(); i++) {
        if (cars.get(i).getCategory().contains("sport")) {
            filteredCarsList.add(cars.get(i));
        }
    }
    return filteredCarsList;
}

private List filter超出除跑车以外的所有车辆（列出车辆）{
List filteredCarsList=new ArrayList（）；
对于（int i=0；i
您可以查看流并像这样使用过滤器操作符

private static List<Car> filterOutSportCars(List<Car> cars) {
   return cars.stream().filter(car -> !car.category.contains("sport")).collect(Collectors.toList());

}

私人静态列表过滤器Outsportcars（列表车辆）{
return cars.stream（）.filter（car->！car.category.contains（“运动”））.collect（Collectors.toList（））；
}
您可以查看流并像这样使用过滤器操作符

private static List<Car> filterOutSportCars(List<Car> cars) {
   return cars.stream().filter(car -> !car.category.contains("sport")).collect(Collectors.toList());

}

私人静态列表过滤器Outsportcars（列表车辆）{
return cars.stream（）.filter（car->！car.category.contains（“运动”））.collect（Collectors.toList（））；
}
只需测试合同-如果你输入了
，那么你期望得到什么？例如，如果调用
filterOutEverythingExceptSportsCars（null）
，或
filterOutEverythingExceptSportsCars（Collections.emptyList（））
，或
filterOutEverythingExceptSportsCars（Arrays.asList（car1，null，car2））
等，会发生什么

然后围绕这一系列先决条件、操作和预期结果构建测试。因此，您的第一个测试可能是：

@Test
givenListOfCarsIsNull_whenFilteringOutEverythingExceptSportsCars_thenReturnEmptyList() {
    final List<Car> in = null; //precondition
    final List<Car> out = filterOutEverythingExceptSportsCars(in); //calling the method
    assertTrue(out.isEmpty()); //verifying expected output
}

@测试
当过滤除跑车之外的所有内容时，GivenListFCars为空\u然后返回空列表（）{
final List in=null；//前提条件
final List out=filterOutEverythingExceptSportsCars（in）；//调用该方法
assertTrue（out.isEmpty（））；//验证预期输出
}

如果您希望在本场景中返回一个空列表。相反，您可能期望抛出异常或其他东西。
只需测试契约-如果您输入了
，那么您期望得到什么？例如，如果调用
filterOutEverythingExceptSportsCars（null）
，或
filterOutEverythingExceptSportsCars（Collections.emptyList（））
，或
filterOutEverythingExceptSportsCars（Arrays.asList（car1，null，car2））
等，会发生什么

然后围绕这一系列先决条件、操作和预期结果构建测试。因此，您的第一个测试可能是：

@Test
givenListOfCarsIsNull_whenFilteringOutEverythingExceptSportsCars_thenReturnEmptyList() {
    final List<Car> in = null; //precondition
    final List<Car> out = filterOutEverythingExceptSportsCars(in); //calling the method
    assertTrue(out.isEmpty()); //verifying expected output
}

@测试
当过滤除跑车之外的所有内容时，GivenListFCars为空\u然后返回空列表（）{
final List in=null；//前提条件
final List out=filterOutEverythingExceptSportsCars（in）；//调用该方法
assertTrue（out.isEmpty（））；//验证预期输出
}

如果您希望在本场景中返回一个空列表。相反，您可能希望抛出异常或其他东西。
首先，您需要使您的方法可测试。在您的实现中，它是一个私有实例方法。由于您没有使用实例中的任何其他内容，因此可以将其设置为包私有静态方法：

static List<Car> filterOutEverythingExceptSportCars(List<Car> cars) {
    List<Car> filteredCarsList = new ArrayList<>();
    for (Car car: cars) {
        if (!car.getCategory().contains("sport")) {
            filteredCarsList.add(car);
        }
    }
    return filteredCarsList;
}

static List filter超出除跑车以外的所有车辆（列出车辆）{
List filteredCarsList=new ArrayList（）；
用于（汽车：汽车）{
如果（！car.getCategory（）.包含（“运动”））{
filteredCarsList.add（汽车）；
}
}
返回filteredCarsList；
}

现在，您可以轻松编写一个单元测试，其中包含要比较的输入和输出列表：

@Test
public static void testFilterOutEverythingExceptSportCars() {
    List<Car> cars = ...;
    List<Car> actual = filterOutEverythingExceptSportCars(cars);
    List<Car> expected = ...;
    assertEquals(expected, actual);
}

@测试
公共静态无效测试过滤器超出除跑车以外的所有内容（）{
列出汽车=。。。；
列表实际值=除跑车外的所有车辆的过滤器；
列表预期=。。。；
资产质量（预期、实际）；
}

您只需静态导入
过滤器outeverythingexceptsportcars
方法，并将测试类与实现放在同一个包中

请注意，for循环的改进取决于您的应用，而不是强制性的。我也没有将命名或if条件更改为匹配。只需编写测试并迭代实现，直到您最喜欢它…
首先，您需要使您的方法可测试。在您的实现中，它是一个私有实例方法。由于您没有使用实例中的任何其他内容，因此可以将其设置为包私有静态方法：

static List<Car> filterOutEverythingExceptSportCars(List<Car> cars) {
    List<Car> filteredCarsList = new ArrayList<>();
    for (Car car: cars) {
        if (!car.getCategory().contains("sport")) {
            filteredCarsList.add(car);
        }
    }
    return filteredCarsList;
}

static List filter超出除跑车以外的所有车辆（列出车辆）{
List filteredCarsList=new ArrayList（）；
用于（汽车：汽车）{
如果（！car.getCategory（）.包含（“运动”））{
filteredCarsList.add（汽车）；
}
}
返回filteredCarsList；
}

现在，您可以轻松编写一个单元测试，其中包含要比较的输入和输出列表：

@Test
public static void testFilterOutEverythingExceptSportCars() {
    List<Car> cars = ...;
    List<Car> actual = filterOutEverythingExceptSportCars(cars);
    List<Car> expected = ...;
    assertEquals(expected, actual);
}

@测试
公共静态无效测试过滤器超出除跑车以外的所有内容（）{
列出汽车=。。。；
列表实际值=除跑车外的所有车辆的过滤器；
列表预期=。。。；
资产质量（预期、实际）；
}

您只需静态导入
过滤器outeverythingexceptsportcars
方法，并将测试类与实现放在同一个包中

请注意，for循环的改进取决于您的应用，而不是强制性的。我也没有将命名或if条件更改为匹配。只需编写测试并迭代实现，直到您最喜欢它…
您可能想尝试一下（编译成java字节码）：

import org.assertj.core.api.Assertions.assertThat
导入org.junit.jupiter.api.Test
类别汽车（变量类别：字符串）
趣味跑车（list:list）=list.filter{it.category.contains（“运动”）}
阶级卡特尔{
@试验
有趣的‘一辆法拉利和一辆卡车’（）{
val法拉利=汽车（“法拉利跑车”）
val卡车=汽车（tr