JDK17、Junit5下的PowerMock平替

最新推荐文章于 2025-02-16 11:00:10 发布
最新推荐文章于 2025-02-16 11:00:10 发布
阅读量1k 收藏 18
点赞数 24
文章标签： java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53025743/article/details/144798707
版权

自制PowerMock功能介绍

在升级到JDK17以及Junit5之后，原来的powermock相关的静态方法和私有方法的API接口不能使用了，给迁移代码带来了极大的阻力。

其中影响最大的分别是静态公有方法的mock和私有方法的执行。于是自研了替代powerMock主要功能的代码。

原有的PowerMock的API的使用：

静态类mock:
	PowerMockito.mockStatic(RedisLock.class);
	PowerMockito.mockStatic(RedisClient.class,RedisLock.class,XXX.class...);
静态方法mock：
    Mockito.when(RedisClient.getJedis()).thenReturn(jedis);
私有静态不可变属性设置：
	Whitebox.setInternalState(RedisLock.class, "LOG", LOG);
私有方法唤醒：
    Whitebox.invokeMethod(RedisLock.class, "renewExpiration", "lockNo101", "lv101", 30000L);        
静态方法验证：
	PowerMockito.verifyStatic(RedisClient.class, atLeast(1));
	RedisClient.returnRedis(jedis);

本着最小程度改变之前用户习惯的原则，新建的类分别以powerMock原来的类PowerMockito和WhiteBox为名，接口也极力接近原来的定义。先展示下最终的成果：

静态类mock--不变
	PowerMockito.mockStatic(RedisLock.class);
	PowerMockito.mockStatic(RedisClient.class,RedisLock.class,XXX.class...);
静态方法mock--不变
    Mockito.when(RedisClient.getJedis()).thenReturn(jedis);
私有静态不可变属性设置--不变
	Whitebox.setInternalState(RedisLock.class, "LOG", LOG);
私有方法唤醒--不变
    Whitebox.invokeMethod(RedisLock.class, "renewExpiration", "lockNo101", "lv101", 30000L);        
静态方法验证--合理改变
	PowerMockito.verifyStatic(RedisClient.class, atLeast(1));
	RedisClient.returnRedis(jedis);
改变后的写法：
PowerMockito.verifyStatic(RedisClient.class, atLeast(1),RedisClient.returnRedis(jedis));

可以看出，在重新修改后，原来代码需要修改的部分非常小。也许，看到这儿你可能会质疑，Junit5中Mockito不是自带了个static类的mock吗，何必麻烦呢？

此时，我们可以使用Mockito自带的mock静态类的方法来对比看看。依旧是以上诉几种情况的对比

静态类mock:
	PowerMockito.mockStatic(RedisLock.class);
	PowerMockito.mockStatic(RedisClient.class,RedisLock.class,XXX.class...);
    try (MockedStatic<RedisLock> mocked0 = mockStatic(RedisLock.class);){
        ...
    }
    try (MockedStatic<RedisLock> mocked0 = mockStatic(RedisLock.class);
        MockedStatic<RedisClient> mocked1 = mockStatic(RedisClient.class);
        ){
        ...
    }
静态方法mock：
    try (MockedStatic<RedisClient> mocked0 = mockStatic(RedisClient.class);){
        mocked0.when(()->RedisClient.getJedis()).thenReturn(jedis);
    }
私有静态不可变属性设置：
	Whitebox.setInternalState(RedisLock.class,RedisLock.class, "LOG", LOG);
私有方法唤醒：
    Whitebox.invokeMethod(RedisLock.class, "renewExpiration", "lockNo101", "lv101", 30000L);        
静态方法验证：
     try (MockedStatic<RedisClient> mocked0 = mockStatic(RedisClient.class);){
        mocked0.verify(()->RedisClient.getJedis(), atLeast(1));
    }

这儿区别已经不小了，如果觉得还不够大，让我们看看个微服务中的实例，下面是我截取了某个域内服务使用Mockito原生写的代码：

