计算@Category在JUnit的一组测试中出现的次数
钱弘壮
问题内容：
问题答案：
我已经使用Java，Selenium，Junit，Maven开发了一整套的自动化测试。
对于每个测试，它们都有一个或多个@Category批注，描述每个测试涵盖的软件区域。例如：
@Test
@Category({com.example.core.categories.Priority1.class,
com.example.core.categories.Export.class,
com.example.core.categories.MemberData.class})
@Test
@Category({com.example.core.categories.Priority1.class,
com.example.core.categories.Import.class,
com.example.core.categories.MemberData.class})
@Test
@Ignore
@Category({com.example.core.categories.Priority2.class,
com.example.core.categories.Import.class,
com.example.core.categories.MemberData.class})
我正在尝试做的是找到一种方法来计算包含给定类别的测试数量。所有可能的类别都是文件//com/example/core/categories夹中作为源列表的文件名。
我曾尝试构建一个shell脚本来进行字数统计，这似乎还可以，但是我认为还有更多的“内置”来处理@Category。
我最大的问题是，即使我得到了正确的计数，也很有可能将一个或多个测试标记为@Ignore，这将使该测试@Category无效，但无需大量使用标志并逐行读取每个文件为了摆脱正确的计数。
有没有一种好方法可以逐项列出@Category的内容，而这也是@Ignore的因素？
输出示例
| Category | Count |
|----------------------------------------------|------:|
| com.example.core.categories.Export.class | 1 |
| com.example.core.categories.Import.class | 1 |
| com.example.core.categories.MemberData.class | 2 |
| com.example.core.categories.Priority1.class | 2 |
| com.example.core.categories.Priority2.class | 0 |
| com.example.core.categories.Priority3.class | 0 |
问题答案：
（推荐方法）
我尝试了一种使用抽象层中的计数器执行此操作的方法，但是这很痛苦，必须在每个Test方法的开头添加源代码。
最后，这是我为满足您的需求而编写的源代码。它很繁重（反射…），但是它对现有源代码的干扰较小，可以完全满足您的需求。
首先，您必须创建一个Testsuite（包含其他各种套件，或者直接包含您想要的所有Test类），以确保最后已经加载了您想要统计的所有Test。
在此套件中，您必须实现一个“最终挂钩” @AfterClass，当整个测试套件已由 JUnit 完全管理时，将被全部调用一次。
这是我为您编写的测试套件实现：
package misc.category;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Vector;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.AfterClass;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
@RunWith(Suite.class)
@Suite.SuiteClasses({ UnitTestWithCategory.class })
public class TestSuiteCountComputer {
public static final String MAIN_TEST_PACKAGES = "misc.category";
private static final Class<?>[] getClasses(final ClassLoader classLoader)
throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
Class<?> CL_class = classLoader.getClass();
while (CL_class != java.lang.ClassLoader.class) {
CL_class = CL_class.getSuperclass();
}
java.lang.reflect.Field ClassLoader_classes_field = CL_class.getDeclaredField("classes");
ClassLoader_classes_field.setAccessible(true);
Vector<?> classVector = (Vector<?>) ClassLoader_classes_field.get(classLoader);
Class<?>[] classes = new Class[classVector.size()]; // Creates an array to avoid concurrent modification
// exception.
return classVector.toArray(classes);
}
// Registers the information.
private static final void registerTest(Map<String, AtomicInteger> testByCategoryMap, String category) {
AtomicInteger count;
if (testByCategoryMap.containsKey(category)) {
count = testByCategoryMap.get(category);
} else {
count = new AtomicInteger(0);
testByCategoryMap.put(category, count);
}
count.incrementAndGet();
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
Map<String, AtomicInteger> testByCategoryMap = new HashMap<>();
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
while (classLoader != null) {
for (Class<?> classToCheck : getClasses(classLoader)) {
String packageName = classToCheck.getPackage() != null ? classToCheck.getPackage().getName() : "";
if (!packageName.startsWith(MAIN_TEST_PACKAGES))
continue;
// For each methods of the class.
for (Method method : classToCheck.getDeclaredMethods()) {
Class<?>[] categoryClassToRegister = null;
boolean ignored = false;
for (Annotation annotation : method.getAnnotations()) {
if (annotation instanceof org.junit.experimental.categories.Category) {
categoryClassToRegister = ((org.junit.experimental.categories.Category) annotation).value();
} else if (annotation instanceof org.junit.Ignore) {
ignored = true;
} else {
// Ignore this annotation.
continue;
}
}
if (ignored) {
// If you want to compute count of ignored test.
registerTest(testByCategoryMap, "(Ignored Tests)");
} else if (categoryClassToRegister != null) {
for (Class<?> categoryClass : categoryClassToRegister) {
registerTest(testByCategoryMap, categoryClass.getCanonicalName());
}
}
}
}
classLoader = classLoader.getParent();
}
System.out.println("\nFinal Statistics:");
System.out.println("Count of Tests\t\tCategory");
for (Entry<String, AtomicInteger> info : testByCategoryMap.entrySet()) {
System.out.println("\t" + info.getValue() + "\t\t" + info.getKey());
}
}
}
您可以适应您的需求，尤其是我在开始时创建的常数，以对软件包进行考虑。
这样一来，您只需要完成已有的工作即可。
例如，这是我很小的测试类：
package misc.category;
import org.junit.Test;
import org.junit.experimental.categories.Category;
public class UnitTestWithCategory {
@Category({CategoryA.class, CategoryB.class})
@Test
public final void Test() {
System.out.println("In Test 1");
}
@Category(CategoryA.class)
@Test
public final void Test2() {
System.out.println("In Test 2");
}
}
在这种情况下，输出为：
In Test 1
In Test 2
Final Statistics:
Count of Tests Category
1 misc.category.CategoryB
2 misc.category.CategoryA
并带有包含@Ignore注释的测试用例：
package misc.category;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.experimental.categories.Category;
public class UnitTestWithCategory {
@Category({CategoryA.class, CategoryB.class})
@Test
public final void Test() {
System.out.println("In Test 1");
}
@Category(CategoryA.class)
@Test
public final void Test2() {
System.out.println("In Test 2");
}
@Category(CategoryA.class)
@Ignore
@Test
public final void Test3() {
System.out.println("In Test 3");
}
}
您将获得输出：
In Test 1
In Test 2
Final Statistics:
Count of Tests Category
1 (Ignored Tests)
1 misc.category.CategoryB
2 misc.category.CategoryA
您可以根据需要轻松删除“（已忽略的测试）”注册，并且当然可以根据需要调整输出。
最终版本的好处是它将处理已经真正加载/执行的测试类，因此您将获得有关已执行内容的真实统计信息，而不是到目前为止的静态统计信息。
静态“按类别测试”计算机
如果您希望像您所要求的那样与现有源代码无关，那么这是一种静态执行“ 按类别测试” 计算的方法。
这是StaticTestWithCategoryCounter我为您写的：
import java.io.File;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Vector;
import java.util.concurrent.atomic.AtomicInteger;
public class StaticTestWithCategoryCounter {
public static final String ROOT_DIR_TO_SCAN = "bin";
public static final String MAIN_TEST_PACKAGES = "misc.category";
private static final Class<?>[] getClasses(final ClassLoader classLoader)
throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
Class<?> CL_class = classLoader.getClass();
while (CL_class != java.lang.ClassLoader.class) {
CL_class = CL_class.getSuperclass();
}
java.lang.reflect.Field ClassLoader_classes_field = CL_class.getDeclaredField("classes");
ClassLoader_classes_field.setAccessible(true);
Vector<?> classVector = (Vector<?>) ClassLoader_classes_field.get(classLoader);
Class<?>[] classes = new Class[classVector.size()]; // Creates an array to avoid concurrent modification
// exception.
return classVector.toArray(classes);
}
// Registers the information.
private static final void registerTest(Map<String, AtomicInteger> testByCategoryMap, String category) {
AtomicInteger count;
if (testByCategoryMap.containsKey(category)) {
count = testByCategoryMap.get(category);
} else {
count = new AtomicInteger(0);
testByCategoryMap.put(category, count);
}
count.incrementAndGet();
}
public static void computeCategoryCounters() throws Exception {
Map<String, AtomicInteger> testByCategoryMap = new HashMap<>();
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
while (classLoader != null) {
for (Class<?> classToCheck : getClasses(classLoader)) {
String packageName = classToCheck.getPackage() != null ? classToCheck.getPackage().getName() : "";
if (!packageName.startsWith(MAIN_TEST_PACKAGES))
continue;
// For each methods of the class.
for (Method method : classToCheck.getDeclaredMethods()) {
Class<?>[] categoryClassToRegister = null;
boolean ignored = false;
for (Annotation annotation : method.getAnnotations()) {
if (annotation instanceof org.junit.experimental.categories.Category) {
categoryClassToRegister = ((org.junit.experimental.categories.Category) annotation).value();
} else if (annotation instanceof org.junit.Ignore) {
ignored = true;
} else {
// Ignore this annotation.
continue;
}
}
if (ignored) {
// If you want to compute count of ignored test.
registerTest(testByCategoryMap, "(Ignored Tests)");
} else if (categoryClassToRegister != null) {
for (Class<?> categoryClass : categoryClassToRegister) {
registerTest(testByCategoryMap, categoryClass.getCanonicalName());
}
}
}
}
classLoader = classLoader.getParent();
}
System.out.println("\nFinal Statistics:");
System.out.println("Count of Tests\t\tCategory");
for (Entry<String, AtomicInteger> info : testByCategoryMap.entrySet()) {
System.out.println("\t" + info.getValue() + "\t\t" + info.getKey());
}
}
public static List<String> listNameOfAvailableClasses(String rootDirectory, File directory, String packageName) throws ClassNotFoundException {
List<String> classeNameList = new ArrayList<>();
if (!directory.exists()) {
return classeNameList;
}
File[] files = directory.listFiles();
for (File file : files) {
if (file.isDirectory()) {
if (file.getName().contains("."))
continue;
classeNameList.addAll(listNameOfAvailableClasses(rootDirectory, file, packageName));
} else if (file.getName().endsWith(".class")) {
String qualifiedName = file.getPath().substring(rootDirectory.length() + 1);
qualifiedName = qualifiedName.substring(0, qualifiedName.length() - 6).replaceAll(File.separator, ".");
if (packageName ==null || qualifiedName.startsWith(packageName))
classeNameList.add(qualifiedName);
}
}
return classeNameList;
}
public static List<Class<?>> loadAllAvailableClasses(String rootDirectory, String packageName) throws ClassNotFoundException {
List<String> classeNameList = listNameOfAvailableClasses(rootDirectory, new File(rootDirectory), packageName);
List<Class<?>> classes = new ArrayList<>();
for (final String className: classeNameList) {
classes.add(Class.forName(className));
}
return classes;
}
public static void main(String[] args) {
try {
loadAllAvailableClasses(ROOT_DIR_TO_SCAN, MAIN_TEST_PACKAGES);
computeCategoryCounters();
} catch (Exception e) {
e.printStackTrace();
}
}
}
您只需要在开始指定两个常量时就对其进行调整即可：
- （字节码）类在哪里
- 哪个主程序包很有趣（您可以将其设置
null为100％可用的程序包）
这个新版本的想法是：
- 列出与您的2个常量匹配的所有类文件
- 加载所有对应的类
- 使用未经修改的动态版本源代码（现在已经加载了类）
让我知道您是否需要更多信息。
类似资料：
-
我已经被设置了一个任务，这意味着我需要创建一个'3个或更多的骰子游戏‘。我所坚持的是这个游戏所需要的计分系统，它是这样的：“玩家依次掷出所有五个骰子，并为同类中的三个或更好的骰子得分。如果玩家只有同类中的两个，他们可能会重新掷出剩余的骰子，试图提高匹配的骰子值。如果没有匹配的数字被掷出，玩家得分为0。 游戏进行了一定数量的回合（比如50回合），游戏结束时总分最高的玩家是获胜者。“我需要计算出如何将
-
我已经将代码中的read整数修复为不再是I而是一个单独的变量“index”，并理解为什么我会收到Over Ofbound异常，但我有点厚，不明白如何在添加哨兵值0的同时修复它。
-
问题内容： 我正在尝试计算中每行显示的数字，例如： 行显示3次。 一个简单的天真的解决方案将涉及将我所有的行都转换为元组，然后应用，如下所示： 产生： 但是，我担心我的方法的效率。也许有一个提供此功能的内置库。我将此问题标记为，因为我认为它可能具有我正在寻找的工具。 问题答案： 您可以使用另一个问题的答案来获得唯一项目的计数。 使用结构化数组的另一种选择是使用一种void类型的视图，该视图将整行连
-
问题内容： 我正在编写一个项目，该项目从.java文件中捕获Java关键字，并使用地图跟踪事件的发生。过去，我已经成功地使用了类似的方法，但是我似乎无法为我的预期用途采用这种方法。 该代码块应该将关键字添加到键，并在每次出现相同的键时递增该值。到目前为止，它添加了关键字，但是未能正确增加该值。这是一个示例输出： 基本上，它会增加映射中的每个值，而不是应该增加的值。我不确定我是否对此考虑过多。我尝试
-
问题内容： 我的sql查询获取固件的错误修复验证列表，例如def-456是一张票，要求我对产品进行固件测试。def-456有几个子任务，记录结果。结果记录为：id：abc-123，abc-124，abc-125等（如下表所示）。这些对应的ID的结果为“通过”或“失败”。我需要计算两个值----> 1.尝试次数：在以下示例中，尝试次数将为3/5，有3次通过和2次失败（即通过/通过+失败），在这里我可
-
假设我有这两个数组： 如何从ARR2获取arr1中的出现次数。两个数组中的所有字符串都是唯一的，不会有重复的。显然，在这个具体案例中的结果是2。 我试过的： 问题是我必须在很少的情况下使用它，并且变量总是在变化，这取决于您单击的内容，而您不能依赖它的值。 提前谢谢！