Revert "Import serde-xml-rs 0.4.1" am: 1620dfabbf am: 4d09061836
Original change: https://android-review.googlesource.com/c/platform/external/rust/crates/serde-xml-rs/+/1769146
Change-Id: I86ecf942dda8979116248c8e9911fc380a63713f
diff --git a/Android.bp b/Android.bp
deleted file mode 100644
index ee9f639..0000000
--- a/Android.bp
+++ /dev/null
@@ -1,34 +0,0 @@
-// This file is generated by cargo2android.py --config cargo2android.json.
-// Do not modify this file as changes will be overridden on upgrade.
-
-
-
-rust_library {
- name: "libserde_xml_rs",
- host_supported: true,
- crate_name: "serde_xml_rs",
- srcs: ["src/lib.rs"],
- edition: "2015",
- rustlibs: [
- "liblog_rust",
- "libserde",
- "libthiserror",
- "libxml",
- ],
- apex_available: [
- "//apex_available:platform",
- "com.android.virt",
- ],
-}
-
-// dependent_library ["feature_list"]
-// cfg-if-1.0.0
-// log-0.4.14 "std"
-// proc-macro2-1.0.27 "default,proc-macro"
-// quote-1.0.9 "default,proc-macro"
-// serde-1.0.126 "default,std"
-// syn-1.0.73 "clone-impls,default,derive,parsing,printing,proc-macro,quote"
-// thiserror-1.0.26
-// thiserror-impl-1.0.26
-// unicode-xid-0.2.2 "default"
-// xml-rs-0.8.3
diff --git a/Cargo.toml b/Cargo.toml
deleted file mode 100644
index fa4d9b9..0000000
--- a/Cargo.toml
+++ /dev/null
@@ -1,18 +0,0 @@
-[package]
-authors = ["Ingvar Stepanyan <me@rreverser.com>"]
-description = "xml-rs based deserializer for Serde (compatible with 0.9+)"
-license = "MIT"
-name = "serde-xml-rs"
-repository = "https://github.com/RReverser/serde-xml-rs"
-version = "0.4.1"
-
-[dependencies]
-log = "0.4"
-serde = "1.0"
-xml-rs = "0.8.0"
-thiserror = "1.0"
-
-[dev-dependencies]
-serde_derive = "1.0"
-simple_logger = "1.0.1"
-docmatic = "0.1.2"
diff --git a/LICENSE b/LICENSE
deleted file mode 100644
index 774d94a..0000000
--- a/LICENSE
+++ /dev/null
@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Ingvar Stepanyan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/METADATA b/METADATA
deleted file mode 100644
index a1b4d08..0000000
--- a/METADATA
+++ /dev/null
@@ -1,17 +0,0 @@
-name: "serde-xml-rs"
-description:
- "xml-rs based deserializer for Serde"
-
-third_party {
- url {
- type: HOMEPAGE
- value: "https://crates.io/crates/serde_xml_rs"
- }
- url {
- type: GIT
- value: "https://github.com/RReverser/serde-xml-rs"
- }
- version: "0.4.1"
- last_upgrade_date { year: 2021 month: 6 day: 21 }
- license_type: NOTICE
-}
\ No newline at end of file
diff --git a/MODULE_LICENSE_MIT b/MODULE_LICENSE_MIT
deleted file mode 100644
index e69de29..0000000
--- a/MODULE_LICENSE_MIT
+++ /dev/null
diff --git a/OWNERS b/OWNERS
deleted file mode 100644
index 98a1473..0000000
--- a/OWNERS
+++ /dev/null
@@ -1,2 +0,0 @@
-include platform/prebuilts/rust:/OWNERS
-
diff --git a/README.md b/README.md
deleted file mode 100644
index f2e530c..0000000
--- a/README.md
+++ /dev/null
@@ -1,62 +0,0 @@
-# serde-xml-rs
-
-[](https://travis-ci.org/RReverser/serde-xml-rs)
-
-xml-rs based deserializer for Serde (compatible with 0.9+)
-
-## Usage
-
-Use `serde_xml_rs::from_reader(...)` on any type that implements [`std::io::Read`](https://doc.rust-lang.org/std/io/trait.Read.html) as following:
-
-```rust
-#[macro_use]
-extern crate serde_derive;
-extern crate serde;
-extern crate serde_xml_rs;
-
-use serde_xml_rs::from_reader;
-
-#[derive(Debug, Deserialize)]
-struct Item {
- pub name: String,
- pub source: String
-}
-
-#[derive(Debug, Deserialize)]
-struct Project {
- pub name: String,
-
- #[serde(rename = "Item", default)]
- pub items: Vec<Item>
-}
-
-fn main() {
- let s = r##"
- <Project name="my_project">
- <Item name="hello" source="world.rs" />
- </Project>
- "##;
- let project: Project = from_reader(s.as_bytes()).unwrap();
- println!("{:#?}", project);
-}
-```
-
-Alternatively, you can use `serde_xml_rs::Deserializer` to create a deserializer from a preconfigured [`xml_rs::EventReader`](https://netvl.github.io/xml-rs/xml/reader/struct.EventReader.html).
-
-## Parsing the "value" of a tag
-
-If you have an input of the form `<foo abc="xyz">bar</foo>`, and you want to get at the`bar`, you can use the special name `$value`:
-
-```rust,ignore
-struct Foo {
- pub abc: String,
- #[serde(rename = "$value")]
- pub body: String,
-}
-```
-
-## Parsed representations
-
-Deserializer tries to be as intuitive as possible.
-
-However, there are some edge cases where you might get unexpected errors, so it's best to check out [`tests`](tests/test.rs) for expectations.
diff --git a/cargo2android.json b/cargo2android.json
deleted file mode 100644
index 42b7833..0000000
--- a/cargo2android.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
- "apex-available": [
- "//apex_available:platform",
- "com.android.virt"
- ],
- "dependencies": true,
- "device": true,
- "run": true
-}
\ No newline at end of file
diff --git a/rustfmt.toml b/rustfmt.toml
deleted file mode 100644
index 8c795ae..0000000
--- a/rustfmt.toml
+++ /dev/null
@@ -1 +0,0 @@
-match_block_trailing_comma = true
diff --git a/src/de/map.rs b/src/de/map.rs
deleted file mode 100644
index ed1d0bb..0000000
--- a/src/de/map.rs
+++ /dev/null
@@ -1,126 +0,0 @@
-use std::io::Read;
-
-use serde::de::{self, IntoDeserializer, Unexpected};
-use xml::attribute::OwnedAttribute;
-use xml::reader::XmlEvent;
-
-use Deserializer;
-use error::{Error, Result};
-
-pub struct MapAccess<'a, R: 'a + Read> {
- attrs: ::std::vec::IntoIter<OwnedAttribute>,
- next_value: Option<String>,
- de: &'a mut Deserializer<R>,
- inner_value: bool,
-}
-
-impl<'a, R: 'a + Read> MapAccess<'a, R> {
- pub fn new(de: &'a mut Deserializer<R>, attrs: Vec<OwnedAttribute>, inner_value: bool) -> Self {
- MapAccess {
- attrs: attrs.into_iter(),
- next_value: None,
- de: de,
- inner_value: inner_value,
- }
- }
-}
-
-impl<'de, 'a, R: 'a + Read> de::MapAccess<'de> for MapAccess<'a, R> {
- type Error = Error;
-
- fn next_key_seed<K: de::DeserializeSeed<'de>>(&mut self, seed: K) -> Result<Option<K::Value>> {
- debug_assert_eq!(self.next_value, None);
- match self.attrs.next() {
- Some(OwnedAttribute { name, value }) => {
- self.next_value = Some(value);
- seed.deserialize(name.local_name.into_deserializer())
- .map(Some)
- },
- None => match *self.de.peek()? {
- XmlEvent::StartElement { ref name, .. } => seed.deserialize(
- if !self.inner_value {
- name.local_name.as_str()
- } else {
- "$value"
- }.into_deserializer(),
- ).map(Some),
- XmlEvent::Characters(_) => seed.deserialize("$value".into_deserializer()).map(Some),
- _ => Ok(None),
- },
- }
- }
-
- fn next_value_seed<V: de::DeserializeSeed<'de>>(&mut self, seed: V) -> Result<V::Value> {
- match self.next_value.take() {
- Some(value) => seed.deserialize(AttrValueDeserializer(value)),
- None => {
- if !self.inner_value {
- if let XmlEvent::StartElement { .. } = *self.de.peek()? {
- self.de.set_map_value();
- }
- }
- let result = seed.deserialize(&mut *self.de)?;
- Ok(result)
- },
- }
- }
-
- fn size_hint(&self) -> Option<usize> {
- self.attrs.size_hint().1
- }
-}
-
-struct AttrValueDeserializer(String);
-
-macro_rules! deserialize_type_attr {
- ($deserialize:ident => $visit:ident) => {
- fn $deserialize<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- visitor.$visit(self.0.parse()?)
- }
- }
-}
-
-impl<'de> de::Deserializer<'de> for AttrValueDeserializer {
- type Error = Error;
-
- fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- visitor.visit_string(self.0)
- }
-
- deserialize_type_attr!(deserialize_i8 => visit_i8);
- deserialize_type_attr!(deserialize_i16 => visit_i16);
- deserialize_type_attr!(deserialize_i32 => visit_i32);
- deserialize_type_attr!(deserialize_i64 => visit_i64);
- deserialize_type_attr!(deserialize_u8 => visit_u8);
- deserialize_type_attr!(deserialize_u16 => visit_u16);
- deserialize_type_attr!(deserialize_u32 => visit_u32);
- deserialize_type_attr!(deserialize_u64 => visit_u64);
- deserialize_type_attr!(deserialize_f32 => visit_f32);
- deserialize_type_attr!(deserialize_f64 => visit_f64);
-
- fn deserialize_enum<V: de::Visitor<'de>>(
- self,
- _name: &str,
- _variants: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value> {
- visitor.visit_enum(self.0.into_deserializer())
- }
-
- fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- visitor.visit_some(self)
- }
-
- fn deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- match self.0.as_str() {
- "true" | "1" => visitor.visit_bool(true),
- "false" | "0" => visitor.visit_bool(false),
- _ => Err(de::Error::invalid_value(Unexpected::Str(&self.0), &"a boolean")),
- }
- }
-
- forward_to_deserialize_any! {
- char str string unit seq bytes map unit_struct newtype_struct tuple_struct
- struct identifier tuple ignored_any byte_buf
- }
-}
diff --git a/src/de/mod.rs b/src/de/mod.rs
deleted file mode 100644
index 94077c5..0000000
--- a/src/de/mod.rs
+++ /dev/null
@@ -1,367 +0,0 @@
-use std::io::Read;
-
-use serde::de::{self, Unexpected};
-use xml::name::OwnedName;
-use xml::reader::{EventReader, ParserConfig, XmlEvent};
-
-use self::map::MapAccess;
-use self::seq::SeqAccess;
-use self::var::EnumAccess;
-use error::{Error, Result};
-
-mod map;
-mod seq;
-mod var;
-
-/// A convenience method for deserialize some object from a string.
-///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// # extern crate serde;
-/// # extern crate serde_xml_rs;
-/// # use serde_xml_rs::from_str;
-/// #[derive(Debug, Deserialize, PartialEq)]
-/// struct Item {
-/// name: String,
-/// source: String,
-/// }
-/// # fn main() {
-/// let s = r##"<item name="hello" source="world.rs" />"##;
-/// let item: Item = from_str(s).unwrap();
-/// assert_eq!(item, Item { name: "hello".to_string(),source: "world.rs".to_string()});
-/// # }
-/// ```
-pub fn from_str<'de, T: de::Deserialize<'de>>(s: &str) -> Result<T> {
- from_reader(s.as_bytes())
-}
-
-/// A convenience method for deserialize some object from a reader.
-///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// # extern crate serde;
-/// # extern crate serde_xml_rs;
-/// # use serde_xml_rs::from_reader;
-/// #[derive(Debug, Deserialize, PartialEq)]
-/// struct Item {
-/// name: String,
-/// source: String,
-/// }
-/// # fn main() {
-/// let s = r##"<item name="hello" source="world.rs" />"##;
-/// let item: Item = from_reader(s.as_bytes()).unwrap();
-/// assert_eq!(item, Item { name: "hello".to_string(),source: "world.rs".to_string()});
-/// # }
-/// ```
-pub fn from_reader<'de, R: Read, T: de::Deserialize<'de>>(reader: R) -> Result<T> {
- T::deserialize(&mut Deserializer::new_from_reader(reader))
-}
-
-pub struct Deserializer<R: Read> {
- depth: usize,
- reader: EventReader<R>,
- peeked: Option<XmlEvent>,
- is_map_value: bool,
-}
-
-impl<'de, R: Read> Deserializer<R> {
- pub fn new(reader: EventReader<R>) -> Self {
- Deserializer {
- depth: 0,
- reader: reader,
- peeked: None,
- is_map_value: false,
- }
- }
-
- pub fn new_from_reader(reader: R) -> Self {
- let config = ParserConfig::new()
- .trim_whitespace(true)
- .whitespace_to_characters(true)
- .cdata_to_characters(true)
- .ignore_comments(true)
- .coalesce_characters(true);
-
- Self::new(EventReader::new_with_config(reader, config))
- }
-
- fn peek(&mut self) -> Result<&XmlEvent> {
- if self.peeked.is_none() {
- self.peeked = Some(self.inner_next()?);
- }
- debug_expect!(self.peeked.as_ref(), Some(peeked) => {
- debug!("Peeked {:?}", peeked);
- Ok(peeked)
- })
- }
-
- fn inner_next(&mut self) -> Result<XmlEvent> {
- loop {
- match self.reader.next()? {
- XmlEvent::StartDocument { .. }
- | XmlEvent::ProcessingInstruction { .. }
- | XmlEvent::Whitespace { .. }
- | XmlEvent::Comment(_) => { /* skip */ }
- other => return Ok(other),
- }
- }
- }
-
- fn next(&mut self) -> Result<XmlEvent> {
- let next = if let Some(peeked) = self.peeked.take() {
- peeked
- } else {
- self.inner_next()?
- };
- match next {
- XmlEvent::StartElement { .. } => {
- self.depth += 1;
- }
- XmlEvent::EndElement { .. } => {
- self.depth -= 1;
- }
- _ => {}
- }
- debug!("Fetched {:?}", next);
- Ok(next)
- }
-
- fn set_map_value(&mut self) {
- self.is_map_value = true;
- }
-
- pub fn unset_map_value(&mut self) -> bool {
- ::std::mem::replace(&mut self.is_map_value, false)
- }
-
- fn read_inner_value<V: de::Visitor<'de>, T, F: FnOnce(&mut Self) -> Result<T>>(
- &mut self,
- f: F,
- ) -> Result<T> {
- if self.unset_map_value() {
- debug_expect!(self.next(), Ok(XmlEvent::StartElement { name, .. }) => {
- let result = f(self)?;
- self.expect_end_element(name)?;
- Ok(result)
- })
- } else {
- f(self)
- }
- }
-
- fn expect_end_element(&mut self, start_name: OwnedName) -> Result<()> {
- expect!(self.next()?, XmlEvent::EndElement { name, .. } => {
- if name == start_name {
- Ok(())
- } else {
- Err(Error::Custom { field: format!(
- "End tag </{}> didn't match the start tag <{}>",
- name.local_name,
- start_name.local_name
- ) })
- }
- })
- }
-
- fn prepare_parse_type<V: de::Visitor<'de>>(&mut self) -> Result<String> {
- if let XmlEvent::StartElement { .. } = *self.peek()? {
- self.set_map_value()
- }
- self.read_inner_value::<V, String, _>(|this| {
- if let XmlEvent::EndElement { .. } = *this.peek()? {
- return Err(Error::UnexpectedToken {
- token: "EndElement".into(),
- found: "Characters".into(),
- });
- }
-
- expect!(this.next()?, XmlEvent::Characters(s) => {
- return Ok(s)
- })
- })
- }
-}
-
-macro_rules! deserialize_type {
- ($deserialize:ident => $visit:ident) => {
- fn $deserialize<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.prepare_parse_type::<V>()?.parse()?;
- visitor.$visit(value)
- }
- }
-}
-
-impl<'de, 'a, R: Read> de::Deserializer<'de> for &'a mut Deserializer<R> {
- type Error = Error;
-
- forward_to_deserialize_any! {
- identifier
- }
-
- fn deserialize_struct<V: de::Visitor<'de>>(
- self,
- _name: &'static str,
- fields: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value> {
- self.unset_map_value();
- expect!(self.next()?, XmlEvent::StartElement { name, attributes, .. } => {
- let map_value = visitor.visit_map(MapAccess::new(
- self,
- attributes,
- fields.contains(&"$value")
- ))?;
- self.expect_end_element(name)?;
- Ok(map_value)
- })
- }
-
- deserialize_type!(deserialize_i8 => visit_i8);
- deserialize_type!(deserialize_i16 => visit_i16);
- deserialize_type!(deserialize_i32 => visit_i32);
- deserialize_type!(deserialize_i64 => visit_i64);
- deserialize_type!(deserialize_u8 => visit_u8);
- deserialize_type!(deserialize_u16 => visit_u16);
- deserialize_type!(deserialize_u32 => visit_u32);
- deserialize_type!(deserialize_u64 => visit_u64);
- deserialize_type!(deserialize_f32 => visit_f32);
- deserialize_type!(deserialize_f64 => visit_f64);
-
- fn deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- if let XmlEvent::StartElement { .. } = *self.peek()? {
- self.set_map_value()
- }
- self.read_inner_value::<V, V::Value, _>(|this| {
- if let XmlEvent::EndElement { .. } = *this.peek()? {
- return visitor.visit_bool(false);
- }
- expect!(this.next()?, XmlEvent::Characters(s) => {
- match s.as_str() {
- "true" | "1" => visitor.visit_bool(true),
- "false" | "0" => visitor.visit_bool(false),
- _ => Err(de::Error::invalid_value(Unexpected::Str(&s), &"a boolean")),
- }
-
- })
- })
- }
-
- fn deserialize_char<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- self.deserialize_string(visitor)
- }
-
- fn deserialize_str<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- self.deserialize_string(visitor)
- }
-
- fn deserialize_bytes<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- self.deserialize_string(visitor)
- }
-
- fn deserialize_byte_buf<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- self.deserialize_string(visitor)
- }
-
- fn deserialize_unit<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- if let XmlEvent::StartElement { .. } = *self.peek()? {
- self.set_map_value()
- }
- self.read_inner_value::<V, V::Value, _>(
- |this| expect!(this.peek()?, &XmlEvent::EndElement { .. } => visitor.visit_unit()),
- )
- }
-
- fn deserialize_unit_struct<V: de::Visitor<'de>>(
- self,
- _name: &'static str,
- visitor: V,
- ) -> Result<V::Value> {
- self.deserialize_unit(visitor)
- }
-
- fn deserialize_newtype_struct<V: de::Visitor<'de>>(
- self,
- _name: &'static str,
- visitor: V,
- ) -> Result<V::Value> {
- visitor.visit_newtype_struct(self)
- }
-
- fn deserialize_tuple_struct<V: de::Visitor<'de>>(
- self,
- _name: &'static str,
- len: usize,
- visitor: V,
- ) -> Result<V::Value> {
- self.deserialize_tuple(len, visitor)
- }
-
- fn deserialize_tuple<V: de::Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
- visitor.visit_seq(SeqAccess::new(self, Some(len)))
- }
-
- fn deserialize_enum<V: de::Visitor<'de>>(
- self,
- _name: &'static str,
- _variants: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value> {
- self.read_inner_value::<V, V::Value, _>(|this| visitor.visit_enum(EnumAccess::new(this)))
- }
-
- fn deserialize_string<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- if let XmlEvent::StartElement { .. } = *self.peek()? {
- self.set_map_value()
- }
- self.read_inner_value::<V, V::Value, _>(|this| {
- if let XmlEvent::EndElement { .. } = *this.peek()? {
- return visitor.visit_str("");
- }
- expect!(this.next()?, XmlEvent::Characters(s) => {
- visitor.visit_string(s)
- })
- })
- }
-
- fn deserialize_seq<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- visitor.visit_seq(SeqAccess::new(self, None))
- }
-
- fn deserialize_map<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- self.unset_map_value();
- expect!(self.next()?, XmlEvent::StartElement { name, attributes, .. } => {
- let map_value = visitor.visit_map(MapAccess::new(self, attributes, false))?;
- self.expect_end_element(name)?;
- Ok(map_value)
- })
- }
-
- fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- match *self.peek()? {
- XmlEvent::EndElement { .. } => visitor.visit_none(),
- _ => visitor.visit_some(self),
- }
- }
-
- fn deserialize_ignored_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- self.unset_map_value();
- let depth = self.depth;
- loop {
- self.next()?;
- if self.depth == depth {
- break;
- }
- }
- visitor.visit_unit()
- }
-
- fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- match *self.peek()? {
- XmlEvent::StartElement { .. } => self.deserialize_map(visitor),
- XmlEvent::EndElement { .. } => self.deserialize_unit(visitor),
- _ => self.deserialize_string(visitor),
- }
- }
-}
diff --git a/src/de/seq.rs b/src/de/seq.rs
deleted file mode 100644
index 7e88d0c..0000000
--- a/src/de/seq.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use std::io::Read;
-
-use serde::de;
-use xml::reader::XmlEvent;
-
-use de::Deserializer;
-use error::{Error, Result};
-
-pub struct SeqAccess<'a, R: 'a + Read> {
- de: &'a mut Deserializer<R>,
- max_size: Option<usize>,
- expected_name: Option<String>,
-}
-
-impl<'a, R: 'a + Read> SeqAccess<'a, R> {
- pub fn new(de: &'a mut Deserializer<R>, max_size: Option<usize>) -> Self {
- let expected_name = if de.unset_map_value() {
- debug_expect!(de.peek(), Ok(&XmlEvent::StartElement { ref name, .. }) => {
- Some(name.local_name.clone())
- })
- } else {
- None
- };
- SeqAccess {
- de: de,
- max_size: max_size,
- expected_name: expected_name,
- }
- }
-}
-
-impl<'de, 'a, R: 'a + Read> de::SeqAccess<'de> for SeqAccess<'a, R> {
- type Error = Error;
-
- fn next_element_seed<T: de::DeserializeSeed<'de>>(
- &mut self,
- seed: T,
- ) -> Result<Option<T::Value>> {
- match self.max_size.as_mut() {
- Some(&mut 0) => {
- return Ok(None);
- },
- Some(max_size) => {
- *max_size -= 1;
- },
- None => {},
- }
- let more = match (self.de.peek()?, self.expected_name.as_ref()) {
- (&XmlEvent::StartElement { ref name, .. }, Some(expected_name)) => {
- &name.local_name == expected_name
- },
- (&XmlEvent::EndElement { .. }, None) |
- (_, Some(_)) |
- (&XmlEvent::EndDocument { .. }, _) => false,
- (_, None) => true,
- };
- if more {
- if self.expected_name.is_some() {
- self.de.set_map_value();
- }
- seed.deserialize(&mut *self.de).map(Some)
- } else {
- Ok(None)
- }
- }
-
- fn size_hint(&self) -> Option<usize> {
- self.max_size
- }
-}
diff --git a/src/de/var.rs b/src/de/var.rs
deleted file mode 100644
index dbb400f..0000000
--- a/src/de/var.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-use std::io::Read;
-
-use serde::de::{self, Deserializer as SerdeDeserializer, IntoDeserializer};
-use xml::name::OwnedName;
-use xml::reader::XmlEvent;
-
-use de::Deserializer;
-use error::{Error, Result};
-
-pub struct EnumAccess<'a, R: 'a + Read> {
- de: &'a mut Deserializer<R>,
-}
-
-impl<'a, R: 'a + Read> EnumAccess<'a, R> {
- pub fn new(de: &'a mut Deserializer<R>) -> Self {
- EnumAccess { de: de }
- }
-}
-
-impl<'de, 'a, R: 'a + Read> de::EnumAccess<'de> for EnumAccess<'a, R> {
- type Error = Error;
- type Variant = VariantAccess<'a, R>;
-
- fn variant_seed<V: de::DeserializeSeed<'de>>(
- self,
- seed: V,
- ) -> Result<(V::Value, VariantAccess<'a, R>)> {
- let name = expect!(
- self.de.peek()?,
-
- &XmlEvent::Characters(ref name) |
- &XmlEvent::StartElement { name: OwnedName { local_name: ref name, .. }, .. } => {
- seed.deserialize(name.as_str().into_deserializer())
- }
- )?;
- self.de.set_map_value();
- Ok((name, VariantAccess::new(self.de)))
- }
-}
-
-pub struct VariantAccess<'a, R: 'a + Read> {
- de: &'a mut Deserializer<R>,
-}
-
-impl<'a, R: 'a + Read> VariantAccess<'a, R> {
- pub fn new(de: &'a mut Deserializer<R>) -> Self {
- VariantAccess { de: de }
- }
-}
-
-impl<'de, 'a, R: 'a + Read> de::VariantAccess<'de> for VariantAccess<'a, R> {
- type Error = Error;
-
- fn unit_variant(self) -> Result<()> {
- self.de.unset_map_value();
- match self.de.next()? {
- XmlEvent::StartElement {
- name, attributes, ..
- } => if attributes.is_empty() {
- self.de.expect_end_element(name)
- } else {
- Err(de::Error::invalid_length(attributes.len(), &"0"))
- },
- XmlEvent::Characters(_) => Ok(()),
- _ => unreachable!(),
- }
- }
-
- fn newtype_variant_seed<T: de::DeserializeSeed<'de>>(self, seed: T) -> Result<T::Value> {
- seed.deserialize(&mut *self.de)
- }
-
- fn tuple_variant<V: de::Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
- self.de.deserialize_tuple(len, visitor)
- }
-
- fn struct_variant<V: de::Visitor<'de>>(
- self,
- _fields: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value> {
- self.de.deserialize_map(visitor)
- }
-}
diff --git a/src/error.rs b/src/error.rs
deleted file mode 100644
index 8d6e4ad..0000000
--- a/src/error.rs
+++ /dev/null
@@ -1,104 +0,0 @@
-use serde::de::Error as DeError;
-use serde::ser::Error as SerError;
-use std::fmt::Display;
-use thiserror::Error;
-
-#[derive(Debug, Error)]
-pub enum Error {
- #[error("Expected token {token}, found {found}")]
- UnexpectedToken { token: String, found: String },
- #[error("custom: {field}")]
- Custom { field: String },
- #[error("unsupported operation: '{operation}'")]
- UnsupportedOperation { operation: String },
-
- #[error("IO error: {source}")]
- Io {
- #[from]
- source: ::std::io::Error,
- },
-
- #[error("FromUtf8Error: {source}")]
- FromUtf8Error {
- #[from]
- source: ::std::string::FromUtf8Error,
- },
-
- #[error("ParseIntError: {source}")]
- ParseIntError {
- #[from]
- source: ::std::num::ParseIntError,
- },
-
- #[error("ParseFloatError: {source}")]
- ParseFloatError {
- #[from]
- source: ::std::num::ParseFloatError,
- },
-
- #[error("ParseBoolError: {source}")]
- ParseBoolError {
- #[from]
- source: ::std::str::ParseBoolError,
- },
-
- #[error("Syntax: {source}")]
- Syntax {
- #[from]
- source: ::xml::reader::Error,
- },
-}
-
-pub type Result<T> = std::result::Result<T, Error>;
-
-macro_rules! expect {
- ($actual: expr, $($expected: pat)|+ => $if_ok: expr) => {
- match $actual {
- $($expected)|+ => $if_ok,
- actual => Err($crate::Error::UnexpectedToken {
- token: stringify!($($expected)|+).to_string(),
- found: format!("{:?}",actual)
- }) as Result<_>
- }
- }
-}
-
-#[cfg(debug_assertions)]
-macro_rules! debug_expect {
- ($actual: expr, $($expected: pat)|+ => $if_ok: expr) => {
- match $actual {
- $($expected)|+ => $if_ok,
- actual => panic!(
- "Internal error: Expected token {}, found {:?}",
- stringify!($($expected)|+),
- actual
- )
- }
- }
-}
-
-#[cfg(not(debug_assertions))]
-macro_rules! debug_expect {
- ($actual: expr, $($expected: pat)|+ => $if_ok: expr) => {
- match $actual {
- $($expected)|+ => $if_ok,
- _ => unreachable!()
- }
- }
-}
-
-impl DeError for Error {
- fn custom<T: Display>(msg: T) -> Self {
- Error::Custom {
- field: msg.to_string(),
- }
- }
-}
-
-impl SerError for Error {
- fn custom<T: Display>(msg: T) -> Self {
- Error::Custom {
- field: msg.to_string(),
- }
- }
-}
diff --git a/src/lib.rs b/src/lib.rs
deleted file mode 100644
index 1f93ed8..0000000
--- a/src/lib.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-//!
-//!
-//! # Examples
-//!
-//! ```rust
-//! extern crate serde;
-//! extern crate serde_xml_rs;
-//!
-//! #[macro_use]
-//! extern crate serde_derive;
-//!
-//! use serde_xml_rs::{from_str, to_string};
-//!
-//! #[derive(Debug, Serialize, Deserialize, PartialEq)]
-//! struct Item {
-//! name: String,
-//! source: String,
-//! }
-//!
-//! fn main() {
-//! let src = r#"<Item><name>Banana</name><source>Store</source></Item>"#;
-//! let should_be = Item {
-//! name: "Banana".to_string(),
-//! source: "Store".to_string(),
-//! };
-//!
-//! let item: Item = from_str(src).unwrap();
-//! assert_eq!(item, should_be);
-//!
-//! let reserialized_item = to_string(&item).unwrap();
-//! assert_eq!(src, reserialized_item);
-//! }
-//! ```
-
-#[macro_use]
-extern crate log;
-#[macro_use]
-extern crate serde;
-extern crate xml;
-
-extern crate thiserror;
-
-#[cfg(test)]
-#[macro_use]
-extern crate serde_derive;
-
-#[macro_use]
-mod error;
-pub mod de;
-pub mod ser;
-
-pub use de::{from_reader, from_str, Deserializer};
-pub use error::Error;
-pub use ser::{to_string, to_writer, Serializer};
-pub use xml::reader::{EventReader, ParserConfig};
diff --git a/src/ser/mod.rs b/src/ser/mod.rs
deleted file mode 100644
index bf97b1f..0000000
--- a/src/ser/mod.rs
+++ /dev/null
@@ -1,419 +0,0 @@
-use std::fmt::Display;
-use std::io::Write;
-
-use serde::ser::{self, Impossible, Serialize};
-
-use self::var::{Map, Struct};
-use error::{Error, Result};
-
-mod var;
-
-/// A convenience method for serializing some object to a buffer.
-///
-/// # Examples
-///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// # extern crate serde;
-/// # extern crate serde_xml_rs;
-/// # use serde_xml_rs::to_writer;
-/// #[derive(Serialize)]
-/// struct Person {
-/// name: String,
-/// age: u32,
-/// }
-///
-/// # fn main() {
-/// let mut buffer = Vec::new();
-/// let joe = Person {name: "Joe".to_string(), age: 42};
-///
-/// to_writer(&mut buffer, &joe).unwrap();
-///
-/// let serialized = String::from_utf8(buffer).unwrap();
-/// println!("{}", serialized);
-/// # }
-/// ```
-pub fn to_writer<W: Write, S: Serialize>(writer: W, value: &S) -> Result<()> {
- let mut ser = Serializer::new(writer);
- value.serialize(&mut ser)
-}
-
-/// A convenience method for serializing some object to a string.
-///
-/// # Examples
-///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// # extern crate serde;
-/// # extern crate serde_xml_rs;
-/// # use serde_xml_rs::to_string;
-/// #[derive(Serialize)]
-/// struct Person {
-/// name: String,
-/// age: u32,
-/// }
-///
-/// # fn main() {
-///
-/// let joe = Person {name: "Joe".to_string(), age: 42};
-/// let serialized = to_string(&joe).unwrap();
-/// println!("{}", serialized);
-/// # }
-/// ```
-pub fn to_string<S: Serialize>(value: &S) -> Result<String> {
- // Create a buffer and serialize our nodes into it
- let mut writer = Vec::with_capacity(128);
- to_writer(&mut writer, value)?;
-
- // We then check that the serialized string is the same as what we expect
- let string = String::from_utf8(writer)?;
- Ok(string)
-}
-
-/// An XML `Serializer`.
-pub struct Serializer<W>
-where
- W: Write,
-{
- writer: W,
-}
-
-impl<W> Serializer<W>
-where
- W: Write,
-{
- pub fn new(writer: W) -> Self {
- Self { writer: writer }
- }
-
- fn write_primitive<P: Display>(&mut self, primitive: P) -> Result<()> {
- write!(self.writer, "{}", primitive)?;
- Ok(())
- }
-
- fn write_wrapped<S: Serialize>(&mut self, tag: &str, value: S) -> Result<()> {
- write!(self.writer, "<{}>", tag)?;
- value.serialize(&mut *self)?;
- write!(self.writer, "</{}>", tag)?;
- Ok(())
- }
-}
-
-#[allow(unused_variables)]
-impl<'w, W> ser::Serializer for &'w mut Serializer<W>
-where
- W: Write,
-{
- type Ok = ();
- type Error = Error;
-
- type SerializeSeq = Impossible<Self::Ok, Self::Error>;
- type SerializeTuple = Impossible<Self::Ok, Self::Error>;
- type SerializeTupleStruct = Impossible<Self::Ok, Self::Error>;
- type SerializeTupleVariant = Impossible<Self::Ok, Self::Error>;
- type SerializeMap = Map<'w, W>;
- type SerializeStruct = Struct<'w, W>;
- type SerializeStructVariant = Impossible<Self::Ok, Self::Error>;
-
- fn serialize_bool(self, v: bool) -> Result<Self::Ok> {
- if v {
- write!(self.writer, "true")?;
- } else {
- write!(self.writer, "false")?;
- }
-
- Ok(())
- }
-
- fn serialize_i8(self, v: i8) -> Result<Self::Ok> {
- self.write_primitive(v)
- }
-
- fn serialize_i16(self, v: i16) -> Result<Self::Ok> {
- self.write_primitive(v)
- }
-
- fn serialize_i32(self, v: i32) -> Result<Self::Ok> {
- self.write_primitive(v)
- }
-
- fn serialize_i64(self, v: i64) -> Result<Self::Ok> {
- self.write_primitive(v)
- }
-
- fn serialize_u8(self, v: u8) -> Result<Self::Ok> {
- self.write_primitive(v)
- }
-
- fn serialize_u16(self, v: u16) -> Result<Self::Ok> {
- self.write_primitive(v)
- }
-
- fn serialize_u32(self, v: u32) -> Result<Self::Ok> {
- self.write_primitive(v)
- }
-
- fn serialize_u64(self, v: u64) -> Result<Self::Ok> {
- self.write_primitive(v)
- }
-
- fn serialize_f32(self, v: f32) -> Result<Self::Ok> {
- self.write_primitive(v)
- }
-
- fn serialize_f64(self, v: f64) -> Result<Self::Ok> {
- self.write_primitive(v)
- }
-
- fn serialize_char(self, v: char) -> Result<Self::Ok> {
- self.write_primitive(v)
- }
-
- fn serialize_str(self, value: &str) -> Result<Self::Ok> {
- self.write_primitive(value)
- }
-
- fn serialize_bytes(self, value: &[u8]) -> Result<Self::Ok> {
- // TODO: I imagine you'd want to use base64 here.
- // Not sure how to roundtrip effectively though...
- Err(Error::UnsupportedOperation {
- operation: "serialize_bytes".to_string(),
- })
- }
-
- fn serialize_none(self) -> Result<Self::Ok> {
- Ok(())
- }
-
- fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok> {
- value.serialize(self)
- }
-
- fn serialize_unit(self) -> Result<Self::Ok> {
- self.serialize_none()
- }
-
- fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok> {
- self.write_wrapped(name, ())
- }
-
- fn serialize_unit_variant(
- self,
- name: &'static str,
- variant_index: u32,
- variant: &'static str,
- ) -> Result<Self::Ok> {
- Err(Error::UnsupportedOperation {
- operation: "serialize_unit_variant".to_string(),
- })
- }
-
- fn serialize_newtype_struct<T: ?Sized + Serialize>(
- self,
- name: &'static str,
- value: &T,
- ) -> Result<Self::Ok> {
- Err(Error::UnsupportedOperation {
- operation: "serialize_newtype_struct".to_string(),
- })
- }
-
- fn serialize_newtype_variant<T: ?Sized + Serialize>(
- self,
- name: &'static str,
- variant_index: u32,
- variant: &'static str,
- value: &T,
- ) -> Result<Self::Ok> {
- self.write_wrapped(variant, value)
- }
-
- fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
- // TODO: Figure out how to constrain the things written to only be composites
- Err(Error::UnsupportedOperation {
- operation: "serialize_seq".to_string(),
- })
- }
-
- fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
- Err(Error::UnsupportedOperation {
- operation: "serialize_tuple".to_string(),
- })
- }
-
- fn serialize_tuple_struct(
- self,
- name: &'static str,
- len: usize,
- ) -> Result<Self::SerializeTupleStruct> {
- Err(Error::UnsupportedOperation {
- operation: "serialize_tuple_struct".to_string(),
- })
- }
-
- fn serialize_tuple_variant(
- self,
- name: &'static str,
- variant_index: u32,
- variant: &'static str,
- len: usize,
- ) -> Result<Self::SerializeTupleVariant> {
- Err(Error::UnsupportedOperation {
- operation: "serialize_tuple_variant".to_string(),
- })
- }
-
- fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
- Ok(Map::new(self))
- }
-
- fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
- write!(self.writer, "<{}>", name)?;
- Ok(Struct::new(self, name))
- }
-
- fn serialize_struct_variant(
- self,
- name: &'static str,
- variant_index: u32,
- variant: &'static str,
- len: usize,
- ) -> Result<Self::SerializeStructVariant> {
- Err(Error::UnsupportedOperation {
- operation: "Result".to_string(),
- })
- }
-}
-
-#[cfg(test)]
-mod tests {
- use super::*;
- use serde::ser::{SerializeMap, SerializeStruct};
- use serde::Serializer as SerSerializer;
-
- #[test]
- fn test_serialize_bool() {
- let inputs = vec![(true, "true"), (false, "false")];
-
- for (src, should_be) in inputs {
- let mut buffer = Vec::new();
-
- {
- let mut ser = Serializer::new(&mut buffer);
- ser.serialize_bool(src).unwrap();
- }
-
- let got = String::from_utf8(buffer).unwrap();
- assert_eq!(got, should_be);
- }
- }
-
- #[test]
- fn test_start_serialize_struct() {
- let mut buffer = Vec::new();
-
- {
- let mut ser = Serializer::new(&mut buffer);
- let _ = ser.serialize_struct("foo", 0).unwrap();
- }
-
- let got = String::from_utf8(buffer).unwrap();
- assert_eq!(got, "<foo>");
- }
-
- #[test]
- fn test_serialize_struct_field() {
- let mut buffer = Vec::new();
-
- {
- let mut ser = Serializer::new(&mut buffer);
- let mut struct_ser = Struct::new(&mut ser, "baz");
- struct_ser.serialize_field("foo", "bar").unwrap();
- }
-
- let got = String::from_utf8(buffer).unwrap();
- assert_eq!(got, "<foo>bar</foo>");
- }
-
- #[test]
- fn test_serialize_struct() {
- #[derive(Serialize)]
- struct Person {
- name: String,
- age: u32,
- }
-
- let bob = Person {
- name: "Bob".to_string(),
- age: 42,
- };
- let should_be = "<Person><name>Bob</name><age>42</age></Person>";
- let mut buffer = Vec::new();
-
- {
- let mut ser = Serializer::new(&mut buffer);
- bob.serialize(&mut ser).unwrap();
- }
-
- let got = String::from_utf8(buffer).unwrap();
- assert_eq!(got, should_be);
- }
-
- #[test]
- fn test_serialize_map_entries() {
- let should_be = "<name>Bob</name><age>5</age>";
- let mut buffer = Vec::new();
-
- {
- let mut ser = Serializer::new(&mut buffer);
- let mut map = Map::new(&mut ser);
- map.serialize_entry("name", "Bob").unwrap();
- map.serialize_entry("age", "5").unwrap();
- }
-
- let got = String::from_utf8(buffer).unwrap();
- assert_eq!(got, should_be);
- }
-
- #[test]
- fn test_serialize_enum() {
- #[derive(Serialize)]
- #[allow(dead_code)]
- enum Node {
- Boolean(bool),
- Number(f64),
- String(String),
- }
-
- let mut buffer = Vec::new();
- let should_be = "<Boolean>true</Boolean>";
-
- {
- let mut ser = Serializer::new(&mut buffer);
- let node = Node::Boolean(true);
- node.serialize(&mut ser).unwrap();
- }
-
- let got = String::from_utf8(buffer).unwrap();
- assert_eq!(got, should_be);
- }
-
- #[test]
- #[ignore]
- fn serialize_a_list() {
- let inputs = vec![1, 2, 3, 4];
-
- let mut buffer = Vec::new();
-
- {
- let mut ser = Serializer::new(&mut buffer);
- inputs.serialize(&mut ser).unwrap();
- }
-
- let got = String::from_utf8(buffer).unwrap();
- println!("{}", got);
- panic!();
- }
-}
diff --git a/src/ser/var.rs b/src/ser/var.rs
deleted file mode 100644
index bb61472..0000000
--- a/src/ser/var.rs
+++ /dev/null
@@ -1,103 +0,0 @@
-use std::io::Write;
-
-use serde::ser::{self, Serialize};
-
-use ser::Serializer;
-use error::{Error, Result};
-
-/// An implementation of `SerializeMap` for serializing to XML.
-pub struct Map<'w, W>
-where
- W: 'w + Write,
-{
- parent: &'w mut Serializer<W>,
-}
-
-impl<'w, W> Map<'w, W>
-where
- W: 'w + Write,
-{
- pub fn new(parent: &'w mut Serializer<W>) -> Map<'w, W> {
- Map { parent }
- }
-}
-
-impl<'w, W> ser::SerializeMap for Map<'w, W>
-where
- W: 'w + Write,
-{
- type Ok = ();
- type Error = Error;
-
- fn serialize_key<T: ?Sized + Serialize>(&mut self, _: &T) -> Result<()> {
- panic!("impossible to serialize the key on its own, please use serialize_entry()")
- }
-
- fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<()> {
- value.serialize(&mut *self.parent)
- }
-
- fn end(self) -> Result<Self::Ok> {
- Ok(())
- }
-
- fn serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>(
- &mut self,
- key: &K,
- value: &V,
- ) -> Result<()> {
- // TODO: Is it possible to ensure our key is never a composite type?
- // Anything which isn't a "primitive" would lead to malformed XML here...
- write!(self.parent.writer, "<")?;
- key.serialize(&mut *self.parent)?;
- write!(self.parent.writer, ">")?;
-
- value.serialize(&mut *self.parent)?;
-
- write!(self.parent.writer, "</")?;
- key.serialize(&mut *self.parent)?;
- write!(self.parent.writer, ">")?;
- Ok(())
- }
-}
-
-/// An implementation of `SerializeStruct` for serializing to XML.
-pub struct Struct<'w, W>
-where
- W: 'w + Write,
-{
- parent: &'w mut Serializer<W>,
- name: &'w str,
-}
-
-impl<'w, W> Struct<'w, W>
-where
- W: 'w + Write,
-{
- pub fn new(parent: &'w mut Serializer<W>, name: &'w str) -> Struct<'w, W> {
- Struct { parent, name }
- }
-}
-
-impl<'w, W> ser::SerializeStruct for Struct<'w, W>
-where
- W: 'w + Write,
-{
- type Ok = ();
- type Error = Error;
-
- fn serialize_field<T: ?Sized + Serialize>(
- &mut self,
- key: &'static str,
- value: &T,
- ) -> Result<()> {
- write!(self.parent.writer, "<{}>", key)?;
- value.serialize(&mut *self.parent)?;
- write!(self.parent.writer, "</{}>", key)?;
- Ok(())
- }
-
- fn end(self) -> Result<Self::Ok> {
- write!(self.parent.writer, "</{}>", self.name).map_err(|e| e.into())
- }
-}
diff --git a/tests/failures.rs b/tests/failures.rs
deleted file mode 100644
index ca51f6b..0000000
--- a/tests/failures.rs
+++ /dev/null
@@ -1,52 +0,0 @@
-#[macro_use]
-extern crate serde_derive;
-extern crate serde_xml_rs;
-
-#[macro_use]
-extern crate log;
-extern crate simple_logger;
-
-use serde_xml_rs::from_str;
-
-#[derive(Debug, Deserialize, PartialEq)]
-struct Item {
- name: String,
- source: String,
-}
-
-#[test]
-fn simple_struct_from_attributes_should_fail() {
- let _ = simple_logger::init();
-
- let s = r##"
- <item name="hello" source="world.rs />
- "##;
-
- let item: Result<Item, _> = from_str(s);
- match item {
- Ok(_) => assert!(false),
- Err(e) => {
- info!("simple_struct_from_attributes_should_fail(): {}", e);
- assert!(true)
- }
- }
-}
-
-#[test]
-fn multiple_roots_attributes_should_fail() {
- let _ = simple_logger::init();
-
- let s = r##"
- <item name="hello" source="world.rs" />
- <item name="hello source="world.rs" />
- "##;
-
- let item: Result<Vec<Item>, _> = from_str(s);
- match item {
- Ok(_) => assert!(false),
- Err(e) => {
- info!("multiple_roots_attributes_should_fail(): {}", e);
- assert!(true)
- }
- }
-}
diff --git a/tests/migrated.rs b/tests/migrated.rs
deleted file mode 100644
index 87d3e6a..0000000
--- a/tests/migrated.rs
+++ /dev/null
@@ -1,1086 +0,0 @@
-#[macro_use]
-extern crate serde_derive;
-
-extern crate log;
-extern crate simple_logger;
-
-extern crate serde;
-extern crate serde_xml_rs;
-
-use std::fmt::Debug;
-
-use serde::{de, ser};
-use serde_xml_rs::{from_str, Error};
-
-#[derive(PartialEq, Debug, Serialize, Deserialize)]
-enum Animal {
- Dog,
- Frog(String),
- Ant(Simple),
- Cat { age: usize, name: String },
-}
-
-#[derive(PartialEq, Debug, Serialize, Deserialize)]
-struct Simple {
- a: (),
- b: usize,
- c: String,
- d: Option<String>,
-}
-
-#[derive(PartialEq, Debug, Serialize, Deserialize)]
-struct Inner {
- a: (),
- b: (usize, String, i8),
- c: Vec<String>,
-}
-
-#[derive(PartialEq, Debug, Serialize, Deserialize)]
-struct Outer {
- inner: Option<Inner>,
-}
-
-fn test_parse_ok<'de, 'a, T>(errors: &[(&'a str, T)])
-where
- T: PartialEq + Debug + ser::Serialize + de::Deserialize<'de>,
-{
- for &(s, ref value) in errors {
- let v: T = from_str(s).unwrap();
- assert_eq!(v, *value);
-
- // // Make sure we can deserialize into an `Element`.
- // let xml_value: Element = from_str(s).unwrap();
-
- // // Make sure we can deserialize from an `Element`.
- // let v: T = from_value(xml_value.clone()).unwrap();
- // assert_eq!(v, *value);
- }
-}
-
-fn test_parse_err<'de, 'a, T>(errors: &[&'a str])
-where
- T: PartialEq + Debug + ser::Serialize + de::Deserialize<'de>,
-{
- for &s in errors {
- assert!(match from_str::<T>(s) {
- Err(Error::Syntax { source: _ }) => true,
- _ => false,
- });
- }
-}
-
-fn test_parse_invalid<'de, 'a, T>(errors: &[&'a str])
-where
- T: PartialEq + Debug + ser::Serialize + de::Deserialize<'de>,
-{
- for &s in errors {
- assert!(match from_str::<T>(s) {
- Err(_) => true,
- _ => false,
- });
- }
-}
-
-#[test]
-fn test_namespaces() {
- let _ = simple_logger::init();
- #[derive(PartialEq, Serialize, Deserialize, Debug)]
- struct Envelope {
- subject: String,
- }
- let s = r#"
- <?xml version="1.0" encoding="UTF-8"?>
- <gesmes:Envelope xmlns:gesmes="http://www.gesmes.org/xml/2002-08-01" xmlns="http://www.ecb.int/vocabulary/2002-08-01/eurofxref">
- <gesmes:subject>Reference rates</gesmes:subject>
- </gesmes:Envelope>"#;
- test_parse_ok(&[(
- s,
- Envelope {
- subject: "Reference rates".to_string(),
- },
- )]);
-}
-
-#[test]
-#[ignore] // FIXME
-fn test_doctype() {
- let _ = simple_logger::init();
- #[derive(PartialEq, Serialize, Deserialize, Debug)]
- struct Envelope {
- subject: String,
- }
-
- test_parse_ok(&[
- (
- r#"
- <?xml version="1.0" encoding="UTF-8"?>
- <!DOCTYPE Envelope>
- <Envelope>
- <subject>Reference rates</subject>
- </Envelope>"#,
- Envelope {
- subject: "Reference rates".to_string(),
- },
- ),
- (
- r#"
- <?xml version="1.0" encoding="UTF-8"?>
- <!DOCTYPE Envelope[]>
- <Envelope>
- <subject>Reference rates</subject>
- </Envelope>"#,
- Envelope {
- subject: "Reference rates".to_string(),
- },
- ),
- (
- r#"
- <?xml version="1.0" encoding="UTF-8"?>
- <!DOCTYPE Envelope [
- <!ELEMENT subject (#PCDATA)>
- ] >
- <Envelope>
- <subject>Reference rates</subject>
- </Envelope>"#,
- Envelope {
- subject: "Reference rates".to_string(),
- },
- ),
- ]);
-}
-
-#[test]
-fn test_doctype_fail() {
- let _ = simple_logger::init();
- #[derive(PartialEq, Serialize, Deserialize, Debug)]
- struct Envelope {
- subject: String,
- }
-
- test_parse_err::<Envelope>(&[
- r#"
- <?xml version="1.0" encoding="UTF-8"?>
- <!DOCTYPE Envelope [
- <!ELEMENT subject (#PCDATA)>
- >
- <Envelope>
- <subject>Reference rates</subject>
- </Envelope>"#,
- r#"
- <?xml version="1.0" encoding="UTF-8"?>
- <Envelope>
- <subject>Reference rates</subject>
-
- <!DOCTYPE Envelope [
- <!ELEMENT subject (#PCDATA)>
- ]>
-
- </Envelope>"#,
- ])
-}
-
-#[test]
-#[ignore] // FIXME
-fn test_forwarded_namespace() {
- #[derive(PartialEq, Serialize, Deserialize, Debug)]
- struct Graphml {
- #[serde(rename = "xsi:schemaLocation")]
- schema_location: String,
- }
- let s = r#"
- <?xml version="1.0" encoding="UTF-8"?>
- <graphml xmlns="http://graphml.graphdrawing.org/xmlns"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
- http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
-
-
- </graphml>"#;
- test_parse_ok(&[(
- s,
- Graphml {
- schema_location: "http://graphml.graphdrawing.org/xmlns
- http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd"
- .to_string(),
- },
- )]);
-}
-
-#[test]
-fn test_parse_string() {
- let _ = simple_logger::init();
-
- test_parse_ok(&[
- (
- "<bla>This is a String</bla>",
- "This is a String".to_string(),
- ),
- ("<bla></bla>", "".to_string()),
- ("<bla> </bla>", "".to_string()),
- ("<bla><boom/></bla>", "<boom/>".to_string()),
- ("<bla>♫</bla>", "♫".to_string()),
- ("<bla>♫</bla>", "♫".to_string()),
- (
- "<bla>♫<![CDATA[<cookies/>]]>♫</bla>",
- "♫<cookies/>♫".to_string(),
- ),
- ]);
-}
-
-#[test]
-#[ignore] // FIXME
-fn test_parse_string_not_trim() {
- let _ = simple_logger::init();
-
- test_parse_ok(&[("<bla> </bla>", " ".to_string())]);
-}
-
-#[test]
-#[ignore] // FIXME
-fn test_parse_enum() {
- use self::Animal::*;
- let _ = simple_logger::init();
-
- test_parse_ok(&[
- ("<Animal xsi:type=\"Dog\"/>", Dog),
- (
- "<Animal xsi:type=\"Frog\">Quak</Animal>",
- Frog("Quak".to_string()),
- ),
- (
- "<Animal xsi:type=\"Ant\"><a/><c>bla</c><b>15</b><d>Foo</d></Animal>",
- Ant(Simple {
- a: (),
- b: 15,
- c: "bla".to_string(),
- d: Some("Foo".to_string()),
- }),
- ),
- (
- "<Animal xsi:type=\"Ant\"><a/><c>bla</c><b>15</b></Animal>",
- Ant(Simple {
- a: (),
- b: 15,
- c: "bla".to_string(),
- d: None,
- }),
- ),
- (
- "<Animal xsi:type=\"Cat\"><age>42</age><name>Shere Khan</name></Animal>",
- Cat {
- age: 42,
- name: "Shere Khan".to_string(),
- },
- ),
- ]);
-
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- struct Helper {
- x: Animal,
- }
-
- test_parse_ok(&[
- ("<Helper><x xsi:type=\"Dog\"/></Helper>", Helper { x: Dog }),
- (
- "<Helper><x xsi:type=\"Frog\">Quak</Animal></Helper>",
- Helper {
- x: Frog("Quak".to_string()),
- },
- ),
- (
- "<Helper><x xsi:type=\"Cat\">
- <age>42</age>
- <name>Shere Khan</name>
- </x></Helper>",
- Helper {
- x: Cat {
- age: 42,
- name: "Shere Khan".to_string(),
- },
- },
- ),
- ]);
-}
-
-#[test]
-fn test_parse_i64() {
- let _ = simple_logger::init();
- test_parse_ok(&[
- ("<bla>0</bla>", 0),
- ("<bla>-2</bla>", -2),
- ("<bla>-1234</bla>", -1234),
- ("<bla> -1234 </bla>", -1234),
- ]);
-}
-
-#[test]
-fn test_parse_u64() {
- let _ = simple_logger::init();
- test_parse_ok(&[
- ("<bla>0</bla>", 0),
- ("<bla>1234</bla>", 1234),
- ("<bla> 1234 </bla>", 1234),
- ]);
-}
-
-#[test]
-fn test_parse_bool_element() {
- let _ = simple_logger::init();
- test_parse_ok(&[
- ("<bla>true</bla>", true),
- ("<bla>false</bla>", false),
- ("<bla> true </bla>", true),
- ("<bla> false </bla>", false),
- ("<bla>1</bla>", true),
- ("<bla>0</bla>", false),
- ]);
-
- test_parse_invalid::<bool>(&["<bla>verum</bla>"]);
-}
-
-#[test]
-fn test_parse_bool_attribute() {
- #[derive(PartialEq, Debug, Deserialize, Serialize)]
- struct Dummy {
- foo: bool,
- }
-
- let _ = simple_logger::init();
- test_parse_ok(&[
- ("<bla foo=\"true\"/>", Dummy { foo: true }),
- ("<bla foo=\"false\"/>", Dummy { foo: false }),
- ("<bla foo=\"1\"/>", Dummy { foo: true }),
- ("<bla foo=\"0\"/>", Dummy { foo: false }),
- ]);
-
- test_parse_invalid::<Dummy>(&[
- "<bla foo=\"bar\"/>",
- "<bla foo=\" true \"/>",
- "<bla foo=\"10\"/>",
- "<bla foo=\"\"/>",
- "<bla/>",
- ]);
-}
-
-#[test]
-fn test_parse_unit() {
- let _ = simple_logger::init();
- test_parse_ok(&[("<bla/>", ())]);
-}
-
-#[test]
-fn test_parse_f64() {
- let _ = simple_logger::init();
- test_parse_ok(&[
- ("<bla>3.0</bla>", 3.0f64),
- ("<bla>3.1</bla>", 3.1),
- ("<bla>-1.2</bla>", -1.2),
- ("<bla>0.4</bla>", 0.4),
- ("<bla>0.4e5</bla>", 0.4e5),
- ("<bla>0.4e15</bla>", 0.4e15),
- ("<bla>0.4e-01</bla>", 0.4e-01), // precision troubles
- ("<bla> 0.4e-01 </bla>", 0.4e-01),
- ]);
-}
-
-#[test]
-fn test_parse_struct() {
- let _ = simple_logger::init();
-
- test_parse_ok(&[
- (
- "<Simple>
- <c>abc</c>
- <a/>
- <b>2</b>
- </Simple>",
- Simple {
- a: (),
- b: 2,
- c: "abc".to_string(),
- d: None,
- },
- ),
- (
- "<Simple><!-- this is a comment -->
- <c>abc</c>
- <a/>
- <b>2</b>
- </Simple>",
- Simple {
- a: (),
- b: 2,
- c: "abc".to_string(),
- d: None,
- },
- ),
- (
- "<Simple d=\"Foo\"><!-- this is a comment -->
- <c>abc</c>
- <a/>
- <b>2</b>
- </Simple>",
- Simple {
- a: (),
- b: 2,
- c: "abc".to_string(),
- d: Some("Foo".to_string()),
- },
- ),
- ]);
-}
-
-#[test]
-fn test_option() {
- let _ = simple_logger::init();
- test_parse_ok(&[
- ("<a/>", Some("".to_string())),
- ("<a></a>", Some("".to_string())),
- ("<a> </a>", Some("".to_string())),
- ("<a>42</a>", Some("42".to_string())),
- ]);
-}
-
-#[test]
-#[ignore] // FIXME
-fn test_option_not_trim() {
- let _ = simple_logger::init();
- test_parse_ok(&[("<a> </a>", Some(" ".to_string()))]);
-}
-
-#[test]
-fn test_amoskvin() {
- let _ = simple_logger::init();
- #[derive(Debug, Deserialize, PartialEq, Serialize)]
- struct Root {
- foo: Vec<Foo>,
- }
-
- #[derive(Debug, Deserialize, PartialEq, Serialize)]
- struct Foo {
- a: String,
- b: Option<String>,
- }
- test_parse_ok(&[(
- "
-<root>
-<foo>
- <a>Hello</a>
- <b>World</b>
-</foo>
-<foo>
- <a>Hi</a>
-</foo>
-</root>",
- Root {
- foo: vec![
- Foo {
- a: "Hello".to_string(),
- b: Some("World".to_string()),
- },
- Foo {
- a: "Hi".to_string(),
- b: None,
- },
- ],
- },
- )]);
-}
-
-#[test]
-#[ignore] // FIXME
-fn test_nicolai86() {
- let _ = simple_logger::init();
- #[derive(Serialize, Deserialize, PartialEq, Debug)]
- struct TheSender {
- name: String,
- }
-
- #[derive(Serialize, Deserialize, PartialEq, Debug)]
- struct CurrencyCube {
- currency: String,
- rate: String,
- }
-
- #[derive(Serialize, Deserialize, PartialEq, Debug)]
- #[allow(non_snake_case)]
- struct InnerCube {
- Cube: Vec<CurrencyCube>,
- }
-
- #[derive(Serialize, Deserialize, PartialEq, Debug)]
- #[allow(non_snake_case)]
- struct OuterCube {
- Cube: Vec<InnerCube>,
- }
-
- #[derive(Serialize, Deserialize, PartialEq, Debug)]
- #[allow(non_snake_case)]
- struct Envelope {
- subject: String,
- Sender: TheSender,
- Cube: OuterCube,
- }
- test_parse_ok(&[
- (
- r#"
- <?xml version="1.0" encoding="UTF-8"?>
- <gesmes:Envelope xmlns:gesmes="http://www.gesmes.org/xml/2002-08-01" xmlns="http://www.ecb.int/vocabulary/2002-08-01/eurofxref">
- <gesmes:subject>Reference rates</gesmes:subject>
- <gesmes:Sender>
- <gesmes:name>European Central Bank</gesmes:name>
- </gesmes:Sender>
- <Cube> </Cube>
- </gesmes:Envelope>"#,
- Envelope {
- subject: "Reference rates".to_string(),
- Sender: TheSender {
- name: "European Central Bank".to_string(),
- },
- Cube: OuterCube { Cube: vec![] },
- },
- ),
- (
- r#"
- <?xml version="1.0" encoding="UTF-8"?>
- <gesmes:Envelope xmlns:gesmes="http://www.gesmes.org/xml/2002-08-01" xmlns="http://www.ecb.int/vocabulary/2002-08-01/eurofxref">
- <gesmes:subject>Reference rates</gesmes:subject>
- <gesmes:Sender>
- <gesmes:name>European Central Bank</gesmes:name>
- </gesmes:Sender>
- <Cube><Cube>
- <Cube currency='GBP' rate='0.81725'/>
- <Cube currency='Latinum' rate='999999'/>
- </Cube></Cube>
- </gesmes:Envelope>"#,
- Envelope {
- subject: "Reference rates".to_string(),
- Sender: TheSender {
- name: "European Central Bank".to_string(),
- },
- Cube: OuterCube {
- Cube: vec![InnerCube {
- Cube: vec![
- CurrencyCube {
- currency: "GBP".to_string(),
- rate: "0.81725".to_string(),
- },
- CurrencyCube {
- currency: "Latinum".to_string(),
- rate: "999999".to_string(),
- },
- ],
- }],
- },
- },
- ),
- ]);
-}
-
-#[test]
-fn test_hugo_duncan2() {
- let _ = simple_logger::init();
- let s = r#"
- <?xml version="1.0" encoding="UTF-8"?>
- <DescribeVpcsResponse xmlns="http://ec2.amazonaws.com/doc/2014-10-01/">
- <requestId>8d521e9a-509e-4ef6-bbb7-9f1ac0d49cd1</requestId>
- <vpcSet>
- <item>
- <vpcId>vpc-ba0d18d8</vpcId>
- <state>available</state>
- </item>
- </vpcSet>
- </DescribeVpcsResponse>"#;
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- #[allow(non_snake_case)]
- struct VpcSet {
- vpcId: String,
- state: String,
- }
-
- #[derive(PartialEq, Debug, Serialize)]
- struct ItemVec<T>(Vec<T>);
-
- impl<'de, T: de::Deserialize<'de>> de::Deserialize<'de> for ItemVec<T> {
- fn deserialize<D>(deserializer: D) -> Result<ItemVec<T>, D::Error>
- where
- D: de::Deserializer<'de>,
- {
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- struct Helper<U> {
- item: Vec<U>,
- }
- let h: Helper<_> = de::Deserialize::deserialize(deserializer)?;
- Ok(ItemVec(h.item))
- }
- }
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- #[allow(non_snake_case)]
- struct DescribeVpcsResponse {
- requestId: String,
- vpcSet: ItemVec<VpcSet>,
- }
- test_parse_ok(&[(
- s,
- DescribeVpcsResponse {
- requestId: "8d521e9a-509e-4ef6-bbb7-9f1ac0d49cd1".to_string(),
- vpcSet: ItemVec(vec![VpcSet {
- vpcId: "vpc-ba0d18d8".to_string(),
- state: "available".to_string(),
- }]),
- },
- )]);
-}
-
-#[test]
-fn test_hugo_duncan() {
- let _ = simple_logger::init();
- let s = "
- <?xml version=\"1.0\" encoding=\"UTF-8\"?>
- <DescribeInstancesResponse xmlns=\"http://ec2.amazonaws.com/doc/2014-10-01/\">
- <requestId>9474f558-10a5-42e8-84d1-f9ee181fe943</requestId>
- <reservationSet/>
- </DescribeInstancesResponse>
- ";
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- #[allow(non_snake_case)]
- struct DescribeInstancesResponse {
- requestId: String,
- reservationSet: (),
- }
- test_parse_ok(&[(
- s,
- DescribeInstancesResponse {
- requestId: "9474f558-10a5-42e8-84d1-f9ee181fe943".to_string(),
- reservationSet: (),
- },
- )]);
-}
-
-#[test]
-fn test_parse_xml_value() {
- let _ = simple_logger::init();
- #[derive(Eq, Debug, PartialEq, Deserialize, Serialize)]
- struct Test {
- #[serde(rename = "$value")]
- myval: String,
- }
- test_parse_ok(&[(
- "<Test>abc</Test>",
- Test {
- myval: "abc".to_string(),
- },
- )]);
-}
-
-#[test]
-#[ignore] // FIXME
-fn test_parse_complexstruct() {
- let _ = simple_logger::init();
-
- test_parse_ok(&[
- (
- "<Outer>
- <inner>
- <b>2</b>
- <b>boom</b>
- <b>88</b>
- </inner>
- </Outer>",
- Outer {
- inner: Some(Inner {
- a: (),
- b: (2, "boom".to_string(), 88),
- c: vec![],
- }),
- },
- ),
- (
- "<Outer>
- <inner>
- <c>abc</c>
- <c>xyz</c>
- <a/>
- <b>2</b>
- <b>boom</b>
- <b>88</b>
- </inner>
- </Outer>",
- Outer {
- inner: Some(Inner {
- a: (),
- b: (2, "boom".to_string(), 88),
- c: vec!["abc".to_string(), "xyz".to_string()],
- }),
- },
- ),
- ("<Outer/>", Outer { inner: None }),
- ]);
-}
-
-#[test]
-fn test_parse_attributes() {
- let _ = simple_logger::init();
-
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- struct A {
- a1: String,
- #[serde(rename = "$value")]
- a2: i32,
- }
-
- test_parse_ok(&[(
- r#"<A a1="What is the answer to the ultimate question?">42</A>"#,
- A {
- a1: "What is the answer to the ultimate question?".to_string(),
- a2: 42,
- },
- )]);
-
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- struct B {
- b1: String,
- b2: i32,
- }
-
- test_parse_ok(&[(
- r#"<B b1="What is the answer to the ultimate question?" b2="42"/>"#,
- B {
- b1: "What is the answer to the ultimate question?".to_string(),
- b2: 42,
- },
- )]);
-
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- struct C {
- c1: B,
- }
-
- test_parse_ok(&[
- (
- r#"<C><c1 b1="What is the answer to the ultimate question?" b2="42"/></C>"#,
- C {
- c1: B {
- b1: "What is the answer to the ultimate question?".to_string(),
- b2: 42,
- },
- },
- ),
- (
- r#"<C><c1 b1="What is the answer to the ultimate question?" b2="42"/> </C>"#,
- C {
- c1: B {
- b1: "What is the answer to the ultimate question?".to_string(),
- b2: 42,
- },
- },
- ),
- (
- r#"<C> <c1 b1="What is the answer to the ultimate question?" b2="42">
- </c1> </C>"#,
- C {
- c1: B {
- b1: "What is the answer to the ultimate question?".to_string(),
- b2: 42,
- },
- },
- ),
- ]);
-
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- struct D {
- d1: Option<A>,
- }
- test_parse_ok(&[(
- r#"<D><d1 a1="What is the answer to the ultimate question?">42</d1></D>"#,
- D {
- d1: Some(A {
- a1: "What is the answer to the ultimate question?".to_string(),
- a2: 42,
- }),
- },
- )]);
-}
-
-#[test]
-#[ignore] // FIXME
-fn test_parse_hierarchies() {
- let _ = simple_logger::init();
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- struct A {
- a1: String,
- a2: (String, String),
- }
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- struct B {
- b1: A,
- b2: (A, A),
- }
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- struct C {
- c1: B,
- c2: Vec<B>,
- }
-
- test_parse_ok(&[
- (
- "<C><c1>
- <b1>
- <a1>No</a1>
- <a2>Maybe</a2>
- <a2>Yes</a2>
- </b1>
- <b2>
- <a1>Red</a1>
- <a2>Green</a2>
- <a2>Blue</a2>
- </b2>
- <b2>
- <a1>London</a1>
- <a2>Berlin</a2>
- <a2>Paris</a2>
- </b2>
- </c1></C>",
- C {
- c1: B {
- b1: A {
- a1: "No".to_string(),
- a2: ("Maybe".to_string(), "Yes".to_string()),
- },
- b2: (
- A {
- a1: "Red".to_string(),
- a2: ("Green".to_string(), "Blue".to_string()),
- },
- A {
- a1: "London".to_string(),
- a2: ("Berlin".to_string(), "Paris".to_string()),
- },
- ),
- },
- c2: vec![],
- },
- ),
- (
- "<C><c1>
- <b2>
- <a2>Green</a2>
- <a2>Blue</a2>
- <a1>Red</a1>
- </b2>
- <b2>
- <a2>Berlin</a2>
- <a2>Paris</a2>
- <a1>London</a1>
- </b2>
- <b1>
- <a2>Maybe</a2>
- <a2>Yes</a2>
- <a1>No</a1>
- </b1>
- </c1></C>",
- C {
- c1: B {
- b1: A {
- a1: "No".to_string(),
- a2: ("Maybe".to_string(), "Yes".to_string()),
- },
- b2: (
- A {
- a1: "Red".to_string(),
- a2: ("Green".to_string(), "Blue".to_string()),
- },
- A {
- a1: "London".to_string(),
- a2: ("Berlin".to_string(), "Paris".to_string()),
- },
- ),
- },
- c2: vec![],
- },
- ),
- ]);
-}
-
-#[test]
-fn unknown_field() {
- #[derive(Deserialize, Debug, PartialEq, Eq, Serialize)]
- struct A {
- other: Vec<Other>,
- }
-
- #[derive(Deserialize, Debug, PartialEq, Eq, Serialize)]
- struct Other {
- d: i32,
- }
- test_parse_ok(&[(
- "<a>
- <b>
- <c>5</c>
- </b>
- <other>
- <d>6</d>
- </other>
- </a>",
- A {
- other: vec![Other { d: 6 }],
- },
- )]);
-}
-
-// #[test]
-// fn eoz() {
-// use std::io::Read;
-// let mut file = std::fs::File::open("Report_test.2.xml").unwrap();
-// let mut s = String::new();
-// file.read_to_string(&mut s).unwrap();
-
-// let _xml_value: Element = from_str(&s).unwrap();
-// }
-
-#[test]
-fn test_parse_unfinished() {
- test_parse_err::<Simple>(&["<Simple>
- <c>abc</c>
- <a/>
- <b>2</b>
- <d/>"]);
-}
-
-#[test]
-fn test_things_qc_found() {
- test_parse_err::<u32>(&["<\u{0}:/"]);
-}
-
-#[test]
-fn futile() {
- let _ = simple_logger::init();
- #[derive(Eq, PartialEq, Debug, Serialize, Deserialize)]
- struct Object {
- id: u8,
- name: String,
- x: u8,
- y: u8,
- width: u8,
- height: u8,
- ellipse: Option<()>,
- }
-
- test_parse_ok(&[
- (
- r###"
- <object id="11" name="testEllipse" x="102" y="38" width="21" height="14">
- <ellipse/>
- </object>
- "###,
- Object {
- id: 11,
- name: "testEllipse".to_owned(),
- x: 102,
- y: 38,
- width: 21,
- height: 14,
- ellipse: Some(()),
- },
- ),
- (
- r###"
- <object id="11" name="testEllipse" x="102" y="38" width="21" height="14">
- </object>
- "###,
- Object {
- id: 11,
- name: "testEllipse".to_owned(),
- x: 102,
- y: 38,
- width: 21,
- height: 14,
- ellipse: None,
- },
- ),
- ]);
-}
-
-#[test]
-fn futile2() {
- let _ = simple_logger::init();
- #[derive(Eq, PartialEq, Debug, Serialize, Deserialize)]
- struct Null;
-
- #[derive(Eq, PartialEq, Debug, Serialize, Deserialize)]
- struct Object {
- field: Option<Null>,
- };
-
- #[derive(Eq, PartialEq, Debug, Serialize, Deserialize)]
- struct Stuff {
- stuff_field: Option<Object>,
- };
-
- test_parse_ok(&[
- (
- r###"
- <object>
- <field/>
- </object>
- "###,
- Object { field: Some(Null) },
- ),
- (
- r###"
- <object>
- </object>
- "###,
- Object { field: None },
- ),
- ]);
-
- test_parse_ok(&[
- (
- r###"
- <object>
- <stuff_field/>
- </object>
- "###,
- Stuff {
- stuff_field: Some(Object { field: None }),
- },
- ),
- (
- r###"
- <object>
- <stuff_field>
- <field/>
- </stuff_field>
- </object>
- "###,
- Stuff {
- stuff_field: Some(Object { field: Some(Null) }),
- },
- ),
- (
- r###"
- <object>
- </object>
- "###,
- Stuff { stuff_field: None },
- ),
- (
- r###"
- <object/>
- "###,
- Stuff { stuff_field: None },
- ),
- ]);
-}
-
-#[test]
-fn newtype_struct() {
- #[derive(PartialEq, Debug, Serialize, Deserialize)]
- struct Wrapper(String);
-
- test_parse_ok(&[(
- r###"<wrapper>Content</wrapper>"###,
- Wrapper("Content".into()),
- )]);
-}
diff --git a/tests/readme.rs b/tests/readme.rs
deleted file mode 100644
index 881d572..0000000
--- a/tests/readme.rs
+++ /dev/null
@@ -1,6 +0,0 @@
-extern crate docmatic;
-
-#[test]
-fn test_readme() {
- docmatic::assert_file("README.md");
-}
diff --git a/tests/round_trip.rs b/tests/round_trip.rs
deleted file mode 100644
index 54b3b53..0000000
--- a/tests/round_trip.rs
+++ /dev/null
@@ -1,110 +0,0 @@
-#[macro_use]
-extern crate serde_derive;
-extern crate serde;
-extern crate serde_xml_rs;
-
-use serde::Deserialize;
-use serde_xml_rs::{from_str, to_string, EventReader, ParserConfig};
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-struct Item {
- name: String,
- source: String,
-}
-
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-enum Node {
- Boolean(bool),
- Identifier { value: String, index: u32 },
- EOF,
-}
-
-#[derive(Debug, Serialize, Deserialize, PartialEq)]
-struct Nodes {
- #[serde(rename = "$value")]
- items: Vec<Node>,
-}
-
-
-#[test]
-fn basic_struct() {
- let src = r#"<Item><name>Banana</name><source>Store</source></Item>"#;
- let should_be = Item {
- name: "Banana".to_string(),
- source: "Store".to_string(),
- };
-
- let item: Item = from_str(src).unwrap();
- assert_eq!(item, should_be);
-
- let reserialized_item = to_string(&item).unwrap();
- assert_eq!(src, reserialized_item);
-}
-
-
-#[test]
-#[ignore]
-fn round_trip_list_of_enums() {
- // Construct some inputs
- let nodes = Nodes {
- items: vec![
- Node::Boolean(true),
- Node::Identifier {
- value: "foo".to_string(),
- index: 5,
- },
- Node::EOF,
- ],
- };
-
- let should_be = r#"
- <Nodes>
- <Boolean>
- true
- </Boolean>
- <Identifier>
- <value>foo</value>
- <index>5</index>
- </Identifier>
- <EOF />
- </Nodes>"#;
-
- let serialized_nodes = to_string(&nodes).unwrap();
- assert_eq!(serialized_nodes, should_be);
-
- // Then turn it back into a `Nodes` struct and make sure it's the same
- // as the original
- let deserialized_nodes: Nodes = from_str(serialized_nodes.as_str()).unwrap();
- assert_eq!(deserialized_nodes, nodes);
-}
-
-#[test]
-fn whitespace_preserving_config() {
- // Test a configuration which does not clip whitespace from tags
-
- let src = r#"
- <Item>
- <name> space banana </name>
- <source> fantasy costco </source>
- </Item>"#;
-
- let item_should_be = Item {
- name: " space banana ".to_string(),
- source: " fantasy costco ".to_string(),
- };
- let config = ParserConfig::new()
- .trim_whitespace(false)
- .whitespace_to_characters(false);
- let mut deserializer =
- serde_xml_rs::Deserializer::new(EventReader::new_with_config(src.as_bytes(), config));
-
- let item = Item::deserialize(&mut deserializer).unwrap();
- assert_eq!(item, item_should_be);
-
- // Space outside values is not preserved.
- let serialized_should_be =
- "<Item><name> space banana </name><source> fantasy costco </source></Item>";
- let reserialized_item = to_string(&item).unwrap();
- assert_eq!(reserialized_item, serialized_should_be);
-}
diff --git a/tests/test.rs b/tests/test.rs
deleted file mode 100644
index 4b8ec86..0000000
--- a/tests/test.rs
+++ /dev/null
@@ -1,161 +0,0 @@
-#[macro_use]
-extern crate serde_derive;
-extern crate serde_xml_rs;
-
-extern crate log;
-extern crate simple_logger;
-
-use serde_xml_rs::from_str;
-
-#[derive(Debug, Deserialize, PartialEq)]
-struct Item {
- name: String,
- source: String,
-}
-
-#[test]
-fn simple_struct_from_attributes() {
- let _ = simple_logger::init();
-
- let s = r##"
- <item name="hello" source="world.rs" />
- "##;
-
- let item: Item = from_str(s).unwrap();
-
- assert_eq!(
- item,
- Item {
- name: "hello".to_string(),
- source: "world.rs".to_string(),
- }
- );
-}
-
-#[test]
-fn multiple_roots_attributes() {
- let _ = simple_logger::init();
-
- let s = r##"
- <item name="hello" source="world.rs" />
- <item name="hello" source="world.rs" />
- "##;
-
- let item: Vec<Item> = from_str(s).unwrap();
-
- assert_eq!(
- item,
- vec![
- Item {
- name: "hello".to_string(),
- source: "world.rs".to_string(),
- },
- Item {
- name: "hello".to_string(),
- source: "world.rs".to_string(),
- },
- ]
- );
-}
-
-#[test]
-fn simple_struct_from_attribute_and_child() {
- let _ = simple_logger::init();
-
- let s = r##"
- <item name="hello">
- <source>world.rs</source>
- </item>
- "##;
-
- let item: Item = from_str(s).unwrap();
-
- assert_eq!(
- item,
- Item {
- name: "hello".to_string(),
- source: "world.rs".to_string(),
- }
- );
-}
-
-#[derive(Debug, Deserialize, PartialEq)]
-struct Project {
- name: String,
-
- #[serde(rename = "item", default)]
- items: Vec<Item>,
-}
-
-#[test]
-fn nested_collection() {
- let _ = simple_logger::init();
-
- let s = r##"
- <project name="my_project">
- <item name="hello1" source="world1.rs" />
- <item name="hello2" source="world2.rs" />
- </project>
- "##;
-
- let project: Project = from_str(s).unwrap();
-
- assert_eq!(
- project,
- Project {
- name: "my_project".to_string(),
- items: vec![
- Item {
- name: "hello1".to_string(),
- source: "world1.rs".to_string(),
- },
- Item {
- name: "hello2".to_string(),
- source: "world2.rs".to_string(),
- },
- ],
- }
- );
-}
-
-#[derive(Debug, Deserialize, PartialEq)]
-enum MyEnum {
- A(String),
- B { name: String, flag: bool },
- C,
-}
-
-#[derive(Debug, Deserialize, PartialEq)]
-struct MyEnums {
- #[serde(rename = "$value")]
- items: Vec<MyEnum>,
-}
-
-#[test]
-fn collection_of_enums() {
- let _ = simple_logger::init();
-
- let s = r##"
- <enums>
- <A>test</A>
- <B name="hello" flag="true" />
- <C />
- </enums>
- "##;
-
- let project: MyEnums = from_str(s).unwrap();
-
- assert_eq!(
- project,
- MyEnums {
- items: vec![
- MyEnum::A("test".to_string()),
- MyEnum::B {
- name: "hello".to_string(),
- flag: true,
- },
- MyEnum::C,
- ],
- }
- );
-}