@ExtendWith(MockitoExtension.class)
public class DeliveryServiceTaskTest {
    MockedStatic<EnvVariable> aStatic1;
    MockedStatic<ConfigUtils> aStatic2;
    MockedStatic<LockUtil> aStatic3;
    MockedStatic<DRMClient> aStatic4;
    
    @BeforeEach
    public void init() throws Exception {
        DistributedResourceManager manager = Mockito.mock(DistributedResourceManager.class);
        aStatic4.when(()->DRMClient.getInstance()).thenReturn(manager);
        Whitebox.setInternalState(SpringContextHelper.class,SpringContextHelper.class,"context",context);
        mockSystemProperty();
    }
    
    @AfterEach
    public void after() {
        aStatic1.close();
        aStatic2.close();
        aStatic3.close();
    }
    
    @Test
    public void should_not_sendEvent_as_trylock_false() {
        DeliveryServiceTask deliveryTaskSpy = Mockito.spy(deliveryServiceTask);
        try (MockedStatic<LockUtil> mocked0 = mockStatic(LockUtil.class);
            MockedStatic<ConfigUtils> mocked1 = mockStatic(ConfigUtils.class)) {
            mocked0.when(() -> LockUtil.tryLock(Mockito.any(ElasticLockWarp.class))).thenReturn(true);
            Mockito.when(LockUtil.tryLock(Mockito.any(ElasticLockWarp.class))).thenReturn(false);

            deliveryTaskSpy.start();

            Mockito.verify(deliveryTaskSpy, never()).sendEvent(Mockito.any(), Mockito.any());
        }
    }

可以很容易看出以上代码不仅臃肿，而且可读性极差，原因在于具体到某个静态类的mock，需要给其费尽心思取个名，在测试结束后，还需要去将mock的资源全部释放掉。很容易想象到，一旦代码里面mock的静态类多了之后，如果采用预先mock，事后释放资源的方式，这样极容易忘记释放某个资源(比如例子中就少释放了一个资源)，要么try-with-source写出难看的一大坨。本来测试第一要义就是可读性，结果还搞得如此难以描述。熟悉我们微服务的代码的人都知道，一个测试类里极有可能要mock十几个静态类，可以想象这种情况代码能有多糟糕。当然，这里还要额外批判一下，如果一个类需要mock十几个静态类，足以说明这个类写的有多差劲。

可以看看这个例子修改后的版本

@ExtendWith(MockitoExtension.class,MockitoStaticExtension.class)
public class DeliveryServiceTaskTest {
    @BeforeEach
    public void init() throws Exception {
        PowerMockito.mockStatic(EnvVariable.class,ConfigUtils.class,LockUtil.class,DRMClient.class)
        DistributedResourceManager manager = Mockito.mock(DistributedResourceManager.class);
        Mockito.when(DRMClient.getInstance()).thenReturn(manager);
        Whitebox.setInternalState(SpringContextHelper.class,"context",context);
    }  
    
    @Test
    public void should_not_sendEvent_as_trylock_false() {
        DeliveryServiceTask deliveryTaskSpy = Mockito.spy(deliveryServiceTask);
        Mockito.when(LockUtil.tryLock(Mockito.any(ElasticLockWarp.class))).thenReturn(true);
        Mockito.when(LockUtil.tryLock(Mockito.any(ElasticLockWarp.class))).thenReturn(false);
        
        deliveryTaskSpy.start();
        
        Mockito.verify(deliveryTaskSpy, never()).sendEvent(Mockito.any(), Mockito.any());
      }
}

使用方式及其简单，仅仅是在测试类上加上注解@ExtendWith(MockitoExtension.class,MockitoStaticExtension.class),然后照常写业务代码。

某个微服务中找到的多个静态类的mock：

