Java Examples for javax.ws.rs.core.MultivaluedMap

public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) throws IOException {
    MultivaluedMap<String, Object> headers = responseContext.getHeaders();
    headers.add("Access-Control-Allow-Origin", "*");
    //headers.add("Access-Control-Allow-Origin", "http://podcastpedia.org"); //allows CORS requests only coming from podcastpedia.org		
    headers.add("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT");
    headers.add("Access-Control-Allow-Headers", "X-Requested-With, Content-Type, X-Codingpedia");
}

/* (non-Javadoc)
	 * @see javax.ws.rs.ext.MessageBodyWriter#writeTo(java.lang.Object, java.lang.Class, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType, javax.ws.rs.core.MultivaluedMap, java.io.OutputStream)
	 */
//@Override
public void writeTo(Renderable viewingPleasure, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    try {
        viewingPleasure.render(// and entityStream is committed after writeTo and interceptors returns.
        new HttpServletRequestWrapper(getContextData(HttpServletRequest.class)) {

            @Override
            public boolean isAsyncSupported() {
                return false;
            }

            @Override
            public boolean isAsyncStarted() {
                return false;
            }

            @Override
            public AsyncContext getAsyncContext() {
                throw new IllegalStateException();
            }

            @Override
            public AsyncContext startAsync() throws IllegalStateException {
                throw new IllegalStateException();
            }

            @Override
            public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException {
                throw new IllegalStateException();
            }
        }, // Also disable async processing on the ServletOutputStream, for consistency with the request.
        new HttpServletResponseWrapper(getContextData(HttpServletResponse.class)) {

            private ServletOutputStream outputStream;

            private PrintWriter writer;

            @Override
            public ServletOutputStream getOutputStream() {
                if (writer != null) {
                    throw new IllegalStateException();
                }
                if (outputStream == null) {
                    outputStream = new ServletOutputStream() {

                        @Override
                        public boolean isReady() {
                            return true;
                        }

                        @Override
                        public void setWriteListener(WriteListener writeListener) {
                            throw new IllegalStateException();
                        }

                        @Override
                        public void write(int b) throws IOException {
                            entityStream.write(b);
                        }

                        @Override
                        public void write(byte[] b) throws IOException {
                            entityStream.write(b);
                        }

                        @Override
                        public void write(byte[] b, int off, int len) throws IOException {
                            entityStream.write(b, off, len);
                        }

                        @Override
                        public void flush() throws IOException {
                            entityStream.flush();
                        }

                        @Override
                        public void close() throws IOException {
                            entityStream.close();
                        }
                    };
                }
                return outputStream;
            }

            @Override
            public PrintWriter getWriter() throws IOException {
                if (outputStream != null) {
                    throw new IllegalStateException();
                }
                if (writer == null) {
                    writer = new PrintWriter(new OutputStreamWriter(entityStream, getCharacterEncoding()));
                }
                return writer;
            }
        });
    } catch (ServletException ex) {
        throw new WebApplicationException(ex);
    }
}

public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) throws IOException {
    MultivaluedMap<String, Object> headers = responseContext.getHeaders();
    headers.add("Access-Control-Allow-Origin", "*");
    headers.add("Access-Control-Allow-Headers", "origin, content-type, accept, authorization");
    headers.add("Access-Control-Allow-Credentials", "true");
    headers.add("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS, HEAD");
    headers.add("Access-Control-Max-Age", "1209600");
}

public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) throws IOException {
    MultivaluedMap<String, Object> headers = responseContext.getHeaders();
    headers.add("Access-Control-Allow-Origin", "*");
    //headers.add("Access-Control-Allow-Origin", "http://podcastpedia.org"); //allows CORS requests only coming from podcastpedia.org		
    headers.add("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT");
    headers.add("Access-Control-Allow-Headers", "X-Requested-With, Content-Type, Authorization");
}

@Override
public void filter(ContainerRequestContext requestContext) throws IOException {
    ObjectReaderInjector.set(new ObjectReaderModifier() {

        @Override
        public ObjectReader modify(EndpointConfigBase<?> endpoint, MultivaluedMap<String, String> httpHeaders, JavaType resultType, ObjectReader r, JsonParser p) throws IOException {
            if (gitHubClasses.contains(resultType.getRawClass())) {
                return r.with(r.getConfig().with(PropertyNamingStrategy.SNAKE_CASE));
            } else {
                return r;
            }
        }
    });
}

public static boolean isRequestCompressedWithGzip(ContainerRequestContext requestContext) {
    MultivaluedMap<String, String> headers = requestContext.getHeaders();
    List<String> encodingHeaderValues = headers.get(CLOUDSTORE_ENCODING_HEADER);
    if (encodingHeaderValues == null || encodingHeaderValues.size() != 1) {
        return false;
    }
    return CLOUDSTORE_ENCODING_HEADER_VALUE.equals(encodingHeaderValues.get(0));
}

@Override
public ContainerRequest filter(ContainerRequest request) {
    MultivaluedMap<String, String> requestHeaders = request.getRequestHeaders();
    List<String> requestHeader = requestHeaders.get("Content-Type");
    if (requestHeader != null) {
        String contentType = requestHeader.get(0);
        if (contentType.startsWith("text/plain")) {
            String newContentType = "application/json" + contentType.substring(10);
            requestHeaders.remove("Content-Type");
            requestHeaders.add("Content-Type", newContentType);
            request.setHeaders((InBoundHeaders) requestHeaders);
        }
    }
    return request;
}

public void writeTo(Object o, Class aClass, Type type, Annotation[] annotations, MediaType mediaType, MultivaluedMap httpHeaders, OutputStream outputStream) throws IOException, WebApplicationException {
    Integer[] integers = (Integer[]) o;
    StringBuilder line = new StringBuilder();
    line.append(testComponent.getTestString()).append(",");
    for (Integer integer : integers) {
        line.append(integer).append(",");
    }
    if (line.length() > 0) {
        line.deleteCharAt(line.length() - 1);
    }
    outputStream.write(line.toString().getBytes());
}

@Override
public void filter(ClientRequestContext requestContext) throws IOException {
    // add header to define the api version
    requestContext.getHeaders().add("Accept", "version=2");
    // log all headers
    MultivaluedMap<String, Object> headers = requestContext.getHeaders();
    Iterator<?> it = headers.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<?, ?> pair = (Map.Entry<?, ?>) it.next();
        logger.debug("Header name: {}, value: {}.", pair.getKey(), pair.getValue());
    }
}

public static ReportParameters toReportParameters(MultivaluedMap<String, String> params) {
    List<ReportParameter> parameters = new ArrayList<ReportParameter>();
    for (MultivaluedMap.Entry<String, List<String>> entry : params.entrySet()) {
        ReportParameter parameter = new ReportParameter();
        parameter.setName(entry.getKey());
        parameter.setValues(entry.getValue());
        parameters.add(parameter);
    }
    return new ReportParameters(parameters);
}

