KaneAI - World’s First E2E Software Testing Agent.Signup for Private Beta Join TestMu Conference

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

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

Source:PowerMock.java

...369           * The reason why we've split the first and "additional types" is370           * because it should not intervene with the mockAllExcept(type,371           * String...methodNames) method.372           */373        final Class<?>[] argumentTypes = mergeArgumentTypes(firstArgumentType, moreTypes);374        return createMock(type, WhiteboxImpl.getAllMethodsExcept(type, methodNameToExclude, argumentTypes));375    }376    /**377     * Mock all methods of a class except for a specific one nicely. Use this378     * method only if you have several overloaded methods.379     *380     * @param <T>                 The type of the mock.381     * @param type                The type that'll be used to create a mock instance.382     * @param methodNameToExclude The name of the method not to mock.383     * @param firstArgumentType   The type of the first parameter of the method not to mock384     * @param moreTypes           Optionally more parameter types that defines the method. Note385     *                            that this is only needed to separate overloaded methods.386     * @return A mock object of type <T>.387     */388    public static synchronized <T> T createNicePartialMockForAllMethodsExcept(Class<T> type,389                                                                              String methodNameToExclude, Class<?> firstArgumentType, Class<?>... moreTypes) {390        /*391           * The reason why we've split the first and "additional types" is392           * because it should not intervene with the mockAllExcept(type,393           * String...methodNames) method.394           */395        final Class<?>[] argumentTypes = mergeArgumentTypes(firstArgumentType, moreTypes);396        return createNiceMock(type, WhiteboxImpl.getAllMethodsExcept(type, methodNameToExclude, argumentTypes));397    }398    /**399     * Mock all methods of a class except for a specific one strictly. Use this400     * method only if you have several overloaded methods.401     *402     * @param <T>                 The type of the mock.403     * @param type                The type that'll be used to create a mock instance.404     * @param methodNameToExclude The name of the method not to mock.405     * @param firstArgumentType   The type of the first parameter of the method not to mock406     * @param moreTypes           Optionally more parameter types that defines the method. Note407     *                            that this is only needed to separate overloaded methods.408     * @return A mock object of type <T>.409     */410    public static synchronized <T> T createStrictPartialMockForAllMethodsExcept(Class<T> type,411                                                                                String methodNameToExclude, Class<?> firstArgumentType, Class<?>... moreTypes) {412        /*413           * The reason why we've split the first and "additional types" is414           * because it should not intervene with the mockAllExcept(type,415           * String...methodNames) method.416           */417        final Class<?>[] argumentTypes = mergeArgumentTypes(firstArgumentType, moreTypes);418        return createStrictMock(type, WhiteboxImpl.getAllMethodsExcept(type, methodNameToExclude, argumentTypes));419    }420    /**421     * Mock a single specific method. Use this to handle overloaded methods.422     *423     * @param <T>                     The type of the mock.424     * @param type                    The type that'll be used to create a mock instance.425     * @param methodNameToMock        The name of the method to mock426     * @param firstArgumentType       The type of the first parameter of the method to mock427     * @param additionalArgumentTypes Optionally more parameter types that defines the method. Note428     *                                that this is only needed to separate overloaded methods.429     * @return A mock object of type <T>.430     */431    public static synchronized <T> T createPartialMock(Class<T> type, String methodNameToMock,432                                                       Class<?> firstArgumentType, Class<?>... additionalArgumentTypes) {433        return doMockSpecific(type, new DefaultMockStrategy(), new String[]{methodNameToMock}, null,434                mergeArgumentTypes(firstArgumentType, additionalArgumentTypes));435    }436    /**437     * Strictly mock a single specific method. Use this to handle overloaded438     * methods.439     *440     * @param <T>                     The type of the mock.441     * @param type                    The type that'll be used to create a mock instance.442     * @param methodNameToMock        The name of the method to mock443     * @param firstArgumentType       The type of the first parameter of the method to mock444     * @param additionalArgumentTypes Optionally more parameter types that defines the method. Note445     *                                that this is only needed to separate overloaded methods.446     * @return A mock object of type <T>.447     */448    public static synchronized <T> T createStrictPartialMock(Class<T> type, String methodNameToMock,449                                                             Class<?> firstArgumentType, Class<?>... additionalArgumentTypes) {450        return doMockSpecific(type, new StrictMockStrategy(), new String[]{methodNameToMock}, null,451                mergeArgumentTypes(firstArgumentType, additionalArgumentTypes));452    }453    /**454     * Nicely mock a single specific method. Use this to handle overloaded455     * methods.456     *457     * @param <T>                     The type of the mock.458     * @param type                    The type that'll be used to create a mock instance.459     * @param methodNameToMock        The name of the method to mock460     * @param firstArgumentType       The type of the first parameter of the method to mock461     * @param additionalArgumentTypes Optionally more parameter types that defines the method. Note462     *                                that this is only needed to separate overloaded methods.463     * @return A mock object of type <T>.464     */465    public static synchronized <T> T createNicePartialMock(Class<T> type, String methodNameToMock,466                                                           Class<?> firstArgumentType, Class<?>... additionalArgumentTypes) {467        return doMockSpecific(type, new NiceMockStrategy(), new String[]{methodNameToMock}, null,468                mergeArgumentTypes(firstArgumentType, additionalArgumentTypes));469    }470    /**471     * Mock a single static method.472     *473     * @param clazz                   The class where the method is specified in.474     * @param methodNameToMock        The first argument475     * @param firstArgumentType       The first argument type.476     * @param additionalArgumentTypes Optional additional argument types.477     */478    public static synchronized void mockStaticPartial(Class<?> clazz, String methodNameToMock,479                                                      Class<?> firstArgumentType, Class<?>... additionalArgumentTypes) {480        doMockSpecific(clazz, new DefaultMockStrategy(), new String[]{methodNameToMock}, null,481                mergeArgumentTypes(firstArgumentType, additionalArgumentTypes));482    }483    /**484     * Mock a single static method (strict).485     *486     * @param clazz                   The class where the method is specified in.487     * @param methodNameToMock        The first argument488     * @param firstArgumentType       The first argument type.489     * @param additionalArgumentTypes Optional additional argument types.490     */491    public static synchronized void mockStaticPartialStrict(Class<?> clazz, String methodNameToMock,492                                                            Class<?> firstArgumentType, Class<?>... additionalArgumentTypes) {493        doMockSpecific(clazz, new StrictMockStrategy(), new String[]{methodNameToMock}, null,494                mergeArgumentTypes(firstArgumentType, additionalArgumentTypes));495    }496    /**497     * Mock a single static method (nice).498     *499     * @param clazz                   The class where the method is specified in.500     * @param methodNameToMock        The first argument501     * @param firstArgumentType       The first argument type.502     * @param additionalArgumentTypes Optional additional argument types.503     */504    public static synchronized void mockStaticPartialNice(Class<?> clazz, String methodNameToMock,505                                                          Class<?> firstArgumentType, Class<?>... additionalArgumentTypes) {506        doMockSpecific(clazz, new NiceMockStrategy(), new String[]{methodNameToMock}, null,507                mergeArgumentTypes(firstArgumentType, additionalArgumentTypes));508    }509    /**510     * A utility method that may be used to mock several <b>static</b> methods511     * in an easy way (by just passing in the method names of the method you512     * wish to mock). Note that you cannot uniquely specify a method to mock513     * using this method if there are several methods with the same name in514     * {@code type}. This method will mock ALL methods that match the515     * supplied name regardless of parameter types and signature. If this is the516     * case you should fall-back on using the517     * {@link #mockStatic(Class, Method...)} method instead.518     *519     * @param clazz       The class that contains the static methods that should be520     *                    mocked.521     * @param methodNames The names of the methods that should be mocked. If522     *                    {@code null}, then this method will have the same effect523     *                    as just calling {@link #mockStatic(Class, Method...)} with the524     *                    second parameter as {@code new Method[0]} (i.e. all525     *                    methods in that class will be mocked).526     */527    public static synchronized void mockStaticPartial(Class<?> clazz, String... methodNames) {528        mockStatic(clazz, Whitebox.getMethods(clazz, methodNames));529    }530    /**531     * A utility method that may be used to mock several <b>static</b> methods532     * (strict) in an easy way (by just passing in the method names of the533     * method you wish to mock). Note that you cannot uniquely specify a method534     * to mock using this method if there are several methods with the same name535     * in {@code type}. This method will mock ALL methods that match the536     * supplied name regardless of parameter types and signature. If this is the537     * case you should fall-back on using the538     * {@link #mockStaticStrict(Class, Method...)} method instead.539     *540     * @param clazz       The class that contains the static methods that should be541     *                    mocked.542     * @param methodNames The names of the methods that should be mocked. If543     *                    {@code null}, then this method will have the same effect544     *                    as just calling {@link #mockStatic(Class, Method...)} with the545     *                    second parameter as {@code new Method[0]} (i.e. all546     *                    methods in that class will be mocked).547     */548    public static synchronized void mockStaticPartialStrict(Class<?> clazz, String... methodNames) {549        mockStaticStrict(clazz, Whitebox.getMethods(clazz, methodNames));550    }551    /**552     * A utility method that may be used to mock several <b>static</b> methods553     * (nice) in an easy way (by just passing in the method names of the method554     * you wish to mock). Note that you cannot uniquely specify a method to mock555     * using this method if there are several methods with the same name in556     * {@code type}. This method will mock ALL methods that match the557     * supplied name regardless of parameter types and signature. If this is the558     * case you should fall-back on using the559     * {@link #mockStaticStrict(Class, Method...)} method instead.560     *561     * @param clazz       The class that contains the static methods that should be562     *                    mocked.563     * @param methodNames The names of the methods that should be mocked. If564     *                    {@code null}, then this method will have the same effect565     *                    as just calling {@link #mockStatic(Class, Method...)} with the566     *                    second parameter as {@code new Method[0]} (i.e. all567     *                    methods in that class will be mocked).568     */569    public static synchronized void mockStaticPartialNice(Class<?> clazz, String... methodNames) {570        mockStaticNice(clazz, Whitebox.getMethods(clazz, methodNames));571    }572    static <T> T doMockSpecific(Class<T> type, MockStrategy mockStrategy, String[] methodNamesToMock,573                                ConstructorArgs constructorArgs, Class<?>... argumentTypes) {574        List<Method> methods = new LinkedList<Method>();575        for (String methodName : methodNamesToMock) {576            methods.add(WhiteboxImpl.findMethodOrThrowException(type, methodName, argumentTypes));577        }578        final Method[] methodArray = methods.toArray(new Method[0]);579        if (WhiteboxImpl.areAllMethodsStatic(methodArray)) {580            if (mockStrategy instanceof DefaultMockStrategy) {581                mockStatic(type, methodArray);582            } else if (mockStrategy instanceof StrictMockStrategy) {583                mockStaticStrict(type, methodArray);584            } else {585                mockStaticNice(type, methodArray);586            }587            return null;588        }589        T mock = null;590        if (mockStrategy instanceof DefaultMockStrategy) {591            mock = createMock(type, constructorArgs, methodArray);592        } else if (mockStrategy instanceof StrictMockStrategy) {593            mock = createStrictMock(type, constructorArgs, methodArray);594        } else {595            mock = createNiceMock(type, constructorArgs, methodArray);596        }597        return mock;598    }599    /**600     * A utility method that may be used to mock several methods in an easy way601     * (by just passing in the method names of the method you wish to mock).602     * Note that you cannot uniquely specify a method to mock using this method603     * if there are several methods with the same name in {@code type}.604     * This method will mock ALL methods that match the supplied name regardless605     * of parameter types and signature. If this is the case you should606     * fall-back on using the {@link #createMock(Class, Method...)} method607     * instead.608     *609     * @param <T>         The type of the mock.610     * @param type        The type that'll be used to create a mock instance.611     * @param methodNames The names of the methods that should be mocked. If612     *                    {@code null}, then this method will have the same effect613     *                    as just calling {@link #createMock(Class, Method...)} with the614     *                    second parameter as {@code new Method[0]} (i.e. all615     *                    methods in that class will be mocked).616     * @return A mock object of type <T>.617     */618    public static synchronized <T> T createPartialMock(Class<T> type, String... methodNames) {619        return createMock(type, Whitebox.getMethods(type, methodNames));620    }621    /**622     * A utility method that may be used to mock several methods in an easy way623     * (by just passing in the method names of the method you wish to mock).624     * Note that you cannot uniquely specify a method to mock using this method625     * if there are several methods with the same name in {@code type}.626     * This method will mock ALL methods that match the supplied name regardless627     * of parameter types and signature. If this is the case you should628     * fall-back on using the {@link #createMock(Class, Method...)} method629     * instead.630     * <p/>631     * With this method you can specify where the class hierarchy the methods632     * are located. This is useful in, for example, situations where class A633     * extends B and both have a method called "mockMe" (A overrides B's mockMe634     * method) and you like to specify the only the "mockMe" method in B should635     * be mocked. "mockMe" in A should be left intact. In this case you should636     * do:637     * <p/>638     * <pre>639     * A tested = createPartialMock(A.class, B.class, &quot;mockMe&quot;);640     * </pre>641     *642     * @param <T>         The type of the mock.643     * @param type        The type that'll be used to create a mock instance.644     * @param where       Where in the class hierarchy the methods resides.645     * @param methodNames The names of the methods that should be mocked. If646     *                    {@code null}, then this method will have the same effect647     *                    as just calling {@link #createMock(Class, Method...)} with the648     *                    second parameter as {@code new Method[0]} (i.e. all649     *                    methods in that class will be mocked).650     * @return A mock object of type <T>.651     */652    public static synchronized <T> T createPartialMock(Class<T> type, Class<? super T> where, String... methodNames) {653        return createMock(type, Whitebox.getMethods(where, methodNames));654    }655    /**656     * A utility method that may be used to strictly mock several methods in an657     * easy way (by just passing in the method names of the method you wish to658     * mock). Note that you cannot uniquely specify a method to mock using this659     * method if there are several methods with the same name in660     * {@code type}. This method will mock ALL methods that match the661     * supplied name regardless of parameter types and signature. If this is the662     * case you should fall-back on using the663     * {@link #createMock(Class, Method...)} method instead.664     *665     * @param <T>         The type of the mock.666     * @param type        The type that'll be used to create a mock instance.667     * @param methodNames The names of the methods that should be mocked. If668     *                    {@code null}, then this method will have the same effect669     *                    as just calling {@link #createMock(Class, Method...)} with the670     *                    second parameter as {@code new Method[0]} (i.e. all671     *                    methods in that class will be mocked).672     * @return A mock object of type <T>.673     */674    public static synchronized <T> T createStrictPartialMock(Class<T> type, String... methodNames) {675        return createStrictMock(type, Whitebox.getMethods(type, methodNames));676    }677    /**678     * A utility method that may be used to strictly mock several methods in an679     * easy way (by just passing in the method names of the method you wish to680     * mock). Note that you cannot uniquely specify a method to mock using this681     * method if there are several methods with the same name in682     * {@code type}. This method will mock ALL methods that match the683     * supplied name regardless of parameter types and signature. If this is the684     * case you should fall-back on using the685     * {@link #createMock(Class, Method...)} method instead.686     * <p/>687     * With this method you can specify where the class hierarchy the methods688     * are located. This is useful in, for example, situations where class A689     * extends B and both have a method called "mockMe" (A overrides B's mockMe690     * method) and you like to specify the only the "mockMe" method in B should691     * be mocked. "mockMe" in A should be left intact. In this case you should692     * do:693     * <p/>694     * <pre>695     * A tested = createPartialMockStrict(A.class, B.class, &quot;mockMe&quot;);696     * </pre>697     *698     * @param <T>         The type of the mock.699     * @param type        The type that'll be used to create a mock instance.700     * @param where       Where in the class hierarchy the methods resides.701     * @param methodNames The names of the methods that should be mocked. If702     *                    {@code null}, then this method will have the same effect703     *                    as just calling {@link #createMock(Class, Method...)} with the704     *                    second parameter as {@code new Method[0]} (i.e. all705     *                    methods in that class will be mocked).706     * @return A mock object of type <T>.707     */708    public static synchronized <T> T createStrictPartialMock(Class<T> type, Class<? super T> where,709                                                             String... methodNames) {710        return createStrictMock(type, Whitebox.getMethods(where, methodNames));711    }712    /**713     * A utility method that may be used to nicely mock several methods in an714     * easy way (by just passing in the method names of the method you wish to715     * mock). Note that you cannot uniquely specify a method to mock using this716     * method if there are several methods with the same name in717     * {@code type}. This method will mock ALL methods that match the718     * supplied name regardless of parameter types and signature. If this is the719     * case you should fall-back on using the720     * {@link #createMock(Class, Method...)} method instead.721     *722     * @param <T>         The type of the mock.723     * @param type        The type that'll be used to create a mock instance.724     * @param methodNames The names of the methods that should be mocked. If725     *                    {@code null}, then this method will have the same effect726     *                    as just calling {@link #createMock(Class, Method...)} with the727     *                    second parameter as {@code new Method[0]} (i.e. all728     *                    methods in that class will be mocked).729     * @return A mock object of type <T>.730     */731    public static synchronized <T> T createNicePartialMock(Class<T> type, String... methodNames) {732        return createNiceMock(type, Whitebox.getMethods(type, methodNames));733    }734    /**735     * A utility method that may be used to nicely mock several methods in an736     * easy way (by just passing in the method names of the method you wish to737     * mock). Note that you cannot uniquely specify a method to mock using this738     * method if there are several methods with the same name in739     * {@code type}. This method will mock ALL methods that match the740     * supplied name regardless of parameter types and signature. If this is the741     * case you should fall-back on using the742     * {@link #createMock(Class, Method...)} method instead.743     * <p/>744     * With this method you can specify where the class hierarchy the methods745     * are located. This is useful in, for example, situations where class A746     * extends B and both have a method called "mockMe" (A overrides B's mockMe747     * method) and you like to specify the only the "mockMe" method in B should748     * be mocked. "mockMe" in A should be left intact. In this case you should749     * do:750     * <p/>751     * <pre>752     * A tested = createPartialMockNice(A.class, B.class, &quot;mockMe&quot;);753     * </pre>754     *755     * @param <T>         The type of the mock.756     * @param type        The type that'll be used to create a mock instance.757     * @param where       Where in the class hierarchy the methods resides.758     * @param methodNames The names of the methods that should be mocked. If759     *                    {@code null}, then this method will have the same effect760     *                    as just calling {@link #createMock(Class, Method...)} with the761     *                    second parameter as {@code new Method[0]} (i.e. all762     *                    methods in that class will be mocked).763     * @return A mock object of type <T>.764     */765    public static synchronized <T> T createNicePartialMock(Class<T> type, Class<? super T> where, String... methodNames) {766        return createNiceMock(type, Whitebox.getMethods(where, methodNames));767    }768    /**769     * A utility method that may be used to mock several methods in an easy way770     * (by just passing in the method names of the method you wish to mock). The771     * mock object created will support mocking of final methods and invokes the772     * default constructor (even if it's private).773     *774     * @param <T>         the type of the mock object775     * @param type        the type of the mock object776     * @param methodNames The names of the methods that should be mocked. If777     *                    {@code null}, then this method will have the same effect778     *                    as just calling {@link #createMock(Class, Method...)} with the779     *                    second parameter as {@code new Method[0]} (i.e. all780     *                    methods in that class will be mocked).781     * @return the mock object.782     */783    public static <T> T createPartialMockAndInvokeDefaultConstructor(Class<T> type, String... methodNames)784            throws Exception {785        return createMock(type, new ConstructorArgs(Whitebox.getConstructor(type)),786                Whitebox.getMethods(type, methodNames));787    }788    /**789     * A utility method that may be used to nicely mock several methods in an790     * easy way (by just passing in the method names of the method you wish to791     * mock). The mock object created will support mocking of final methods and792     * invokes the default constructor (even if it's private).793     *794     * @param <T>         the type of the mock object795     * @param type        the type of the mock object796     * @param methodNames The names of the methods that should be mocked. If797     *                    {@code null}, then this method will have the same effect798     *                    as just calling {@link #createMock(Class, Method...)} with the799     *                    second parameter as {@code new Method[0]} (i.e. all800     *                    methods in that class will be mocked).801     * @return the mock object.802     */803    public static <T> T createNicePartialMockAndInvokeDefaultConstructor(Class<T> type, String... methodNames)804            throws Exception {805        return createNiceMock(type, new ConstructorArgs(Whitebox.getConstructor(type)),806                Whitebox.getMethods(type, methodNames));807    }808    /**809     * A utility method that may be used to strictly mock several methods in an810     * easy way (by just passing in the method names of the method you wish to811     * mock). The mock object created will support mocking of final methods and812     * invokes the default constructor (even if it's private).813     *814     * @param <T>         the type of the mock object815     * @param type        the type of the mock object816     * @param methodNames The names of the methods that should be mocked. If817     *                    {@code null}, then this method will have the same effect818     *                    as just calling {@link #createMock(Class, Method...)} with the819     *                    second parameter as {@code new Method[0]} (i.e. all820     *                    methods in that class will be mocked).821     * @return the mock object.822     */823    public static <T> T createStrictPartialMockAndInvokeDefaultConstructor(Class<T> type, String... methodNames)824            throws Exception {825        return createStrictMock(type, new ConstructorArgs(Whitebox.getConstructor(type)),826                Whitebox.getMethods(type, methodNames));827    }828    /**829     * A utility method that may be used to mock several methods in an easy way830     * (by just passing in the method names of the method you wish to mock). The831     * mock object created will support mocking of final and native methods and832     * invokes a specific constructor based on the supplied argument values.833     *834     * @param <T>                  the type of the mock object835     * @param type                 the type of the mock object836     * @param methodNames          The names of the methods that should be mocked. If837     *                             {@code null}, then this method will have the same effect838     *                             as just calling {@link #createMock(Class, Method...)} with the839     *                             second parameter as {@code new Method[0]} (i.e. all840     *                             methods in that class will be mocked).841     * @param constructorArguments The constructor arguments that will be used to invoke a842     *                             certain constructor. (optional)843     * @return the mock object.844     */845    public static <T> T createPartialMock(Class<T> type, String[] methodNames, Object... constructorArguments) {846        Constructor<?> constructor = WhiteboxImpl.findUniqueConstructorOrThrowException(type, constructorArguments);847        ConstructorArgs constructorArgs = new ConstructorArgs(constructor, constructorArguments);848        return doMock(type, false, new DefaultMockStrategy(), constructorArgs, Whitebox.getMethods(type, methodNames));849    }850    /**851     * * A utility method that may be used to strictly mock several methods in852     * an easy way (by just passing in the method names of the method you wish853     * to mock). The mock object created will support mocking of final and854     * native methods and invokes a specific constructor based on the supplied855     * argument values.856     *857     * @param <T>                  the type of the mock object858     * @param type                 the type of the mock object859     * @param methodNames          The names of the methods that should be mocked. If860     *                             {@code null}, then this method will have the same effect861     *                             as just calling {@link #createMock(Class, Method...)} with the862     *                             second parameter as {@code new Method[0]} (i.e. all863     *                             methods in that class will be mocked).864     * @param constructorArguments The constructor arguments that will be used to invoke a865     *                             certain constructor. (optional)866     * @return the mock object.867     */868    public static <T> T createStrictPartialMock(Class<T> type, String[] methodNames, Object... constructorArguments) {869        Constructor<?> constructor = WhiteboxImpl.findUniqueConstructorOrThrowException(type, constructorArguments);870        ConstructorArgs constructorArgs = new ConstructorArgs(constructor, constructorArguments);871        return doMock(type, false, new StrictMockStrategy(), constructorArgs, Whitebox.getMethods(type, methodNames));872    }873    /**874     * * A utility method that may be used to nicely mock several methods in an875     * easy way (by just passing in the method names of the method you wish to876     * mock). The mock object created will support mocking of final and native877     * methods and invokes a specific constructor based on the supplied argument878     * values.879     *880     * @param <T>                  the type of the mock object881     * @param type                 the type of the mock object882     * @param methodNames          The names of the methods that should be mocked. If883     *                             {@code null}, then this method will have the same effect884     *                             as just calling {@link #createMock(Class, Method...)} with the885     *                             second parameter as {@code new Method[0]} (i.e. all886     *                             methods in that class will be mocked).887     * @param constructorArguments The constructor arguments that will be used to invoke a888     *                             certain constructor. (optional)889     * @return the mock object.890     */891    public static <T> T createNicePartialMock(Class<T> type, String[] methodNames, Object... constructorArguments) {892        Constructor<?> constructor = WhiteboxImpl.findUniqueConstructorOrThrowException(type, constructorArguments);893        ConstructorArgs constructorArgs = new ConstructorArgs(constructor, constructorArguments);894        return doMock(type, false, new NiceMockStrategy(), constructorArgs, Whitebox.getMethods(type, methodNames));895    }896    /**897     * A utility method that may be used to mock several methods in an easy way898     * (by just passing in the method names of the method you wish to mock). Use899     * this to handle overloaded methods. The mock object created will support900     * mocking of final and native methods and invokes a specific constructor901     * based on the supplied argument values.902     *903     * @param <T>                  the type of the mock object904     * @param type                 the type of the mock object905     * @param methodName           The names of the methods that should be mocked. If906     *                             {@code null}, then this method will have the same effect907     *                             as just calling {@link #createMock(Class, Method...)} with the908     *                             second parameter as {@code new Method[0]} (i.e. all909     *                             methods in that class will be mocked).910     * @param methodParameterTypes Parameter types that defines the method. Note that this is911     *                             only needed to separate overloaded methods.912     * @param constructorArguments The constructor arguments that will be used to invoke a913     *                             certain constructor. (optional)914     * @return the mock object.915     */916    public static <T> T createPartialMock(Class<T> type, String methodName, Class<?>[] methodParameterTypes,917                                          Object... constructorArguments) {918        Constructor<?> constructor = WhiteboxImpl.findUniqueConstructorOrThrowException(type, constructorArguments);919        ConstructorArgs constructorArgs = new ConstructorArgs(constructor, constructorArguments);920        return doMockSpecific(type, new DefaultMockStrategy(), new String[]{methodName}, constructorArgs,921                methodParameterTypes);922    }923    /**924     * A utility method that may be used to strictly mock several methods in an925     * easy way (by just passing in the method names of the method you wish to926     * mock). Use this to handle overloaded methods. The mock object created927     * will support mocking of final and native methods and invokes a specific928     * constructor based on the supplied argument values.929     *930     * @param <T>                  the type of the mock object931     * @param type                 the type of the mock object932     * @param methodName           The names of the methods that should be mocked. If933     *                             {@code null}, then this method will have the same effect934     *                             as just calling {@link #createMock(Class, Method...)} with the935     *                             second parameter as {@code new Method[0]} (i.e. all936     *                             methods in that class will be mocked).937     * @param methodParameterTypes Parameter types that defines the method. Note that this is938     *                             only needed to separate overloaded methods.939     * @param constructorArguments The constructor arguments that will be used to invoke a940     *                             certain constructor. (optional)941     * @return the mock object.942     */943    public static <T> T createStrictPartialMock(Class<T> type, String methodName, Class<?>[] methodParameterTypes,944                                                Object... constructorArguments) {945        Constructor<?> constructor = WhiteboxImpl.findUniqueConstructorOrThrowException(type, constructorArguments);946        ConstructorArgs constructorArgs = new ConstructorArgs(constructor, constructorArguments);947        return doMockSpecific(type, new StrictMockStrategy(), new String[]{methodName}, constructorArgs,948                methodParameterTypes);949    }950    /**951     * A utility method that may be used to nicely mock several methods in an952     * easy way (by just passing in the method names of the method you wish to953     * mock). Use this to handle overloaded methods. The mock object created954     * will support mocking of final and native methods and invokes a specific955     * constructor based on the supplied argument values.956     *957     * @param <T>                  the type of the mock object958     * @param type                 the type of the mock object959     * @param methodName           The names of the methods that should be mocked. If960     *                             {@code null}, then this method will have the same effect961     *                             as just calling {@link #createMock(Class, Method...)} with the962     *                             second parameter as {@code new Method[0]} (i.e. all963     *                             methods in that class will be mocked).964     * @param methodParameterTypes Parameter types that defines the method. Note that this is965     *                             only needed to separate overloaded methods.966     * @param constructorArguments The constructor arguments that will be used to invoke a967     *                             certain constructor. (optional)968     * @return the mock object.969     */970    public static <T> T createNicePartialMock(Class<T> type, String methodName, Class<?>[] methodParameterTypes,971                                              Object... constructorArguments) {972        Constructor<?> constructor = WhiteboxImpl.findUniqueConstructorOrThrowException(type, constructorArguments);973        ConstructorArgs constructorArgs = new ConstructorArgs(constructor, constructorArguments);974        return doMockSpecific(type, new NiceMockStrategy(), new String[]{methodName}, constructorArgs,975                methodParameterTypes);976    }977    /**978     * A utility method that may be used to mock several methods in an easy way979     * (by just passing in the method names of the method you wish to mock). Use980     * this to handle overloaded methods <i>and</i> overloaded constructors. The981     * mock object created will support mocking of final and native methods and982     * invokes a specific constructor based on the supplied argument values.983     *984     * @param <T>                       the type of the mock object985     * @param type                      the type of the mock object986     * @param methodName                The names of the methods that should be mocked. If987     *                                  {@code null}, then this method will have the same effect988     *                                  as just calling {@link #createMock(Class, Method...)} with the989     *                                  second parameter as {@code new Method[0]} (i.e. all990     *                                  methods in that class will be mocked).991     * @param methodParameterTypes      Parameter types that defines the method. Note that this is992     *                                  only needed to separate overloaded methods.993     * @param constructorArguments      The constructor arguments that will be used to invoke a994     *                                  certain constructor.995     * @param constructorParameterTypes Parameter types that defines the constructor that should be996     *                                  invoked. Note that this is only needed to separate overloaded997     *                                  constructors.998     * @return the mock object.999     */1000    public static <T> T createPartialMock(Class<T> type, String methodName, Class<?>[] methodParameterTypes,1001                                          Object[] constructorArguments, Class<?>[] constructorParameterTypes) {1002        ConstructorArgs constructorArgs = new ConstructorArgs(Whitebox.getConstructor(type, constructorParameterTypes),1003                constructorArguments);1004        return doMockSpecific(type, new DefaultMockStrategy(), new String[]{methodName}, constructorArgs,1005                methodParameterTypes);1006    }1007    /**1008     * A utility method that may be used to strictly mock several methods in an1009     * easy way (by just passing in the method names of the method you wish to1010     * mock). Use this to handle overloaded methods <i>and</i> overloaded1011     * constructors. The mock object created will support mocking of final and1012     * native methods and invokes a specific constructor based on the supplied1013     * argument values.1014     *1015     * @param <T>                       the type of the mock object1016     * @param type                      the type of the mock object1017     * @param methodName                The names of the methods that should be mocked. If1018     *                                  {@code null}, then this method will have the same effect1019     *                                  as just calling {@link #createMock(Class, Method...)} with the1020     *                                  second parameter as {@code new Method[0]} (i.e. all1021     *                                  methods in that class will be mocked).1022     * @param methodParameterTypes      Parameter types that defines the method. Note that this is1023     *                                  only needed to separate overloaded methods.1024     * @param constructorArguments      The constructor arguments that will be used to invoke a1025     *                                  certain constructor.1026     * @param constructorParameterTypes Parameter types that defines the constructor that should be1027     *                                  invoked. Note that this is only needed to separate overloaded1028     *                                  constructors.1029     * @return the mock object.1030     */1031    public static <T> T createStrictPartialMock(Class<T> type, String methodName, Class<?>[] methodParameterTypes,1032                                                Object[] constructorArguments, Class<?>[] constructorParameterTypes) {1033        ConstructorArgs constructorArgs = new ConstructorArgs(Whitebox.getConstructor(type, constructorParameterTypes),1034                constructorArguments);1035        return doMockSpecific(type, new StrictMockStrategy(), new String[]{methodName}, constructorArgs,1036                methodParameterTypes);1037    }1038    /**1039     * A utility method that may be used to nicely mock several methods in an1040     * easy way (by just passing in the method names of the method you wish to1041     * mock). Use this to handle overloaded methods <i>and</i> overloaded1042     * constructors. The mock object created will support mocking of final and1043     * native methods and invokes a specific constructor based on the supplied1044     * argument values.1045     *1046     * @param <T>                       the type of the mock object1047     * @param type                      the type of the mock object1048     * @param methodName                The names of the methods that should be mocked. If1049     *                                  {@code null}, then this method will have the same effect1050     *                                  as just calling {@link #createMock(Class, Method...)} with the1051     *                                  second parameter as {@code new Method[0]} (i.e. all1052     *                                  methods in that class will be mocked).1053     * @param methodParameterTypes      Parameter types that defines the method. Note that this is1054     *                                  only needed to separate overloaded methods.1055     * @param constructorArguments      The constructor arguments that will be used to invoke a1056     *                                  certain constructor.1057     * @param constructorParameterTypes Parameter types that defines the constructor that should be1058     *                                  invoked. Note that this is only needed to separate overloaded1059     *                                  constructors.1060     * @return the mock object.1061     */1062    public static <T> T createNicePartialMock(Class<T> type, String methodName, Class<?>[] methodParameterTypes,1063                                              Object[] constructorArguments, Class<?>[] constructorParameterTypes) {1064        ConstructorArgs constructorArgs = new ConstructorArgs(Whitebox.getConstructor(type, constructorParameterTypes),1065                constructorArguments);1066        return doMockSpecific(type, new NiceMockStrategy(), new String[]{methodName}, constructorArgs,1067                methodParameterTypes);1068    }1069    /**1070     * Used to specify expectations on private static methods. If possible use1071     * 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,...

mergeArgumentTypes

Using AI Code Generation

1package com.powermock.demo;2import org.junit.Test;3import org.junit.runner.RunWith;4import org.powermock.api.easymock.PowerMock;5import org.powermock.core.classloader.annotations.PrepareForTest;6import org.powermock.modules.junit4.PowerMockRunner;7import static org.easymock.EasyMock.expect;8import static org.junit.Assert.assertEquals;9@RunWith(PowerMockRunner.class)10@PrepareForTest( { StaticMethod.class })11public class EasyMockMergeArgumentTypesTest {12    public void testMergeArgumentTypes() {13        StaticMethod mock = PowerMock.createMock(StaticMethod.class);14        expect(mock.mergeArgumentTypes(1, 2)).andReturn(3);15        PowerMock.replayAll();16        assertEquals(3, mock.mergeArgumentTypes(1, 2));17        PowerMock.verifyAll();18    }19}20package com.powermock.demo;21public class StaticMethod {22    public static int mergeArgumentTypes(int a, int b) {23        return a + b;24    }25}

mergeArgumentTypes

Using AI Code Generation

1import static org.powermock.api.easymock.PowerMock.*;2import org.powermock.api.easymock.PowerMock;3import org.powermock.api.easymock.annotation.Mock;4import java.lang.reflect.Method;5import org.junit.Test;6import org.junit.runner.RunWith;7import org.powermock.core.classloader.annotations.PrepareForTest;8import org.powermock.modules.junit4.PowerMockRunner;9@RunWith(PowerMockRunner.class)10@PrepareForTest({PowerMock.class})11public class ExampleTest {12    private Example example;13    public void testExample() throws Exception {14        Method method = Example.class.getMethod("add", int.class, int.class);15        Method realMethod = Example.class.getMethod("add", int.class, int.class);16        Class<?>[] argumentTypes = mergeArgumentTypes(method, realMethod);17        expectPrivate(example, method, argumentTypes, 1, 2).andCallRealMethod();18        replayAll();19        assertEquals(3, example.add(1, 2));20        verifyAll();21    }22}

mergeArgumentTypes

Using AI Code Generation

1import org.powermock.api.easymock.annotation.Mock;2import org.powermock.api.easymock.annotation.MockNice;3import org.powermock.api.easymock.annotation.MockStrict;4import org.powermock.api.easymock.annotation.MockUp;5import java.util.List;6public class ClassWithOverloadedMethods {7    public void overloadedMethod(int a) {8    }9    public void overloadedMethod(String a) {10    }11    public void overloadedMethod(List<String> a) {12    }13    public void overloadedMethod(String a, String b) {14    }15    public void overloadedMethod(String a, String b, String c) {16    }17    public void overloadedMethod(String a, String b, String c, String d) {18    }19    public void overloadedMethod(String a, String b, String c, String d, String e) {20    }21    public void overloadedMethod(String a, String b, String c, String d, String e, String f) {22    }23    public void overloadedMethod(String a, String b, String c, String d, String e, String f, String g) {24    }25    public void overloadedMethod(String a, String b, String c, String d, String e, String f, String g, String h) {26    }27    public void overloadedMethod(String a, String b, String c, String d, String e, String f, String g, String h, String i) {28    }29    public void overloadedMethod(String a, String b, String c, String d, String e, String f, String g, String h, String i, String j) {30    }31    public void overloadedMethod(String a, String b, String c, String d, String e, String f, String g, String h, String i, String j, String k) {32    }

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.