Java Mockito-验证集合中的对象是否称为方法

我正在与Mockito框架进行斗争：

我有一个特定类型的

集合

，我想验证其中是否有任何对象调用了特定方法。这是我的密码：

@Mock
private Set<MyType> myTypes = (Set<MyType>) mock(Set.class);

@Before
public void setUp() throws Exception{
    TestObject testObject = spy(new TestObject());        

    for(int i = 0; i < 4; i++){        
        MyType mT = mock(MyType.class);
        mT.setName("Name"+i);
        myTypes.add(mT);
    }

    testObject.setMyTypesSet(myTypes);
}

@Test
public void myTypeSet_Test(){

    //call method which calls "getName()" for each element in the set        
    testObject.myTypeSet();

    //HERE IS MY STRUGGLE
    verify(myType, times(3)).getName();
}

@Mock
私有集myTypes=（Set）mock（Set.class）；
@以前
public void setUp（）引发异常{
TestObject TestObject=spy（新的TestObject（））；
对于（int i=0；i<4；i++）{
MyType mT=mock（MyType.class）；
mT.setName（“名称”+i）；
myTypes.add（mT）；
}
testObject.setMyTypesSet（myTypes）；
}
@试验
公共无效myTypeSet_测试（）{
//调用方法，该方法为集合中的每个元素调用“getName（）”
testObject.myTypeSet（）；
//这是我的奋斗
验证（myType，times（3））.getName（）；
}

---

因此，

myTypes

对象有一个名为

getName（）

的方法。我想测试方法

getName（）

在我测试的方法中是否被调用了3次。我无法写入

verify（myTypes，times（3））.getName（）

，因为

Set

没有方法

getName（）

。我希望我已经说清楚了。

来验证getName方法在每个对象上被调用了3次

for(MyType myType : myTypes) {
  verify(myType, times(3)).getName();
}

验证getName方法在任何对象上总共调用了3次

public class MyTypeTest {

  @Mock private Set<MyType> myTypes = new HashSet<>();

  @Before
  public void setUp() throws Exception{
    TestObject testObject = spy(new TestObject());

    for(int i = 0; i < 4; i++){
      MyType mT = Mockito.mock(MyType.class);
      mT.setName("Name"+i);
      myTypes.add(mT);
    }

    testObject.setMyTypesSet(myTypes);
  }

  @Test
  public void myTypeSet_Test(){

    //call method which calls "getName()" for each element in the set
    testObject.myTypeSet();

    int numberOfCalls = 0;
    for(MyType myTypeMock : myTypes) {
      Collection<Invocation> invocations = Mockito.mockingDetails(myTypeMock).getInvocations();
      numberOfCalls += invocations.size();
    }

    assertEquals(3, numberOfCalls)
  }


}

class MyType {
  private String name;
  public void setName(String n) { name = n;}
  public String getName() {return name};
}

公共类MyTypeTest{
@Mock private Set myTypes=new HashSet（）；
@以前
public void setUp（）引发异常{
TestObject TestObject=spy（新的TestObject（））；
对于（int i=0；i<4；i++）{
MyType mT=Mockito.mock（MyType.class）；
mT.setName（“名称”+i）；
myTypes.add（mT）；
}
testObject.setMyTypesSet（myTypes）；
}
@试验
公共无效myTypeSet_测试（）{
//调用方法，该方法为集合中的每个元素调用“getName（）”
testObject.myTypeSet（）；
int numberOfCalls=0；
对于（MyType myTypeMock:myTypes）{
集合调用=Mockito.mockingDetails（myTypeMock.getInvocations（）；
numberOfCalls+=invocations.size（）；
}
assertEquals（3，numberOfCalls）
}
}
类MyType{
私有字符串名称；
public void setName（字符串n）{name=n；}
公共字符串getName（）{return name}；
}

验证getName方法在每个对象上调用了3次

for(MyType myType : myTypes) {
  verify(myType, times(3)).getName();
}

验证getName方法在任何对象上总共调用了3次

public class MyTypeTest {

  @Mock private Set<MyType> myTypes = new HashSet<>();

