Test your AI Agents with the all-new Agent to Agent Testing Platform.Learn More

How to use doExpectPrivate method of org.powermock.api.easymock.PowerMock class

Best Powermock code snippet using org.powermock.api.easymock.PowerMock.doExpectPrivate

Source:PowerMock.java

...1071     * variant with only method name.1072     */1073    public static synchronized <T> IExpectationSetters<T> expectPrivate(Class<?> clazz, Method method,1074                                                                        Object... arguments) throws Exception {1075        return doExpectPrivate(clazz, method, arguments);1076    }1077    /**1078     * Used to specify expectations on private methods. If possible use variant1079     * with only method name.1080     */1081    public static synchronized <T> IExpectationSetters<T> expectPrivate(Object instance, Method method,1082                                                                        Object... arguments) throws Exception {1083        return doExpectPrivate(instance, method, arguments);1084    }1085    /**1086     * Used to specify expectations on private methods. Use this method to1087     * handle overloaded methods.1088     */1089    @SuppressWarnings("all")1090    public static synchronized <T> IExpectationSetters<T> expectPrivate(Object instance, String methodName,1091                                                                        Class<?>[] parameterTypes, Object... arguments) throws Exception {1092        if (arguments == null) {1093            arguments = new Object[0];1094        }1095        if (instance == null) {1096            throw new IllegalArgumentException("instance cannot be null.");1097        } else if (arguments.length != parameterTypes.length) {1098            throw new IllegalArgumentException(1099                    "The length of the arguments must be equal to the number of parameter types.");1100        }1101        Method foundMethod = Whitebox.getMethod(instance.getClass(), methodName, parameterTypes);1102        WhiteboxImpl.throwExceptionIfMethodWasNotFound(instance.getClass(), methodName, foundMethod, parameterTypes);1103        return doExpectPrivate(instance, foundMethod, arguments);1104    }1105    /**1106     * Used to specify expectations on methods using the method name. Works on1107     * for example private or package private methods.1108     */1109    public static synchronized <T> IExpectationSetters<T> expectPrivate(Object instance, String methodName,1110                                                                        Object... arguments) throws Exception {1111        if (instance == null) {1112            throw new IllegalArgumentException("Instance or class cannot be null.");1113        }1114        return expectPrivate(instance, methodName, Whitebox.getType(instance), arguments);1115    }1116    /**1117     * Used to specify expectations on methods without specifying a method name.1118     * Works on for example private or package private methods. PowerMock tries1119     * to find a unique method to expect based on the argument parameters. If1120     * PowerMock is unable to locate a unique method you need to revert to using1121     * {@link #expectPrivate(Object, String, Object...)}.1122     */1123    public static synchronized <T> IExpectationSetters<T> expectPrivate(Object instance, Object... arguments)1124            throws Exception {1125        return expectPrivate(instance, null, Whitebox.getType(instance), arguments);1126    }1127    /**1128     * Used to specify expectations on methods using the method name at a1129     * specific place in the class hierarchy (specified by the1130     * {@code where} parameter). Works on for example private or package1131     * private methods.1132     * <p/>1133     * Use this for overloaded methods.1134     */1135    public static synchronized <T> IExpectationSetters<T> expectPrivate(Object instance, String methodName,1136                                                                        Class<?> where, Class<?>[] parameterTypes, Object... arguments) throws Exception {1137        if (instance == null) {1138            throw new IllegalArgumentException("Instance or class to expect cannot be null.");1139        }1140        Method[] methods = null;1141        if (methodName != null) {1142            if (parameterTypes == null) {1143                methods = Whitebox.getMethods(where, methodName);1144            } else {1145                methods = new Method[]{Whitebox.getMethod(where, methodName, parameterTypes)};1146            }1147        }1148        Method methodToExpect;1149        if (methods != null && methods.length == 1) {1150            methodToExpect = methods[0];1151        } else {1152            methodToExpect = WhiteboxImpl.findMethodOrThrowException(instance, null, methodName, arguments);1153        }1154        return doExpectPrivate(instance, methodToExpect, arguments);1155    }1156    /**1157     * Used to specify expectations on methods using the method name at a1158     * specific place in the class hierarchy (specified by the1159     * {@code where} parameter). Works on for example private or package1160     * private methods.1161     */1162    public static synchronized <T> IExpectationSetters<T> expectPrivate(Object instance, String methodName,1163                                                                        Class<?> where, Object... arguments) throws Exception {1164        return expectPrivate(instance, methodName, where, null, arguments);1165    }1166    /**1167     * This method just delegates to EasyMock class extensions1168     * {@link org.easymock.EasyMock#expectLastCall()} method.1169     *1170     * @return The expectation setter.1171     * @see org.easymock.EasyMock#expectLastCall()1172     */1173    public static synchronized IExpectationSetters<Object> expectLastCall() {1174        return org.easymock.EasyMock.expectLastCall();1175    }1176    /**1177     * Sometimes it is useful to allow replay and verify on non-mocks. For1178     * example when using partial mocking in some tests and no mocking in other1179     * test-methods, but using the same setUp and tearDown.1180     */1181    public static synchronized void niceReplayAndVerify() {1182        MockRepository.putAdditionalState(NICE_REPLAY_AND_VERIFY_KEY, true);1183    }1184    /**1185     * Test if a object is a mock created by EasyMock or not.1186     */1187    private static boolean isEasyMocked(Object mock) {1188        return Enhancer.isEnhanced(mock.getClass()) || Proxy.isProxyClass(mock.getClass());1189    }1190    /**1191     * Replay all classes and mock objects known by PowerMock. This includes all1192     * classes that are prepared for test using the {@link PrepareForTest} or1193     * {@link PrepareOnlyThisForTest} annotations and all classes that have had1194     * their static initializers removed by using the1195     * {@link SuppressStaticInitializationFor} annotation. It also includes all1196     * mock instances created by PowerMock such as those created or used by1197     * {@link #createMock(Class, Method...)},1198     * {@link #mockStatic(Class, Method...)},1199     * {@link #expectNew(Class, Object...)},1200     * {@link #createPartialMock(Class, String...)} etc.1201     * <p/>1202     * To make it easy to pass in additional mocks <i>not</i> created by the1203     * PowerMock API you can optionally specify them as <tt>additionalMocks</tt>1204     * . These are typically those mock objects you have created using pure1205     * EasyMock or EasyMock class extensions. No additional mocks needs to be1206     * specified if you're only using PowerMock API methods.1207     * <p/>1208     * Note that the <tt>additionalMocks</tt> are also automatically verified1209     * when invoking the {@link #verifyAll()} method.1210     *1211     * @param additionalMocks Mocks not created by the PowerMock API. These are typically1212     *                        those mock objects you have created using pure EasyMock or1213     *                        EasyMock class extensions.1214     */1215    public static synchronized void replayAll(Object... additionalMocks) {1216        MockRepository.addObjectsToAutomaticallyReplayAndVerify(additionalMocks);1217        for (Object classToReplayOrVerify : MockRepository.getObjectsToAutomaticallyReplayAndVerify()) {1218            replay(classToReplayOrVerify);1219        }1220    }1221    /**1222     * Reset all classes and mock objects known by PowerMock. This includes all1223     * classes that are prepared for test using the {@link PrepareForTest} or1224     * {@link PrepareOnlyThisForTest} annotations and all classes that have had1225     * their static initializers removed by using the1226     * {@link SuppressStaticInitializationFor} annotation. It also includes all1227     * mock instances created by PowerMock such as those created or used by1228     * {@link #createMock(Class, Method...)},1229     * {@link #mockStatic(Class, Method...)},1230     * {@link #expectNew(Class, Object...)},1231     * {@link #createPartialMock(Class, String...)} etc.1232     * <p/>1233     * To make it easy to pass in additional mocks <i>not</i> created by the1234     * PowerMock API you can optionally specify them as <tt>additionalMocks</tt>1235     * . These are typically those mock objects you have created using pure1236     * EasyMock or EasyMock class extensions. No additional mocks needs to be1237     * specified if you're only using PowerMock API methods.1238     *1239     * @param additionalMocks Mocks not created by the PowerMock API. These are typically1240     *                        those mock objects you have created using pure EasyMock or1241     *                        EasyMock class extensions.1242     */1243    public static synchronized void resetAll(Object... additionalMocks) {1244        MockRepository.addObjectsToAutomaticallyReplayAndVerify(additionalMocks);1245        for (Object classToReplayOrVerify : MockRepository.getObjectsToAutomaticallyReplayAndVerify()) {1246            reset(classToReplayOrVerify);1247        }1248    }1249    /**1250     * Reset a list of class mocks.1251     */1252    public static synchronized void reset(Class<?>... classMocks) {1253        for (Class<?> type : classMocks) {1254            final MethodInvocationControl invocationHandler = MockRepository.getStaticMethodInvocationControl(type);1255            if (invocationHandler != null) {1256                invocationHandler.reset();1257            }1258            NewInvocationControl<?> newInvocationControl = MockRepository.getNewInstanceControl(type);1259            if (newInvocationControl != null) {1260                try {1261                    newInvocationControl.reset();1262                } catch (AssertionError e) {1263                    NewInvocationControlAssertionError.throwAssertionErrorForNewSubstitutionFailure(e, type);1264                }1265            }1266        }1267    }1268    /**1269     * Reset a list of mock objects or classes.1270     */1271    public static synchronized void reset(Object... mocks) {1272        try {1273            for (Object mock : mocks) {1274                if (mock instanceof Class<?>) {1275                    reset((Class<?>) mock);1276                } else {1277                    MethodInvocationControl invocationControl = MockRepository.getInstanceMethodInvocationControl(mock);1278                    if (invocationControl != null) {1279                        invocationControl.reset();1280                    } else {1281                        if (isNiceReplayAndVerifyMode() && !isEasyMocked(mock)) {1282                            // ignore non-mock1283                        } else {1284                            /*1285                                    * Delegate to easy mock class extension if we have1286                                    * no handler registered for this object.1287                                    */1288                            try {1289                                org.easymock.EasyMock.reset(mock);1290                            } catch (RuntimeException e) {1291                                throw new RuntimeException(mock + " is not a mock object", e);1292                            }1293                        }1294                    }1295                }1296            }1297        } catch (Throwable t) {1298            MockRepository.putAdditionalState(NICE_REPLAY_AND_VERIFY_KEY, false);1299            if (t instanceof RuntimeException) {1300                throw (RuntimeException) t;1301            } else if (t instanceof Error) {1302                throw (Error) t;1303            }1304            throw new RuntimeException(t);1305        }1306    }1307    /**1308     * Verify all classes and mock objects known by PowerMock. This includes all1309     * classes that are prepared for test using the {@link PrepareForTest} or1310     * {@link PrepareOnlyThisForTest} annotations and all classes that have had1311     * their static initializers removed by using the1312     * {@link SuppressStaticInitializationFor} annotation. It also includes all1313     * mock instances created by PowerMock such as those created or used by1314     * {@link #createMock(Class, Method...)},1315     * {@link #mockStatic(Class, Method...)},1316     * {@link #expectNew(Class, Object...)},1317     * {@link #createPartialMock(Class, String...)} etc.1318     * <p/>1319     * Note that all <tt>additionalMocks</tt> passed to the1320     * {@link #replayAll(Object...)} method are also verified here1321     * automatically.1322     */1323    public static synchronized void verifyAll() {1324        for (Object classToReplayOrVerify : MockRepository.getObjectsToAutomaticallyReplayAndVerify()) {1325            verify(classToReplayOrVerify);1326        }1327    }1328    /**1329     * Switches the mocks or classes to replay mode. Note that you must use this1330     * method when using PowerMock!1331     *1332     * @param mocks mock objects or classes loaded by PowerMock.1333     * @throws RuntimeException If something unexpected goes wrong.1334     */1335    public static synchronized void replay(Object... mocks) {1336        try {1337            for (Object mock : mocks) {1338                if (mock instanceof Class<?>) {1339                    replay((Class<?>) mock);1340                } else {1341                    MethodInvocationControl invocationControl = MockRepository.getInstanceMethodInvocationControl(mock);1342                    if (invocationControl != null) {1343                        invocationControl.replay();1344                    } else {1345                        if (isNiceReplayAndVerifyMode() && !isEasyMocked(mock)) {1346                            // ignore non-mock1347                        } else {1348                            /*1349                                    * Delegate to easy mock class extension if we have1350                                    * no handler registered for this object.1351                                    */1352                            try {1353                                org.easymock.EasyMock.replay(mock);1354                            } catch (RuntimeException e) {1355                                throw new RuntimeException(mock + " is not a mock object", e);1356                            }1357                        }1358                    }1359                }1360            }1361        } catch (Throwable t) {1362            MockRepository.putAdditionalState(NICE_REPLAY_AND_VERIFY_KEY, false);1363            if (t instanceof RuntimeException) {1364                throw (RuntimeException) t;1365            } else if (t instanceof Error) {1366                throw (Error) t;1367            }1368            throw new RuntimeException(t);1369        }1370    }1371    /**1372     * Switches the mocks or classes to verify mode. Note that you must use this1373     * method when using PowerMock!1374     *1375     * @param objects mock objects or classes loaded by PowerMock.1376     */1377    public static synchronized void verify(Object... objects) {1378        for (Object mock : objects) {1379            if (mock instanceof Class<?>) {1380                verifyClass((Class<?>) mock);1381            } else {1382                EasyMockMethodInvocationControl invocationControl = (EasyMockMethodInvocationControl) MockRepository.getInstanceMethodInvocationControl(mock);1383                if (invocationControl != null) {1384                    invocationControl.verify();1385                } else {1386                    if (isNiceReplayAndVerifyMode() && !isEasyMocked(mock)) {1387                        // ignore non-mock1388                    } else {1389                        /*1390                               * Delegate to easy mock class extension if we have no1391                               * handler registered for this object.1392                               */1393                        try {1394                            org.easymock.EasyMock.verify(mock);1395                        } catch (RuntimeException e) {1396                            throw new RuntimeException(mock + " is not a mock object", e);1397                        }1398                    }1399                }1400            }1401        }1402    }1403    /**1404     * Convenience method for createMock followed by expectNew.1405     *1406     * @param type      The class that should be mocked.1407     * @param arguments The constructor arguments.1408     * @return A mock object of the same type as the mock.1409     * @throws Exception1410     */1411    public static synchronized <T> T createMockAndExpectNew(Class<T> type, Object... arguments) throws Exception {1412        T mock = createMock(type);1413        expectNew(type, arguments).andReturn(mock);1414        return mock;1415    }1416    /**1417     * Convenience method for createMock followed by expectNew when PowerMock1418     * cannot determine which constructor to use automatically. This happens1419     * when you have one constructor taking a primitive type and another one1420     * taking the wrapper type of the primitive. For example {@code int}1421     * and {@code Integer}.1422     *1423     * @param type           The class that should be mocked.1424     * @param parameterTypes The constructor parameter types.1425     * @param arguments      The constructor arguments.1426     * @return A mock object of the same type as the mock.1427     * @throws Exception1428     */1429    public static synchronized <T> T createMockAndExpectNew(Class<T> type, Class<?>[] parameterTypes,1430                                                            Object... arguments) throws Exception {1431        T mock = createMock(type);1432        expectNew(type, parameterTypes, arguments).andReturn(mock);1433        return mock;1434    }1435    /**1436     * Convenience method for createNiceMock followed by expectNew.1437     *1438     * @param type      The class that should be mocked.1439     * @param arguments The constructor arguments.1440     * @return A mock object of the same type as the mock.1441     * @throws Exception1442     */1443    public static synchronized <T> T createNiceMockAndExpectNew(Class<T> type, Object... arguments) throws Exception {1444        T mock = createNiceMock(type);1445        IExpectationSetters<T> expectationSetters = expectNiceNew(type, arguments);1446        if (expectationSetters != null) {1447            expectationSetters.andReturn(mock);1448        }1449        return mock;1450    }1451    /**1452     * Convenience method for createNiceMock followed by expectNew when1453     * PowerMock cannot determine which constructor to use automatically. This1454     * happens when you have one constructor taking a primitive type and another1455     * one taking the wrapper type of the primitive. For example1456     * {@code int} and {@code Integer}.1457     *1458     * @param type           The class that should be mocked.1459     * @param parameterTypes The constructor parameter types.1460     * @param arguments      The constructor arguments.1461     * @return A mock object of the same type as the mock.1462     * @throws Exception1463     */1464    public static synchronized <T> T createNiceMockAndExpectNew(Class<T> type, Class<?>[] parameterTypes,1465                                                                Object... arguments) throws Exception {1466        T mock = createNiceMock(type);1467        IExpectationSetters<T> expectationSetters = expectNiceNew(type, parameterTypes, arguments);1468        if (expectationSetters != null) {1469            expectationSetters.andReturn(mock);1470        }1471        return mock;1472    }1473    /**1474     * Convenience method for createStrictMock followed by expectNew.1475     *1476     * @param type      The class that should be mocked.1477     * @param arguments The constructor arguments.1478     * @return A mock object of the same type as the mock.1479     * @throws Exception1480     */1481    public static synchronized <T> T createStrictMockAndExpectNew(Class<T> type, Object... arguments) throws Exception {1482        T mock = createStrictMock(type);1483        expectStrictNew(type, arguments).andReturn(mock);1484        return mock;1485    }1486    /**1487     * Convenience method for createStrictMock followed by expectNew when1488     * PowerMock cannot determine which constructor to use automatically. This1489     * happens when you have one constructor taking a primitive type and another1490     * one taking the wrapper type of the primitive. For example1491     * {@code int} and {@code Integer}.1492     *1493     * @param type           The class that should be mocked.1494     * @param parameterTypes The constructor parameter types.1495     * @param arguments      The constructor arguments.1496     * @return A mock object of the same type as the mock.1497     * @throws Exception1498     */1499    public static synchronized <T> T createStrictMockAndExpectNew(Class<T> type, Class<?>[] parameterTypes,1500                                                                  Object... arguments) throws Exception {1501        T mock = createStrictMock(type);1502        expectStrictNew(type, parameterTypes, arguments).andReturn(mock);1503        return mock;1504    }1505    /**1506     * Allows specifying expectations on new invocations. For example you might1507     * want to throw an exception or return a mock. Note that you must replay1508     * the class when using this method since this behavior is part of the class1509     * mock.1510     * <p/>1511     * Use this method when you need to specify parameter types for the1512     * constructor when PowerMock cannot determine which constructor to use1513     * automatically. In most cases you should use1514     * {@link #expectNew(Class, Object...)} instead.1515     */1516    public static synchronized <T> IExpectationSetters<T> expectNew(Class<T> type, Class<?>[] parameterTypes,1517                                                                    Object... arguments) throws Exception {1518        return doExpectNew(type, new DefaultMockStrategy(), parameterTypes, arguments);1519    }1520    @SuppressWarnings("unchecked")1521    private static <T> IExpectationSetters<T> doExpectNew(Class<T> type, MockStrategy mockStrategy,1522                                                          Class<?>[] parameterTypes, Object... arguments) throws Exception {1523        if (type == null) {1524            throw new IllegalArgumentException("type cannot be null");1525        } else if (mockStrategy == null) {1526            throw new IllegalArgumentException("Internal error: Mock strategy cannot be null");1527        }1528        final boolean isNiceMock = mockStrategy instanceof NiceMockStrategy;1529        final Class<T> unmockedType = (Class<T>) WhiteboxImpl.getOriginalUnmockedType(type);1530        if (!isNiceMock) {1531            if (parameterTypes == null) {1532                WhiteboxImpl.findUniqueConstructorOrThrowException(type, arguments);1533            } else {1534                WhiteboxImpl.getConstructor(unmockedType, parameterTypes);1535            }1536        }1537        /*1538           * Check if this type has been mocked before1539           */1540        NewInvocationControl<IExpectationSetters<T>> newInvocationControl = (NewInvocationControl<IExpectationSetters<T>>) MockRepository1541                .getNewInstanceControl(unmockedType);1542        if (newInvocationControl == null) {1543            InvocationSubstitute<T> mock = doMock(InvocationSubstitute.class, false, mockStrategy, null,1544                    (Method[]) null);1545            newInvocationControl = new EasyMockNewInvocationControl<T>(mock, type);1546            MockRepository.putNewInstanceControl(type, newInvocationControl);1547            MockRepository.addObjectsToAutomaticallyReplayAndVerify(WhiteboxImpl.getOriginalUnmockedType(type));1548        }1549        if (isNiceMock && (arguments == null || arguments.length == 0)) {1550            return null;1551        }1552        return newInvocationControl.expectSubstitutionLogic(arguments);1553    }1554    /**1555     * Allows specifying expectations on new invocations. For example you might1556     * want to throw an exception or return a mock. Note that you must replay1557     * the class when using this method since this behavior is part of the class1558     * mock.1559     */1560    public static synchronized <T> IExpectationSetters<T> expectNew(Class<T> type, Object... arguments)1561            throws Exception {1562        return doExpectNew(type, new DefaultMockStrategy(), null, arguments);1563    }1564    /**1565     * Allows specifying expectations on new invocations for private member1566     * (inner) classes, local or anonymous classes. For example you might want1567     * to throw an exception or return a mock. Note that you must replay the1568     * class when using this method since this behavior is part of the class1569     * mock.1570     *1571     * @param fullyQualifiedName The fully-qualified name of the inner/local/anonymous type to1572     *                           expect.1573     * @param arguments          Optional number of arguments.1574     */1575    @SuppressWarnings("unchecked")1576    public static synchronized <T> IExpectationSetters<T> expectNew(String fullyQualifiedName, Object... arguments)1577            throws Exception {1578        final Class<?> forName = Class.forName(fullyQualifiedName);1579        return (IExpectationSetters<T>) doExpectNew(forName, new DefaultMockStrategy(), null, arguments);1580    }1581    /**1582     * Allows specifying expectations on new invocations. For example you might1583     * want to throw an exception or return a mock.1584     * <p/>1585     * This method checks the order of constructor invocations.1586     * <p/>1587     * Note that you must replay the class when using this method since this1588     * behavior is part of the class mock.1589     */1590    public static synchronized <T> IExpectationSetters<T> expectStrictNew(Class<T> type, Object... arguments)1591            throws Exception {1592        return doExpectNew(type, new StrictMockStrategy(), null, arguments);1593    }1594    /**1595     * Allows specifying expectations on new invocations. For example you might1596     * want to throw an exception or return a mock. Note that you must replay1597     * the class when using this method since this behavior is part of the class1598     * mock.1599     * <p/>1600     * This method checks the order of constructor invocations.1601     * <p/>1602     * Use this method when you need to specify parameter types for the1603     * constructor when PowerMock cannot determine which constructor to use1604     * automatically. In most cases you should use1605     * {@link #expectNew(Class, Object...)} instead.1606     */1607    public static synchronized <T> IExpectationSetters<T> expectStrictNew(Class<T> type, Class<?>[] parameterTypes,1608                                                                          Object... arguments) throws Exception {1609        return doExpectNew(type, new StrictMockStrategy(), parameterTypes, arguments);1610    }1611    /**1612     * Allows specifying expectations on new invocations. For example you might1613     * want to throw an exception or return a mock.1614     * <p/>1615     * This method allows any number of calls to a new constructor without1616     * throwing an exception.1617     * <p/>1618     * Note that you must replay the class when using this method since this1619     * behavior is part of the class mock.1620     */1621    public static synchronized <T> IExpectationSetters<T> expectNiceNew(Class<T> type, Object... arguments)1622            throws Exception {1623        return doExpectNew(type, new NiceMockStrategy(), null, arguments);1624    }1625    /**1626     * Allows specifying expectations on new invocations. For example you might1627     * want to throw an exception or return a mock. Note that you must replay1628     * the class when using this method since this behavior is part of the class1629     * mock.1630     * <p/>1631     * This method allows any number of calls to a new constructor without1632     * throwing an exception.1633     * <p/>1634     * Use this method when you need to specify parameter types for the1635     * constructor when PowerMock cannot determine which constructor to use1636     * automatically. In most cases you should use1637     * {@link #expectNew(Class, Object...)} instead.1638     */1639    public static synchronized <T> IExpectationSetters<T> expectNiceNew(Class<T> type, Class<?>[] parameterTypes,1640                                                                        Object... arguments) throws Exception {1641        return doExpectNew(type, new NiceMockStrategy(), parameterTypes, arguments);1642    }1643    /**1644     * Suppress constructor calls on specific constructors only.1645     *1646     * @deprecated Use {@link #suppress(Constructor[])} instead.1647     */1648    @Deprecated1649    public static synchronized void suppressConstructor(Constructor<?>... constructors) {1650        SuppressCode.suppressConstructor(constructors);1651    }1652    /**1653     * This method can be used to suppress the code in a specific constructor.1654     *1655     * @param clazz          The class where the constructor is located.1656     * @param parameterTypes The parameter types of the constructor to suppress.1657     * @deprecated Use {@link #suppress(Constructor)} instead.1658     */1659    @Deprecated1660    public static synchronized void suppressSpecificConstructor(Class<?> clazz, Class<?>... parameterTypes) {1661        SuppressCode.suppressSpecificConstructor(clazz, parameterTypes);1662    }1663    /**1664     * Suppress all constructors in the given class and it's super classes.1665     *1666     * @param classes The classes whose constructors will be suppressed.1667     * @deprecated Use {@link #suppress(Constructor[])} instead.1668     */1669    @Deprecated1670    public static synchronized void suppressConstructor(Class<?>... classes) {1671        SuppressCode.suppressConstructor(classes);1672    }1673    /**1674     * Suppress all constructors in the given class.1675     *1676     * @param clazz                      The classes whose constructors will be suppressed.1677     * @param excludePrivateConstructors optionally keep code in private constructors1678     * @deprecated Use {@link #suppress(Constructor[])} instead.1679     */1680    @Deprecated1681    public static synchronized void suppressConstructor(Class<?> clazz, boolean excludePrivateConstructors) {1682        SuppressCode.suppressConstructor(clazz, excludePrivateConstructors);1683    }1684    /**1685     * Suppress specific fields. This works on both instance methods and static1686     * methods. Note that replay and verify are not needed as this is not part1687     * of a mock behavior.1688     *1689     * @deprecated Use {@link #suppress(Field[])} instead.1690     */1691    @Deprecated1692    public static synchronized void suppressField(Field... fields) {1693        SuppressCode.suppressField(fields);1694    }1695    /**1696     * Suppress all fields for these classes.1697     *1698     * @deprecated Use {@link #suppress(Field[])} instead.1699     */1700    @Deprecated1701    public static synchronized void suppressField(Class<?>[] classes) {1702        SuppressCode.suppressField(classes);1703    }1704    /**1705     * Suppress multiple methods for a class.1706     *1707     * @param clazz      The class whose methods will be suppressed.1708     * @param fieldNames The names of the methods that'll be suppressed. If field names1709     *                   are empty, <i>all</i> fields in the supplied class will be1710     *                   suppressed.1711     * @deprecated Use {@link #suppress(Field)} instead.1712     */1713    @Deprecated1714    public static synchronized void suppressField(Class<?> clazz, String... fieldNames) {1715        SuppressCode.suppressField(clazz, fieldNames);1716    }1717    /**1718     * Suppress specific method calls on all types containing this method. This1719     * works on both instance methods and static methods. Note that replay and1720     * verify are not needed as this is not part of a mock behavior.1721     *1722     * @deprecated Use {@link #suppress(Method[])} instead.1723     */1724    @Deprecated1725    public static synchronized void suppressMethod(Method... methods) {1726        SuppressCode.suppressMethod(methods);1727    }1728    /**1729     * Suppress all methods for these classes.1730     *1731     * @param cls               The first class whose methods will be suppressed.1732     * @param additionalClasses Additional classes whose methods will be suppressed.1733     * @deprecated Use {@link #suppress(Method[])} instead.1734     */1735    @Deprecated1736    public static synchronized void suppressMethod(Class<?> cls, Class<?>... additionalClasses) {1737        SuppressCode.suppressMethod(cls, additionalClasses);1738    }1739    /**1740     * Suppress all methods for these classes.1741     *1742     * @param classes Classes whose methods will be suppressed.1743     * @deprecated Use {@link #suppress(Method[])} instead.1744     */1745    @Deprecated1746    public static synchronized void suppressMethod(Class<?>[] classes) {1747        SuppressCode.suppressMethod(classes);1748    }1749    /**1750     * Suppress multiple methods for a class.1751     *1752     * @param clazz                 The class whose methods will be suppressed.1753     * @param methodName            The first method to be suppress in class {@code clazz}.1754     * @param additionalMethodNames Additional methods to suppress in class {@code clazz}.1755     * @deprecated Use {@link #suppress(Method[])} instead.1756     */1757    @Deprecated1758    public static synchronized void suppressMethod(Class<?> clazz, String methodName, String... additionalMethodNames) {1759        SuppressCode.suppressMethod(clazz, methodName, additionalMethodNames);1760    }1761    /**1762     * Suppress multiple methods for a class.1763     *1764     * @param clazz       The class whose methods will be suppressed.1765     * @param methodNames Methods to suppress in class {@code clazz}.1766     * @deprecated Use {@link #suppress(Method[])} instead.1767     */1768    @Deprecated1769    public static synchronized void suppressMethod(Class<?> clazz, String[] methodNames) {1770        SuppressCode.suppressMethod(clazz, methodNames);1771    }1772    /**1773     * Suppress all methods for this class.1774     *1775     * @param clazz                 The class which methods will be suppressed.1776     * @param excludePrivateMethods optionally not suppress private methods1777     * @deprecated Use {@link #suppress(Method[])} instead.1778     */1779    @Deprecated1780    public static synchronized void suppressMethod(Class<?> clazz, boolean excludePrivateMethods) {1781        SuppressCode.suppressMethod(clazz, excludePrivateMethods);1782    }1783    /**1784     * Suppress a specific method call. Use this for overloaded methods.1785     *1786     * @deprecated Use {@link #suppress(Method)} instead.1787     */1788    @Deprecated1789    public static synchronized void suppressMethod(Class<?> clazz, String methodName, Class<?>[] parameterTypes) {1790        SuppressCode.suppressMethod(clazz, methodName, parameterTypes);1791    }1792    @SuppressWarnings("unchecked")1793    private static <T> T doMock(Class<T> type, boolean isStatic, MockStrategy mockStrategy,1794                                ConstructorArgs constructorArgs, Method... methods) {1795        if (type == null) {1796            throw new IllegalArgumentException("The class to mock cannot be null");1797        }1798        /*1799         * Clear the EasyMock state after the test method is executed.1800         */1801        MockRepository.addAfterMethodRunner(new Runnable() {1802            @Override1803            public void run() {1804                LastControl.reportLastControl(null);1805            }1806        });1807        IMocksControl control = mockStrategy.createMockControl(type);1808        MockRepository.addAfterMethodRunner(new EasyMockStateCleaner());1809        T mock;1810        if (type.isInterface()) {1811            mock = control.createMock(type);1812        } else if (type.getName().startsWith("java.") && Modifier.isFinal(type.getModifiers())) {1813            Class<?> replicaType = createReplicaType(type, isStatic, constructorArgs);1814            final Object replica = doCreateMock(replicaType, constructorArgs, control, methods);1815            control = mockStrategy.createMockControl(replicaType);1816            MockInvocationHandler h = new MockInvocationHandler((MocksControl) control);1817            final Set<Method> methodsToMock = toSet(methods);1818            if (isStatic) {1819                MockRepository.putStaticMethodInvocationControl(type, new EasyMockMethodInvocationControl<Object>(h,1820                        methodsToMock, replica));1821                MockRepository.addObjectsToAutomaticallyReplayAndVerify(type);1822                return null;1823            } else {1824                final T newInstance;1825                if (constructorArgs == null) {1826                    newInstance = Whitebox.newInstance(type);1827                    DefaultFieldValueGenerator.fillWithDefaultValues(newInstance);1828                } else {1829                    try {1830                        newInstance = (T) constructorArgs.getConstructor().newInstance(constructorArgs.getInitArgs());1831                    } catch (Exception e) {1832                        throw new RuntimeException("Internal error", e);1833                    }1834                }1835                MockRepository.putInstanceMethodInvocationControl(newInstance,1836                        new EasyMockMethodInvocationControl<Object>(h, methodsToMock, replica));1837                if (!(newInstance instanceof InvocationSubstitute<?>)) {1838                    MockRepository.addObjectsToAutomaticallyReplayAndVerify(newInstance);1839                }1840                return newInstance;1841            }1842        } else {1843            mock = doCreateMock(type, constructorArgs, control, methods);1844        }1845        MockInvocationHandler h = new MockInvocationHandler((MocksControl) control);1846        final Set<Method> methodsToMock = toSet(methods);1847        if (isStatic) {1848            MockRepository.putStaticMethodInvocationControl(type, new EasyMockMethodInvocationControl<T>(h,1849                    methodsToMock, mock));1850            MockRepository.addObjectsToAutomaticallyReplayAndVerify(type);1851        } else {1852            MockRepository.putInstanceMethodInvocationControl(mock, new EasyMockMethodInvocationControl<T>(h,1853                    methodsToMock));1854            if (!(mock instanceof InvocationSubstitute<?>)) {1855                MockRepository.addObjectsToAutomaticallyReplayAndVerify(mock);1856            }1857        }1858        ClassLoader classLoader = mock.getClass().getClassLoader();1859        if (classLoader instanceof MockClassLoader) {1860            ((MockClassLoader) classLoader).cache(mock.getClass());1861        }1862        return mock;1863    }1864    private static <T> Class<?> createReplicaType(Class<T> type, boolean isStatic, ConstructorArgs constructorArgs) {1865        final ClassReplicaCreator classReplicaCreator = new ClassReplicaCreator();1866        final Class<?> replicaType;1867        if (isStatic || constructorArgs == null) {1868            replicaType = classReplicaCreator.createClassReplica(type);1869        } else {1870            try {1871                replicaType = classReplicaCreator.createInstanceReplica(constructorArgs.getConstructor().newInstance(1872                        constructorArgs.getInitArgs()));1873            } catch (RuntimeException e) {1874                throw e;1875            } catch (InvocationTargetException e) {1876                Throwable targetException = e.getTargetException();1877                if (targetException instanceof RuntimeException) {1878                    throw (RuntimeException) targetException;1879                }1880                throw new RuntimeException(e);1881            } catch (Exception e) {1882                throw new RuntimeException(e);1883            }1884        }1885        return replicaType;1886    }1887    private static <T> T doCreateMock(Class<T> type, ConstructorArgs constructorArgs, final IMocksControl control,1888                                      Method... methods) {1889        T mock;1890        MocksControl mocksControl = ((MocksControl) control);1891        if (constructorArgs == null) {1892            if (methods == null) {1893                mock = mocksControl.createMock(type);1894            } else {1895                mock = mocksControl.createMock(null, type, null, methods);1896            }1897        } else {1898            if (methods == null) {1899                mock = mocksControl.createMock(null, type, constructorArgs);1900            } else {1901                mock = mocksControl.createMock(null, type, constructorArgs, methods);1902            }1903        }1904        return mock;1905    }1906    private static Set<Method> toSet(Method[] methods) {1907        return methods == null ? null : new HashSet<Method>(Arrays.asList(methods));1908    }1909    private static Class<?>[] mergeArgumentTypes(Class<?> firstArgumentType, Class<?>... additionalArgumentTypes) {1910        if (firstArgumentType == null) {1911            return additionalArgumentTypes == null ? new Class<?>[0] : additionalArgumentTypes;1912        } else if (additionalArgumentTypes == null) {1913            additionalArgumentTypes = new Class<?>[0];1914        }1915        final Class<?>[] argumentTypes = new Class[additionalArgumentTypes.length + 1];1916        argumentTypes[0] = firstArgumentType;1917        if (additionalArgumentTypes.length != 0) {1918            System.arraycopy(additionalArgumentTypes, 0, argumentTypes, 1, additionalArgumentTypes.length);1919        }1920        return argumentTypes;1921    }1922    @SuppressWarnings("unchecked")1923    private static <T> IExpectationSetters<T> doExpectPrivate(Object instance, Method methodToExpect,1924                                                              Object... arguments) throws Exception {1925        WhiteboxImpl.performMethodInvocation(instance, methodToExpect, arguments);1926        return (IExpectationSetters<T>) org.easymock.EasyMock.expectLastCall();1927    }1928    private static synchronized void replay(Class<?>... types) {1929        for (Class<?> type : types) {1930            final MethodInvocationControl invocationHandler = MockRepository.getStaticMethodInvocationControl(type);1931            if (invocationHandler != null) {1932                invocationHandler.replay();1933            }1934            NewInvocationControl<?> newInvocationControl = MockRepository.getNewInstanceControl(type);1935            if (newInvocationControl != null) {1936                newInvocationControl.replay();1937            }...

doExpectPrivate

Using AI Code Generation

1PowerMock.doExpectPrivate(mockedObject, "privateMethod", new Class[]{String.class}, new Object[]{"test"})2  .andReturn("test");3PowerMock.doExpectPrivate(mockedObject, "privateMethod", new Class[]{String.class}, new Object[]{"test"})4  .andThrow(new Exception("test"));5PowerMock.doExpectPrivate(mockedObject, "privateMethod", new Class[]{String.class}, new Object[]{"test"})6  .andAnswer(new IAnswer<Object>() {7    public Object answer() throws Throwable {8      return "test";9    }10  });11PowerMock.doExpectPrivate(mockedObject, "privateMethod", new Class[]{String.class}, new Object[]{"test"})12  .andDelegateTo(new Object());13PowerMock.doExpectPrivate(mockedObject, "privateMethod", new Class[]{String.class}, new Object[]{"test"})14  .andVoid();15PowerMock.doExpectPrivate(mockedObject, "privateMethod", new Class[]{String.class}, new Object[]{"test"})16  .andVoidAnswer(new IVoidAnswer() {17    public void answer() throws Throwable {18    }19  });20PowerMock.doExpectPrivate(mockedObject, "privateMethod", new Class[]{String.class}, new Object[]{"test"})21  .andStubAnswer(new IAnswer<Object>() {22    public Object answer() throws Throwable {23      return "test";24    }25  });26PowerMock.doExpectPrivate(mockedObject, "privateMethod", new Class[]{String.class}, new Object[]{"test"})27  .andStubDelegateTo(new Object());28PowerMock.doExpectPrivate(mock

doExpectPrivate

Using AI Code Generation

1import static org.powermock.api.easymock.PowerMock.doExpectPrivate;2import java.lang.reflect.Method;3import java.util.List;4import org.easymock.EasyMock;5import org.junit.Test;6public class PowerMockExample {7	public void testPrivateMethod() throws Exception {8		PrivateMethodDemo demoMock = EasyMock.createMock(PrivateMethodDemo.class);9		PrivateMethodDemo demo = new PrivateMethodDemo();10		List<String> listMock = EasyMock.createMock(List.class);11		Method methodMock = EasyMock.createMock(Method.class);12		Object objectMock = EasyMock.createMock(Object.class);13		EasyMock.expect(demoMock.getPrivateMethod()).andReturn(methodMock);14		EasyMock.expect(methodMock.invoke(objectMock, listMock)).andReturn(null);15		EasyMock.replay(demoMock, listMock, methodMock, objectMock);

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.