    @Test
    public void test_gen_notify_req_should_return_not_null_when_test_data_combination() throws Exception {
        try (MockedStatic<SystemLangCache> aStatic = Mockito.mockStatic(SystemLangCache.class);
             MockedStatic<SpringContextUtil> aStatic1 = Mockito.mockStatic(SpringContextUtil.class);
             MockedStatic<ApplicationContext> aStatic2 = Mockito.mockStatic(ApplicationContext.class);
             MockedStatic<CommonLogicUtils> aStatic3 = Mockito.mockStatic(CommonLogicUtils.class);
             MockedStatic<DateConvertor> aStatic4 = Mockito.mockStatic(DateConvertor.class);
             MockedStatic<JacksonUtil> aStatic5 = Mockito.mockStatic(JacksonUtil.class);
             MockedStatic<SubTemplateInfoFactory> aStatic6 = Mockito.mockStatic(SubTemplateInfoFactory.class);
             MockedStatic<TemplateUtils> aStatic7 = Mockito.mockStatic(TemplateUtils.class)) {
            
            // setup
            Mockito.when(SystemLangCache.getDefaultLang()).thenReturn("string");
            Mockito.when(SpringContextUtil.getBean("drmReader")).thenReturn(drmReader);
            ...
        }
    }

修改后的版本：

    @Test
    public void test_gen_notify_req_should_return_not_null_when_test_data_combination() throws Exception {
        PowerMockito.mockStatic(SystemLangCache.class, SpringContextUtil.class, ApplicationContext.class,
            CommonLogicUtils.class, DateConvertor.class, JacksonUtil.class, SubTemplateInfoFactory.class,
            TemplateUtils.class);

        // setup
        Mockito.when(SystemLangCache.getDefaultLang()).thenReturn("string");
        Mockito.when(SpringContextUtil.getBean("drmReader")).thenReturn(drmReader);
        ...
    }

不必关注资源的开启和释放，也不必被try-with-source搞乱代码结构，更不必做mock命名。

代码源码

以下是代码源码，希望批评指正。

1 PowerMockito

围绕MockStatic功能和VerifyStatic进行。

import static org.mockito.Mockito.times;

import org.mockito.MockedStatic;
import org.mockito.Mockito;
import org.mockito.verification.VerificationMode;

import java.util.HashMap;
import java.util.Map;

public class PowerMockito {
    private static final ThreadLocal<Map<Class<?>, MockedStatic<?>>> MOCKED_STATICS = new ThreadLocal<>();

    static {
        MOCKED_STATICS.set(new HashMap<>());
    }

    public static void mockStatic(Class<?> type, Class<?>... aClasses) {
        doMockStatic(type);
        if (aClasses != null) {
            for (Class<?> aClass : aClasses) {
                doMockStatic(aClass);
            }
        }
    }

    private static void doMockStatic(Class<?> type) {
        assertNotNull(type, "mock class can not be null");
        Map<Class<?>, MockedStatic<?>> classMockedStaticMap = MOCKED_STATICS.get();
        if (!classMockedStaticMap.containsKey(type)) {
            classMockedStaticMap.put(type, Mockito.mockStatic(type));
        }
    }

    public static void closeAllStatic() {
        for (Map.Entry<Class<?>, MockedStatic<?>> classMockedStaticEntry : MOCKED_STATICS.get().entrySet()) {
            classMockedStaticEntry.getValue().close();
        }
        MOCKED_STATICS.get().clear();
    }

    public static MockedStatic<?> get(Class<?> aClass) {
        if (!MOCKED_STATICS.get().containsKey(aClass)) {
            throw new IllegalStateException("Static mock for " + aClass.getName() + " is not found");
        }
        return MOCKED_STATICS.get().get(aClass);
    }

    public static boolean contains(Class<?> aClass) {
        return MOCKED_STATICS.get().containsKey(aClass);
    }

    public static void verifyStatic(Class<?> aClass, MockedStatic.Verification verification) {
        verifyStatic(aClass, times(1), verification);
    }