  @Before
  public void setUp() throws Exception{
    TestObject testObject = spy(new TestObject());

    for(int i = 0; i < 4; i++){
      MyType mT = Mockito.mock(MyType.class);
      mT.setName("Name"+i);
      myTypes.add(mT);
    }

    testObject.setMyTypesSet(myTypes);
  }

  @Test
  public void myTypeSet_Test(){

    //call method which calls "getName()" for each element in the set
    testObject.myTypeSet();

    int numberOfCalls = 0;
    for(MyType myTypeMock : myTypes) {
      Collection<Invocation> invocations = Mockito.mockingDetails(myTypeMock).getInvocations();
      numberOfCalls += invocations.size();
    }

    assertEquals(3, numberOfCalls)
  }


}

class MyType {
  private String name;
  public void setName(String n) { name = n;}
  public String getName() {return name};
}

公共类MyTypeTest{
@Mock private Set myTypes=new HashSet（）；
@以前
public void setUp（）引发异常{
TestObject TestObject=spy（新的TestObject（））；
对于（int i=0；i<4；i++）{
MyType mT=Mockito.mock（MyType.class）；
mT.setName（“名称”+i）；
myTypes.add（mT）；
}
testObject.setMyTypesSet（myTypes）；
}
@试验
公共无效myTypeSet_测试（）{
//调用方法，该方法为集合中的每个元素调用“getName（）”
testObject.myTypeSet（）；
int numberOfCalls=0；
对于（MyType myTypeMock:myTypes）{
集合调用=Mockito.mockingDetails（myTypeMock.getInvocations（）；
numberOfCalls+=invocations.size（）；
}
assertEquals（3，numberOfCalls）
}
}
类MyType{
私有字符串名称；
public void setName（字符串n）{name=n；}
公共字符串getName（）{return name}；
}

您不需要在此处模拟

集合

；有一个常规的

集合

填充模拟就足够了：

private Set<MyType> myTypes = new HashSet<>();

---

这是假设您实际为每个set元素调用

getName（）

3次。如果不是这样的话，您只需要为每个调用一次，那么它将是

次（1）

，

您不需要在此处模拟

集

；有一个常规的

集合

填充模拟就足够了：

private Set<MyType> myTypes = new HashSet<>();

---

这是假设您实际为每个set元素调用

getName（）

3次。如果不是这种情况，并且您只需为每个元素调用一次，那么它将是

次（1）

，

您只需在集合的每个模拟元素上调用verify：

for (MyType myType : myTypes) {
    verify(myType, times(3))
    .getName();
}

但这对实际代码不起作用，因为

myTypes

被定义为

Mock

：

@Mock
private Set<MyType> myTypes = (Set<MyType>) mock(Set.class);

事实上，

myTypes

不必是模拟的。
将其声明为普通对象：

private Set<MyType> myTypes = new HashSet<>();

作者：

请注意，间谍活动不是一种好的做法，而是一种变通方法。所以尽可能避免这种情况，尤其是在你不需要的时候

---

这应该很好。

您只需在集合的每个模拟元素上调用verify：

for (MyType myType : myTypes) {
    verify(myType, times(3))
    .getName();
}

但这对实际代码不起作用，因为

myTypes

被定义为

Mock

：

@Mock
private Set<MyType> myTypes = (Set<MyType>) mock(Set.class);

事实上，

myTypes

不必是模拟的。
将其声明为普通对象：

private Set<MyType> myTypes = new HashSet<>();

作者：

请注意，间谍活动不是一种好的做法，而是一种变通方法。所以尽可能避免这种情况，尤其是在你不需要的时候

---

而且应该没问题。

我想如果知道它总共被调用了3次就足够了。我会试试这个并给出反馈。谢谢！：）我想如果知道它总共被呼叫了3次就足够了。我会试试这个并给出反馈。谢谢！：）非常感谢。我会试试的，但到目前为止似乎是合法的！非常感谢。我会试试的，但到目前为止似乎是合法的！谢谢你的解释！我将尝试代码并给出一个回顾，但似乎是合乎逻辑的！谢谢你的解释！我将尝试代码并给出一个回顾，但似乎是合乎逻辑的！