def actor = factory.createBlockingActor(target)
        def testThread = Thread.currentThread()

        when:
        actor.dispatch(new MethodInvocation(TargetObject.class.getMethod('doStuff', String.class), ['param'] as Object[]))

        then:
        1 * target.doStuff('param') >> {
            assert Thread.currentThread() == testThread
        }
    }

                } else {
                    addDir(entry.name)
                }
                addMode(entry.name, entry.getUnixMode())
                addCompressionMethod(entry.name, entry.getMethod())
            }
        } finally {
            zipFile.close();
        }
    }

    void hasCompression(String relativePath, int compressionMethod) {

        ClassLoader loader = getClass().getClassLoader();
        try {
            Method getEncoderMethod = loader.loadClass("java.util.Base64").getMethod("getEncoder");
            Method encodeMethod = loader.loadClass("java.util.Base64$Encoder").getMethod("encodeToString", byte[].class);
            Object encoder = getEncoderMethod.invoke(null);

    public static String displayValueOf(Object value) {
        String result = null;
        if (value != null) {
            boolean hasCustomToString;
            try {
                Method toString = value.getClass().getMethod("toString");
                hasCustomToString = !toString.getDeclaringClass().equals(Object.class);
            } catch (NoSuchMethodException ignore) {
                hasCustomToString = false;
            }

                                    optionValueMethod.getMethod().getDeclaringClass().getName()));
                }
            }
        }
        return valueMethod;
    }

    private static String[] getOptionNames(JavaMethod<Object, Collection> optionValueMethod) {
        OptionValues optionValues = optionValueMethod.getMethod().getAnnotation(OptionValues.class);
        return optionValues.value();
    }

                    return ByteStreams.toByteArray(inputStream);
                }
            }
        });
    }

    @Override
    public ZipCompressionMethod getCompressionMethod() {
        switch (entry.getMethod()) {
            case java.util.zip.ZipEntry.STORED:
                return ZipCompressionMethod.STORED;
            case java.util.zip.ZipEntry.DEFLATED:
                return ZipCompressionMethod.DEFLATED;

    def proxyForwardsToDispatch() {
        when:
        adapter.getSource().doStuff('param')

        then:
        1 * dispatch.dispatch(new MethodInvocation(ProxyTest.class.getMethod('doStuff', String.class), ['param'] as Object[]))
    }

    def proxyIsEqualWhenItHasTheSameTypeAndDispatch() {
        def other = new ProxyDispatchAdapter<ProxyTest>(dispatch, ProxyTest.class)

        HttpContext context = Mock()
        response.getFirstHeader("location") >> new BasicHeader('location', 'http://redirectTo')
        request.getRequestLine() >> Mock(RequestLine) {
            getMethod() >> httpMethod
        }
        request.getParams() >> Mock(HttpParams)

        when:
        def redirect = new AlwaysFollowAndPreserveMethodRedirectStrategy().getRedirect(request, response, context)

        assertTrue(6 == responseData.getContentLength() || 7 == responseData.getContentLength());
        assertNotNull(responseData.getLastModified());
        assertEquals(Constants.GET_METHOD, responseData.getMethod());
        assertEquals("text/plain", responseData.getMimeType());
        assertTrue(responseData.getUrl().endsWith("test/text1.txt"));

                    }

                    visitMethodCallExpression((MethodCallExpression) target);
                }

                if (call.getMethod() instanceof ConstantExpression) {
                    ConstantExpression methodName = (ConstantExpression) call.getMethod();
                    if (isOfType(methodName, String.class)) {
                        String methodNameText = methodName.getText();