`

使用classloader自定义测试套件TestSuite

    博客分类:
  • Test
阅读更多
junit自带了一个suite用来将多个test case放在一起执行, 但是有时候test case太多, 或者每次只需要对特定的几个test case进行测试, 这样写就比较繁琐, 于是希望通过一种带有通配符的表达式来指定需要测试的某些符合条件的test case, 于是根据这个需求, 实现了一个自己的PathSuite, 不过目前还比较简单, 关键是表达式的解析实现比较难搞, 不知道有没有现成的类似的通配符表达式可用? 反正我是没有找到:(
这里需要借助ClassLoader用来加载指定的class文件, 因为通过表达式得到的只是一些文件路径, 要将指定的路径转换成class定义以及类实例就需要借助ClassLoader, 当然这里使用的都是ClassLoader非常简单的功能.
/**
 * <p>
* 使用Junit Runner运行指定package下所有的*Test.java测试类或者指定的类.
* </p>
* 目前只支持形如
* <ul>
* <li>"com.mysoft.item.test.*"匹配整个package</li>
* <li>"com.mysoft.item.test.*ATest.class",匹配整个package下的某些文件(未实现)</li>
* <li>"com.mysoft.item.test.**", 匹配整个package以及子package(未实现)</li>
* <li>"com.mysoft.item.test.internal.CTest.class"匹配单个文件</li>
* </ul>
* 的表达式
 * @since 2009-10-14 下午06:00:12
 */
public class PathSuite extends CompositeRunner {
    private TestClass fTestClass;
    private final static String classSuffix = ".class";

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    public @interface Paths {
        /**
         * 指定需要运行的测试目录或测试类
         * @return
         */
        public String[] value();

        /**
         * 指定那些不需要运行的测试目录或测试类(未实现)
         * @return
         */
        public String[] exclude() default {};
    }

    public PathSuite(Class<?> klass) throws InitializationError {
        super(klass.getSimpleName());

        Class<?>[] annotatedClasses = getAnnotatedClasses(klass);
        for (Class<?> each : annotatedClasses) {
            Runner childRunner = Request.aClass(each).getRunner();
            if (childRunner != null)
                add(childRunner);
        }

        fTestClass = new TestClass(klass);
        MethodValidator methodValidator = new MethodValidator(fTestClass);
        methodValidator.validateStaticMethods();
        methodValidator.assertValid();
    }

    private static Class<?>[] getAnnotatedClasses(Class<?> klass) throws InitializationError {
        Paths annotation = klass.getAnnotation(Paths.class);
        if (annotation == null)
            throw new InitializationError(String.format("class '%s' must have a Paths annotation", klass
                    .getName()));

        return getTestClasses(annotation.value());
    }

    private static Class<?>[] getTestClasses(String[] testClassPaths) {
        List<String> classNames = getClassNames(testClassPaths);

        ClassLoader loader = new TestClassLoader();
        List<Class<?>> classes = new ArrayList<Class<?>>();
        for (String className : classNames) {
            try {
                Class<?> clazz = loader.loadClass(className);
                // 去掉抽象类
                if (Modifier.isAbstract(clazz.getModifiers())) {
                    continue;
                }
                classes.add(clazz);
            } catch (Exception e) {
                throw new RuntimeException(String.format("加载测试类[%s]失败", className), e);
            }
        }

        return classes.toArray(new Class<?>[0]);
    }

    private static List<String> getClassNames(String[] testClassPaths) {
        List<String> classNames = new ArrayList<String>();
        for (String testClassPath : testClassPaths) {
            // com.mysoft.item.test.*
            if (StringUtils.isBlank(testClassPath)) {
                continue;
            }
            String packagePrefix = testClassPath.replaceAll("\\*.*", "");
            if (isClass(testClassPath)) {
                // com.mysoft.item.test.ATest.class

                // com.mysoft.item.test.ATest
                testClassPath = testClassPath.replaceFirst("\\.class", "");
                // com.mysoft.item.test
                packagePrefix = testClassPath.substring(0, testClassPath.lastIndexOf(".") + 1);

                // com/mysoft/item/test/ATest.class
                testClassPath = testClassPath.replace(".", "/") + classSuffix;
            } else {
                // com.mysoft.item.test.
                packagePrefix = testClassPath.replaceAll("\\*.*", "");
                // com/mysoft/item/test/*
                testClassPath = testClassPath.replace(".", "/");
            }


            classNames.addAll(getClassNames(testClassPath, packagePrefix));
        }
        return classNames;
    }

    private static boolean isClass(String testClassPath) {
        return testClassPath.endsWith(classSuffix);
    }

    private static List<String> getClassNames(String path,
            String packagePrefix) {
        // com/mysoft/item/test
        path = path.replaceFirst("\\/\\*$", "");

        String absolutePath = PathUtils.getAbsolutePath(path);

        return findClasses(packagePrefix, new File(absolutePath));
    }

    private static List<String> findClasses(String packagePrefix, File folder) {
        List<String> result = new ArrayList<String>();
        if (folder.isDirectory()) {
            // 得到里面的每一个class文件
            File[] testClasses = folder.listFiles(new FilenameFilter() {
                public boolean accept(File dir, String name) {
                    return name.endsWith("Test.class");
                }
            });

            for (File file : testClasses) {
                result.add(getClassName(packagePrefix, file));
            }
        } else {
            result.add(getClassName(packagePrefix, folder));
        }
        return result;
    }

    private static String getClassName(String packagePrefix, File file) {
        return packagePrefix + file.getName().replaceFirst("\\.class", "");

    }
}



TestClassLoader的实现, 这个是从网上找来的一个类似的实现做了些改动, 可以凑合着用用^_^, 不过大部分ClassLoader差不多都这样用
/**
* 用来加载当前classpath下的Test Class
 * @since 2009-10-21 下午03:46:34
 */
public class TestClassLoader extends ClassLoader {

    /**
     * @param name 形如"java.lang.String"的字符串
     * {@inheritDoc} 
     */
    @Override
    protected Class<?> findClass(String name)
            throws ClassNotFoundException {
        byte[] bytes = loadClassBytes(name);
        Class<?> theClass = defineClass(name, bytes, 0, bytes.length);// A
        if (theClass == null)
            throw new ClassFormatError();
        return theClass;
    }

    private byte[] loadClassBytes(String className) throws
            ClassNotFoundException {
        try {
            String classFile = getClassFile(className);
            FileInputStream fis = new FileInputStream(classFile);
            FileChannel fileC = fis.getChannel();
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            WritableByteChannel outC = Channels.newChannel(baos);
            ByteBuffer buffer = ByteBuffer.allocateDirect(1024);
            while (true) {
                int i = fileC.read(buffer);
                if (i == 0 || i == -1) {
                    break;
                }
                buffer.flip();
                outC.write(buffer);
                buffer.clear();
            }
            fis.close();
            return baos.toByteArray();
        } catch (IOException fnfe) {
            throw new ClassNotFoundException(className);
        }
    }

    private String getClassFile(String name) {
        StringBuffer sb = new StringBuffer(getBaseDir());
        name = name.replace('.', File.separatorChar) + ".class";
        sb.append(File.separator + name);
        return sb.toString();
    }

    private String getBaseDir() {
        return TestClassLoader.class.getResource(File.pathSeparator).toString();
    }

    // 新增的一个findResource方法
    @Override
    protected URL findResource(String name) {
        try {
            URL url = super.findResource(name);
            if (url != null)
                return url;
            url = new URL("file:///" + converName(name));
            // 简化处理,所有资源从文件系统中获取
            return url;
        } catch (MalformedURLException mue) {
            throw new RuntimeException(mue);
        }
    }

    private String converName(String name) {
        StringBuffer sb = new StringBuffer(getBaseDir());
        name = name.replace('.', File.separatorChar);
        sb.append(File.separator + name);
        return sb.toString();
    }
}



这里只是为了演示classloader的用法, 其实根本没有必要这么复杂, 其中
Class<?> clazz = loader.loadClass(className);

这一句, 可以简单的使用
Class<?> clazz = Class.forName(className);

代替搞定.
另外eclipse也可以直接选中指定的package运行里面所有的test case, 我也是最近从测试人员那里知晓的:(
0
0
分享到:
评论
1 楼 HashSet 2014-03-25  
另外eclipse也可以直接选中指定的package运行里面所有的test case, 我也是最近从测试人员那里知晓的:(


怎么做

相关推荐

    自定义classloader的使用

    本文将深入探讨自定义Classloader的使用。 一、Classloader的工作原理 Java的类加载机制遵循双亲委派模型,即当一个类加载器需要加载类时,它首先委托父类加载器尝试加载,只有当父类加载器无法加载时,才会尝试...

    ClassLoader的 一些测试

    这篇测试主要探讨了ClassLoader的工作原理及其在实际应用中的使用。通过阅读给出的博文链接,我们可以深入理解ClassLoader的功能、分类以及如何进行自定义。 首先,ClassLoader的基本职责是加载.class文件,将字节...

    java自定义类加载classloader文档,包括代码

    package test.classloader; import java.io.*; import org.apache.log4j.Logger; public class MyClassLoader extends ClassLoader { private String baseDir; private static final Logger logger = Logger....

    使用classloader动态加载Class

    1. **自定义ClassLoader**:Java允许我们创建自定义的ClassLoader,这通常用于实现动态加载类的需求。自定义ClassLoader需要重写`findClass()`或`loadClass()`方法。`loadClass()`方法是类加载的入口,它会调用`find...

    classloader

    Android系统主要使用三种类型的类加载器:Bootstrap ClassLoader、Extension ClassLoader和App ClassLoader(也称为PathClassLoader)。 1. Bootstrap ClassLoader:这是最基础的类加载器,负责加载系统的预定义类...

    ClassLoader运行机制 自己写的

    这里我们将详细讨论ClassLoader的运行机制,特别是自定义ClassLoader的设计与实现。 ClassLoader的基本职责是根据类名动态加载对应的类文件。在Java中,类加载过程遵循双亲委派模型(Parent Delegation Model)。这...

    web_classloader_test.zip_web classloader

    `web_classloader_test`可能包含了这样的自定义类加载器的实现。 5. **热部署与热更新**:在开发阶段,开发者可能希望在不重启服务器的情况下更新代码。这就需要类加载器支持类的动态加载和卸载。这个测试可能包含...

    使用自定义ClassLoader解决反序列化serialVesionUID不一致问题 _ 回忆飘如雪1

    标题和描述中提到的解决方案是通过自定义`ClassLoader`来处理`serialVersionUID`不一致的问题。以下是几种常见方法的优缺点以及自定义`ClassLoader`的详细解释: 1. **修改序列化byte数据**: 这种方法直接修改已...

    Android Classloader测试demo

    在Android系统中,Classloader(类加载器)是至关重要的组件,它负责查找并加载Java类到Dalvik或ART运行时环境。这个测试demo是为了帮助开发者深入理解Android中两种主要的类加载器:DexClassLoader和...

    定义ClassLoader调用外部jar包

    默认情况下,Java使用系统ClassLoader(Bootstrap ClassLoader)加载JDK核心库,然后是Extension ClassLoader加载扩展库,最后是App ClassLoader加载应用类路径(ClassPath)下的类。当这些默认ClassLoader无法满足...

    Java ClassLoader定制实例

    在实际应用中,我们可以通过反射API来使用自定义ClassLoader加载的类。例如,我们可以创建一个`Class`对象,然后调用`newInstance()`方法来创建该类的实例。 总结来说,Java ClassLoader的定制是一项强大的技术,它...

    ClassLoader 案例

    自定义ClassLoader允许开发者根据特定需求加载类,比如动态加载或更新类文件,这在某些高级应用场景中非常有用,如插件系统、热部署等。本案例将深入探讨如何创建一个自定义的ClassLoader,利用Java反射和注解技术...

    ClassLoader小例子

    下面我们将详细讨论ClassLoader的基本概念、工作流程以及如何自定义ClassLoader。 1. **ClassLoader的基本概念** - 类加载器是Java中的一个核心组件,它负责将类的.class文件加载到JVM中,并转换为可执行的Java...

    JVM ClassLoader简析

    这些代码可能展示了如何创建自定义ClassLoader,以及如何使用ClassLoader加载非标准位置的类。通过分析这些示例,我们可以更好地理解ClassLoader的工作机制。 总的来说,理解和掌握JVM ClassLoader对于优化Java应用...

    Android 使用classloader原理进行热更新

    热更新通常依赖于类加载器(Classloader)的工作原理来实现,本篇文章将深入探讨如何利用Android的类加载器实现热更新的机制。 首先,我们需要理解什么是类加载器。在Java和Android中,类加载器是负责查找、加载和...

    ClassLoader类加载器

    以下是对ClassLoader API的使用和自定义的详细说明。 首先,我们来看ClassLoader的基本概念。在Java中,每个类都是由一个ClassLoader实例加载的。系统中存在三种基本的ClassLoader: 1. Bootstrap ClassLoader:这...

    ClassLoader

    4. **使用`defineClass`方法定义类**:当输入流不为空时,使用`ClassLoader`的`defineClass`方法将字节数组转换为`Class`对象。 5. **实例化类**:通过`myLoader.loadClass(...

    深入理解ClassLoader工作机制.docx

    这个过程可以通过自定义ClassLoader来实现,比如从数据库中加载类。 2. **验证**:验证是确保加载的类符合Java语言规范,不会破坏JVM的安全性。它检查字节码的格式、数据流和操作符计算、类和字段的访问控制等。 3...

Global site tag (gtag.js) - Google Analytics