}

    @Override
    public TestSpec includeMethods(String clazz, Collection<String> newMethods) {
        List<String> methods = this.methods.get(clazz);
        if (methods == null) {
            methods = new ArrayList<String>(newMethods.size());
            this.methods.put(clazz, methods);
        }
        methods.addAll(newMethods);
        return this;
    }

    @Override

@GroovyASTTransformation
public class TestCaseTransform implements ASTTransformation {
    public void visit(ASTNode[] nodes, SourceUnit source) {
        ClassNode clazz = (ClassNode) nodes[1];
        clazz.setSuperClass(new ClassNode(GroovyTestCase.class));
    }

                public static boolean isClassUnderTestLoaded;
                private final Class<?> bootstrappedTestClass;

                public CustomRunner(Class<?> clazz) throws Exception {
                    super(clazz);
                    bootstrappedTestClass = clazz;
                }

                @Override
                protected Statement methodBlock(final FrameworkMethod method) {
                    return new Statement() {

        createJavaClass("Class1")
        def source2 = createJavaClass("Class2", "proto")
        def class1 = scalaClassFile('Class1.class')
        def class2 = scalaClassFile('proto/Class2.class')

        when:
        withBuildCache().run(compilationTask)
        then:
        class1.isFile()
        class2.isFile()
        file(compiledFile).isFile()

 *
 * @author koichik
 */
class JclLoggerAdapterFactory implements LoggerAdapterFactory {

    @Override
    public LoggerAdapter getLoggerAdapter(final Class<?> clazz) {
        return new JclLoggerAdapter(clazz);
    }

    @Override
    public void releaseAll() {
        LogFactory.releaseAll();
    }

     *
     * @param clazz
     *            クラス
     * @return コンバータ
     */
    protected Converter findDefaultConverter(final Class<?> clazz) {
        if (clazz == java.sql.Date.class) {
            return DEFAULT_DATE_CONVERTER;
        }
        if (clazz == Time.class) {
            return DEFAULT_TIME_CONVERTER;
        }
        if (java.util.Date.class.isAssignableFrom(clazz)) {

    }

    @Override
    public ClassLoader getLocalClassLoader() {
        return localClassLoader;
    }

    @Override
    public boolean defines(Class<?> clazz) {
        return localClassLoader.equals(clazz.getClassLoader());
    }

    @Override
    public void onReuse() {
        parent.onReuse();
        listener.childScopeCreated(parent.getId(), id, origin);

        normalizer.appendConfigurationToHasher(hasher)
        return hasher.hash()
    }

    private static byte[] bytesOf(Class<?> clazz) {
        String classFile = "/${clazz.getName().replaceAll('\\.', '/')}.class"
        return IOUtils.toByteArray(clazz.getResource(classFile).openStream())
    }

        Constructor[] constructors = NativeServices.getConstructors()

        expect:
        constructors.size() == 0
    }

    private static URL jar(Class clazz) {
        clazz.getProtectionDomain().getCodeSource().getLocation()
    }

        cast.apply(target);
    }

    @Override
    public void applyRules(@Nullable String pluginId, Class<?> clazz) {
        String message = String.format("Cannot apply model rules of plugin '%s' as the target '%s' is not model rule aware", clazz.getName(), target.toString());
        throw new UnsupportedOperationException(message);
    }

    @Override