public void loadData() {
SimpleDateFormat formatIn = new SimpleDateFormat("MMMM d, yyyy");
SimpleDateFormat formatOut = new SimpleDateFormat("MM/d/yy");
ObjectMapper objectMapper = new ObjectMapper();
JsonFactory jsonFactory = new JsonFactory();
Random random = new Random();
try {
JsonParser jsonParserBlog =
jsonFactory.createParser(getResources().openRawResource(R.raw.blog));
List<Blog> entries =
objectMapper.readValue(jsonParserBlog, new TypeReference<List<Blog>>() {});
JsonParser jsonParserEmoji =
jsonFactory.createParser(getResources().openRawResource(R.raw.emoji));
List<String> emojies =
objectMapper.readValue(jsonParserEmoji, new TypeReference<List<String>>() {});
int numEmoji = emojies.size();
for (Blog blog : entries) {
blog.setEmoji(emojies.get(random.nextInt(numEmoji)));
try {
blog.setDate(formatOut.format(formatIn.parse(blog.getDate())));
} catch (ParseException e) {
e.printStackTrace();
}
}
Realm realm = Realm.getInstance(this);
realm.beginTransaction();
realm.copyToRealm(entries);
realm.commitTransaction();
realm.close();
} catch (Exception e) {
throw new IllegalStateException("Could not load blog data.");
}
}
@Override
public Object nullSafeGet(ResultSet rs, String[] names, SessionImplementor session, Object owner)
throws HibernateException, SQLException {
try {
String value = rs.getString(names[0]);
if (value == null) {
return null;
}
Object object = null;
if (isArray) {
ObjectMapper objectMapper = ObjectMapperBeanFactory.getObjectMapper();
JavaType type =
objectMapper.getTypeFactory().constructCollectionType(List.class, targetClass);
object = objectMapper.readValue(value, type);
} else {
ObjectMapper objectMapper = ObjectMapperBeanFactory.getObjectMapper();
object = objectMapper.readValue(value, targetClass);
}
return object;
} catch (IOException e) {
throw new HibernateException(e);
}
}
// 初始化list数据函数
public void InitListDataForHistory(String url, JSONObject json, AjaxStatus status) {
if (status.getCode() == AjaxStatus.NETWORK_ERROR
&& app.GetServiceData("user_Histories") == null) {
aq.id(R.id.ProgressText).gone();
app.MyToast(aq.getContext(), getResources().getString(R.string.networknotwork));
return;
}
ObjectMapper mapper = new ObjectMapper();
try {
if (isLastisNext == 1) {
m_ReturnUserPlayHistories =
mapper.readValue(json.toString(), ReturnUserPlayHistories.class);
app.SaveServiceData("user_Histories", json.toString());
} else if (isLastisNext > 1) {
m_ReturnUserPlayHistories = null;
m_ReturnUserPlayHistories =
mapper.readValue(json.toString(), ReturnUserPlayHistories.class);
}
// 创建数据源对象
GetVideoMovies();
} catch (JsonParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (JsonMappingException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
private FileMetaData getFileContentInfo(File file) {
try {
MultivaluedMap<String, String> queryParams = new MultivaluedMapImpl();
queryParams.add("redirect", "meta");
ClientResponse resp =
getRootApiWebResource()
.path("files")
.path(String.valueOf(file.getId()))
.path("content")
.queryParams(queryParams)
.accept(MediaType.APPLICATION_OCTET_STREAM)
.accept(MediaType.TEXT_HTML)
.accept(MediaType.APPLICATION_XHTML_XML)
.get(ClientResponse.class);
String sResp = resp.getEntity(String.class);
FileMetaData fileInfo =
mapper.readValue(
mapper.readValue(sResp, JsonNode.class).findPath(RESPONSE).toString(),
FileMetaData.class);
logger.info(fileInfo.toString());
return fileInfo;
} catch (BaseSpaceException bs) {
throw bs;
} catch (Throwable t) {
throw new RuntimeException(t);
}
}
@Override
public Object read(Type type, Class<?> contextClass, HttpInputMessage inputMessage)
throws IOException, HttpMessageNotReadableException {
try {
TumblrResponse tumblrResponse =
objectMapper.readValue(inputMessage.getBody(), TumblrResponse.class);
checkResponse(tumblrResponse);
Object result;
if (TumblrResponse.class.equals(type)) {
// don't parse the response json, callee is going to process is manually
result = tumblrResponse;
} else {
// parse the response json into an instance of the given class
JavaType javaType = getJavaType(type, contextClass);
String response = tumblrResponse.getResponseJson();
result = objectMapper.readValue(response, javaType);
}
return result;
} catch (JsonParseException ex) {
throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex);
} catch (EOFException ex) {
throw new HttpMessageNotReadableException("Could not read JSON: " + ex.getMessage(), ex);
} catch (Exception e) {
e.printStackTrace();
throw new IOException(e);
}
}
@Override
public Object resolveArgument(MethodParameter param, NativeWebRequest request) throws Exception {
if (request.getNativeRequest() instanceof ClientDataRequest
&& param.hasParameterAnnotation(PortletRequestBody.class)) {
String value = param.getParameterAnnotation(PortletRequestBody.class).value();
ClientDataRequest clientDataRequest = request.getNativeRequest(ClientDataRequest.class);
if (!PortletRequestBody.DEFAULT.equals(value)) {
if (isMethod(clientDataRequest, RequestMethod.POST)) {
String json =
JSON_MAPPER.readTree(getRequestBody(clientDataRequest)).get(value).toString();
return JSON_MAPPER.readValue(json, param.getParameterType());
} else if (isMethod(clientDataRequest, RequestMethod.GET)) {
return JSON_MAPPER.readValue(request.getParameter(value), param.getParameterType());
}
throw new RuntimeException(
MessageFormat.format(
"REST Method {0} for values not supported.", clientDataRequest.getMethod()));
}
if (isMethod(clientDataRequest, RequestMethod.POST)) {
return JSON_MAPPER.readValue(clientDataRequest.getReader(), param.getParameterType());
}
throw new RuntimeException(
MessageFormat.format(
"REST Method {0} for body not supported.", clientDataRequest.getMethod()));
}
return WebArgumentResolver.UNRESOLVED;
}
// Update and return given train line with the Jackson parser
// AG
public static <T> TrainLine updateLine(T address, TrainLine line) {
try {
Object trainData = new Object();
if (address instanceof URL) {
// Get train data from web
trainData = mapper.readValue((URL) address, Object.class);
} else if (address instanceof File) {
// Get train data locally
trainData = mapper.readValue((File) address, Object.class);
}
// System.out.println(trainData.toString());
// Go inside the wrapper
Object tripListObj = getFromMap(trainData, TRIP_LIST_KEY);
line = new TrainLine(tripListObj);
} catch (JsonParseException e) {
e.printStackTrace();
} catch (JsonMappingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
return line;
}
@Before
public void prepareTest() throws Exception {
syncConfiguration =
MAPPER.readValue(
MongoElasticsearchSyncIT.class.getResourceAsStream("/testSync.json"),
MongoElasticsearchSyncConfiguration.class);
syncConfiguration.getDestination().setClusterName(cluster().getClusterName());
MongoPersistWriter setupWriter = new MongoPersistWriter(syncConfiguration.getSource());
setupWriter.prepare(null);
InputStream testActivityFolderStream =
MongoElasticsearchSyncIT.class.getClassLoader().getResourceAsStream("activities");
List<String> files = IOUtils.readLines(testActivityFolderStream, Charsets.UTF_8);
for (String file : files) {
LOGGER.info("File: " + file);
InputStream testActivityFileStream =
MongoElasticsearchSyncIT.class.getClassLoader().getResourceAsStream("activities/" + file);
Activity activity = MAPPER.readValue(testActivityFileStream, Activity.class);
activity.getAdditionalProperties().remove("$license");
StreamsDatum datum = new StreamsDatum(activity, activity.getVerb());
setupWriter.write(datum);
LOGGER.info("Wrote: " + activity.getVerb());
srcCount++;
}
setupWriter.cleanUp();
}
@Test
public void getInitTasks() throws Exception {
String jsonTasks =
given().filter(sessionFilter).get("/web/2016/4/25").then().extract().asString();
Task[][] returned = om.readValue(jsonTasks, Task[][].class);
assertThat(returned[4][0], equalTo(PermanentUserData.tasks.get(1)));
assertThat(returned[0][0], equalTo(PermanentUserData.tasks.get(2)));
assertThat(returned[2][0], equalTo(PermanentUserData.tasks.get(3)));
Task[] futureTasks = {
PermanentUserData.tasks.get(4), PermanentUserData.tasks.get(5), PermanentUserData.tasks.get(6)
};
assertThat(Arrays.asList(returned[1]), containsInAnyOrder(futureTasks));
assertThat(returned[1].length, equalTo(futureTasks.length));
jsonTasks =
given()
.header(PermanentUserData.tokenHeader)
.get("/m/2016/5/2")
.then()
.extract()
.asString();
returned = om.readValue(jsonTasks, Task[][].class);
assertThat(returned[0][0], equalTo(PermanentUserData.tasks.get(2)));
assertThat(returned[3][0], equalTo(PermanentUserData.tasks.get(3)));
assertThat(returned[2][0], equalTo(PermanentUserData.tasks.get(4)));
Task[] futureTasks2 = {PermanentUserData.tasks.get(5), PermanentUserData.tasks.get(6)};
assertThat(returned[1].length, equalTo(futureTasks2.length));
assertThat(Arrays.asList(returned[1]), containsInAnyOrder(futureTasks2));
}
@Test
public void vote() throws Exception {
ObjectMapper mapper = new ObjectMapper();
Restaurant restaurantB =
mapper.readValue(new StringReader(testRestaurantJson1), Restaurant.class);
restaurantRepository.saveAndFlush(restaurantB);
Restaurant restaurantA =
mapper.readValue(new StringReader(testRestaurantJson2), Restaurant.class);
restaurantRepository.saveAndFlush(restaurantA);
doVote(restaurantB.getRestaurantName(), "qqq");
doVote(restaurantB.getRestaurantName(), "www");
doVote(restaurantB.getRestaurantName(), "ddd");
doVote(restaurantA.getRestaurantName(), "kkk");
doVote(restaurantA.getRestaurantName(), "lll");
List<Vote> votes = votesRepository.findAll();
// check all votes are here
assertEquals(MAX_TOTAL_VOTES, votes.size());
Map<Long, Long> res =
votes.stream().collect(Collectors.groupingBy(Vote::getRestaurantId, Collectors.counting()));
// check all votes counter correctly
assertEquals(3l, res.get(restaurantB.getId()).longValue());
assertEquals(2l, res.get(restaurantA.getId()).longValue());
}
public String createMessage(HttpClientErrorException ex) {
String result = "";
try {
String responseBody = ex.getResponseBodyAsString();
if (!TextUtils.isEmpty(responseBody)) {
result = ex.getMessage() + ": " + responseBody;
ErrorBody errorBody = mapper.readValue(ex.getResponseBodyAsByteArray(), ErrorBody.class);
if (errorBody.fault != null) {
result = ex.getMessage() + " " + errorBody.fault.reason + " " + errorBody.fault.detail;
} else {
ErrorBody.Fault fault =
mapper.readValue(ex.getResponseBodyAsByteArray(), ErrorBody.Fault.class);
if (fault != null) {
result = ex.getMessage() + " " + fault.reason + " " + fault.detail;
}
}
}
} catch (Exception f) {
result = f.getMessage();
}
if (TextUtils.isEmpty(result)) {
result = ex.getMessage();
}
return result;
}
@Override
public GraphRowModel next() {
String json = response.next();
if (json != null) {
try {
GraphRowModel graphRowModel = new GraphRowModel();
JSONObject jsonObject = getOuterObject(json);
JSONArray dataObject =
jsonObject.getJSONArray("results").getJSONObject(0).getJSONArray("data");
for (int i = 0; i < dataObject.length(); i++) {
String graphJson = dataObject.getJSONObject(i).getString("graph");
String rowJson = dataObject.getJSONObject(i).getString("row");
GraphModel graphModel = objectMapper.readValue(graphJson, GraphModel.class);
Object[] rows = objectMapper.readValue(rowJson, Object[].class);
graphRowModel.addGraphRowResult(graphModel, rows);
}
return graphRowModel;
} catch (Exception e) {
LOGGER.error("failed to parse: {}", json);
throw new RuntimeException(e);
}
} else {
return null;
}
}
/**
* Load project's configuration.
*
* @throws IOException if cannot load configuration.
*/
@SuppressWarnings("unchecked")
public void load() throws IOException {
getInternalPref().clear();
getPkgclssExclude().clear();
prjCfgFile.getParentFile().mkdirs();
if (prjCfgFile.exists()) {
try {
getInternalPref()
.putAll(
(Map<Object, Object>) mapper.readValue(prjCfgFile, Map.class).get(JSON_GENERAL));
getPkgclssExclude()
.addAll(
(Collection<? extends String>)
mapper.readValue(prjCfgFile, Map.class).get(JSON_PKGFILTER));
} catch (IOException ex) {
LOGGER.log(
Level.INFO,
"Project's JaCoCoverage configuration file format is outdated or invalid. Reset cause:",
ex);
String msg =
"The project's JaCoCoverage configuration file format is outdated or invalid.\n"
+ "The configuration file has been reset to support new format.";
DialogDisplayer.getDefault()
.notify(new NotifyDescriptor.Message(msg, NotifyDescriptor.WARNING_MESSAGE));
}
}
}
@Test
public void testKillTaskSerde() throws Exception {
final KillTask task = new KillTask(null, "foo", new Interval("2010-01-01/P1D"), null);
final String json = jsonMapper.writeValueAsString(task);
Thread.sleep(100); // Just want to run the clock a bit to make sure the task id doesn't change
final KillTask task2 = (KillTask) jsonMapper.readValue(json, Task.class);
Assert.assertEquals("foo", task.getDataSource());
Assert.assertEquals(new Interval("2010-01-01/P1D"), task.getInterval());
Assert.assertEquals(task.getId(), task2.getId());
Assert.assertEquals(task.getGroupId(), task2.getGroupId());
Assert.assertEquals(task.getDataSource(), task2.getDataSource());
Assert.assertEquals(task.getInterval(), task2.getInterval());
final KillTask task3 =
(KillTask)
jsonMapper.readValue(
jsonMapper.writeValueAsString(
new ClientKillQuery("foo", new Interval("2010-01-01/P1D"))),
Task.class);
Assert.assertEquals("foo", task3.getDataSource());
Assert.assertEquals(new Interval("2010-01-01/P1D"), task3.getInterval());
}
private <T> T jsonReadWriteRead(String s, Class<T> klass) {
try {
return jsonMapper.readValue(
jsonMapper.writeValueAsBytes(jsonMapper.readValue(s, klass)), klass);
} catch (Exception e) {
throw Throwables.propagate(e);
}
}
private <T> T deserializeResponse(final Response response, final Class<T> clazz)
throws KillBillClientException {
final T result;
try {
if (DEBUG) {
final String content = response.getResponseBody();
log.debug("Received: " + content);
result = mapper.readValue(content, clazz);
} else {
InputStream in = null;
try {
in = response.getResponseBodyAsStream();
result = mapper.readValue(in, clazz);
} finally {
if (in != null) {
try {
in.close();
} catch (IOException e) {
log.warn(
"Failed to close http-client - provided InputStream: {}",
e.getLocalizedMessage());
}
}
}
}
} catch (final IOException e) {
throw new KillBillClientException(e, response);
}
if (KillBillObjects.class.isAssignableFrom(clazz)) {
final KillBillObjects objects = ((KillBillObjects) result);
final String paginationCurrentOffset =
response.getHeader(JaxrsResource.HDR_PAGINATION_CURRENT_OFFSET);
if (paginationCurrentOffset != null) {
objects.setPaginationCurrentOffset(Integer.parseInt(paginationCurrentOffset));
}
final String paginationNextOffset =
response.getHeader(JaxrsResource.HDR_PAGINATION_NEXT_OFFSET);
if (paginationNextOffset != null) {
objects.setPaginationNextOffset(Integer.parseInt(paginationNextOffset));
}
final String paginationTotalNbRecords =
response.getHeader(JaxrsResource.HDR_PAGINATION_TOTAL_NB_RECORDS);
if (paginationTotalNbRecords != null) {
objects.setPaginationTotalNbRecords(Integer.parseInt(paginationTotalNbRecords));
}
final String paginationMaxNbRecords =
response.getHeader(JaxrsResource.HDR_PAGINATION_MAX_NB_RECORDS);
if (paginationMaxNbRecords != null) {
objects.setPaginationMaxNbRecords(Integer.parseInt(paginationMaxNbRecords));
}
objects.setPaginationNextPageUri(
response.getHeader(JaxrsResource.HDR_PAGINATION_NEXT_PAGE_URI));
objects.setKillBillHttpClient(this);
}
return result;
}
public void initRoutes() {
get("api/devices", (request, response) -> deviceService.getAllDevices(), toJson());
post(
"api/devices",
(req, res) -> {
DeviceRequest createDeviceRequest = mapper.readValue(req.body(), DeviceRequest.class);
deviceService.createDevice(createDeviceRequest);
return "created";
});
get(
"api/devices/:deviceId",
(req, res) -> deviceService.getDevice(req.params("deviceId")),
toJson());
put(
"api/devices/:deviceId",
(req, res) -> {
String deviceId = req.params("deviceId");
if (deviceId != null && !deviceId.trim().isEmpty()) {
DeviceRequest createDeviceRequest = mapper.readValue(req.body(), DeviceRequest.class);
deviceService.changeDevice(deviceId, createDeviceRequest);
return "modified";
} else throw new RuntimeException("Incorrect request, missing device id");
});
delete(
"api/devices/:deviceId",
(req, res) -> {
String deviceId = req.params("deviceId");
if (deviceId != null && !deviceId.trim().isEmpty()) {
deviceService.shutdownDevice(deviceId);
return "Delete device " + deviceId;
} else throw new RuntimeException("Incorrect request, missing device id");
},
toJson());
post(
"api/devices/:deviceId/tasks",
(req, res) -> {
String deviceId = req.params("deviceId");
String requestBody = req.body();
DeviceTask task = DeviceTaskParser.parseTask(mapper, mapper.readTree(requestBody));
return deviceService.executeTask(deviceId, task);
},
toJson());
get(
"api/devices/:deviceId/tasks",
(req, res) -> {
String deviceId = req.params("deviceId");
return deviceService.getCurrentTasks(deviceId);
},
toJson());
}
// [JACKSON-484]
public void testInetAddress() throws IOException {
InetAddress address = MAPPER.readValue(quote("127.0.0.1"), InetAddress.class);
assertEquals("127.0.0.1", address.getHostAddress());
// should we try resolving host names? That requires connectivity...
final String HOST = "google.com";
address = MAPPER.readValue(quote(HOST), InetAddress.class);
assertEquals(HOST, address.getHostName());
}
@Test
public void testV1Serialization() throws Exception {
final Interval interval = new Interval("2011-10-01/2011-10-02");
final ImmutableMap<String, Object> loadSpec =
ImmutableMap.<String, Object>of("something", "or_other");
DataSegment segment =
new DataSegment(
"something",
interval,
"1",
loadSpec,
Arrays.asList("dim1", "dim2"),
Arrays.asList("met1", "met2"),
NoneShardSpec.instance(),
IndexIO.CURRENT_VERSION_ID,
1);
final Map<String, Object> objectMap =
mapper.readValue(
mapper.writeValueAsString(segment), new TypeReference<Map<String, Object>>() {});
Assert.assertEquals(10, objectMap.size());
Assert.assertEquals("something", objectMap.get("dataSource"));
Assert.assertEquals(interval.toString(), objectMap.get("interval"));
Assert.assertEquals("1", objectMap.get("version"));
Assert.assertEquals(loadSpec, objectMap.get("loadSpec"));
Assert.assertEquals("dim1,dim2", objectMap.get("dimensions"));
Assert.assertEquals("met1,met2", objectMap.get("metrics"));
Assert.assertEquals(ImmutableMap.of("type", "none"), objectMap.get("shardSpec"));
Assert.assertEquals(IndexIO.CURRENT_VERSION_ID, objectMap.get("binaryVersion"));
Assert.assertEquals(1, objectMap.get("size"));
DataSegment deserializedSegment =
mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
Assert.assertEquals(segment.getDataSource(), deserializedSegment.getDataSource());
Assert.assertEquals(segment.getInterval(), deserializedSegment.getInterval());
Assert.assertEquals(segment.getVersion(), deserializedSegment.getVersion());
Assert.assertEquals(segment.getLoadSpec(), deserializedSegment.getLoadSpec());
Assert.assertEquals(segment.getDimensions(), deserializedSegment.getDimensions());
Assert.assertEquals(segment.getMetrics(), deserializedSegment.getMetrics());
Assert.assertEquals(segment.getShardSpec(), deserializedSegment.getShardSpec());
Assert.assertEquals(segment.getSize(), deserializedSegment.getSize());
Assert.assertEquals(segment.getIdentifier(), deserializedSegment.getIdentifier());
deserializedSegment = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
Assert.assertEquals(0, segment.compareTo(deserializedSegment));
deserializedSegment = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
Assert.assertEquals(0, deserializedSegment.compareTo(segment));
deserializedSegment = mapper.readValue(mapper.writeValueAsString(segment), DataSegment.class);
Assert.assertEquals(segment.hashCode(), deserializedSegment.hashCode());
}
/**
* Load a kernel function from a file path. If the .gz extension is specified, the file considered
* compressed.
*
* @param kernel The input kernel
* @param outputFilePath The output file path
* @throws FileNotFoundException
* @throws IOException
*/
public static Kernel load(String inputFilePath) throws FileNotFoundException, IOException {
ObjectMapper mapper = new ObjectMapper();
if (inputFilePath.endsWith(".gz")) {
GZIPInputStream zip = new GZIPInputStream(new FileInputStream(new File(inputFilePath)));
return mapper.readValue(zip, Kernel.class);
} else {
return mapper.readValue(new File(inputFilePath), Kernel.class);
}
}
// for [JACKSON-652]
// @since 1.9
public void testUntypedWithJsonArrays() throws Exception {
// by default we get:
Object ob = MAPPER.readValue("[1]", Object.class);
assertTrue(ob instanceof List<?>);
// but can change to produce Object[]:
MAPPER.configure(DeserializationFeature.USE_JAVA_ARRAY_FOR_JSON_ARRAY, true);
ob = MAPPER.readValue("[1]", Object.class);
assertEquals(Object[].class, ob.getClass());
}
public static JsonHeader deserializeJsonHeader(final String ratJson)
throws JsonParseException, JsonMappingException, IOException {
ObjectMapper mapper = new ObjectMapper();
RATJsonObject ratJsonObject = (RATJsonObject) mapper.readValue(ratJson, RATJsonObject.class);
TypeFactory typeFactory = mapper.getTypeFactory();
MapType mapType = typeFactory.constructMapType(HashMap.class, String.class, String.class);
HashMap<String, String> map = mapper.readValue(ratJsonObject.getHeader(), mapType);
JsonHeader header = new JsonHeader();
header.setHeaderProperties(map);
return header;
}
@Test
public void testSerde() throws IOException {
ObjectMapper jsonMapper = new DefaultObjectMapper();
SearchSortSpec spec = new SearchSortSpec(StringComparators.ALPHANUMERIC);
String expectJsonSpec = "{\"type\":{\"type\":\"alphanumeric\"}}";
String jsonSpec = jsonMapper.writeValueAsString(spec);
Assert.assertEquals(expectJsonSpec, jsonSpec);
Assert.assertEquals(spec, jsonMapper.readValue(jsonSpec, SearchSortSpec.class));
String expectJsonSpec2 = "{\"type\":\"alphanumeric\"}";
Assert.assertEquals(spec, jsonMapper.readValue(expectJsonSpec2, SearchSortSpec.class));
}
@Test
public void testSerde() throws Exception {
final ObjectMapper objectMapper = new DefaultObjectMapper();
final String json = "{ \"type\" : \"partial\", \"expr\" : \".(...)?\" }";
MatchingDimExtractionFn extractionFn =
(MatchingDimExtractionFn) objectMapper.readValue(json, ExtractionFn.class);
Assert.assertEquals(".(...)?", extractionFn.getExpr());
// round trip
Assert.assertEquals(
extractionFn,
objectMapper.readValue(objectMapper.writeValueAsBytes(extractionFn), ExtractionFn.class));
}
/**
* Performs roundtrip test for the specified class.
*
* @param <TClass> Item class
* @param item Item to be checked
* @param asclass Class to be used during conversions
* @return Deserialized object after the roundtrip
* @throws IOException JSON Conversion error
* @throws AssertionError Validation error
*/
public static <TClass> TClass testRoundTrip(TClass item, Class<TClass> asclass)
throws IOException, AssertionError {
ObjectMapper mapper = new ObjectMapper();
String serialized1 = mapper.writeValueAsString(item);
JsonNode json1 = mapper.readTree(serialized1);
TClass deserialized1 = mapper.readValue(serialized1, asclass);
String serialized2 = mapper.writeValueAsString(deserialized1);
JsonNode json2 = mapper.readTree(serialized2);
TClass deserialized2 = mapper.readValue(serialized2, asclass);
assertEquals(json2, json1, "JSONs must be equal after the second roundtrip");
return deserialized2;
}
// [JACKSON-597]
public void testClass() throws IOException {
ObjectMapper mapper = new ObjectMapper();
assertSame(String.class, mapper.readValue(quote("java.lang.String"), Class.class));
// then primitive types
assertSame(Boolean.TYPE, mapper.readValue(quote("boolean"), Class.class));
assertSame(Byte.TYPE, mapper.readValue(quote("byte"), Class.class));
assertSame(Short.TYPE, mapper.readValue(quote("short"), Class.class));
assertSame(Character.TYPE, mapper.readValue(quote("char"), Class.class));
assertSame(Integer.TYPE, mapper.readValue(quote("int"), Class.class));
assertSame(Long.TYPE, mapper.readValue(quote("long"), Class.class));
assertSame(Float.TYPE, mapper.readValue(quote("float"), Class.class));
assertSame(Double.TYPE, mapper.readValue(quote("double"), Class.class));
assertSame(Void.TYPE, mapper.readValue(quote("void"), Class.class));
}
public void testDateMidnightDeser() throws IOException {
// couple of acceptable formats, so:
DateMidnight date = MAPPER.readValue("[2001,5,25]", DateMidnight.class);
assertEquals(2001, date.getYear());
assertEquals(5, date.getMonthOfYear());
assertEquals(25, date.getDayOfMonth());
DateMidnight date2 = MAPPER.readValue(quote("2005-07-13"), DateMidnight.class);
assertEquals(2005, date2.getYear());
assertEquals(7, date2.getMonthOfYear());
assertEquals(13, date2.getDayOfMonth());
// since 1.6.1, for [JACKSON-360]
assertNull(MAPPER.readValue(quote(""), DateMidnight.class));
}
@SuppressWarnings("unchecked")
@Override
public final <T> List<T> decodeList(final String entitiesAsString, final Class<T> clazz) {
Preconditions.checkNotNull(entitiesAsString);
List<T> entities = null;
try {
if (clazz.equals(Role.class)) {
entities =
objectMapper.readValue(
entitiesAsString,
new TypeReference<List<Role>>() {
// ...
});
} else if (clazz.equals(Privilege.class)) {
entities =
objectMapper.readValue(
entitiesAsString,
new TypeReference<List<Privilege>>() {
// ...
});
} else if (clazz.equals(User.class)) {
entities =
objectMapper.readValue(
entitiesAsString,
new TypeReference<List<User>>() {
// ...
});
} else if (clazz.equals(Principal.class)) {
entities =
objectMapper.readValue(
entitiesAsString,
new TypeReference<List<Principal>>() {
// ...
});
} else {
entities = objectMapper.readValue(entitiesAsString, List.class);
}
} catch (final JsonParseException parseEx) {
logger.error("", parseEx);
} catch (final JsonMappingException mappingEx) {
logger.error("", mappingEx);
} catch (final IOException ioEx) {
logger.error("", ioEx);
}
return entities;
}
@RequestMapping(value = "/getGRNFromOderId", method = RequestMethod.GET)
public void getGRNFromOderId(
HttpServletResponse httpservletResponse,
@RequestParam String oderId,
@RequestParam String status) {
try {
List<GrnVO> valueObj = grnManager.getGRNFromOderId(oderId, status);
if (valueObj != null && valueObj.size() > 0) {
ObjectMapper mapper = new ObjectMapper();
ObjectNode objectNode = new ObjectNode(mapper.getNodeFactory());
JsonObjectUtil<GrnVO> jsonUtil = new JsonObjectUtil<GrnVO>();
String m = jsonUtil.getJsonObjectDataDetail(valueObj, 1);
ArrayNode node = mapper.readValue(m, ArrayNode.class);
objectNode.put("Data", node);
objectNode.put("success", true);
writeJson(httpservletResponse, objectNode, mapper);
} else {
writeJsonString(httpservletResponse, "{\"Data\":\"Empty\",\"success\":false}");
}
} catch (Exception e) {
getLogger().error(e.getMessage());
writeJsonString(
httpservletResponse, "{\"Data\":\"" + e.getMessage() + "\",\"success\":false}");
}
}
@Test
public void voteAndGetResults() throws Exception {
// do 5 votes
vote();
MvcResult result =
mockMvc
.perform(
get("/vote/showWinner")
.contentType(MediaType.APPLICATION_JSON)
.with(httpBasic("user", "")))
.andExpect(status().isOk())
.andReturn();
String contentAsString = result.getResponse().getContentAsString();
ObjectMapper mapper = new ObjectMapper();
VoteResult[] voteResult =
mapper.readValue(new StringReader(contentAsString), VoteResult[].class);
// check we have results for all restaurants
assertEquals(2, voteResult.length);
// check it was sorted properly
assertEquals(RESTAURANT_B_NAME, voteResult[0].getRestaurantName());
// check votes counted properly
assertEquals(3, voteResult[0].getVotes());
assertEquals(2, voteResult[1].getVotes());
}