    public static void verifyStatic(Class<?> aClass, VerificationMode verificationMode,
        MockedStatic.Verification verification) {
        assertNotNull(aClass, "Static mock class can not be null");
        assertNotNull(verificationMode, "Static mock verificationMode can not be null");
        assertNotNull(verification, "Static mock verification can not be null");
        if (!MOCKED_STATICS.get().containsKey(aClass)) {
            throw new IllegalStateException("Static mock for " + aClass.getName() + " is not found");
        }
        MOCKED_STATICS.get().get(aClass).verify(verification, verificationMode);
    }

    public static void closeStatic(Class<?> type, Class<?>... aClasses) {
        closeStatic(type);
        if (aClasses != null) {
            for (Class<?> aClass : aClasses) {
                closeStatic(type);
            }
        }
    }

    private static void closeStatic(Class<?> type) {
        Map<Class<?>, MockedStatic<?>> classMockedStaticMap = MOCKED_STATICS.get();
        if (classMockedStaticMap.containsKey(type)) {
            classMockedStaticMap.get(type).close();
            classMockedStaticMap.remove(type);
        }
    }

    private static void assertNotNull(Object object, String msg) {
        if (object == null) {
            throw new IllegalArgumentException(msg);
        }
    }
}

2 PowerMockito的Whitebox功能

提供原来框架的setInternalState、getInternalState、getField、invokeMethod功能，API接口一致。由于java17的反射不再允许改变静态final字段的值，所以这方面就花费了不小心思。

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.Map;

/**
 * 功能描述
 *
 * @since 2024-09-12
 */
public class Whitebox {
    public static final Logger LOG = LoggerFactory.getLogger(Whitebox.class);

    private static final Map<Class<?>, Class<?>> PRIMITIVE_TYPE_WRAPPER =
        Map.of(int.class, Integer.class, long.class, Long.class, boolean.class, Boolean.class, byte.class, Byte.class,
            char.class, Character.class, double.class, Double.class, float.class, Float.class);

    public static void setInternalState(Object object, String fieldName, Object value) {
        if (object == null) {
            throw new IllegalArgumentException("The instance containing the field cannot be null");
        }
        Class<?> aClass = object instanceof Class<?> ? (Class<?>) object : object.getClass();
        try {
            Field field = getField(aClass, fieldName);
            removeFinalModifierIfPresent(field);
            field.set(object, value);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException("Internal error: Failed to set field in method setInternalState.", e);
        }
    }

    public static Field getField(Class<?> declaringClass, String fieldName) throws NoSuchFieldException {
        Field field = getDeclaredField(declaringClass, fieldName);
        field.setAccessible(true);
        return field;
    }

    public static <T> T getInternalState(Object object, String fieldName) {
        try {
            Field foundField = getField(getClassType(object), fieldName);
            return (T) foundField.get(object);
        } catch (IllegalAccessException | NoSuchFieldException e) {
            throw new RuntimeException("Internal error: Failed to get field in method getInternalState.", e);
        }
    }

    public static <T> T invokeMethod(Object tested, String methodToExecute) throws Exception {
        Class<?> testedType = getClassType(tested);
        Method declaredMethod = getDeclaredMethod(testedType, methodToExecute, null);
        return doInvokeMethod(tested, declaredMethod, methodToExecute, null);
    }

    public static <T> T invokeMethod(Object tested, String methodToExecute, Object... arguments) throws Exception {
        Class<?> testedType = getClassType(tested);
        if (arguments == null) {
            arguments = new Object[1];
            arguments[0] = null;
        }
        Class<?>[] parameterTypes = getParameterClasses(arguments);
        Method declaredMethod = getDeclaredMethod(testedType, methodToExecute, parameterTypes);
        return doInvokeMethod(tested, declaredMethod, methodToExecute, arguments);
    }

