JaCoCo 和错过了私有默认构造函数的覆盖范围

Question

我想看看一个例子来防止JaCoCo将私有空构造函数报告为Java类中的未覆盖代码。

在我有的 maven 插件配置中

   <rule>
     <element>CLASS</element>
       <excludes>
         <exclude>JAVAC.SYNTHCLASS</exclude>
         <exclude>JAVAC.SYNTHMETH</exclude>
       </excludes>
     </element>
   </rule>

构造函数没有类似的东西吗？

Answer 1

不支持此操作。官方文件说：

用于测试执行在设计上存在问题或不可能执行的代码的筛选器

• 私有的、空的默认构造函数 - 假设没有调用它
• 普通吸盘手和二传手
• 抛出断言错误的块 - 如果条件（如果 ！assertion 抛出新的断言错误），则应忽略整个块）

参见 ： https://github.com/jacoco/jacoco/issues/298

更新：这已在 https://github.com/jacoco/jacoco/pull/529 中修复，应该在 0.8.0 中。

Answer 2

无法关闭该选项。如果您迫切需要满足与覆盖范围相关的某些质量门，您可以随时使用解决方法并通过反射调用这些私有构造函数。

Answer 3

对于这个用例，反射是完全可以接受的，很少有众所周知的类。波纹管代码可以与基于名称的自动类检测一起使用。对于带有附加断言的示例".*工厂"类。

@Test
public void testCoverage()
    throws SecurityException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
    coverageSingleton(MySingleton1.class);
    coverageSingleton(MySingleton2.class);
}
private <S> void coverageSingleton(Class<S> singletonClass)
    throws SecurityException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
    final Constructor<S> constructor = singletonClass.getDeclaredConstructor();
    constructor.setAccessible(true);
    constructor.newInstance();
}

Answer 4

根据官方文档，它将与0.8.0一起发布

筛选测试执行有问题或不可能执行的代码 设计

没有参数的私有空构造函数 - 完成

您可以在此处找到详细信息。

Answer 5

这并没有解决空私有构造函数不需要覆盖的基本问题，但要实际使 JaCoCo 报告空私有构造函数的覆盖率，您需要调用它。你是怎么做到的？您可以在静态初始化块中调用它。

public class MyClass {
   static {
      new MyClass();
   }
   private MyClass(){}
}

编辑：事实证明，不能保证要执行的静态初始化块。因此，我们只能使用这样的方法：

static <T> void callPrivateConstructorIfPresent(Class<T> clazz){
        try{
            Constructor<T> noArgsConstructor = clazz.getDeclaredConstructor();
            if(!noArgsConstructor.isAccessible()){
                noArgsConstructor.setAccessible(true);
                try {
                    noArgsConstructor.newInstance();
                } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) 
                {
                    e.printStackTrace();
                }
                noArgsConstructor.setAccessible(false);
            }
        } catch(NoSuchMethodException e){}
    }

Answer 6

由于 0.8.0 尚未发布，我创建了一个 hamcrest 匹配器，用于检查类是否为实用程序类，并使用反射调用私有构造函数（仅用于代码覆盖目的）。

https://github.com/piotrpolak/android-http-server/blob/master/http/src/test/java/ro/polak/http/utilities/IOUtilitiesTest.java

package ro.polak.http.utilities;
import org.junit.Test;

import static org.hamcrest.core.Is.is;
import static org.junit.Assert.assertThat;
import static ro.polak.http.ExtraMarchers.utilityClass;
public class IOUtilitiesTest {
    @Test
    public void shouldNotBeInstantiable() {
        assertThat(IOUtilities.class, is(utilityClass()));
    }
}

https://github.com/piotrpolak/android-http-server/blob/master/http/src/test/java/ro/polak/http/ExtraMarchers.java

package ro.polak.http;
import org.hamcrest.Description;
import org.hamcrest.Matcher;
import org.hamcrest.TypeSafeMatcher;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class ExtraMarchers {
    private static final UtilClassMatcher utilClassMatcher = new UtilClassMatcher();
    public static Matcher<? super Class<?>> utilityClass() {
        return utilClassMatcher;
    }
    private static class UtilClassMatcher extends TypeSafeMatcher<Class<?>> {
        @Override
        protected boolean matchesSafely(Class<?> clazz) {
            boolean isUtilityClass = false;
            try {
                isUtilityClass = isUtilityClass(clazz);
            } catch (ClassNotFoundException | InstantiationException e) {
                // Swallowed
            }
            // This code will attempt to call empty constructor to generate code coverage
            if (isUtilityClass) {
                callPrivateConstructor(clazz);
            }
            return isUtilityClass;
        }
        @Override
        protected void describeMismatchSafely(Class<?> clazz, Description mismatchDescription) {
            if (clazz == null) {
                super.describeMismatch(clazz, mismatchDescription);
            } else {
                mismatchDescription.appendText("The class " + clazz.getCanonicalName() + " is not an utility class.");
                boolean isNonUtilityClass = true;
                try {
                    isNonUtilityClass = !isUtilityClass(clazz);
                } catch (ClassNotFoundException e) {
                    mismatchDescription.appendText(" The class is not found. " + e);
                } catch (InstantiationException e) {
                    mismatchDescription.appendText(" The class can not be instantiated. " + e);
                }
                if (isNonUtilityClass) {
                    mismatchDescription.appendText(" The class should not be instantiable.");
                }
            }
        }
        @Override
        public void describeTo(Description description) {
        }
        private void callPrivateConstructor(Class clazz) {
            try {
                Constructor<?> constructor = clazz.getDeclaredConstructor();
                constructor.setAccessible(true);
                constructor.newInstance();
            } catch (NoSuchMethodException | IllegalAccessException |
                    InstantiationException | InvocationTargetException e) {
                // Swallowed
            }
        }
        private boolean isUtilityClass(Class clazz) throws ClassNotFoundException, InstantiationException {
            boolean hasPrivateConstructor = false;
            try {
                clazz.newInstance();
            } catch (IllegalAccessException e) {
                hasPrivateConstructor = true;
            }
            return hasPrivateConstructor;
        }
    }
}