import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
@Test
public void runImage_withStandaloneImage_shouldStartDockerContainer() throws IOException, InterruptedException, DockerClient.DockerClientException {
    DockerClient client = new DockerClient(build,launcher,listener);

    client.runImage("imagename","containername");

    verify(launcher, new VerificationMode() {

        public void verify(VerificationData verificationData) {
            assertEquals(verificationData.getAllInvocations().size(),1);
            Launcher.ProcStarter ps = (Launcher.ProcStarter) verificationData.getAllInvocations().get(0).getRawArguments()[0];
            String cmd = StringUtils.join(ps.cmds()," ");
            assertEquals("docker run -d --name containername imagename",cmd);
        }
    }).launch(Matchers.<Launcher.ProcStarter>any());
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
public void verify(VerificationData verificationData) {
  List<Invocation> invocations = verificationData.getAllInvocations();
  InvocationMatcher invocationMatcher = verificationData.getWanted();

  if (invocations == null || invocations.isEmpty()) {
    throw new MockitoException(
        "\nNo interactions with "
            + invocationMatcher.getInvocation().getMock()
            + " mock so far");
  }
  Invocation invocation = invocations.get(invocations.size() - 1);

  if (!invocationMatcher.matches(invocation)) {
    throw new MockitoException("\nWanted but not invoked:\n" + invocationMatcher);
  }
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
public void verify(final VerificationData data) {
    int soFar = 0;
    AssertionError error = null;
    while (soFar <= timeout) {
        //noinspection ErrorNotRethrown
        try {
            delegate.verify(data);
            return;
        } catch (final AssertionError e) {
            error = e;
            soFar += treshhold;
            sleep(treshhold);
        }
    }
    if (error != null) {
        throw error;
    }
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
public void verify(VerificationData data) {
    int soFar = 0;
    MockitoAssertionError error = null;
    while (soFar <= timeout) {
        try {
            delegate.verify(data);
            return;
        } catch (MockitoAssertionError e) {
            error = e;
            soFar += treshhold;
            sleep(treshhold);
        }
    }
    if (error != null) {
        throw error;
    }
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
@Test
public void runImage_withHub_shouldStartDockerContainer() throws IOException, InterruptedException, DockerClient.DockerClientException {
    DockerClient client = new DockerClient(build,launcher,listener);

    client.runImage("imagename","containername","linkimage","linkname");

    verify(launcher, new VerificationMode() {
        public void verify(VerificationData verificationData) {
            assertEquals(verificationData.getAllInvocations().size(),1);
            Launcher.ProcStarter ps = (Launcher.ProcStarter) verificationData.getAllInvocations().get(0).getRawArguments()[0];
            String cmd = StringUtils.join(ps.cmds()," ");
            assertEquals("docker run -d --name containername --link linkimage:linkname imagename",cmd);
        }
    }).launch(Matchers.<Launcher.ProcStarter>any());
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
@Test
public void killImage__shouldKillDockerContainer() throws IOException, InterruptedException, DockerClient.DockerClientException {
    DockerClient client = new DockerClient(build,launcher,listener);

    client.killImage("containername");
    verify(launcher, new VerificationMode() {

        public void verify(VerificationData verificationData) {
            assertEquals(verificationData.getAllInvocations().size(), 1);
            Launcher.ProcStarter ps = (Launcher.ProcStarter) verificationData.getAllInvocations().get(0).getRawArguments()[0];
            String cmd = StringUtils.join(ps.cmds(), " ");
            assertEquals("docker kill containername", cmd);
        }
    }).launch(Matchers.<Launcher.ProcStarter>any());
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
@Test
public void rmImage__shouldRemoveDockerContainer() throws IOException, InterruptedException, DockerClient.DockerClientException {
    DockerClient client = new DockerClient(build,launcher,listener);

    client.rmImage("containername");
    verify(launcher, new VerificationMode() {

        public void verify(VerificationData verificationData) {
            assertEquals(verificationData.getAllInvocations().size(), 1);
            Launcher.ProcStarter ps = (Launcher.ProcStarter) verificationData.getAllInvocations().get(0).getRawArguments()[0];
            String cmd = StringUtils.join(ps.cmds(), " ");
            assertEquals("docker rm containername", cmd);
        }
    }).launch(Matchers.<Launcher.ProcStarter>any());
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
public void verify(VerificationData data) {
    List<Invocation> invocations = data.getAllInvocations();
    InvocationMatcher wanted = data.getWanted();
    
    InvocationsFinder finder = new InvocationsFinder();
    List<Invocation> found = finder.findInvocations(invocations, wanted);
    int foundSize = found.size();
    if (foundSize > maxNumberOfInvocations) {
        new Reporter().wantedAtMostX(maxNumberOfInvocations, foundSize);
    }
    
    invocationMarker.markVerified(found, wanted);
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void verify(VerificationData data) {
    Invocation unverified = new InvocationsFinder().findFirstUnverified(data.getAllInvocations());                       
    if (unverified != null) {
        new Reporter().noMoreInteractionsWanted(unverified, (List) data.getAllInvocations());
    }
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
public void verify(VerificationData data) {
    MissingInvocationChecker missingInvocation = new MissingInvocationChecker();
    AtLeastXNumberOfInvocationsChecker numberOfInvocations = new AtLeastXNumberOfInvocationsChecker();
    
    if (wantedCount == 1) {
        missingInvocation.check(data.getAllInvocations(), data.getWanted());
    }
    numberOfInvocations.check(data.getAllInvocations(), data.getWanted(), wantedCount);
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
public void verify(VerificationData data) {
    if (wantedCount > 0) {
        MissingInvocationChecker missingInvocation = new MissingInvocationChecker();
        missingInvocation.check(data.getAllInvocations(), data.getWanted());
    }
    NumberOfInvocationsChecker numberOfInvocations = new NumberOfInvocationsChecker();
    numberOfInvocations.check(data.getAllInvocations(), data.getWanted(), wantedCount);
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
@SuppressWarnings("unchecked")
   public void verify(VerificationData data) {
	InvocationMatcher wantedMatcher = data.getWanted();
	List<Invocation> invocations = data.getAllInvocations();
	List<Invocation> chunk = finder.findInvocations(invocations,wantedMatcher);
	if (invocations.size() != 1 && chunk.size() > 0) {			
		Invocation unverified = finder.findFirstUnverified(invocations);
		reporter.noMoreInteractionsWanted(unverified, (List) invocations);
	} else if (invocations.size() != 1 || chunk.size() == 0) {
		reporter.wantedButNotInvoked(wantedMatcher);
	}
	marker.markVerified(chunk.get(0), wantedMatcher);
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public void verify(VerificationData data) {
    Invocation unverified = new InvocationsFinder().findFirstUnverified(data.getAllInvocations());
    if (unverified != null) {
        new Reporter().noMoreInteractionsWanted(unverified, (List) data.getAllInvocations());
    }
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
/**
 * Verify the given ongoing verification data, and confirm that it satisfies the delegate verification mode
 * before the full duration has passed.
 *
 * In practice, this polls the delegate verification mode until it is satisfied. If it is not satisfied once
 * the full duration has passed, the last error returned by the delegate verification mode will be thrown
 * here in turn. This may be thrown early if the delegate is unsatisfied and the verification mode is known
 * to never recover from this situation (e.g. {@link AtMost}).
 *
 * If it is satisfied before the full duration has passed, behaviour is dependent on the returnOnSuccess parameter
 * given in the constructor. If true, this verification mode is immediately satisfied once the delegate is. If
 * false, this verification mode is not satisfied until the delegate is satisfied and the full time has passed.
 *
 * @throws MockitoAssertionError if the delegate verification mode does not succeed before the timeout
 */
public void verify(VerificationData data) {
    MockitoAssertionError error = null;
    
    long startTime = System.currentTimeMillis();
    while (System.currentTimeMillis() - startTime <= durationMillis) {
        try {
            delegate.verify(data);
            
            if (returnOnSuccess) {
                return;
            } else {
                error = null;
            }
        } catch (MockitoAssertionError e) {
            if (canRecoverFromFailure(delegate)) {
                error = e;
                sleep(pollingPeriodMillis);
            } else {
                throw e;
            }
        }
    }
    
    if (error != null) {
        throw error;
    }
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
@Override
public void verify(final VerificationData data) {
    InvocationsFinder finder = new InvocationsFinder();
    List<Invocation> actualInvocations = finder.findInvocations(data.getAllInvocations(), data.getWanted());
    if (actualInvocations.size() != 1) {
        throw new MockitoException("This verifier can only be used with 1 invocation, got "
                + actualInvocations.size());
    }
    Invocation invocation = actualInvocations.get(0);
    arguments = invocation.getArguments();
    invocation.markVerified();

}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
@Override
public void verify(VerificationData data) {
    List<Invocation> invocations = data.getAllInvocations();
    InvocationMatcher matcher = data.getWanted();
    Invocation invocation = invocations.get(invocations.size() - 1);

    if (!matcher.matches(invocation)) {
        throw new MockitoException("This is not the last interaction with the mock object");
    }
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
@Override
public void verify(VerificationData data) {
    try {
        if (wantedCount > 0) {
            MissingInvocationChecker missingInvocation = new MissingInvocationChecker();
            missingInvocation.check(data.getAllInvocations(), data.getWanted());
        }
        NumberOfInvocationsChecker numberOfInvocations = new NumberOfInvocationsChecker();
        numberOfInvocations.check(data.getAllInvocations(), data.getWanted(), wantedCount);
    } catch (MockitoAssertionError mae) {
        throw new SejdaRuntimeException(failureDescribingMessage, mae);
    }
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
@Override
public void verify(VerificationData data) {
    super.verify(data);
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
public void verify(VerificationData data) {
    List<Invocation> allInvocations = new AllInvocationsFinder().find(inOrder.getMocksToBeVerifiedInOrder());
    VerificationDataInOrderImpl dataInOrder = new VerificationDataInOrderImpl(inOrder, allInvocations, data.getWanted());
    mode.verifyInOrder(dataInOrder);
}
 

import org.mockito.internal.verification.api.VerificationData; //导入依赖的package包/类
public void verify(VerificationData data) {
    mode.verify(data);
}