Unit testing 单元测试Java8谓词

我有一个像这样的Java8谓词。如何为此编写单元测试

 Predicate<DTO> isDone = (dtO) ->
                (!dto.isFinished() &&
                !dto.isCompleted());

谓词isDone=（dtO）->
（！dto.isFinished（）&&
！dto.isCompleted（））；

---

谢谢

如果您有对谓词的引用（如您的示例中所示），那么我看不到任何问题。下面是Mockito/JUnit的简单示例：

@Mock
private DTO mockDTO;

@Test
public void testIsDone_Finished_NotComplete()
{
    when(mockDTO.isFinished()).thenReturn(true);
    when(mockDTO.isCompleted()).thenReturn(false);

    boolean expected = false;
    boolean actual = isDone.test(mockDTO);

    Assert.assertEquals(expected, actual);
}

---

如果您有一个对谓词的引用（正如您的示例中所示），那么我看不到任何问题。下面是Mockito/JUnit的简单示例：

@Mock
private DTO mockDTO;

@Test
public void testIsDone_Finished_NotComplete()
{
    when(mockDTO.isFinished()).thenReturn(true);
    when(mockDTO.isCompleted()).thenReturn(false);

    boolean expected = false;
    boolean actual = isDone.test(mockDTO);

    Assert.assertEquals(expected, actual);
}

---

我会这样测试它：

private final Predicate<DTO> isDone = (dto) ->
        (!dto.isFinished() && !dto.isCompleted());

@Test
public void a() throws Exception {
    // given
    DTO dto = new DTO(true, true);

    // when
    boolean result = isDone.test(dto);

    // then
    assertThat(result).isFalse();
}

@Test
public void s() throws Exception {
    // given
    DTO dto = new DTO(true, false);

    // when
    boolean result = isDone.test(dto);

    // then
    assertThat(result).isFalse();
}

@Test
public void d() throws Exception {
    // given
    DTO dto = new DTO(false, true);

    // when
    boolean result = isDone.test(dto);

    // then
    assertThat(result).isFalse();
}

@Test
public void f() throws Exception {
    // given
    DTO dto = new DTO(false, false);

    // when
    boolean result = isDone.test(dto);

    // then
    assertThat(result).isTrue();
}

@AllArgsConstructor
public static class DTO {
    private final boolean isFinished;
    private final boolean isCompleted;

    public boolean isFinished() {
        return isFinished;
    }

    public boolean isCompleted() {
        return isCompleted;
    }
}

private final Predicate isDone=（dto）->
（！dto.isFinished（）&&！dto.isCompleted（））；
@试验
public void a（）引发异常{
//给定
DTO DTO=新的DTO（真，真）；
//什么时候
布尔结果=isDone.test（dto）；
//然后
断言（result）.isFalse（）；
}
@试验
public void s（）引发异常{
//给定
DTO DTO=新的DTO（真、假）；
//什么时候
布尔结果=isDone.test（dto）；
//然后
断言（result）.isFalse（）；
}
@试验
public void d（）引发异常{
//给定
DTO DTO=新的DTO（假、真）；
//什么时候
布尔结果=isDone.test（dto）；
//然后
断言（result）.isFalse（）；
}
@试验
public void f（）引发异常{
//给定
DTO DTO=新的DTO（假，假）；
//什么时候
布尔结果=isDone.test（dto）；
//然后
断言（result.isTrue（）；
}
@AllArgsConstructor
公共静态类DTO{
私人决赛结束；
私有最终布尔值已完成；
公共布尔值已完成（）{
返回已完成；
}
公共布尔值已完成（）{
返回已完成；
}
}

而不是

a

，

s

和

f

正确地命名测试，例如：

应该在完成和完成时完成

我假设
DTO
只是一个值对象，所以我宁愿创建真实的实例，而不是使用mock。
我会这样测试它：

private final Predicate<DTO> isDone = (dto) ->
        (!dto.isFinished() && !dto.isCompleted());

@Test
public void a() throws Exception {
    // given
    DTO dto = new DTO(true, true);

    // when
    boolean result = isDone.test(dto);

    // then
    assertThat(result).isFalse();
}

@Test
public void s() throws Exception {
    // given
    DTO dto = new DTO(true, false);

    // when
    boolean result = isDone.test(dto);

    // then
    assertThat(result).isFalse();
}

@Test
public void d() throws Exception {
    // given
    DTO dto = new DTO(false, true);

    // when
    boolean result = isDone.test(dto);

    // then
    assertThat(result).isFalse();
}

@Test
public void f() throws Exception {
    // given
    DTO dto = new DTO(false, false);

    // when
    boolean result = isDone.test(dto);

    // then
    assertThat(result).isTrue();
}

@AllArgsConstructor
public static class DTO {
    private final boolean isFinished;
    private final boolean isCompleted;

    public boolean isFinished() {
        return isFinished;
    }

    public boolean isCompleted() {
        return isCompleted;
    }
}

private final Predicate isDone=（dto）->
（！dto.isFinished（）&&！dto.isCompleted（））；
@试验
public void a（）引发异常{
//给定
DTO DTO=新的DTO（真，真）；
//什么时候
布尔结果=isDone.test（dto）；
//然后
断言（result）.isFalse（）；
}
@试验
public void s（）引发异常{
//给定
DTO DTO=新的DTO（真、假）；
//什么时候
布尔结果=isDone.test（dto）；
//然后
断言（result）.isFalse（）；
}
@试验
public void d（）引发异常{
//给定
DTO DTO=新的DTO（假、真）；
//什么时候
布尔结果=isDone.test（dto）；
//然后
断言（result）.isFalse（）；
}
@试验
public void f（）引发异常{
//给定
DTO DTO=新的DTO（假，假）；
//什么时候
布尔结果=isDone.test（dto）；
//然后
断言（result.isTrue（）；
}
@AllArgsConstructor
公共静态类DTO{
私人决赛结束；
私有最终布尔值已完成；
公共布尔值已完成（）{
返回已完成；
}
公共布尔值已完成（）{
返回已完成；
}
}

而不是
a
，
s
和
f
正确地命名测试，例如：
应该在完成和完成时完成

我想
DTO
只是一个值对象，所以我宁愿创建真实的实例，而不是使用mock。
首先用文字描述要测试的不同内容。你应该在描述中包含一个特定的输入和预期的输出。首先用文字描述不同的测试内容。您应该在描述中包含特定的输入和预期的输出。我的资源类中有一个私有谓词，我的测试类无法访问它。我应该如何测试它呢？私有布尔值hasNewCourseInfo（课程课程）{Predicate dateofPredicate=e->e.getDateofCreation（）.isAfter（课程.getcourseStatus（）.getDateofCreation（））；return-Course.GetEvents（）.stream（）.anyMatch（dateofPredicate）；}我的资源类中有一个私有谓词，我的测试类无法访问它。我应该如何测试它呢？私有布尔值hasNewCourseInfo（课程课程）{Predicate dateofPredicate=e->e.getDateofCreation（）.isAfter（课程.getcourseStatus（）.getDateofCreation（））；return-Course.GetEvents（）.stream（）.anyMatch（预测日期）；}