@Test
public void shouldAddCorsHeaders() {
    CorsFilter filter = new CorsFilter();
    ContainerRequestContext reqContext = mock(ContainerRequestContext.class);
    ContainerResponseContext resContext = mock(ContainerResponseContext.class);
    MultivaluedMap<String, Object> headers = mock(MultivaluedMap.class);
    when(resContext.getHeaders()).thenReturn(headers);
    filter.filter(reqContext, resContext);
    verify(headers).add("Access-Control-Allow-Origin", "*");
    verify(headers).add("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
}

public void testGetAllSecurities() throws Exception {
    MultivaluedMap<String, String> queryParameters = _uriInfo.getQueryParameters();
    queryParameters.putSingle("name", StringUtils.EMPTY);
    queryParameters.putSingle("identifier", StringUtils.EMPTY);
    queryParameters.putSingle("type", StringUtils.EMPTY);
    queryParameters.put("securityId", Collections.<String>emptyList());
    String resultJson = _webSecuritiesResource.getJSON(null, null, null, null, null, queryParameters.getFirst("name"), queryParameters.getFirst("identifier"), queryParameters.getFirst("type"), queryParameters.get("securityId"), _uriInfo);
    assertNotNull(resultJson);
    assertJSONObjectEquals(loadJson("com/opengamma/web/security/allSecuritiesJson.txt"), new JSONObject(resultJson));
}

public void writeTo(Object o, Class aClass, Type type, Annotation[] annotations, MediaType mediaType, MultivaluedMap httpHeaders, OutputStream outputStream) throws IOException, WebApplicationException {
    Integer[] integers = (Integer[]) o;
    StringBuilder line = new StringBuilder();
    line.append(testComponent.getTestString()).append(",");
    for (Integer integer : integers) {
        line.append(integer).append(",");
    }
    if (line.length() > 0) {
        line.deleteCharAt(line.length() - 1);
    }
    outputStream.write(line.toString().getBytes());
}

public void writeTo(Object o, Class aClass, Type type, Annotation[] annotations, MediaType mediaType, MultivaluedMap httpHeaders, OutputStream outputStream) throws IOException, WebApplicationException {
    Integer[] integers = (Integer[]) o;
    StringBuilder line = new StringBuilder();
    line.append(testComponent.getTestString()).append(",");
    for (Integer integer : integers) {
        line.append(integer).append(",");
    }
    if (line.length() > 0) {
        line.deleteCharAt(line.length() - 1);
    }
    outputStream.write(line.toString().getBytes());
}

@Override
public void filter(ContainerRequestContext request) {
    MultivaluedMap<String, String> headers = request.getHeaders();
    if (headers.containsKey(HttpHeaders.ACCEPT_LANGUAGE)) {
        List<String> acceptLanguageValues = headers.remove(HttpHeaders.ACCEPT_LANGUAGE);
        for (int i = 0; i < acceptLanguageValues.size(); i++) {
            final String acceptLanguageValue = acceptLanguageValues.get(i);
            // replace es-419 (invalid) with es_ES (valid, hopefully good enough.)
            if (acceptLanguageValue.contains(ES_419)) {
                acceptLanguageValues.set(i, acceptLanguageValue.replace(ES_419, ES_ES));
            }
        }
        headers.put(HttpHeaders.ACCEPT_LANGUAGE, acceptLanguageValues);
    }
}

@Override
public void aroundWriteTo(WriterInterceptorContext context) throws IOException, WebApplicationException {
    boolean compress = false;
    String ae = request.getHeader("accept-encoding");
    if (ae != null && ae.indexOf("gzip") >= 0) {
        compress = true;
    }
    if (compress) {
        MultivaluedMap<String, Object> headers = context.getHeaders();
        for (Object type : headers.get("content-type")) {
            String ctype = type.toString();
            if (ctype.contains("zip") || ctype.contains("compress") || ctype.contains("image")) {
                compress = false;
                break;
            }
        }
        if (compress) {
            headers.add("Content-Encoding", "gzip");
            final OutputStream outputStream = context.getOutputStream();
            context.setOutputStream(new GZIPOutputStream(outputStream));
        }
    }
    context.proceed();
}

/**
     * @see MessageBodyWriter#writeTo(Object, Class, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType,
     *      javax.ws.rs.core.MultivaluedMap, java.io.OutputStream)
     */
@Override
public void writeTo(MergeResult mergeResult, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    Writer writer = new OutputStreamWriter(entityStream);
    MergeResult.MergeStatus status = mergeResult.getMergeStatus();
    switch(mergeResult.getMergeStatus()) {
        case FAST_FORWARD:
        case ALREADY_UP_TO_DATE:
        case MERGED:
            writer.write(status.toString());
            writer.write('\n');
            break;
        case FAILED:
            writer.write("error: Failed to merge:");
            for (String failed : mergeResult.getFailed()) {
                writer.write("        ");
                writer.write(failed);
                writer.write('\n');
            }
            break;
        case CONFLICTING:
            for (String conflict : mergeResult.getConflicts()) {
                writer.write("CONFLICT(content): Merge conflict in: " + conflict);
                writer.write('\n');
            }
            writer.write("Automatic merge failed; fix conflicts and then commit the result");
            writer.write('\n');
            break;
        case NOT_SUPPORTED:
            writer.write("Operation not supported");
            writer.write('\n');
            break;
        default:
            break;
    }
    writer.flush();
}

/**
     * @see MessageBodyWriter#writeTo(Object, Class, java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType,
     *      javax.ws.rs.core.MultivaluedMap, java.io.OutputStream)
     */
@Override
public void writeTo(MergeResult mergeResult, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    Writer writer = new OutputStreamWriter(entityStream);
    MergeResult.MergeStatus status = mergeResult.getMergeStatus();
    switch(mergeResult.getMergeStatus()) {
        case FAST_FORWARD:
        case ALREADY_UP_TO_DATE:
        case MERGED:
            writer.write(status.toString());
            writer.write('\n');
            break;
        case FAILED:
            writer.write("error: Failed to merge:");
            for (String failed : mergeResult.getFailed()) {
                writer.write("        ");
                writer.write(failed);
                writer.write('\n');
            }
            break;
        case CONFLICTING:
            for (String conflict : mergeResult.getConflicts()) {
                writer.write("CONFLICT(content): Merge conflict in: " + conflict);
                writer.write('\n');
            }
            writer.write("Automatic merge failed; fix conflicts and then commit the result");
            writer.write('\n');
            break;
        case NOT_SUPPORTED:
            writer.write("Operation not supported");
            writer.write('\n');
            break;
        default:
            break;
    }
    writer.flush();
}

/**
     * Fetches all gpx data that are within the specified bounding box and page
     * number.
     *
     * @param responseType Class representing the response
     * @param String leftLong
     * @param String bottomLat
     * @param String rightLong
     * @param String topLat
     * @param String page
     * @return response object (instance of responseType class)
     */
public <T> T getGpsTracks(Class<T> responseType, String leftLong, String bottomLat, String rightLong, String topLat, String page) throws com.sun.jersey.api.client.UniformInterfaceException {
    javax.ws.rs.core.MultivaluedMap<String, String> qParams = new com.sun.jersey.api.representation.Form();
    qParams.add("bbox", MessageFormat.format("{0},{1},{2},{3}", leftLong, bottomLat, rightLong, topLat));
    qParams.add("page", page);
    return webResource.path("trackpoints").queryParams(qParams).accept(MediaType.TEXT_XML, MediaType.APPLICATION_XML).get(responseType);
}

/**
	 * @see javax.ws.rs.ext.MessageBodyWriter#writeTo(java.lang.Object, java.lang.Class,
	 *      java.lang.reflect.Type, java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType,
	 *      javax.ws.rs.core.MultivaluedMap, java.io.OutputStream)
	 */
@Override
public void writeTo(RDF t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    if (rdfContext == null)
        throw new JAXBMarshalException(Messages.i18n.format("UNABLE_TO_MARSHAL", mediaType), new NullPointerException(Messages.i18n.format("FAILED_TO_CREATE_ONT_JAXBCTX")));
    try {
        rdfContext.createMarshaller().marshal(t, entityStream);
    } catch (JAXBException e) {
        throw new JAXBMarshalException(Messages.i18n.format("UNABLE_TO_MARSHAL", mediaType), e);
    }
}

/**
    * @param t
    * @param type
    * @param genericType
    * @param annotations
    * @param mediaType
    * @param httpHeaders
    * @param entityStream
    * @throws java.io.IOException
    * @throws javax.ws.rs.WebApplicationException
    * @see javax.ws.rs.ext.MessageBodyWriter#writeTo(Object,
    *      Class, java.lang.reflect.Type,
    *      java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType,
    *      javax.ws.rs.core.MultivaluedMap, java.io.OutputStream)
    */
public void writeTo(IIOImage t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException {
    ImageWriter writer = IIOImageProviderHelper.getImageWriterByMediaType(mediaType);
    ImageWriteParam param;
    if (mediaType.equals(MediaType.valueOf("image/jpeg"))) {
        param = new JPEGImageWriteParam(Locale.US);
    } else {
        param = writer.getDefaultWriteParam();
    }
    /*
      * If the image output type supports compression, set it to the highest
      * maximum
      */
    ImageWriterParams writerParams = FindAnnotation.findAnnotation(annotations, ImageWriterParams.class);
    if (writerParams != null) {
        if (param.canWriteCompressed()) {
            param.setCompressionMode(writerParams.compressionMode());
            param.setCompressionQuality(writerParams.compressionQuality());
        }
    } else if (param.canWriteCompressed()) {
        param.setCompressionMode(ImageWriteParam.MODE_EXPLICIT);
        param.setCompressionQuality(1.0f);
    }
    BufferedOutputStream buff = new BufferedOutputStream(entityStream, 2048);
    ImageOutputStream ios = ImageIO.createImageOutputStream(buff);
    try {
        writer.setOutput(ios);
        IIOImage img = new IIOImage(t.getRenderedImage(), null, null);
        writer.write(null, img, param);
    } finally {
        writer.dispose();
    }
}

/**
     * {@inheritDoc}
     */
@Override
public ObjectWriter modify(final EndpointConfigBase<?> endpoint, final MultivaluedMap<String, Object> responseHeaders, final Object valueToWrite, final ObjectWriter w, final JsonGenerator g) throws IOException {
    final ObjectWriter writer = original == null ? w : original.modify(endpoint, responseHeaders, valueToWrite, w, g);
    final FilterProvider customFilterProvider = writer.getConfig().getFilterProvider();
    // Try the custom (user) filter provider first.
    return customFilterProvider == null ? writer.with(filterProvider) : writer.with(new FilterProvider() {

        @Override
        public BeanPropertyFilter findFilter(final Object filterId) {
            return customFilterProvider.findFilter(filterId);
        }

        @Override
        public PropertyFilter findPropertyFilter(final Object filterId, final Object valueToFilter) {
            final PropertyFilter filter = customFilterProvider.findPropertyFilter(filterId, valueToFilter);
            if (filter != null) {
                return filter;
            }
            return filterProvider.findPropertyFilter(filterId, valueToFilter);
        }
    });
}

/**
     * @see javax.ws.rs.ext.MessageBodyWriter#writeTo(java.lang.Object, java.lang.Class, java.lang.reflect.Type,
     *      java.lang.annotation.Annotation[], javax.ws.rs.core.MediaType, javax.ws.rs.core.MultivaluedMap,
     *      java.io.OutputStream)
     */
@Override
public void writeTo(ContentStream t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    String mimeType = t.getMimeType();
    if (mimeType != null) {
        httpHeaders.putSingle(HttpHeaders.CONTENT_TYPE, mimeType);
    }
    httpHeaders.putSingle("Content-Disposition", "attachment; filename=\"" + t.getFileName() + '"');
    Date lastModificationDate = t.getLastModificationDate();
    if (lastModificationDate != null) {
        httpHeaders.putSingle(HttpHeaders.LAST_MODIFIED, t.getLastModificationDate());
    }
    httpHeaders.putSingle(HttpHeaders.CACHE_CONTROL, "public, no-cache, no-store, no-transform");
    try (InputStream content = t.getStream()) {
        byte[] buf = new byte[8192];
        int rd;
        while ((rd = content.read(buf)) != -1) {
            entityStream.write(buf, 0, rd);
        }
        entityStream.flush();
    }
}

@Override
public Object readFrom(Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException {
    InputStreamReader streamReader = new InputStreamReader(entityStream, UTF_8);
    try {
        Type jsonType;
        if (type.equals(genericType)) {
            jsonType = type;
        } else {
            jsonType = genericType;
        }
        return getGson().fromJson(streamReader, jsonType);
    } finally {
        streamReader.close();
    }
}

@Override
public void execute() {
    Client jerseyClient = context.getJerseyClient();
    // setup the query
    WebResource webResource = jerseyClient.resource(quepyURL);
    MultivaluedMap<String, String> params = new MultivaluedMapImpl();
    params.add("text", question.getQuestion());
    // get the response
    ClientResponse response = webResource.queryParams(params).type("application/x-www-form-urlencoded").get(ClientResponse.class);
    String text = response.getEntity(String.class);
    //System.out.println(text);
    ObjectMapper mapper = new ObjectMapper();
    try {
        JsonNode rootNode = mapper.readTree(text);
        String errorMessage = rootNode.path("error").asText();
        if (!"".equals(errorMessage)) {
            throw new StageException(errorMessage, ErrorCodes.COULD_NOT_UNDERSTAND_QUESTION);
        }
        // Note that we could have multiple answers (or the answer could be a list) and this only extracts the first result
        String query = rootNode.path("query").asText();
        // set the query where the Run Query stage expects it
        List<String> queries = new ArrayList<>();
        queries.add(query);
        context.addOutput(RunSPARQLQueryStage.EXPECTED_INPUT_NAME, queries);
        setOutput(text);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
}

public void writeTo(Object m, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    LinkedBuffer buffer = LinkedBuffer.allocate(1024);
    if (List.class.isInstance(m)) {
        Schema schema = RuntimeSchema.getSchema(getListGenericType((List) m, genericType));
        ProtobufIOUtil.writeListTo(entityStream, (List) m, schema, buffer);
    } else {
        Schema schema = RuntimeSchema.getSchema(type);
        ProtobufIOUtil.writeTo(entityStream, m, schema, buffer);
    }
}

public void writeTo(InputStream inputStream, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException {
    int c = inputStream.read();
    if (c == -1) {
        httpHeaders.putSingle(HttpHeaderNames.CONTENT_LENGTH, Integer.toString(0));
        // fix RESTEASY-204
        entityStream.write(new byte[0]);
        return;
    } else
        entityStream.write(c);
    while ((c = inputStream.read()) != -1) {
        entityStream.write(c);
    }
}

public Object readFrom(Class<Object> receivedClassInfo, Type type, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> stringStringMultivaluedMap, InputStream inputStream) throws IOException, WebApplicationException {
    Document<Element> doc = getAbderaInstance().getParser().parse(inputStream);
    Element el = doc.getRoot();
    if (!receivedClassInfo.isAssignableFrom(el.getClass())) {
        throw new IOException("Unexpected payload, expected " + receivedClassInfo.getName() + ", received " + el.getClass().getName());
    }
    return el;
}

@Override
public void writeTo(Object t, Class<?> type, Type type1, Annotation[] antns, MediaType mt, MultivaluedMap<String, Object> headers, OutputStream out) throws IOException, WebApplicationException {
    try {
        List ct = Collections.singletonList(Constants.GWT_RPC_MEDIA_TYPE + "; charset=UTF-8");
        if (!ct.equals(headers.get("Content-Type"))) {
            headers.put("Content-Type", ct);
        }
        if (t instanceof String && ((String) t).isEmpty()) {
            out.flush();
            return;
        }
        String data = GwtRpcUtil.serialize(t);
        out.write(data.getBytes("UTF-8"));
        out.flush();
    } catch (SerializationException ex) {
        logger.error("Failed to serialize message", ex);
    }
}

@Override
public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) throws IOException {
    MultivaluedMap<String, Object> headers = responseContext.getHeaders();
    headers.add("Access-Control-Allow-Origin", "*");
    headers.add("Access-Control-Allow-Methods", "POST, GET, UPDATE, OPTIONS");
    headers.add("Access-Control-Allow-Headers", "x-http-method-override, content-type");
}

@Override
public void writeTo(Object object, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    try (OutputStreamWriter writer = new OutputStreamWriter(entityStream, Charsets.UTF_8)) {
        try (JsonWriter jsonWriter = new JsonWriter(new BufferedWriter(writer))) {
            if (object instanceof GeneratedMessage) {
                ProtobufJsonWriter.serialize((GeneratedMessage) object, jsonWriter);
            } else {
                Iterable<? extends Message> iterable = (Iterable<? extends Message>) object;
                jsonWriter.beginArray();
                for (Message msg : iterable) {
                    ProtobufJsonWriter.serialize(msg, jsonWriter);
                }
                jsonWriter.endArray();
            }
        }
    }
}

/**
     * Get file system using its storageResourceId
     * 
     * @param storageResourceId
     * @return
     */
public VNXeFileSystem getByStorageResource(String storageResourceId) {
    MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl();
    queryParams.add(VNXeConstants.FILTER, VNXeConstants.STORAGE_RESOURCE_FILTER + "\"" + storageResourceId + "\"");
    setQueryParameters(queryParams);
    VNXeFileSystem result = null;
    List<VNXeFileSystem> fsList = getDataForObjects(VNXeFileSystem.class);
    // it should just return 1
    if (fsList != null && !fsList.isEmpty()) {
        result = fsList.get(0);
    } else {
        _logger.info("No file system found using the storage resource id: " + storageResourceId);
    }
    return result;
}

public void writeTo(String obj, Class<?> type, Type genType, Annotation[] anns, MediaType mt, MultivaluedMap<String, Object> headers, OutputStream os) throws IOException {
    if (type == String.class && type == genType) {
        obj = "Nonexistent method".equals(obj) ? "StringTextWriter - " + obj : obj;
        super.writeTo(obj, type, genType, anns, mt, headers, os);
        return;
    }
    throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
}

@Test
public void testSnappyReaderInterceptor() throws IOException {
    SnappyReaderInterceptor readerInterceptor = new SnappyReaderInterceptor();
    MultivaluedMap<String, String> headers = new MultivaluedHashMap<>();
    headers.put(SnappyReaderInterceptor.CONTENT_ENCODING, Arrays.asList(SnappyReaderInterceptor.SNAPPY));
    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
    SnappyFramedOutputStream snappyFramedOutputStream = new SnappyFramedOutputStream(byteArrayOutputStream);
    snappyFramedOutputStream.write("Hello".getBytes());
    ByteArrayInputStream inputStream = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
    ReaderInterceptorContext mockInterceptorContext = Mockito.mock(ReaderInterceptorContext.class);
    Mockito.when(mockInterceptorContext.getHeaders()).thenReturn(headers);
    Mockito.when(mockInterceptorContext.getInputStream()).thenReturn(inputStream);
    Mockito.doNothing().when(mockInterceptorContext).setInputStream(Mockito.any(InputStream.class));
    // call aroundReadFrom on mock
    readerInterceptor.aroundReadFrom(mockInterceptorContext);
    // verify that setInputStream method was called once with argument which is an instance of SnappyFramedInputStream
    Mockito.verify(mockInterceptorContext, Mockito.times(1)).setInputStream(Mockito.any(SnappyFramedInputStream.class));
}

@Override
public Object readFrom(Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException {
    try {
        JSONObject json = new JSONObject(JavaUtils.readText(entityStream));
        Method method = getFactoryMethod(type);
        if (method != null) {
            return method.invoke(CoreActivator.getModelFactory(), json);
        } else {
            return getJSONConstructor(type).newInstance(json);
        }
    } catch (Exception e) {
        throw new RuntimeException("Deserializing a " + type.getName() + " object failed", e);
    }
}

public void writeTo(Object o, ResponseTemplate annotation, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream os) throws IOException {
    ModelWrapper model = new ModelWrapper(this.model.getData(), manager);
    model.put(annotation.responseName(), o);
    Template template = null;
    template = Velocity.getTemplate(annotation.value());
    OutputStreamWriter writer = new OutputStreamWriter(os);
    template.merge(new VelocityContext(model), writer);
    writer.flush();
}

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public void writeTo(Optional<?> entity, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException {
    if (!entity.isPresent()) {
        throw new NotFoundException();
    }
    final Type innerGenericType = (genericType instanceof ParameterizedType) ? ((ParameterizedType) genericType).getActualTypeArguments()[0] : entity.get().getClass();
    MessageBodyWriter writer = mbw.get().getMessageBodyWriter(entity.get().getClass(), innerGenericType, annotations, mediaType);
    writer.writeTo(entity.get(), entity.get().getClass(), innerGenericType, annotations, mediaType, httpHeaders, entityStream);
}

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public void writeTo(Optional<?> entity, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException {
    if (!entity.isPresent()) {
        throw EmptyOptionalException.INSTANCE;
    }
    final Type innerGenericType = (genericType instanceof ParameterizedType) ? ((ParameterizedType) genericType).getActualTypeArguments()[0] : entity.get().getClass();
    final MessageBodyWriter writer = mbw.get().getMessageBodyWriter(entity.get().getClass(), innerGenericType, annotations, mediaType);
    writer.writeTo(entity.get(), entity.get().getClass(), innerGenericType, annotations, mediaType, httpHeaders, entityStream);
}

@Test
public void testGetGeoRSSFormat() {
    AbstractRestSearchEndpoint endpoint = Mockito.mock(AbstractRestSearchEndpoint.class, Mockito.CALLS_REAL_METHODS);
    MultivaluedMap<String, String> props = new MetadataMap<String, String>();
    Assert.assertNull(endpoint.getGeoRSSFormat(props));
    props.putSingle(SearchConstants.GEORSS_RESULT_FORMAT_PARAMETER, null);
    Assert.assertNull(endpoint.getGeoRSSFormat(props));
    props.clear();
    props.putSingle(SearchConstants.GEORSS_RESULT_FORMAT_PARAMETER, "");
    props.clear();
    props.putSingle(SearchConstants.GEORSS_RESULT_FORMAT_PARAMETER, "value");
    assertEquals("value", endpoint.getGeoRSSFormat(props));
    props.clear();
    props.put(SearchConstants.GEORSS_RESULT_FORMAT_PARAMETER, Arrays.asList("value1", "value2"));
    assertEquals("value1", endpoint.getGeoRSSFormat(props));
}

@Override
public void filter(final ContainerRequestContext requestContext, final ContainerResponseContext responseContext) throws IOException {
    final MultivaluedMap<String, Object> headers = responseContext.getHeaders();
    headers.add(ACCESS_CONTROL_ALLOW_ORIGIN_KEY, ACCESS_CONTROL_ALLOW_ORIGIN_VALUE);
    headers.add(ACCESS_CONTROL_ALLOW_HEADERS_KEY, ACCESS_CONTROL_ALLOW_HEADERS_VALUE);
    headers.add(ACCESS_CONTROL_ALLOW_CREDENTIALS_KEY, ACCESS_CONTROL_ALLOW_CREDENTIALS_VALUE);
    headers.add(ACCESS_CONTROL_ALLOW_METHODS_KEY, ACCESS_CONTROL_ALLOW_METHODS_VALUE);
    headers.add(ACCESS_CONTROL_MAX_AGE_KEY, ACCESS_CONTROL_MAX_AGE_VALUE);
}

@Override
public void writeTo(T t, Class<?> cls, Type genericType, Annotation[] anns, MediaType m, MultivaluedMap<String, Object> headers, OutputStream os) throws IOException {
    String prefix = getContext().getHttpServletRequest().getParameter("_jsonp");
    //!isEmpty(prefix);
    boolean hasPrefix = !(null == prefix || prefix.isEmpty());
    if (hasPrefix) {
        os.write(prefix.getBytes(HttpUtils.getSetEncoding(m, headers, "UTF-8")));
        os.write('(');
    }
    super.writeTo(t, cls, genericType, anns, m, headers, os);
    if (hasPrefix) {
        os.write(')');
    }
}

public static Pair[] fromMap(MultivaluedMap<String, Object> source) {
    if (!(source == null || source.isEmpty())) {
        final List<Pair> list = new ArrayList<>();
        for (String key : source.keySet()) {
            List<Object> values = source.get(key);
            if (!(values == null || values.isEmpty())) {
                for (Object v : values) {
                    list.add(Pair.of(key, HeaderHelper.getHeaderAsString(v)));
                }
            } else {
                list.add(Pair.of(key, null));
            }
        }
        return list.toArray(new Pair[list.size()]);
    }
    return new Pair[0];
}

@Override
public void filter(ClientRequestContext requestContext) throws IOException {
    if (Strings.isNotBlank(authorizationHeader)) {
        MultivaluedMap<String, Object> headers = requestContext.getHeaders();
        headers.put("Authorization", Collections.<Object>singletonList(authorizationHeader));
        if (LOG.isDebugEnabled()) {
            LOG.debug("Added authorizationHeader: " + authorizationHeader);
        }
    }
}

private MultivaluedMap<String, Object> extractMetaData(ClientResponse jettyResponse) {
    MultivaluedMap<String, Object> metadata = new StringKeyObjectValueIgnoreCaseMultivaluedMap();
    for (Map.Entry<String, List<String>> header : jettyResponse.getHeaders().entrySet()) {
        for (Object value : header.getValue()) {
            metadata.putSingle(header.getKey(), value);
        }
    }
    return metadata;
}

@Override
public void writeTo(Map map, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    StringBuilder data = new StringBuilder();
    for (Object key : map.keySet()) {
        data.append(key.toString());
        data.append(":");
        if (null == map.get(key.toString())) {
            data.append("Check logs for more details");
        } else {
            data.append(map.get(key.toString()).toString());
        }
        data.append("\n");
    }
    entityStream.write(data.toString().getBytes());
}

@Override
public void writeTo(Collection<Language> detected, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    JsonGenerator jg = getJsonFactory().createJsonGenerator(entityStream);
    jg.writeStartArray();
    for (Language lang : detected) {
        jg.writeStartObject();
        jg.writeStringField("lang", lang.getLang());
        if (lang.getProb() > 0) {
            jg.writeNumberField("prob", lang.getProb());
        }
        jg.writeEndObject();
    }
    jg.writeEndArray();
    jg.close();
}

@Before
public void init() {
    StatisticsManager statisticsManager = mock(StatisticsManager.class);
    ScheduledExecutorService executor = mock(ScheduledExecutorService.class);
    ClientResponse clientResponse = mock(ClientResponse.class);
    response = mock(JsonRestClientResponse.class);
    when(response.getJsonResponse()).thenReturn("[{\"one\":1, \"two\":2, \"three\":3}]");
    when(response.getStatusCode()).thenReturn(200);
    when(response.getClientResponse()).thenReturn(clientResponse);
    SFlowRTConnection connection = mock(SFlowRTConnection.class);
    when(connection.get(anyString(), Mockito.<MultivaluedMap<String, String>>any())).thenReturn(response);
    when(connection.getExecutor()).thenReturn(executor);
    doNothing().when(executor).execute(any(Runnable.class));
    task = new ReadGbpFlowCacheTask("cache1", connection, statisticsManager, 100, 0.1, "sum");
}

public void filter(ContainerRequestContext requestContext, ContainerResponseContext responseContext) throws IOException {
    final MultivaluedMap<String, Object> headers = responseContext.getHeaders();
    if (requestContext.getMethod().equalsIgnoreCase("OPTIONS")) {
        final String request = requestContext.getHeaderString("Access-Control-Request-Headers");
        final String method = requestContext.getHeaderString("Access-Control-Request-Method");
        if (request == null || method == null) {
            return;
        }
        headers.add("Access-Control-Allow-Origin", corsAllowOrigin);
        headers.add("Access-Control-Allow-Methods", method);
        headers.add("Access-Control-Allow-Headers", request);
    } else {
        headers.add("Access-Control-Allow-Origin", corsAllowOrigin);
    }
}

@Override
public KVPairs getValue(HttpContext c) {
    KVPairs pairs = new KVPairs();
    MultivaluedMap<String, String> params = c.getRequest().getFormParameters();
    for (Map.Entry<String, List<String>> param : params.entrySet()) {
        String key = param.getKey();
        Object value = param.getValue().iterator().next();
        pairs.putValue(key, value.toString());
    }
    return pairs;
}

@SuppressWarnings("rawtypes")
@Override
public BPMNModel readFrom(Class aClass, Type type, Annotation[] annotations, MediaType mediaType, MultivaluedMap multivaluedMap, InputStream bpmnInputStream) throws IOException, WebApplicationException {
    try {
        return BPMNParser.parseModel(bpmnInputStream, "UTF-8");
    } catch (ModelException e) {
        logger.warning("Invalid Model: " + e.getMessage());
        e.printStackTrace();
    } catch (ParseException e) {
        logger.warning("Invalid Model: " + e.getMessage());
        e.printStackTrace();
    } catch (ParserConfigurationException e) {
        logger.warning("Invalid Model: " + e.getMessage());
        e.printStackTrace();
    } catch (SAXException e) {
        logger.warning("Invalid Model: " + e.getMessage());
        e.printStackTrace();
    }
    return null;
}

@Override
public ContainerResponse filter(ContainerRequest request, ContainerResponse response) {
    //https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching_FAQ
    MultivaluedMap<String, Object> headers = response.getHttpHeaders();
    headers.putSingle(HttpHeaders.CACHE_CONTROL, "no-cache, no-store");
    headers.putSingle("Pragma", "no-cache");
    headers.putSingle(HttpHeaders.EXPIRES, "0");
    return response;
}

/**
     * This method would convert ParameterAndvalue[] to MultiValueMap<String, String>
     * @param paramAndValues
     * @return
     */
public static MultivaluedMap<String, String> getParamAndValueAsMultiValueMap(ParameterAndValue[] paramAndValues) {
    MultivaluedMap<String, String> parameters = new MultivaluedMapImpl<String>();
    if (paramAndValues != null) {
        for (ParameterAndValue paramAndValue : paramAndValues) {
            parameters.put(paramAndValue.getParameter(), new ArrayList<String>(Arrays.asList(paramAndValue.getValue())));
        }
    }
    return parameters;
}

@Override
public ServiceRestResources readFrom(Class<ServiceRestResources> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException {
    try {
        SAXParser parser = parserFactor.newSAXParser();
        WadlSaxHandler handler = new WadlSaxHandler();
        parser.parse(entityStream, handler);
        return handler.toServiceRestResource();
    } catch (ParserConfigurationException e) {
        throw new RuntimeException(e);
    } catch (SAXException e) {
        throw new WebApplicationException("Cannot parse WADL data.", e, 422);
    }
}

@Override
public ContainerResponse filter(ContainerRequest request, ContainerResponse response) {
    String incomingOrigin = request.getHeaderValue(CorsHeaders.ORIGIN);
    if (incomingOrigin == null) {
        return response;
    }
    MultivaluedMap<String, Object> h = response.getHttpHeaders();
    putIfNotPresent(h, CorsHeaders.ALLOW_ORIGIN, allowOrigin);
    if (!exposeHeaders.isEmpty()) {
        putIfNotPresent(h, CorsHeaders.EXPOSE_HEADERS, exposeHeaders);
    }
    if (allowCredentials) {
        putIfNotPresent(h, CorsHeaders.ALLOW_CREDENTIALS, Boolean.toString(allowCredentials));
    }
    return response;
}

public static JsonObject buildOutput(TableViewResource tableViewResource, MultivaluedMap<String, String> queryParams) {
    JsonObject output = new JsonObject();
    applyQueryParams(tableViewResource, queryParams);
    JsonArray data = tableViewResource.getData();
    final String sEcho = queryParams.getFirst("sEcho");
    output.addProperty("iTotalRecords", tableViewResource.getTotalNumOfRecords());
    output.addProperty("iTotalDisplayRecords", tableViewResource.getFilteredNumOfRecords());
    output.addProperty("sEcho", sEcho);
    output.add("aaData", data);
    return output;
}

@Override
public void writeTo(EachRefPack pack, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    try {
        final OutputStreamWriter out = new OutputStreamWriter(entityStream, Charsets.UTF_8.name());
        final RefAdvertiser advertiser = new RefAdvertiser() {

            @Override
            protected void writeOne(final CharSequence line) throws IOException {
                out.append(line.toString().replace(' ', '\t'));
            }

            @Override
            protected void end() {
            }
        };
        advertiser.init(pack.repository);
        advertiser.setDerefTags(true);
        try {
            pack.sendAdvertisedRefs(advertiser);
            out.flush();
        } finally {
            pack.dispose();
        }
    } finally {
        entityStream.flush();
    }
}

@Override
public ServerResponse preProcess(HttpRequest request, ResourceMethod method) throws UnauthorizedException {
    // pass public methods
    if (method.getResourceClass().equals(PublicServiceRest.class)) {
        return null;
    }
    // user not logged-in?
    if (AuthService.getCurrentAccount() == null) {
        ServerResponse response = new ServerResponse();
        response.setStatus(HttpResponseCodes.SC_UNAUTHORIZED);
        MultivaluedMap<String, Object> headers = new Headers<Object>();
        headers.add("Content-Type", "text/plain");
        response.setMetadata(headers);
        response.setEntity("{\"code\":401, \"message\":\"HTTP error 401: Unauthorized to access " + request.getPreprocessedPath() + "\"" + "");
        return response;
    }
    return null;
}

@Test
@Ignore
public void runAppAndBasicTest() throws InterruptedException, ExecutionException {
    Client client = ClientBuilder.newClient();
    WebTarget resource = client.target("http://localhost:8080/simple-app/single/ping");
    Builder request = resource.request();
    request.accept(MediaType.TEXT_PLAIN);
    MultivaluedMap<String, Object> headers = request.get().getHeaders();
    assertFalse("" + headers.get("Access-Control-Allow-Origin"), headers.get("Access-Control-Allow-Origin") != null);
}

@Override
public T readFrom(Class<T> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException {
    if (String.class.isAssignableFrom(type.getClass())) {
        return (T) IOUtils.toString(entityStream);
    }
    T result = super.readFrom(type, genericType, annotations, mediaType, httpHeaders, entityStream);
    if (result instanceof PrismObject) {
        return (T) ((PrismObject) result).asObjectable();
    }
    return result;
}

public ApiRequestJsonSerializationSettings process(final MultivaluedMap<String, String> queryParameters, final Set<String> mandatoryResponseParameters) {
    final Set<String> responseParameters = ApiParameterHelper.extractFieldsForResponseIfProvided(queryParameters);
    if (!responseParameters.isEmpty()) {
        responseParameters.addAll(mandatoryResponseParameters);
    }
    final boolean prettyPrint = ApiParameterHelper.prettyPrint(queryParameters);
    final boolean template = ApiParameterHelper.template(queryParameters);
    final boolean makerCheckerable = ApiParameterHelper.makerCheckerable(queryParameters);
    final boolean includeJson = ApiParameterHelper.includeJson(queryParameters);
    return ApiRequestJsonSerializationSettings.from(prettyPrint, responseParameters, template, makerCheckerable, includeJson);
}

@Override
public void filter(final ContainerRequestContext containerRequestContext) throws IOException {
    final MultivaluedMap<String, String> parameters = containerRequestContext.getUriInfo().getQueryParameters();
    final String token = parameters.getFirst(TOKEN_PARAMETER);
    if (!Strings.isNullOrEmpty(token)) {
        try {
            final User user = userBackend.loginUsingSoundCloud(token);
            containerRequestContext.setProperty(Key.get(User.class, Names.named(CURRENT_USER_NAME)).toString(), user);
        } catch (final NotAuthorizedException e) {
            final Response response = notAuthorizedExceptionMapper.toResponse(e);
            containerRequestContext.abortWith(response);
        }
    }
}

@Override
public ServerResponse preProcess(HttpRequest request, ResourceMethodInvoker methodInvoker) throws Failure, WebApplicationException {
    Method method = methodInvoker.getMethod();
    Annotation[][] methodParameterAnnotations = method.getParameterAnnotations();
    Class<?>[] methodParameterTypes = method.getParameterTypes();
    MultivaluedMap<String, String> pathParameters = request.getUri().getPathParameters();
    for (int i = 0, l = methodParameterAnnotations.length; i < l; i++) {
        Annotation[] parameterAnnotations = methodParameterAnnotations[i];
        Annotation sessionContextAnnotation = null;
        Annotation pathParamAnnotation = null;
        for (Annotation parameterAnnotation : parameterAnnotations) {
            if (parameterAnnotation.annotationType().equals(SessionContext.class)) {
                sessionContextAnnotation = parameterAnnotation;
            } else {
                pathParamAnnotation = parameterAnnotation;
            }
        }
        if ((sessionContextAnnotation != null) && (pathParamAnnotation != null)) {
            Class<?> methodParameterType = methodParameterTypes[i];
            if (methodParameterType.equals(Long.class)) {
                String pathParam = ((PathParam) pathParamAnnotation).value();
                String pathParamValue = pathParameters.getFirst(pathParam);
                Long contextId = NumberUtils.createLong(pathParamValue);
                SessionContextType contextType = ((SessionContext) sessionContextAnnotation).type();
                fi.otavanopisto.muikku.rest.SessionContextImpl sessionContext = new fi.otavanopisto.muikku.rest.SessionContextImpl(contextId, contextType);
                switch(sessionContext.getType()) {
                    case ENVIRONMENT:
                        break;
                    case COURSE:
                        // TODO Courses in seesion context :)
                        throw new RuntimeException("Course in session context");
                }
            }
        }
    }
    return null;
}

@GET
public CancelSpotInstanceRequestsResponseType handleGet(@Context UriInfo uriInfo) {
    if (uriInfo == null) {
        throw new IllegalArgumentException("uriInfo may not be null");
    }
    MultivaluedMap<String, String> form = uriInfo.getQueryParameters();
    final CancelSpotInstanceRequestsType request = new CancelSpotInstanceRequestsType();
    if (form != null && !form.isEmpty()) {
        SpotInstanceRequestIdSetType spotInstanceRequestIdSet = DescribeSpotInstanceRequests.extractRequestIdSet(form);
        request.setSpotInstanceRequestIdSet(spotInstanceRequestIdSet);
    }
    try {
        return serviceRM.cancelSpotInstanceRequests(request);
    } catch (RemoteException e) {
        throw new QueryException(QueryError.GeneralError, e);
    }
}

@Override
public void writeTo(Facets facets, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException {
    JsonGenerator jg = getGenerator(entityStream);
    jg.writeStartArray();
    for (CompositeType facet : facets.facets) {
        jg.writeStartObject();
        writeFacet(jg, facet, true);
        jg.writeEndObject();
    }
    jg.writeEndArray();
    // flush
    jg.flush();
    jg.close();
    entityStream.flush();
}

@Override
public void writeTo(CSLItemDataList data, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    final PrintStream printStream = new PrintStream(entityStream);
    printStream.println('[');
    boolean first = true;
    for (CSLItemData item : data.getData()) {
        if (item != null) {
            if (!first)
                printStream.print(',');
            else
                first = false;
            printStream.println(item.toJson(jsonFactory.createJsonBuilder()).toString());
        }
    }
    printStream.println(']');
}

@Override
public MultivaluedMap<String, String> getHeaders() {
    HeaderMap headers = new HeaderMap();
    for (Header header : httpResponse.getAllHeaders()) {
        List<String> valueList = new ArrayList<String>();
        for (HeaderElement element : header.getElements()) valueList.add(element.toString());
        headers.put(header.getName(), valueList);
    }
    return headers;
}

public void writeTo(LoginInfo login, Class<?> arg1, Type arg2, Annotation[] arg3, MediaType arg4, MultivaluedMap<String, Object> arg5, OutputStream arg6) throws IOException, WebApplicationException {
    JSONObject json = new JSONObject();
    json.element("entity-type", "login");
    json.element("username", login.getUsername());
    json.element("isAdministrator", login.isAdministrator());
    JSONArray g = new JSONArray();
    for (String group : login.getGroups()) {
        g.add(group);
    }
    json.element("groups", g);
    arg6.write(json.toString().getBytes("UTF-8"));
}

@Override
public ContainerResponse filter(ContainerRequest containerRequest, ContainerResponse containerResponse) {
    log.fine("Origin: " + containerRequest.getHeaderValue("Origin") + " - " + containerRequest.getRequestUri());
    if (StringUtils.equals("http://localhost:8000", containerRequest.getHeaderValue("Origin"))) {
        final MultivaluedMap<String, Object> httpHeaders = containerResponse.getHttpHeaders();
        httpHeaders.putSingle("Access-Control-Allow-Origin", containerRequest.getHeaderValue("Origin"));
        httpHeaders.putSingle("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");
    }
    return containerResponse;
}

@Test
@SuppressWarnings({ "rawtypes", "unchecked" })
public void testHasHeaders() {
    RequestError error = mock(RequestError.class);
    when(error.getRequestUrl()).thenReturn("foo");
    MultivaluedMap headers = mock(MultivaluedMap.class);
    when(error.getHeaders()).thenReturn(headers);
    RequestException exception = new RequestException(error);
    MultivaluedMap<String, Object> actualHeaders = exception.getHeaders();
    assertSame(headers, actualHeaders);
}

@Override
public Order readFrom(Class<Order> type, Type type1, Annotation[] antns, MediaType mt, MultivaluedMap<String, String> mm, InputStream in) throws IOException, WebApplicationException {
    Order order = new Order();
    InputStreamReader reader = new InputStreamReader(in);
    JsonElement json = new JsonParser().parse(reader);
    JsonObject jsonObject = json.getAsJsonObject();
    if (jsonObject.get("additions") != null) {
        order.setAdditions(jsonObject.get("additions").getAsString());
    } else {
        order.setAdditions("");
    }
    if (jsonObject.get("drinkName") != null) {
        order.setDrinkName(jsonObject.get("drinkName").getAsString());
    } else {
        order.setDrinkName("");
    }
    if (jsonObject.get("cost") != null) {
        order.setCost(jsonObject.get("cost").getAsDouble());
    }
    if (jsonObject.get("orderId") != null) {
        order.setOrderId(jsonObject.get("orderId").getAsString());
    }
    order.setLocked(false);
    return order;
}

public ClientResponse execute(ClientExecutionContext ctx) throws Exception {
    ClientRequest request = ctx.getRequest();
    ClientResponse response = null;
    response = ctx.proceed();
    if ((response.getResponseStatus() != null) && (response.getResponseStatus().getStatusCode() == 404)) {
        BaseClientResponse r = (BaseClientResponse) response;
        MultivaluedMap<String, String> headers = r.getHeaders();
        headers.add("full-path", request.getUri());
        r.setHeaders(headers);
    }
    return response;
}

@Override
public void writeTo(User user, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    JsonObjectBuilder jsonUser = Json.createObjectBuilder();
    jsonUser.add("username", user.getUsername());
    if (user.getFullName() != null) {
        jsonUser.add("fullName", user.getFullName());
    }
    JsonArrayBuilder roles = Json.createArrayBuilder();
    for (Role role : user.getRoles()) {
        roles.add(role.name());
    }
    jsonUser.add("roles", roles);
    try (JsonWriter writer = Json.createWriter(entityStream)) {
        writer.writeObject(jsonUser.build());
    }
}

public Map<String, String> getWorkflowVariablesFromPathSegment(PathSegment pathSegment) {
    Map<String, String> variables = null;
    MultivaluedMap<String, String> matrixParams = pathSegment.getMatrixParameters();
    if (matrixParams != null && !matrixParams.isEmpty()) {
        variables = Maps.newHashMap();
        for (String key : matrixParams.keySet()) {
            String value = matrixParams.getFirst(key) == null ? "" : matrixParams.getFirst(key);
            variables.put(key, value);
        }
    }
    return variables;
}

@Test
public void testArtifactPost() {
    ClientConfig clientConfig = new DefaultClientConfig();
    clientConfig.getClasses().add(DataWriter.class);
    Client client = Client.create(clientConfig);
    WebResource webRes = client.resource("http://localhost:8080/restrepo");
    Data data = new Data();
    data.data = new byte[] { 1, 2, 3 };
    Dictionary dictionary = new Dictionary();
    dictionary.put("bungle", "muncher");
    MultiPart multiPart = new MultiPart().bodyPart(new BodyPart(data, MediaType.APPLICATION_OCTET_STREAM_TYPE)).bodyPart(new BodyPart(dictionary, MediaType.APPLICATION_XML_TYPE));
    ClientResponse response = webRes.path("artifact").type(MultiPartMediaTypes.MULTIPART_MIXED_TYPE).put(ClientResponse.class, multiPart);
    MultivaluedMap<String, String> headers = response.getHeaders();
    for (String header : headers.keySet()) {
        System.err.println(header + " : " + headers.get(header));
    }
    assertEquals("Creation response code", Response.Status.CREATED.getStatusCode(), response.getStatus());
}

@Test
public void provide() throws Exception {
    SearchModel expected = new SearchModel();
    expected.setQ("qparam");
    expected.setOffset(1);
    expected.setLimit(10);
    expected.setFields(new String[] { "field1", "field2" });
    expected.setSort(new String[] { "+field1", "-field2" });
    expected.setFilterExpression("field1=1");
    MultivaluedMap<String, String> queryParameters = new MultivaluedHashMap<>();
    queryParameters.put("_q", Lists.newArrayList("qparam"));
    queryParameters.put("_offset", Lists.newArrayList("1"));
    queryParameters.put("_limit", Lists.newArrayList("10"));
    queryParameters.put("_fields", Lists.newArrayList("field1,field2"));
    queryParameters.put("_sort", Lists.newArrayList("+field1,-field2"));
    queryParameters.put("_filter", Lists.newArrayList("field1=1"));
    queryParameters.put("_none", Lists.newArrayList("none"));
    UriInfo uriInfo = mock(UriInfo.class);
    when(uriInfo.getQueryParameters()).thenReturn(queryParameters);
    SearchFactory factory = mock(SearchFactory.class);
    when(factory.getUriInfo()).thenReturn(uriInfo);
    when(factory.getMethod()).thenReturn("GET");
    when(factory.provide()).thenCallRealMethod();
    assertEquals(uriInfo, factory.getUriInfo());
    assertEquals("GET", factory.getMethod());
    SearchModel actual = factory.provide();
    assertEquals(expected, actual);
}

@POST
@Consumes("application/x-www-form-urlencoded")
public Response startLongRunningProcess(@FormParam("numberOfIterations") int numberOfIterations, MultivaluedMap<String, String> formParams) {
    //public Response startLongRunningProcess(@QueryParam("numberOfIterations") int numberOfIterations, @Context UriInfo ui, @Context HttpHeaders hh) {
    ProcessIdentifier identification = processStarter.start(new ProcessInput(numberOfIterations));
    URI uri = UriBuilder.fromResource(LongRunningProcessResource.class).path(identification.toString()).build();
    uri = uriInfo.getBaseUriBuilder().path(LongRunningProcessResource.class).path(identification.toString()).build();
    return Response.created(uri).build();
}

public Map<String, String> getWorkflowVariablesFromPathSegment(PathSegment pathSegment) {
    Map<String, String> variables = null;
    MultivaluedMap<String, String> matrixParams = pathSegment.getMatrixParameters();
    if (matrixParams != null && !matrixParams.isEmpty()) {
        variables = Maps.newHashMap();
        for (String key : matrixParams.keySet()) {
            String value = matrixParams.getFirst(key) == null ? "" : matrixParams.getFirst(key);
            variables.put(key, value);
        }
    }
    return variables;
}

@RequestMapping(value = "/search", produces = MediaType.APPLICATION_JSON_VALUE)
public ResponseEntity<String> query() {
    WebResource webResource = jerseyClient.resource(String.format("%s/v1/search", markLogicBaseURL));
    String payload = "";
    MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl();
    queryParams.add("format", "json");
    queryParams.add("view", "all");
    queryParams.add("options", "all");
    queryParams.add("start", "1");
    queryParams.add("pageLength", "10");
    ClientResponse response = webResource.queryParams(queryParams).type("application/json").post(ClientResponse.class, payload);
    return new ResponseEntity<String>(response.getEntity(String.class), HttpStatus.valueOf(response.getStatus()));
}

@Override
public void writeTo(Swagger data, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> headers, OutputStream out) throws IOException {
    if (mediaType.isCompatible(MediaType.APPLICATION_JSON_TYPE)) {
        if (prettyPrint) {
            out.write(Json.pretty().writeValueAsBytes(data));
        } else {
            out.write(Json.mapper().writeValueAsBytes(data));
        }
    } else if (mediaType.toString().startsWith("application/yaml")) {
        headers.remove("Content-Type");
        headers.add("Content-Type", "application/yaml");
        if (prettyPrint) {
            out.write(Yaml.pretty().writeValueAsBytes(data));
        } else {
            out.write(Yaml.mapper().writeValueAsBytes(data));
        }
    } else if (mediaType.isCompatible(MediaType.APPLICATION_XML_TYPE)) {
        headers.remove("Content-Type");
        headers.add("Content-Type", "application/json");
        if (prettyPrint) {
            out.write(Json.pretty().writeValueAsBytes(data));
        } else {
            out.write(Json.mapper().writeValueAsBytes(data));
        }
    }
}

/** Returns people results as a JSON string. **/
@GET
public Response handleViz(@Context UriInfo ui) {
    MultivaluedMap<String, String> queryParams = ui.getQueryParameters();
    String fname = SearchController.getParam("fname", queryParams);
    String lname = SearchController.getParam("lname", queryParams);
    if (fname == null || lname == null) {
        return error();
    }
    String fullName = fname + " " + lname;
    System.out.println("fname=" + fname + " lname=" + lname);
    Person p = Config.cc.getPerson(fullName.toUpperCase());
    if (p == null) {
        return error();
    }
    WatsonUserModeller WUM = new WatsonUserModeller();
    String vizHTML = WUM.getPersonVizHTML(p);
    if (vizHTML == null) {
        return error();
    }
    return Response.ok(vizHTML).header("Access-Control-Allow-Origin", "*").header("Access-Control-Allow-Methods", "GET, POST, DELETE, PUT").build();
}

public Response toResponse(WebApplicationException exception) {
    final Response exceptionResponse = exception.getResponse();
    final MultivaluedMap<String, Object> metadata = exceptionResponse.getMetadata();
    StringBuffer dump = new StringBuffer();
    if (metadata != null && metadata.size() != 0) {
        dump.append("metadata: [");
        for (Map.Entry<String, List<Object>> entry : metadata.entrySet()) {
            dump.append(entry.getKey()).append(":").append(entry.getValue()).append(",");
        }
        dump.append("]");
    }
    return reportError(exceptionResponse.getStatus(), exception, "Not supported request. Please check URL, HTTP method and transfered data are correct. " + dump);
}

public static GeolocalizacionRequest localizarPedidoPorId(String pedidoId) {
    Client client = Client.create();
    WebResource webResource = client.resource("http://localhost:8080/TeleCafe/rest/mockup/localizacion");
    MultivaluedMap formData = new MultivaluedMapImpl();
    String input = "{\"idpedido\":\"" + pedidoId + "\"}";
    ClientResponse response = webResource.type("application/json").post(ClientResponse.class, input);
    String respuesta = response.getEntity(String.class);
    Gson gson = new Gson();
    GeolocalizacionRequest gloc = new GeolocalizacionRequest();
    gloc = gson.fromJson(respuesta, GeolocalizacionRequest.class);
    return gloc;
}

@Override
public void writeTo(Model model, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    String lang = null;
    if (mediaType.isCompatible(MediaType.valueOf("application/rdf+xml"))) {
        lang = "RDF/XML";
    }
    if (mediaType.isCompatible(MediaType.valueOf("text/turtle"))) {
        lang = "TTL";
    }
    if (mediaType.isCompatible(MediaType.valueOf("text/rdf+n3"))) {
        lang = "N3";
    }
    if (mediaType.isCompatible(MediaType.valueOf("text/plain"))) {
        lang = "N-TRIPLE";
    }
    if (mediaType.isCompatible(MediaType.valueOf("application/n-triples"))) {
        lang = "N-TRIPLE";
    }
    if (mediaType.isCompatible(MediaType.valueOf("text/n-triples"))) {
        lang = "N-TRIPLE";
    }
    if (model.isEmpty()) {
        throw new NotFoundException();
    } else {
        model.write(entityStream, lang);
    }
}

@Override
public void writeTo(List objs, Class<?> arg1, Type arg2, Annotation[] arg3, MediaType arg4, MultivaluedMap<String, Object> arg5, OutputStream out) throws IOException, WebApplicationException {
    JsonArray array = new JsonArray();
    for (Object obj : objs) {
        JsonParser parser = new JsonParser();
        try {
            JAXBContext context = JAXBContext.newInstance(obj.getClass());
            Marshaller marshaller = context.createMarshaller();
            StringWriter sw = new StringWriter();
            JSONJAXBContext.getJSONMarshaller(marshaller).marshallToJSON(obj, sw);
            array.add(parser.parse(sw.toString()));
        } catch (JAXBException e) {
            array.add(new JsonPrimitive(obj.toString()));
        }
    }
    out.write(new Gson().toJson(array).getBytes());
}

@Test
public void should_create_a_new_book() {
    MultivaluedMap<String, String> form = new MultivaluedMapImpl();
    form.add("title", "Clean Code");
    form.add("author", "Robert C. Martin");
    Client client = new Client();
    WebResource webResource = client.resource(buildUri("/book"));
    Book book = webResource.post(Book.class, form);
    Assert.assertEquals("Clean Code", book.getTitle());
    Assert.assertEquals("Robert C. Martin", book.getAuthor());
}

@SuppressWarnings({ "rawtypes", "unchecked" })
@Override
public void writeTo(Optional<?> entity, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException {
    if (!entity.isPresent()) {
        throw EmptyOptionalException.INSTANCE;
    }
    final Type innerGenericType = (genericType instanceof ParameterizedType) ? ((ParameterizedType) genericType).getActualTypeArguments()[0] : entity.get().getClass();
    final MessageBodyWriter writer = mbw.get().getMessageBodyWriter(entity.get().getClass(), innerGenericType, annotations, mediaType);
    writer.writeTo(entity.get(), entity.get().getClass(), innerGenericType, annotations, mediaType, httpHeaders, entityStream);
}

public static ElasticSearchConfig parse(ServletContext context, MultivaluedMap<String, String> formParams) {
    ElasticSearchConfig config = new ElasticSearchConfig();
    if (formParams != null && formParams.containsKey(FormParameters.ES_HOSTNAME)) {
        config.setHostname(formParams.getFirst(FormParameters.ES_HOSTNAME));
    } else {
        config.setHostname(context.getInitParameter(FormParameters.ES_HOSTNAME));
    }
    if (formParams != null && formParams.containsKey(FormParameters.ES_PROTOCOL)) {
        config.setProtocol(formParams.getFirst(FormParameters.ES_PROTOCOL));
    } else {
        config.setProtocol(context.getInitParameter(FormParameters.ES_PROTOCOL));
    }
    if (formParams != null && formParams.containsKey(FormParameters.ES_INDEX)) {
        config.setIndex(formParams.getFirst(FormParameters.ES_INDEX));
    } else {
        config.setIndex(context.getInitParameter(FormParameters.ES_INDEX));
    }
    if (formParams != null && formParams.containsKey(FormParameters.ES_TYPE)) {
        config.setType(formParams.getFirst(FormParameters.ES_TYPE));
    } else {
        config.setType(context.getInitParameter(FormParameters.ES_TYPE));
    }
    if (formParams != null && formParams.containsKey(FormParameters.ES_PORT)) {
        config.setPort(formParams.getFirst(FormParameters.ES_PORT));
    } else {
        config.setPort(context.getInitParameter(FormParameters.ES_PORT));
    }
    System.out.println("ES Config:" + config);
    return config;
}

public static MultivaluedMap<String, String> resolveFromURI(String buildPath, String uriString) {
    String targetPath = null;
    try {
        URI uri = new URI(uriString);
        // FIXME: Hack!! we need to figure it
        targetPath = uri.getPath().replace("/am", "");
    // out
    } catch (URISyntaxException e) {
        throw new RuntimeException("Malformed URL " + uriString);
    }
    return resolve(buildPath, targetPath);
}

@Override
public void writeTo(Stream<?> stream, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    JsonGenerator jg = new JsonFactory().createGenerator(entityStream, JsonEncoding.UTF8);
    jg.writeStartArray();
    AtomicBoolean first = new AtomicBoolean(true);
    stream.forEach( i -> {
        try {
            String json = objectMapper.writeValueAsString(i);
            if (first.get()) {
                first.set(false);
            } else {
                jg.writeRaw(',');
            }
            jg.writeRaw(json);
            jg.flush();
        } catch (IOException e) {
            e.printStackTrace();
            throw new RuntimeException(e);
        }
    });
    jg.writeEndArray();
    jg.flush();
    jg.close();
}

@Override
protected Response handleRequest(HttpHeaders headers, String body, UriInfo uriInfo, Request.Type requestType, final ResourceInstance resource) {
    return new Response() {

        @Override
        public Object getEntity() {
            WidgetLayoutEntity entity = new WidgetLayoutEntity();
            entity.setUserName(resource.getKeyValueMap().get(Resource.Type.User));
            return entity;
        }

        @Override
        public int getStatus() {
            return 0;
        }

        @Override
        public MultivaluedMap<String, Object> getMetadata() {
            return null;
        }
    };
}

@Override
public void writeTo(SaltProject t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    // collect document graphs from the salt project
    List<SDocument> docs = new LinkedList<>();
    List<SCorpusGraph> corpusGraphs = t.getCorpusGraphs();
    if (corpusGraphs != null) {
        for (SCorpusGraph c : corpusGraphs) {
            if (c.getDocuments() != null) {
                docs.addAll(c.getDocuments());
            }
        }
    }
    GraphMLWriter.writeDocuments(entityStream, docs);
}

public Collection get(String parentType, String subCollectionType, MultivaluedMap<String, String> queryParams, String username) {
    AthenaSearch search = new AthenaSearch(queryParams);
    search.setType(parentType);
    Set<PTicket> tickets = apa.findTickets(search);
    Map<String, Tag> tagMap = new HashMap<String, Tag>();
    Set<Tag> tags = new HashSet<Tag>();
    for (PTicket ticket : tickets) {
        nullSafeAddAllTags(tagMap, ticket);
    }
    tags.addAll(tagMap.values());
    return tags;
}

public ContainerRequest filter(ContainerRequest request) {
    String path = request.getPath(false);
    MultivaluedMap<String, String> headers = request.getRequestHeaders();
    if (path.endsWith("/_count")) {
        // make sure to strip out query params
        headers.add(BARDConstants.REQUEST_HEADER_COUNT, "true");
        //request.setHeaders(headers);
        String uriString = request.getRequestUri().toString().replace("/_count", "");
        try {
            URI uri = new URI(uriString);
            // new jersey 
            request.setRequestUri(request.getBaseUri(), uri);
        // old jersey
        //request.setUris(request.getBaseUri(), uri);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
    }
    //old jersey
    //MultivaluedMap<String, String> queryParams = request.getQueryParameters();
    // New jersey...
    MultivaluedMap<String, String> queryParams = request.getUriInfo().getQueryParameters();
    if (queryParams.containsKey("callback")) {
        List<String> vals = queryParams.get("callback");
        if (vals.size() == 1) {
            headers.add(BARDConstants.REQUEST_HEADER_JSONP, vals.get(0));
        //request.setHeaders(headers); 
        }
    }
    return request;
}

@Override
public void writeTo(TypedList<GovernanceArtifact> typedList, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    GenericArtifactJSONWriter messageWriter = new GenericArtifactJSONWriter();
    try {
        messageWriter.writeTo(typedList, entityStream, Util.getBaseURL(uriInfo));
    } catch (GovernanceException e) {
        log.error(e);
        throw new WebApplicationException(Response.Status.INTERNAL_SERVER_ERROR);
    }
}

@Before
public void setUp() {
    resource = mock(WebResource.class);
    when(resource.path(Matchers.<String>any())).thenReturn(resource);
    when(resource.queryParam(Matchers.<String>any(), Matchers.<String>any())).thenReturn(resource);
    when(resource.queryParams(Matchers.<MultivaluedMap<String, String>>any())).thenReturn(resource);
    resourceBuilder = mock(WebResource.Builder.class);
    when(resource.type(eq(MediaType.APPLICATION_JSON))).thenReturn(resourceBuilder);
    when(resourceBuilder.acceptLanguage(Matchers.<Locale>any())).thenReturn(resourceBuilder);
    when(resourceBuilder.type(eq(MediaType.APPLICATION_JSON))).thenReturn(resourceBuilder);
    client = getClient(resource);
    when(resource.get(resourceClass)).thenReturn(getMockObject());
    when(resourceBuilder.get(eq(resourceClass))).thenReturn(getMockObject());
}

@Override
public Object readFrom(Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException {
    try (InputStreamReader streamReader = new InputStreamReader(entityStream, UTF_8)) {
        Type jsonType;
        if (type.equals(genericType)) {
            jsonType = type;
        } else {
            jsonType = genericType;
        }
        return getGson().fromJson(streamReader, jsonType);
    }
}

@Override
public void writeTo(Map<String, String> t, Class<?> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, Object> httpHeaders, OutputStream entityStream) throws IOException, WebApplicationException {
    final PrintStream printStream = new PrintStream(entityStream, false, "UTF8");
    for (Entry<String, String> entry : t.entrySet()) {
        printStream.print("-D");
        printStream.print(entry.getKey());
        printStream.print("=\"");
        printStream.print(entry.getValue().replaceAll("\"", "\\\""));
        printStream.print("\" ");
    }
    printStream.flush();
    printStream.close();
}

@Override
public void writeTo(final T t, final Class<?> type, final Type type1, final Annotation[] antns, final MediaType mt, final MultivaluedMap<String, Object> mm, final OutputStream out) throws IOException, WebApplicationException {
    try {
        Marshaller m = WPSMarshallerPool.getInstance().acquireMarshaller();
        m.marshal(t, out);
        WPSMarshallerPool.getInstance().recycle(m);
    } catch (JAXBException ex) {
        LOGGER.log(Level.SEVERE, "JAXB exception while writing the feature collection", ex);
    }
}

@Test
public void testFind() throws Exception {
    Resources resources = new Resources();
    resources.getResources().add(new Currency());
    when(coupaClientMock.get(anyString(), any(MultivaluedMap.class), eq(Resources.class))).thenReturn(resources);
    Iterable<Resource> results = coupaModule.find(ResourceType.Currency, new HashMap<String, String>(), false, 0, null);
    assertNotNull(results);
    assertEquals(1, Streams.from(results).size());
}

@Test
public void testGenerateMultipartFormDataOutput() {
    Document doc = new Document();
    doc.setName(DOC_NAME);
    doc.setPath(DOC_PATH);
    doc.setDocumentId(DOC_ID);
    List<Document> documents = new ArrayList<Document>();
    documents.add(doc);
    DocumentSignatureRequest request = new DocumentSignatureRequest();
    request.setDocuments(documents);
    MultipartFormDataOutput output = DocuSignUtils.generateMultipartFormDataOutput(request);
    Assert.assertNotNull(output);
    Map<String, OutputPart> formData = output.getFormData();
    Assert.assertNotNull(formData);
    OutputPart envDef = formData.get(DocuSignUtils.ENVELOPE_DEFINITION);
    Assert.assertNotNull(envDef);
    Assert.assertEquals(request, envDef.getEntity());
    Assert.assertEquals(MediaType.APPLICATION_JSON_TYPE, envDef.getMediaType());
    OutputPart doc1 = formData.get("doc1.txt");
    Assert.assertNotNull(doc1);
    MultivaluedMap<String, Object> headers = doc1.getHeaders();
    Assert.assertNotNull(headers);
    List<Object> contentDisposition = headers.get(FieldName.CONTENT_DISPOSITION);
    Assert.assertNotNull(contentDisposition);
    Assert.assertEquals("file; filename=\"" + DOC_NAME + "\"; documentId=" + DOC_ID + "", contentDisposition.get(0));
    FileDataSource file1 = (FileDataSource) doc1.getEntity();
    Assert.assertNotNull(file1);
    Assert.assertEquals(DOC_PATH, file1.getFile().getPath());
}

public static Variant getVariant(HttpHeaders headers) {
    // copied (except for the acceptHeaders fix) from RestEasy's RequestImpl class
    ServerDrivenNegotiation negotiation = new ServerDrivenNegotiation();
    MultivaluedMap<String, String> requestHeaders = headers.getRequestHeaders();
    List<String> acceptHeaders = requestHeaders.get(ACCEPT);
    // Fix
    if (acceptHeaders != null && !acceptHeaders.isEmpty()) {
        List<String> fixedAcceptHeaders = new ArrayList<String>();
        for (String header : acceptHeaders) {
            fixedAcceptHeaders.add(header.replaceAll("q=\\.", "q=0."));
        }
        acceptHeaders = fixedAcceptHeaders;
        negotiation.setAcceptHeaders(acceptHeaders);
        negotiation.setAcceptCharsetHeaders(requestHeaders.get(ACCEPT_CHARSET));
        negotiation.setAcceptEncodingHeaders(requestHeaders.get(ACCEPT_ENCODING));
        negotiation.setAcceptLanguageHeaders(requestHeaders.get(ACCEPT_LANGUAGE));
        return negotiation.getBestMatch(variants);
    // ** use below instead of above when RESTEASY-960 is fixed **
    // return restRequest.selectVariant(variants);
    }
    return null;
}