    private static <T> T doInvokeMethod(Object tested, Method declaredMethod, String methodToExecute,
        Object... arguments) throws Exception {
        if (declaredMethod == null) {
            LOG.error("can not find method {}", methodToExecute);
            return null;
        }

        declaredMethod.setAccessible(true);
        try {
            return (T) declaredMethod.invoke(tested, arguments);
        } catch (InvocationTargetException e) {
            throw (Exception) e.getTargetException();
        }
    }

    private static Class<?>[] getParameterClasses(Object[] arguments) {
        if (arguments == null) {
            return null;
        }
        Class<?>[] parameterTypes = new Class[arguments.length];
        for (int i = 0; i < arguments.length; i++) {
            if (arguments[i] == null) {
                parameterTypes[i] = null;
                continue;
            }
            parameterTypes[i] = getClassType(arguments[i]);
        }
        return parameterTypes;
    }

    private static void removeFinalModifierIfPresent(Field field) throws IllegalAccessException {
        int fieldModifiersMask = field.getModifiers();
        if ((fieldModifiersMask & Modifier.FINAL) == Modifier.FINAL) {
            setModifiersToField(field);
        }
    }

    private static void setModifiersToField(Field field) {
        try {
            Method getDeclaredFields0 = Class.class.getDeclaredMethod("getDeclaredFields0", boolean.class);
            getDeclaredFields0.setAccessible(true);
            Field[] fields = (Field[]) getDeclaredFields0.invoke(Field.class, false);
            Field modifiersField = null;
            for (Field each : fields) {
                if ("modifiers".equals(each.getName())) {
                    modifiersField = each;
                    break;
                }
            }
            modifiersField.setAccessible(true);
            modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
        } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }

    private static Class<?> getClassType(Object object) {
        if (object == null) {
            throw new IllegalArgumentException("The object to perform the operation on cannot be null.");
        }
        return object instanceof Class<?> ? (Class<?>) object : object.getClass();
    }

    public static Method getDeclaredMethod(Class<?> aClass, String methodName, Class<?>... parameterTypes) {
        for (Class<?> clazz = aClass; clazz != Object.class; clazz = clazz.getSuperclass()) {
            try {
                for (Method declaredMethod : clazz.getDeclaredMethods()) {
                    if (declaredMethod.getName().equals(methodName)
                        && isParameterTypesRight(declaredMethod, parameterTypes)) {
                        return declaredMethod;
                    }
                }
            } catch (Exception e) {
                // Nothing Should do
            }
        }
        return null;
    }

    public static Field getDeclaredField(Class<?> aClass, String fieldName) {
        for (Class<?> clazz = aClass; clazz != Object.class; clazz = clazz.getSuperclass()) {
            try {
                return clazz.getDeclaredField(fieldName);
            } catch (Exception e) {
                // Nothing Should do
            }
        }
        return null;
    }

    private static boolean isParameterTypesRight(Method declaredMethod, Class<?>[] parameterTypes) {
        Class<?>[] types = declaredMethod.getParameterTypes();
        if (parameterTypes == null) {
            return types == null || types.length == 0;
        }

        if (types == null) {
            return parameterTypes == null || parameterTypes.length == 0;
        }

        if (parameterTypes.length != types.length) {
            return false;
        }

        for (int i = 0; i < types.length; i++) {
            if (parameterTypes[i] == null) {
                continue;
            }
            if (parameterTypes[i] != types[i] && !types[i].isAssignableFrom(parameterTypes[i])
                && !isWrapperOfPrimitive(types[i], parameterTypes[i])) {
                return false;
            }
        }

        return true;
    }

    private static boolean isWrapperOfPrimitive(Class<?> primitiveClass, Class<?> wrapperClass) {
        if (!PRIMITIVE_TYPE_WRAPPER.containsKey(primitiveClass)) {
            return false;
        }
        return PRIMITIVE_TYPE_WRAPPER.get(primitiveClass).equals(wrapperClass);
    }
}

3、MockedStaticExtension

import org.junit.jupiter.api.extension.AfterEachCallback;
import org.junit.jupiter.api.extension.ExtensionContext;

/**
 * 功能描述
 *
 * @since 2024-10-14
 */
public class MockStaticExtension implements AfterEachCallback {

