signalapp/serde_json
signalapp/serde_json
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Format with rustfmt 0.99.6-nightly

Browse Source
This commit is contained in:
David Tolnay 2018-11-06 14:19:13 -08:00
parent ef59f615f4
commit b3001f48ee
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
7 changed files with 361 additions and 434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/de.rs
View File

@ -346,13 +346,11 @@ impl<'de, R: Read<'de>> Deserializer<R> {
// number as a `u64` until we grow too large. At that point, switch to
// parsing the value as a `f64`.
if overflow!(res * 10 + digit, u64::max_value()) {
return Ok(ParserNumber::F64(try!(
self.parse_long_integer(
positive,
res,
1, // res * 10^1
)
)));
return Ok(ParserNumber::F64(try!(self.parse_long_integer(
positive,
res,
1, // res * 10^1
))));
}
res = res * 10 + digit;
@ -867,9 +865,11 @@ impl<'de, R: Read<'de>> Deserializer<R> {
return Err(self.peek_error(ErrorCode::InvalidNumber));
}
}
b'1'...b'9' => while let b'0'...b'9' = try!(self.peek_or_null()) {
self.eat_char();
},
b'1'...b'9' => {
while let b'0'...b'9' = try!(self.peek_or_null()) {
self.eat_char();
}
}
_ => {
return Err(self.error(ErrorCode::InvalidNumber));
}

17
src/lib.rs
View File

@ -319,32 +319,29 @@
#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
// Whitelisted clippy lints
#![cfg_attr(
feature = "cargo-clippy",
allow(doc_markdown, needless_pass_by_value)
)]
#![cfg_attr(feature = "cargo-clippy", allow(doc_markdown, needless_pass_by_value))]
// Whitelisted clippy_pedantic lints
#![cfg_attr(feature = "cargo-clippy", allow(
// Deserializer::from_str, into_iter
// Deserializer::from_str, into_iter
should_implement_trait,
// integer and float ser/de requires these sorts of casts
// integer and float ser/de requires these sorts of casts
cast_possible_truncation,
cast_possible_wrap,
cast_precision_loss,
cast_sign_loss,
// string ser/de uses indexing and slicing
// string ser/de uses indexing and slicing
indexing_slicing,
// things are often more readable this way
// things are often more readable this way
cast_lossless,
shadow_reuse,
shadow_unrelated,
single_match_else,
stutter,
use_self,
// not practical
// not practical
missing_docs_in_private_items,
similar_names,
// we support older compilers
// we support older compilers
redundant_field_names,
))]
#![deny(missing_docs)]

12
src/number.rs
View File

@ -175,11 +175,13 @@ impl Number {
pub fn as_i64(&self) -> Option<i64> {
#[cfg(not(feature = "arbitrary_precision"))]
match self.n {
N::PosInt(n) => if n <= i64::max_value() as u64 {
Some(n as i64)
} else {
None
},
N::PosInt(n) => {
if n <= i64::max_value() as u64 {
Some(n as i64)
} else {
None
}
}
N::NegInt(n) => Some(n),
N::Float(_) => None,
}

7
src/raw.rs
View File

@ -1,9 +1,12 @@
use std::fmt::{self, Debug, Display};
use std::mem;
use serde::ser::{Serialize, Serializer, SerializeStruct};
use serde::de::{self, Deserialize, Deserializer, DeserializeSeed, IntoDeserializer, MapAccess, Unexpected, Visitor};
use serde::de::value::BorrowedStrDeserializer;
use serde::de::{
self, Deserialize, DeserializeSeed, Deserializer, IntoDeserializer, MapAccess, Unexpected,
Visitor,
};
use serde::ser::{Serialize, SerializeStruct, Serializer};
use error::Error;

12
src/read.rs
View File

@ -369,7 +369,9 @@ where
{
let raw = self.raw_buffer.take().unwrap();
let raw = String::from_utf8(raw).unwrap();
visitor.visit_map(OwnedRawDeserializer { raw_value: Some(raw) })
visitor.visit_map(OwnedRawDeserializer {
raw_value: Some(raw),
})
}
}
@ -578,7 +580,9 @@ impl<'a> Read<'a> for SliceRead<'a> {
{
let raw = &self.slice[self.raw_buffering_start_index..self.index];
let raw = str::from_utf8(raw).unwrap();
visitor.visit_map(BorrowedRawDeserializer { raw_value: Some(raw) })
visitor.visit_map(BorrowedRawDeserializer {
raw_value: Some(raw),
})
}
}
@ -667,7 +671,9 @@ impl<'a> Read<'a> for StrRead<'a> {
V: Visitor<'a>,
{
let raw = &self.data[self.delegate.raw_buffering_start_index..self.delegate.index];
visitor.visit_map(BorrowedRawDeserializer { raw_value: Some(raw) })
visitor.visit_map(BorrowedRawDeserializer {
raw_value: Some(raw),
})
}
}

