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

Question

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

在我的maven插件配置中

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

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

Answer 1

不支持此功能。 官方文档说：

过滤测试执行有问题或设计上不可能的代码

• 私有的、空的默认构造函数 - 假设没有调用它
• 普通 getter 和 setter
• 抛出 AssertionErrors 的块 - 如果出现条件（if !assertion throw new AssertionError），则应忽略整个块

另请参阅：https://github.com/jacoco/jacoco/issues/298

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

Answer 2

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

Answer 3

对于这个用例，反射是完全可以接受的，有很少且众所周知的类。下面的代码可以与基于名称的自动类检测一起使用。对于具有附加断言的示例“.*Factory”类。

@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

如果你使用Lombok，最简单的方法是用

@Generated

注释构造函数，这样JaCoCo将忽略这个构造函数。

import lombok.Generated;

public class MyClass {
   @Generated
   private MyClass(){}
}

Answer 6

这并没有解决空私有构造函数不需要覆盖的基本问题，但要真正让 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 7

由于 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;
        }
    }
}