    @Override
    public void afterEach(ExtensionContext context) throws Exception {
        PowerMockito.closeAllStatic();
    }
}

最后说一句，其实写这个工具类我更多的是迫不得已。静态类大量出现在某个类中，说明要么有人滥用静态类，违背对象的封装，将本不该做静态类的类写成了静态类，要么是有人把一个类写的太大太杂，写成了一个大锅烩。“某有三尺长剑，可斩尽天下妖邪，惟愿永不出鞘”。希望大家都有良好的代码习惯，并互勉。

JDK11下的Mock框架进化：从PowerMockito到Mockito Only
java专栏
08-22 649
PowerMockito是一个强大的库，它扩展了Mockito的功能，使得我们可以模拟那些原本不可模拟的方法，例如静态方法、私有方法等。然而，随着Java的发展，越来越多的功能被内置到了Java本身，PowerMockito的一些功能变得不再那么必要。在Java 11的环境下，我们来看看如何优雅地解决这些问题，从PowerMockito过渡到纯Mockito，让我们的单元测试更加简单高效！虽然这里我们只实现了最基本的模拟功能，但你可以根据自己的需求来扩展更多的功能，比如模拟异常抛出等。
【项目实战】使用Junit5+PowerMock+Mockito来编写单元测试的小技巧汇总
本本本添哥
09-12 648
使用Junit5+PowerMock+Mockito来编写单元测试，要求如下：（1）设置测试数据（Arrange），执行待测方法（Act），然后验证结果（Assert）（2）结果使用Assertions的API进行校验，比如在所有的assertEquals变成为Assertions.assertEquals（3）@Test下面的方法不加public（4）注意导入的方法，都是static（4）改成（5）不使用注解，改成（6）使用TestMe、百度Comate AI工具帮你完成单元测试。
Java单元测试实践-05.Mockito、PowerMock基本功能使用
adrninistrat0r的博客
08-12 4660
1. Mockito与PowerMock的功能 以下针对使用Mockito与PowerMock作为单元测试Mock框架进行说明。 1.1. Mockito 参考 https://github.com/mockito/mockito/wiki/FAQ 。 Mockito是一个Java的Mock框架。支持对类或接口进行Mock，不支持对静态方法、私有方法、构造函数等进行Mock。 1.2. PowerMock 参考 https://github.com/powermock/powermock/blob/rele
JDK17以上版本不兼容导致的mock maker问题：Could not initialize plugin: interface org.mockito.plugins.MockMaker
daisy__forever的博客
08-02 3188
对于高版本java和springboot在使用Mockito时产生的不兼容问题
1.2 混合环境配置技巧（JUnit5 + PowerMock + 其他框架）
最新发布
weixin_43476824的博客
02-16 358
注：所有配置示例基于Java 17 + Spring Boot 3.0验证通过，实际使用时请根据项目环境调整版本号。
powermock记录
妙法化城
04-03 209
// spy的对象属性、方法都初始化了 J21 hj21 = PowerMockito.spy(new HJ21()); // mock的对象属性、方法未初始化 J21 hj21 = PowerMockito.mock(new HJ21());
PowerMock在Java开发自测中的应用
04-17 2098
一、背景介绍 Java开发中的单元测试，不仅可以检测代码逻辑的正确性，同样也可以通过边界测试用例考验代码健壮性，它是开发过程中重要的质量保证手段。单元测试用例以及持续集成测试用例不断增加和迭代会驱动代码不断完善。本文以PowerMock工具作为主要的讨论对象，通过开发过程中遇到的不同的问题场景，阐述对应问题场景下PowerMock在单元测试发挥的作用。 所谓Mock对象实际是将类似于数...
JUNIT5 + Mockito
IOT_player的博客
04-27 9633
JUNIT5+Mockito maven配置与实践
PowerMockito.whenNew使用方法
热门推荐
yangman
03-25 1万+
package demo; import junit.framework.Assert; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.InjectMocks; import org.powermock.api.mockito.PowerMockito; import org.powermo...
解决Gradle在IDEA中运行Java17的Junit单元测试程序报错：module java.base does not “opens java.lang“ to unnamed module
文若书生的专栏
01-07 5932
【代码】解决Gradle在IDEA中运行Java17的Junit单元测试程序报错：module java.base does not "opens java.lang" to unnamed module。
PowerMock+Mockito-junit测试套件1.6.3版本
05-20
1. **Mocking静态方法**：在某些情况下，静态方法可能对系统行为有直接影响，PowerMock允许我们mock这些静态方法，从而隔离被测试代码。 2. **构造函数mock**：对于那些不允许实例化或包含复杂初始化逻辑的对象，...
powermock-module-junit4-1.6.5.zip
09-25
fcrepo-mint.zip,fedora commons repository minter模块：提供存储库标识符和路径服务。
powermock-mockito-junit-1.6.2.zip
12-09
PowerMock-Mockito-JUnit-1.6.2.zip 是一个包含PowerMock、Mockito和JUnit集成库的压缩包，适用于Java开发环境。这个版本的PowerMock要求使用1.6或更高版本的Java Development Kit (JDK)。下面将详细解释这三个主要...
powermock-mockito-junit-1.6.3.zip 当前最新版
12-09
PowerMock-Mockito-JUnit-1.6.3.zip 是一个包含最新版本的 PowerMock、Mockito 和 JUnit 库的压缩文件。这些工具在Java开发中被广泛用于单元测试和模拟，尤其对于处理静态方法、构造器、final类和方法、私有方法等...
PowerMock与Mockito在JUnit 1.6.2环境下的使用指南
压缩包"powermock-mockito-junit-1.6.2.zip"包含了用于单元测试的PowerMock框架、Mockito框架以及JUnit框架的整合。这个压缩包可能还包含了为特定测试用例准备的示例代码或配置文件。文件名称列表中只出现一个条目，...
Java单元测试框架与实践（Junit5 + Mockito）
夜谷子
06-01 8256
Java单元测试框架与实践 本文首先在理论上归纳了单元测试在宏观和微观层面要遵循的基本原则，以及测试覆盖率的要求和评价维度。然后具体阐述了笔者实战中总结的基于Junit + Mockito 的单元测试框架和具体实施方法。 本文主要参考和引用了《码出高效：Java开发手册》、Junit5、mockito等官方文档以及若干篇相关博客的内容，具体可见文末参考链接部分。 基本原则 宏观层面：AIR原则 ...
JAVA 单元测试之PowerMockito
m0_56670140的博客
06-30 808
引入PowerMock包，版本号一定要对应，不然可能会因为版本不兼容报错。2、一个简单的测试示例。
java第十七课 Junit的使用
Birdlun的博客
06-05 349
目录 为什么使用测试类？ 列：使用Junit了测试 导包 编写测试类 创建测试类 运行所有测试类 测试类运行结果 为什么使用测试类？ 用main方法就是写一个方法实现一些功能，把方法的调用方式放在main函数中。这样的测试方式一个是使得main函数太过于混乱，再者测试过程需要人的仔细观察来辨别每个函数的功能实现，哪一个函数出错了，哪一个函数没有输出之类的问题层出不穷，单元测试就...
JUnit配置（IDEA2024，jdk17）maven依赖（MAC、Windows）
小刘的SHARING SPACE
07-09 2257
概念：是一个Apache组织开发的一个项目管理和构建工具，它基于项目对象模型（POM）的概念，通过一小段描述信息来管理项目的构建。作用：依赖管理统一项目结构（不同IDE都是一样的结构，项目就可迁移了）跨平台标准化流程（清理，编译，测试，打包，发布）项目对象模型是指通过pom.xml中配置的一小段信息来描述这个工程：groupId，artifactId，version（坐标）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值