660
src/ser.rs
View File

@ -87,51 +87,46 @@ where
#[inline]
fn serialize_bool(self, value: bool) -> Result<()> {
try!(
self.formatter
.write_bool(&mut self.writer, value)
.map_err(Error::io)
);
try!(self
.formatter
.write_bool(&mut self.writer, value)
.map_err(Error::io));
Ok(())
}
#[inline]
fn serialize_i8(self, value: i8) -> Result<()> {
try!(
self.formatter
.write_i8(&mut self.writer, value)
.map_err(Error::io)
);
try!(self
.formatter
.write_i8(&mut self.writer, value)
.map_err(Error::io));
Ok(())
}
#[inline]
fn serialize_i16(self, value: i16) -> Result<()> {
try!(
self.formatter
.write_i16(&mut self.writer, value)
.map_err(Error::io)
);
try!(self
.formatter
.write_i16(&mut self.writer, value)
.map_err(Error::io));
Ok(())
}
#[inline]
fn serialize_i32(self, value: i32) -> Result<()> {
try!(
self.formatter
.write_i32(&mut self.writer, value)
.map_err(Error::io)
);
try!(self
.formatter
.write_i32(&mut self.writer, value)
.map_err(Error::io));
Ok(())
}
#[inline]
fn serialize_i64(self, value: i64) -> Result<()> {
try!(
self.formatter
.write_i64(&mut self.writer, value)
.map_err(Error::io)
);
try!(self
.formatter
.write_i64(&mut self.writer, value)
.map_err(Error::io));
Ok(())
}
@ -145,41 +140,37 @@ where
#[inline]
fn serialize_u8(self, value: u8) -> Result<()> {
try!(
self.formatter
.write_u8(&mut self.writer, value)
.map_err(Error::io)
);
try!(self
.formatter
.write_u8(&mut self.writer, value)
.map_err(Error::io));
Ok(())
}
#[inline]
fn serialize_u16(self, value: u16) -> Result<()> {
try!(
self.formatter
.write_u16(&mut self.writer, value)
.map_err(Error::io)
);
try!(self
.formatter
.write_u16(&mut self.writer, value)
.map_err(Error::io));
Ok(())
}
#[inline]
fn serialize_u32(self, value: u32) -> Result<()> {
try!(
self.formatter
.write_u32(&mut self.writer, value)
.map_err(Error::io)
);
try!(self
.formatter
.write_u32(&mut self.writer, value)
.map_err(Error::io));
Ok(())
}
#[inline]
fn serialize_u64(self, value: u64) -> Result<()> {
try!(
self.formatter
.write_u64(&mut self.writer, value)
.map_err(Error::io)
);
try!(self
.formatter
.write_u64(&mut self.writer, value)
.map_err(Error::io));
Ok(())
}
@ -195,18 +186,16 @@ where
fn serialize_f32(self, value: f32) -> Result<()> {
match value.classify() {
FpCategory::Nan | FpCategory::Infinite => {
try!(
self.formatter
.write_null(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.write_null(&mut self.writer)
.map_err(Error::io));
}
_ => {
try!(
self.formatter
.write_f32(&mut self.writer, value)
.map_err(Error::io)
);
try!(self
.formatter
.write_f32(&mut self.writer, value)
.map_err(Error::io));
}
}
Ok(())
@ -216,18 +205,16 @@ where
fn serialize_f64(self, value: f64) -> Result<()> {
match value.classify() {
FpCategory::Nan | FpCategory::Infinite => {
try!(
self.formatter
.write_null(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.write_null(&mut self.writer)
.map_err(Error::io));
}
_ => {
try!(
self.formatter
.write_f64(&mut self.writer, value)
.map_err(Error::io)
);
try!(self
.formatter
.write_f64(&mut self.writer, value)
.map_err(Error::io));
}
}
Ok(())
@ -258,11 +245,10 @@ where
#[inline]
fn serialize_unit(self) -> Result<()> {
try!(
self.formatter
.write_null(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.write_null(&mut self.writer)
.map_err(Error::io));
Ok(())
}
@ -301,38 +287,32 @@ where
where
T: Serialize,
{
try!(
self.formatter
.begin_object(&mut self.writer)
.map_err(Error::io)
);
try!(
self.formatter
.begin_object_key(&mut self.writer, true)
.map_err(Error::io)
);
try!(self
.formatter
.begin_object(&mut self.writer)
.map_err(Error::io));
try!(self
.formatter
.begin_object_key(&mut self.writer, true)
.map_err(Error::io));
try!(self.serialize_str(variant));
try!(
self.formatter
.end_object_key(&mut self.writer)
.map_err(Error::io)
);
try!(
self.formatter
.begin_object_value(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.end_object_key(&mut self.writer)
.map_err(Error::io));
try!(self
.formatter
.begin_object_value(&mut self.writer)
.map_err(Error::io));
try!(value.serialize(&mut *self));
try!(
self.formatter
.end_object_value(&mut self.writer)
.map_err(Error::io)
);
try!(
self.formatter
.end_object(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.end_object_value(&mut self.writer)
.map_err(Error::io));
try!(self
.formatter
.end_object(&mut self.writer)
.map_err(Error::io));
Ok(())
}
@ -352,26 +332,23 @@ where
#[inline]
fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
if len == Some(0) {
try!(
self.formatter
.begin_array(&mut self.writer)
.map_err(Error::io)
);
try!(
self.formatter
.end_array(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.begin_array(&mut self.writer)
.map_err(Error::io));
try!(self
.formatter
.end_array(&mut self.writer)
.map_err(Error::io));
Ok(Compound::Map {
ser: self,
state: State::Empty,
})
} else {
try!(
self.formatter
.begin_array(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.begin_array(&mut self.writer)
.map_err(Error::io));
Ok(Compound::Map {
ser: self,
state: State::First,
@ -401,53 +378,46 @@ where
variant: &'static str,
len: usize,
) -> Result<Self::SerializeTupleVariant> {
try!(
self.formatter
.begin_object(&mut self.writer)
.map_err(Error::io)
);
try!(
self.formatter
.begin_object_key(&mut self.writer, true)
.map_err(Error::io)
);
try!(self
.formatter
.begin_object(&mut self.writer)
.map_err(Error::io));
try!(self
.formatter
.begin_object_key(&mut self.writer, true)
.map_err(Error::io));
try!(self.serialize_str(variant));
try!(
self.formatter
.end_object_key(&mut self.writer)
.map_err(Error::io)
);
try!(
self.formatter
.begin_object_value(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.end_object_key(&mut self.writer)
.map_err(Error::io));
try!(self
.formatter
.begin_object_value(&mut self.writer)
.map_err(Error::io));
self.serialize_seq(Some(len))
}
#[inline]
fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
if len == Some(0) {
try!(
self.formatter
.begin_object(&mut self.writer)
.map_err(Error::io)
);
try!(
self.formatter
.end_object(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.begin_object(&mut self.writer)
.map_err(Error::io));
try!(self
.formatter
.end_object(&mut self.writer)
.map_err(Error::io));
Ok(Compound::Map {
ser: self,
state: State::Empty,
})
} else {
try!(
self.formatter
.begin_object(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.begin_object(&mut self.writer)
.map_err(Error::io));
Ok(Compound::Map {
ser: self,
state: State::First,
@ -474,27 +444,23 @@ where
variant: &'static str,
len: usize,
) -> Result<Self::SerializeStructVariant> {
try!(
self.formatter
.begin_object(&mut self.writer)
.map_err(Error::io)
);
try!(
self.formatter
.begin_object_key(&mut self.writer, true)
.map_err(Error::io)
);
try!(self
.formatter
.begin_object(&mut self.writer)
.map_err(Error::io));
try!(self
.formatter
.begin_object_key(&mut self.writer, true)
.map_err(Error::io));
try!(self.serialize_str(variant));
try!(
self.formatter
.end_object_key(&mut self.writer)
.map_err(Error::io)
);
try!(
self.formatter
.begin_object_value(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.end_object_key(&mut self.writer)
.map_err(Error::io));
try!(self
.formatter
.begin_object_value(&mut self.writer)
.map_err(Error::io));
self.serialize_map(Some(len))
}
@ -527,11 +493,10 @@ where
}
}
try!(
self.formatter
.begin_string(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.begin_string(&mut self.writer)
.map_err(Error::io));
{
let mut adapter = Adapter {
writer: &mut self.writer,
@ -545,11 +510,10 @@ where
}
}
}
try!(
self.formatter
.end_string(&mut self.writer)
.map_err(Error::io)
);
try!(self
.formatter
.end_string(&mut self.writer)
.map_err(Error::io));
Ok(())
}
}
@ -594,18 +558,16 @@ where
ref mut ser,
ref mut state,
} => {
try!(
ser.formatter
.begin_array_value(&mut ser.writer, *state == State::First)
.map_err(Error::io)
);
try!(ser
.formatter
.begin_array_value(&mut ser.writer, *state == State::First)
.map_err(Error::io));
*state = State::Rest;
try!(value.serialize(&mut **ser));
try!(
ser.formatter
.end_array_value(&mut ser.writer)
.map_err(Error::io)
);
try!(ser
.formatter
.end_array_value(&mut ser.writer)
.map_err(Error::io));
Ok(())
}
#[cfg(feature = "arbitrary_precision")]
@ -701,11 +663,10 @@ where
State::Empty => {}
_ => try!(ser.formatter.end_array(&mut ser.writer).map_err(Error::io)),
}
try!(
ser.formatter
.end_object_value(&mut ser.writer)
.map_err(Error::io)
);
try!(ser
.formatter
.end_object_value(&mut ser.writer)
.map_err(Error::io));
try!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io));
Ok(())
}
@ -735,20 +696,18 @@ where
ref mut ser,
ref mut state,
} => {
try!(
ser.formatter
.begin_object_key(&mut ser.writer, *state == State::First)
.map_err(Error::io)
);
try!(ser
.formatter
.begin_object_key(&mut ser.writer, *state == State::First)
.map_err(Error::io));
*state = State::Rest;
try!(key.serialize(MapKeySerializer { ser: *ser }));
try!(
ser.formatter
.end_object_key(&mut ser.writer)
.map_err(Error::io)
);
try!(ser
.formatter
.end_object_key(&mut ser.writer)
.map_err(Error::io));
Ok(())
}
#[cfg(feature = "arbitrary_precision")]
@ -765,17 +724,15 @@ where
{
match *self {
Compound::Map { ref mut ser, .. } => {
try!(
ser.formatter
.begin_object_value(&mut ser.writer)
.map_err(Error::io)
);
try!(ser
.formatter
.begin_object_value(&mut ser.writer)
.map_err(Error::io));
try!(value.serialize(&mut **ser));
try!(
ser.formatter
.end_object_value(&mut ser.writer)
.map_err(Error::io)
);
try!(ser
.formatter
.end_object_value(&mut ser.writer)
.map_err(Error::io));
Ok(())
}
#[cfg(feature = "arbitrary_precision")]
@ -884,11 +841,10 @@ where
State::Empty => {}
_ => try!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io)),
}
try!(
ser.formatter
.end_object_value(&mut ser.writer)
.map_err(Error::io)
);
try!(ser
.formatter
.end_object_value(&mut ser.writer)
.map_err(Error::io));
try!(ser.formatter.end_object(&mut ser.writer).map_err(Error::io));
Ok(())
}
@ -962,90 +918,78 @@ where
}
fn serialize_i8(self, value: i8) -> Result<()> {
try!(
self.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.write_i8(&mut self.ser.writer, value)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(self
.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io));
try!(self
.ser
.formatter
.write_i8(&mut self.ser.writer, value)
.map_err(Error::io));
try!(self
.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
}
fn serialize_i16(self, value: i16) -> Result<()> {
try!(
self.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.write_i16(&mut self.ser.writer, value)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(self
.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io));
try!(self
.ser
.formatter
.write_i16(&mut self.ser.writer, value)
.map_err(Error::io));
try!(self
.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
}
fn serialize_i32(self, value: i32) -> Result<()> {
try!(
self.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.write_i32(&mut self.ser.writer, value)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(self
.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io));
try!(self
.ser
.formatter
.write_i32(&mut self.ser.writer, value)
.map_err(Error::io));
try!(self
.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
}
fn serialize_i64(self, value: i64) -> Result<()> {
try!(
self.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.write_i64(&mut self.ser.writer, value)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(self
.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io));
try!(self
.ser
.formatter
.write_i64(&mut self.ser.writer, value)
.map_err(Error::io));
try!(self
.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
}
@ -1059,90 +1003,78 @@ where
}
fn serialize_u8(self, value: u8) -> Result<()> {
try!(
self.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.write_u8(&mut self.ser.writer, value)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(self
.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io));
try!(self
.ser
.formatter
.write_u8(&mut self.ser.writer, value)
.map_err(Error::io));
try!(self
.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
}
fn serialize_u16(self, value: u16) -> Result<()> {
try!(
self.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.write_u16(&mut self.ser.writer, value)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(self
.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io));
try!(self
.ser
.formatter
.write_u16(&mut self.ser.writer, value)
.map_err(Error::io));
try!(self
.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
}
fn serialize_u32(self, value: u32) -> Result<()> {
try!(
self.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.write_u32(&mut self.ser.writer, value)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(self
.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io));
try!(self
.ser
.formatter
.write_u32(&mut self.ser.writer, value)
.map_err(Error::io));
try!(self
.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
}
fn serialize_u64(self, value: u64) -> Result<()> {
try!(
self.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.write_u64(&mut self.ser.writer, value)
.map_err(Error::io)
);
try!(
self.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io)
);
try!(self
.ser
.formatter
.begin_string(&mut self.ser.writer)
.map_err(Error::io));
try!(self
.ser
.formatter
.write_u64(&mut self.ser.writer, value)
.map_err(Error::io));
try!(self
.ser
.formatter
.end_string(&mut self.ser.writer)
.map_err(Error::io));
Ok(())
}

67
tests/test.rs
View File

@ -7,10 +7,7 @@
// except according to those terms.
#![cfg(not(feature = "preserve_order"))]
#![cfg_attr(
feature = "cargo-clippy",
allow(float_cmp, unreadable_literal)
)]
#![cfg_attr(feature = "cargo-clippy", allow(float_cmp, unreadable_literal))]
#![cfg_attr(feature = "trace-macros", feature(trace_macros))]
#[cfg(feature = "trace-macros")]
trace_macros!(true);
@ -1192,7 +1189,8 @@ fn test_parse_struct() {
[ null, 2, [\"abc\", \"xyz\"] ]
]
]",
).unwrap();
)
.unwrap();
assert_eq!(
v,
@ -1680,7 +1678,8 @@ fn test_json_pointer() {
" ": 7,
"m~n": 8
}"#,
).unwrap();
)
.unwrap();
assert_eq!(data.pointer("").unwrap(), &data);
assert_eq!(data.pointer("/foo").unwrap(), &json!(["bar", "baz"]));
assert_eq!(data.pointer("/foo/0").unwrap(), &json!("bar"));
@ -1718,7 +1717,8 @@ fn test_json_pointer_mut() {
" ": 7,
"m~n": 8
}"#,
).unwrap();
)
.unwrap();
// Basic pointer checks
assert_eq!(data.pointer_mut("/foo").unwrap(), &json!(["bar", "baz"]));
@ -1956,31 +1956,21 @@ fn test_category() {
assert!(from_str::<Vec<usize>>("[0").unwrap_err().is_eof());
assert!(from_str::<Vec<usize>>("[0,").unwrap_err().is_eof());
assert!(
from_str::<BTreeMap<String, usize>>("{")
.unwrap_err()
.is_eof()
);
assert!(
from_str::<BTreeMap<String, usize>>("{\"k\"")
.unwrap_err()
.is_eof()
);
assert!(
from_str::<BTreeMap<String, usize>>("{\"k\":")
.unwrap_err()
.is_eof()
);
assert!(
from_str::<BTreeMap<String, usize>>("{\"k\":0")
.unwrap_err()
.is_eof()
);
assert!(
from_str::<BTreeMap<String, usize>>("{\"k\":0,")
.unwrap_err()
.is_eof()
);
assert!(from_str::<BTreeMap<String, usize>>("{")
.unwrap_err()
.is_eof());
assert!(from_str::<BTreeMap<String, usize>>("{\"k\"")
.unwrap_err()
.is_eof());
assert!(from_str::<BTreeMap<String, usize>>("{\"k\":")
.unwrap_err()
.is_eof());
assert!(from_str::<BTreeMap<String, usize>>("{\"k\":0")
.unwrap_err()
.is_eof());
assert!(from_str::<BTreeMap<String, usize>>("{\"k\":0,")
.unwrap_err()
.is_eof());
let fail = FailReader(io::ErrorKind::NotConnected);
assert!(from_reader::<_, String>(fail).unwrap_err().is_io());
@ -2111,14 +2101,12 @@ fn test_boxed_raw_value() {
serde_json::from_str(r#"{"a": 1, "b": {"foo": 2}, "c": 3}"#).unwrap();
assert_eq!(r#"{"foo": 2}"#, wrapper_from_str.b.get());
let wrapper_from_reader: Wrapper = serde_json::from_reader(
br#"{"a": 1, "b": {"foo": 2}, "c": 3}"#.as_ref(),
).unwrap();
let wrapper_from_reader: Wrapper =
serde_json::from_reader(br#"{"a": 1, "b": {"foo": 2}, "c": 3}"#.as_ref()).unwrap();
assert_eq!(r#"{"foo": 2}"#, wrapper_from_reader.b.get());
let wrapper_from_value: Wrapper =
serde_json::from_value(json!({"a": 1, "b": {"foo": 2}, "c": 3}))
.unwrap();
serde_json::from_value(json!({"a": 1, "b": {"foo": 2}, "c": 3})).unwrap();
assert_eq!(r#"{"foo":2}"#, wrapper_from_value.b.get());
let wrapper_to_string = serde_json::to_string(&wrapper_from_str).unwrap();
@ -2134,9 +2122,8 @@ fn test_boxed_raw_value() {
assert_eq!(r#"{"foo": "bar"}"#, array_from_str[2].get());
assert_eq!(r#"null"#, array_from_str[3].get());
let array_from_reader: Vec<Box<RawValue>> = serde_json::from_reader(
br#"["a", 42, {"foo": "bar"}, null]"#.as_ref(),
).unwrap();
let array_from_reader: Vec<Box<RawValue>> =
serde_json::from_reader(br#"["a", 42, {"foo": "bar"}, null]"#.as_ref()).unwrap();
assert_eq!(r#""a""#, array_from_reader[0].get());
assert_eq!(r#"42"#, array_from_reader[1].get());
assert_eq!(r#"{"foo": "bar"}"#, array_from_reader[2].get());