private InvocationContainerImpl getInvocationContainer() { assertGoodMock(); return MockUtil.getInvocationContainer(toInspect); }
private MockHandler<Object> mockHandler() { assertGoodMock(); return MockUtil.getMockHandler(toInspect); }
/** * Creates an empty Optional using reflection to stay backwards-compatible with older JDKs. * * @return an empty Optional. */ public static Object emptyOptional() { // no need for double-checked locking if (emptyOptional != null) { return emptyOptional; } return emptyOptional = invokeNullaryFactoryMethod("java.util.Optional", "empty"); }
public static MockitoException stubPassedToVerify(Object mock) { return new CannotVerifyStubOnlyMock(join( "Argument \"" + MockUtil.getMockName(mock) + "\" passed to verify is a stubOnly() mock which cannot be verified.", "If you intend to verify invocations on this mock, don't use stubOnly() in its MockSettings." )); }
@Override public boolean isSpy(){ return MockUtil.isSpy(toInspect); }
/** * Create a new InstanceField. * * @param field The field that should be accessed, note that no checks are performed to ensure * the field belong to this instance class. * @param instance The instance from which the field shall be accessed. */ public InstanceField(Field field, Object instance) { this.field = Checks.checkNotNull(field, "field"); this.instance = Checks.checkNotNull(instance, "instance"); }
@SuppressWarnings("unchecked") public MockNameImpl(String mockName, Class<?> classToMock) { if (mockName == null) { this.mockName = toInstanceName(classToMock); this.defaultName = true; } else { this.mockName = mockName; } }
/** * Joins Strings with EOL character * * @param start the starting String * @param lines collection to join */ public static String join(String start, Collection<?> lines) { return join(start, "", lines); }
public static String warnForVM(String vmName1, String warnMessage1, String vmName2, String warnMessage2) { return warnForVM(JVM_NAME, vmName1, warnMessage1, vmName2, warnMessage2); }
public static MockitoException wrongTypeReturnedByDefaultAnswer(Object mock, String expectedType, String actualType, String methodName) { return new WrongTypeOfReturnValue(join( "Default answer returned a result with the wrong type:", actualType + " cannot be returned by " + methodName + "()", methodName + "() should return " + expectedType, "", "The default answer of " + MockUtil.getMockName(mock) + " that was configured on the mock is probably incorrectly implemented.", "" )); }
public static <T extends Iterable<?>> T checkItemsNotNull(T iterable, String checkedIterable) { checkNotNull(iterable, checkedIterable); for (Object item : iterable) { checkNotNull(item, "item in " + checkedIterable); } return iterable; } }
/** * Creates an empty IntStream using reflection to stay backwards-compatible with older JDKs. * * @return an empty IntStream. */ public static Object emptyIntStream() { // note: the empty stream can not be stored as a singleton. return invokeNullaryFactoryMethod("java.util.stream.IntStream", "empty"); }
@Override public MockSettings useConstructor(Object... constructorArgs) { Checks.checkNotNull(constructorArgs, "constructorArgs", "If you need to pass null, please cast it to the right type, e.g.: useConstructor((String) null)"); this.useConstructor = true; this.constructorArgs = constructorArgs; return this; }
/** * Creates an empty OptionalDouble using reflection to stay backwards-compatible with older JDKs. * * @return an empty OptionalDouble. */ public static Object emptyOptionalDouble() { // no need for double-checked locking if (emptyOptionalDouble != null) { return emptyOptionalDouble; } return emptyOptionalDouble = invokeNullaryFactoryMethod("java.util.OptionalDouble", "empty"); }
/** * Creates an empty OptionalInt using reflection to stay backwards-compatible with older JDKs. * * @return an empty OptionalInt. */ public static Object emptyOptionalInt() { // no need for double-checked locking if (emptyOptionalInt != null) { return emptyOptionalInt; } return emptyOptionalInt = invokeNullaryFactoryMethod("java.util.OptionalInt", "empty"); }
/** * Creates an empty DoubleStream using reflection to stay backwards-compatible with older JDKs. * * @return an empty DoubleStream. */ public static Object emptyDoubleStream() { // note: the empty stream can not be stored as a singleton. return invokeNullaryFactoryMethod("java.util.stream.DoubleStream", "empty"); }
/** * Creates an empty OptionalLong using reflection to stay backwards-compatible with older JDKs. * * @return an empty OptionalLong. */ public static Object emptyOptionalLong() { // no need for double-checked locking if (emptyOptionalLong != null) { return emptyOptionalLong; } return emptyOptionalLong = invokeNullaryFactoryMethod("java.util.OptionalLong", "empty"); }
/** * Creates an empty Stream using reflection to stay backwards-compatible with older JDKs. * * @return an empty Stream. */ public static Object emptyStream() { // note: the empty stream can not be stored as a singleton. return invokeNullaryFactoryMethod("java.util.stream.Stream", "empty"); }
/** * Creates an empty LongStream using reflection to stay backwards-compatible with older JDKs. * * @return an empty LongStream. */ public static Object emptyLongStream() { // note: the empty stream can not be stored as a singleton. return invokeNullaryFactoryMethod("java.util.stream.LongStream", "empty"); }