src/vendor/toml/src/encoder/rustc_serialize.rs

   1 use std::mem;
   2
   3 use rustc_serialize;
   4 use Value;
   5 use super::{Encoder, Error, State};
   6 use super::Error::*;
   7
   8 impl rustc_serialize::Encoder for Encoder {
   9     type Error = Error;
  10
  11     fn emit_nil(&mut self) -> Result<(), Error> { Ok(()) }
  12     fn emit_usize(&mut self, v: usize) -> Result<(), Error> {
  13         self.emit_i64(v as i64)
  14     }
  15     fn emit_u8(&mut self, v: u8) -> Result<(), Error> {
  16         self.emit_i64(v as i64)
  17     }
  18     fn emit_u16(&mut self, v: u16) -> Result<(), Error> {
  19         self.emit_i64(v as i64)
  20     }
  21     fn emit_u32(&mut self, v: u32) -> Result<(), Error> {
  22         self.emit_i64(v as i64)
  23     }
  24     fn emit_u64(&mut self, v: u64) -> Result<(), Error> {
  25         self.emit_i64(v as i64)
  26     }
  27     fn emit_isize(&mut self, v: isize) -> Result<(), Error> {
  28         self.emit_i64(v as i64)
  29     }
  30     fn emit_i8(&mut self, v: i8) -> Result<(), Error> {
  31         self.emit_i64(v as i64)
  32     }
  33     fn emit_i16(&mut self, v: i16) -> Result<(), Error> {
  34         self.emit_i64(v as i64)
  35     }
  36     fn emit_i32(&mut self, v: i32) -> Result<(), Error> {
  37         self.emit_i64(v as i64)
  38     }
  39     fn emit_i64(&mut self, v: i64) -> Result<(), Error> {
  40         self.emit_value(Value::Integer(v))
  41     }
  42     fn emit_bool(&mut self, v: bool) -> Result<(), Error> {
  43         self.emit_value(Value::Boolean(v))
  44     }
  45     fn emit_f32(&mut self, v: f32) -> Result<(), Error> { self.emit_f64(v as f64) }
  46     fn emit_f64(&mut self, v: f64) -> Result<(), Error> {
  47         self.emit_value(Value::Float(v))
  48     }
  49     fn emit_char(&mut self, v: char) -> Result<(), Error> {
  50         self.emit_str(&*format!("{}", v))
  51     }
  52     fn emit_str(&mut self, v: &str) -> Result<(), Error> {
  53         self.emit_value(Value::String(format!("{}", v)))
  54     }
  55     fn emit_enum<F>(&mut self, _name: &str, f: F)
  56         -> Result<(), Error>
  57         where F: FnOnce(&mut Encoder) -> Result<(), Error>
  58     {
  59         f(self)
  60     }
  61     fn emit_enum_variant<F>(&mut self, _v_name: &str, _v_id: usize,
  62                             _len: usize, f: F) -> Result<(), Error>
  63         where F: FnOnce(&mut Encoder) -> Result<(), Error>
  64     {
  65         f(self)
  66     }
  67     fn emit_enum_variant_arg<F>(&mut self, _a_idx: usize, f: F)
  68         -> Result<(), Error>
  69         where F: FnOnce(&mut Encoder) -> Result<(), Error>
  70     {
  71         f(self)
  72     }
  73     fn emit_enum_struct_variant<F>(&mut self, _v_name: &str, _v_id: usize,
  74                                    _len: usize,
  75                                    _f: F)
  76         -> Result<(), Error>
  77         where F: FnOnce(&mut Encoder) -> Result<(), Error>
  78     {
  79         panic!()
  80     }
  81     fn emit_enum_struct_variant_field<F>(&mut self,
  82                                          _f_name: &str,
  83                                          _f_idx: usize,
  84                                          _f: F)
  85         -> Result<(), Error>
  86         where F: FnOnce(&mut Encoder) -> Result<(), Error>
  87     {
  88         panic!()
  89     }
  90     fn emit_struct<F>(&mut self, _name: &str, _len: usize, f: F)
  91         -> Result<(), Error>
  92         where F: FnOnce(&mut Encoder) -> Result<(), Error>
  93     {
  94         self.table(f)
  95     }
  96     fn emit_struct_field<F>(&mut self, f_name: &str, _f_idx: usize, f: F)
  97         -> Result<(), Error>
  98         where F: FnOnce(&mut Encoder) -> Result<(), Error>
  99     {
 100         let old = mem::replace(&mut self.state,
 101                                State::NextKey(format!("{}", f_name)));
 102         try!(f(self));
 103         if self.state != State::Start {
 104             return Err(NoValue)
 105         }
 106         self.state = old;
 107         Ok(())
 108     }
 109     fn emit_tuple<F>(&mut self, len: usize, f: F)
 110         -> Result<(), Error>
 111         where F: FnOnce(&mut Encoder) -> Result<(), Error>
 112     {
 113         self.emit_seq(len, f)
 114     }
 115     fn emit_tuple_arg<F>(&mut self, idx: usize, f: F)
 116         -> Result<(), Error>
 117         where F: FnOnce(&mut Encoder) -> Result<(), Error>
 118     {
 119         self.emit_seq_elt(idx, f)
 120     }
 121     fn emit_tuple_struct<F>(&mut self, _name: &str, _len: usize, _f: F)
 122         -> Result<(), Error>
 123         where F: FnOnce(&mut Encoder) -> Result<(), Error>
 124     {
 125         unimplemented!()
 126     }
 127     fn emit_tuple_struct_arg<F>(&mut self, _f_idx: usize, _f: F)
 128         -> Result<(), Error>
 129         where F: FnOnce(&mut Encoder) -> Result<(), Error>
 130     {
 131         unimplemented!()
 132     }
 133     fn emit_option<F>(&mut self, f: F)
 134         -> Result<(), Error>
 135         where F: FnOnce(&mut Encoder) -> Result<(), Error>
 136     {
 137         f(self)
 138     }
 139     fn emit_option_none(&mut self) -> Result<(), Error> {
 140         self.emit_none()
 141     }
 142     fn emit_option_some<F>(&mut self, f: F) -> Result<(), Error>
 143         where F: FnOnce(&mut Encoder) -> Result<(), Error>
 144     {
 145         f(self)
 146     }
 147     fn emit_seq<F>(&mut self, _len: usize, f: F)
 148         -> Result<(), Error>
 149         where F: FnOnce(&mut Encoder) -> Result<(), Error>
 150     {
 151         self.seq(f)
 152     }
 153     fn emit_seq_elt<F>(&mut self, _idx: usize, f: F)
 154         -> Result<(), Error>
 155         where F: FnOnce(&mut Encoder) -> Result<(), Error>
 156     {
 157         f(self)
 158     }
 159     fn emit_map<F>(&mut self, len: usize, f: F)
 160         -> Result<(), Error>
 161         where F: FnOnce(&mut Encoder) -> Result<(), Error>
 162     {
 163         self.emit_struct("foo", len, f)
 164     }
 165     fn emit_map_elt_key<F>(&mut self, _idx: usize, f: F) -> Result<(), Error>
 166         where F: FnOnce(&mut Encoder) -> Result<(), Error>
 167     {
 168         self.table_key(f)
 169     }
 170     fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> Result<(), Error>
 171         where F: FnOnce(&mut Encoder) -> Result<(), Error>
 172     {
 173         f(self)
 174     }
 175 }
 176
 177 impl rustc_serialize::Encodable for Value {
 178     fn encode<E>(&self, e: &mut E) -> Result<(), E::Error>
 179         where E: rustc_serialize::Encoder
 180     {
 181         match *self {
 182             Value::String(ref s) => e.emit_str(s),
 183             Value::Integer(i) => e.emit_i64(i),
 184             Value::Float(f) => e.emit_f64(f),
 185             Value::Boolean(b) => e.emit_bool(b),
 186             Value::Datetime(ref s) => e.emit_str(s),
 187             Value::Array(ref a) => {
 188                 e.emit_seq(a.len(), |e| {
 189                     for item in a {
 190                         try!(item.encode(e));
 191                     }
 192                     Ok(())
 193                 })
 194             }
 195             Value::Table(ref t) => {
 196                 e.emit_map(t.len(), |e| {
 197                     for (i, (key, value)) in t.iter().enumerate() {
 198                         try!(e.emit_map_elt_key(i, |e| e.emit_str(key)));
 199                         try!(e.emit_map_elt_val(i, |e| value.encode(e)));
 200                     }
 201                     Ok(())
 202                 })
 203             }
 204         }
 205     }
 206 }
 207
 208 #[cfg(test)]
 209 mod tests {
 210     use std::collections::{BTreeMap, HashSet};
 211     use rustc_serialize::{self, Encodable, Decodable};
 212
 213     use {Encoder, Decoder, DecodeError};
 214     use Value;
 215     use Value::{Table, Integer, Array, Float};
 216
 217     macro_rules! encode( ($t:expr) => ({
 218         let mut e = Encoder::new();
 219         $t.encode(&mut e).unwrap();
 220         e.toml
 221     }) );
 222
 223     macro_rules! decode( ($t:expr) => ({
 224         let mut d = Decoder::new($t);
 225         Decodable::decode(&mut d).unwrap()
 226     }) );
 227
 228     macro_rules! map( ($($k:ident, $v:expr),*) => ({
 229         let mut _m = BTreeMap::new();
 230         $(_m.insert(stringify!($k).to_string(), $v);)*
 231         _m
 232     }) );
 233
 234     #[test]
 235     fn smoke() {
 236         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 237         struct Foo { a: isize }
 238
 239         let v = Foo { a: 2 };
 240         assert_eq!(encode!(v), map! { a, Integer(2) });
 241         assert_eq!(v, decode!(Table(encode!(v))));
 242     }
 243
 244     #[test]
 245     fn smoke_hyphen() {
 246         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 247         struct Foo { a_b: isize }
 248
 249         let v = Foo { a_b: 2 };
 250         assert_eq!(encode!(v), map! { a_b, Integer(2) });
 251         assert_eq!(v, decode!(Table(encode!(v))));
 252
 253         let mut m = BTreeMap::new();
 254         m.insert("a-b".to_string(), Integer(2));
 255         assert_eq!(v, decode!(Table(encode!(v))));
 256     }
 257
 258     #[test]
 259     fn nested() {
 260         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 261         struct Foo { a: isize, b: Bar }
 262         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 263         struct Bar { a: String }
 264
 265         let v = Foo { a: 2, b: Bar { a: "test".to_string() } };
 266         assert_eq!(encode!(v),
 267                    map! {
 268                        a, Integer(2),
 269                        b, Table(map! {
 270                            a, Value::String("test".to_string())
 271                        })
 272                    });
 273         assert_eq!(v, decode!(Table(encode!(v))));
 274     }
 275
 276     #[test]
 277     fn application_decode_error() {
 278         #[derive(PartialEq, Debug)]
 279         struct Range10(usize);
 280         impl Decodable for Range10 {
 281              fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<Range10, D::Error> {
 282                  let x: usize = try!(Decodable::decode(d));
 283                  if x > 10 {
 284                      Err(d.error("Value out of range!"))
 285                  } else {
 286                      Ok(Range10(x))
 287                  }
 288              }
 289         }
 290         let mut d_good = Decoder::new(Integer(5));
 291         let mut d_bad1 = Decoder::new(Value::String("not an isize".to_string()));
 292         let mut d_bad2 = Decoder::new(Integer(11));
 293
 294         assert_eq!(Ok(Range10(5)), Decodable::decode(&mut d_good));
 295
 296         let err1: Result<Range10, _> = Decodable::decode(&mut d_bad1);
 297         assert!(err1.is_err());
 298         let err2: Result<Range10, _> = Decodable::decode(&mut d_bad2);
 299         assert!(err2.is_err());
 300     }
 301
 302     #[test]
 303     fn array() {
 304         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 305         struct Foo { a: Vec<isize> }
 306
 307         let v = Foo { a: vec![1, 2, 3, 4] };
 308         assert_eq!(encode!(v),
 309                    map! {
 310                        a, Array(vec![
 311                             Integer(1),
 312                             Integer(2),
 313                             Integer(3),
 314                             Integer(4)
 315                        ])
 316                    });
 317         assert_eq!(v, decode!(Table(encode!(v))));
 318     }
 319
 320     #[test]
 321     fn tuple() {
 322         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 323         struct Foo { a: (isize, isize, isize, isize) }
 324
 325         let v = Foo { a: (1, 2, 3, 4) };
 326         assert_eq!(encode!(v),
 327                    map! {
 328                        a, Array(vec![
 329                             Integer(1),
 330                             Integer(2),
 331                             Integer(3),
 332                             Integer(4)
 333                        ])
 334                    });
 335         assert_eq!(v, decode!(Table(encode!(v))));
 336     }
 337
 338     #[test]
 339     fn inner_structs_with_options() {
 340         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 341         struct Foo {
 342             a: Option<Box<Foo>>,
 343             b: Bar,
 344         }
 345         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 346         struct Bar {
 347             a: String,
 348             b: f64,
 349         }
 350
 351         let v = Foo {
 352             a: Some(Box::new(Foo {
 353                 a: None,
 354                 b: Bar { a: "foo".to_string(), b: 4.5 },
 355             })),
 356             b: Bar { a: "bar".to_string(), b: 1.0 },
 357         };
 358         assert_eq!(encode!(v),
 359                    map! {
 360                        a, Table(map! {
 361                            b, Table(map! {
 362                                a, Value::String("foo".to_string()),
 363                                b, Float(4.5)
 364                            })
 365                        }),
 366                        b, Table(map! {
 367                            a, Value::String("bar".to_string()),
 368                            b, Float(1.0)
 369                        })
 370                    });
 371         assert_eq!(v, decode!(Table(encode!(v))));
 372     }
 373
 374     #[test]
 375     fn hashmap() {
 376         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 377         struct Foo {
 378             map: BTreeMap<String, isize>,
 379             set: HashSet<char>,
 380         }
 381
 382         let v = Foo {
 383             map: {
 384                 let mut m = BTreeMap::new();
 385                 m.insert("foo".to_string(), 10);
 386                 m.insert("bar".to_string(), 4);
 387                 m
 388             },
 389             set: {
 390                 let mut s = HashSet::new();
 391                 s.insert('a');
 392                 s
 393             },
 394         };
 395         assert_eq!(encode!(v),
 396             map! {
 397                 map, Table(map! {
 398                     foo, Integer(10),
 399                     bar, Integer(4)
 400                 }),
 401                 set, Array(vec![Value::String("a".to_string())])
 402             }
 403         );
 404         assert_eq!(v, decode!(Table(encode!(v))));
 405     }
 406
 407     #[test]
 408     fn tuple_struct() {
 409         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 410         struct Foo(isize, String, f64);
 411
 412         let v = Foo(1, "foo".to_string(), 4.5);
 413         assert_eq!(
 414             encode!(v),
 415             map! {
 416                 _field0, Integer(1),
 417                 _field1, Value::String("foo".to_string()),
 418                 _field2, Float(4.5)
 419             }
 420         );
 421         assert_eq!(v, decode!(Table(encode!(v))));
 422     }
 423
 424     #[test]
 425     fn table_array() {
 426         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 427         struct Foo { a: Vec<Bar>, }
 428         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 429         struct Bar { a: isize }
 430
 431         let v = Foo { a: vec![Bar { a: 1 }, Bar { a: 2 }] };
 432         assert_eq!(
 433             encode!(v),
 434             map! {
 435                 a, Array(vec![
 436                     Table(map!{ a, Integer(1) }),
 437                     Table(map!{ a, Integer(2) }),
 438                 ])
 439             }
 440         );
 441         assert_eq!(v, decode!(Table(encode!(v))));
 442     }
 443
 444     #[test]
 445     fn type_errors() {
 446         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 447         struct Foo { bar: isize }
 448
 449         let mut d = Decoder::new(Table(map! {
 450             bar, Float(1.0)
 451         }));
 452         let a: Result<Foo, DecodeError> = Decodable::decode(&mut d);
 453         match a {
 454             Ok(..) => panic!("should not have decoded"),
 455             Err(e) => {
 456                 assert_eq!(format!("{}", e),
 457                            "expected a value of type `integer`, but \
 458                             found a value of type `float` for the key `bar`");
 459             }
 460         }
 461     }
 462
 463     #[test]
 464     fn missing_errors() {
 465         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 466         struct Foo { bar: isize }
 467
 468         let mut d = Decoder::new(Table(map! {
 469         }));
 470         let a: Result<Foo, DecodeError> = Decodable::decode(&mut d);
 471         match a {
 472             Ok(..) => panic!("should not have decoded"),
 473             Err(e) => {
 474                 assert_eq!(format!("{}", e),
 475                            "expected a value of type `integer` for the key `bar`");
 476             }
 477         }
 478     }
 479
 480     #[test]
 481     fn parse_enum() {
 482         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 483         struct Foo { a: E }
 484         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 485         enum E {
 486             Bar(isize),
 487             Baz(f64),
 488             Last(Foo2),
 489         }
 490         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 491         struct Foo2 {
 492             test: String,
 493         }
 494
 495         let v = Foo { a: E::Bar(10) };
 496         assert_eq!(
 497             encode!(v),
 498             map! { a, Integer(10) }
 499         );
 500         assert_eq!(v, decode!(Table(encode!(v))));
 501
 502         let v = Foo { a: E::Baz(10.2) };
 503         assert_eq!(
 504             encode!(v),
 505             map! { a, Float(10.2) }
 506         );
 507         assert_eq!(v, decode!(Table(encode!(v))));
 508
 509         let v = Foo { a: E::Last(Foo2 { test: "test".to_string() }) };
 510         assert_eq!(
 511             encode!(v),
 512             map! { a, Table(map! { test, Value::String("test".to_string()) }) }
 513         );
 514         assert_eq!(v, decode!(Table(encode!(v))));
 515     }
 516
 517     #[test]
 518     fn unused_fields() {
 519         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 520         struct Foo { a: isize }
 521
 522         let v = Foo { a: 2 };
 523         let mut d = Decoder::new(Table(map! {
 524             a, Integer(2),
 525             b, Integer(5)
 526         }));
 527         assert_eq!(v, Decodable::decode(&mut d).unwrap());
 528
 529         assert_eq!(d.toml, Some(Table(map! {
 530             b, Integer(5)
 531         })));
 532     }
 533
 534     #[test]
 535     fn unused_fields2() {
 536         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 537         struct Foo { a: Bar }
 538         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 539         struct Bar { a: isize }
 540
 541         let v = Foo { a: Bar { a: 2 } };
 542         let mut d = Decoder::new(Table(map! {
 543             a, Table(map! {
 544                 a, Integer(2),
 545                 b, Integer(5)
 546             })
 547         }));
 548         assert_eq!(v, Decodable::decode(&mut d).unwrap());
 549
 550         assert_eq!(d.toml, Some(Table(map! {
 551             a, Table(map! {
 552                 b, Integer(5)
 553             })
 554         })));
 555     }
 556
 557     #[test]
 558     fn unused_fields3() {
 559         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 560         struct Foo { a: Bar }
 561         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 562         struct Bar { a: isize }
 563
 564         let v = Foo { a: Bar { a: 2 } };
 565         let mut d = Decoder::new(Table(map! {
 566             a, Table(map! {
 567                 a, Integer(2)
 568             })
 569         }));
 570         assert_eq!(v, Decodable::decode(&mut d).unwrap());
 571
 572         assert_eq!(d.toml, None);
 573     }
 574
 575     #[test]
 576     fn unused_fields4() {
 577         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 578         struct Foo { a: BTreeMap<String, String> }
 579
 580         let v = Foo { a: map! { a, "foo".to_string() } };
 581         let mut d = Decoder::new(Table(map! {
 582             a, Table(map! {
 583                 a, Value::String("foo".to_string())
 584             })
 585         }));
 586         assert_eq!(v, Decodable::decode(&mut d).unwrap());
 587
 588         assert_eq!(d.toml, None);
 589     }
 590
 591     #[test]
 592     fn unused_fields5() {
 593         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 594         struct Foo { a: Vec<String> }
 595
 596         let v = Foo { a: vec!["a".to_string()] };
 597         let mut d = Decoder::new(Table(map! {
 598             a, Array(vec![Value::String("a".to_string())])
 599         }));
 600         assert_eq!(v, Decodable::decode(&mut d).unwrap());
 601
 602         assert_eq!(d.toml, None);
 603     }
 604
 605     #[test]
 606     fn unused_fields6() {
 607         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 608         struct Foo { a: Option<Vec<String>> }
 609
 610         let v = Foo { a: Some(vec![]) };
 611         let mut d = Decoder::new(Table(map! {
 612             a, Array(vec![])
 613         }));
 614         assert_eq!(v, Decodable::decode(&mut d).unwrap());
 615
 616         assert_eq!(d.toml, None);
 617     }
 618
 619     #[test]
 620     fn unused_fields7() {
 621         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 622         struct Foo { a: Vec<Bar> }
 623         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 624         struct Bar { a: isize }
 625
 626         let v = Foo { a: vec![Bar { a: 1 }] };
 627         let mut d = Decoder::new(Table(map! {
 628             a, Array(vec![Table(map! {
 629                 a, Integer(1),
 630                 b, Integer(2)
 631             })])
 632         }));
 633         assert_eq!(v, Decodable::decode(&mut d).unwrap());
 634
 635         assert_eq!(d.toml, Some(Table(map! {
 636             a, Array(vec![Table(map! {
 637                 b, Integer(2)
 638             })])
 639         })));
 640     }
 641
 642     #[test]
 643     fn unused_fields8() {
 644         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 645         struct Foo { a: BTreeMap<String, Bar> }
 646         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 647         struct Bar { a: isize }
 648
 649         let v = Foo { a: map! { a, Bar { a: 2 } } };
 650         let mut d = Decoder::new(Table(map! {
 651             a, Table(map! {
 652                 a, Table(map! {
 653                     a, Integer(2),
 654                     b, Integer(2)
 655                 })
 656             })
 657         }));
 658         assert_eq!(v, Decodable::decode(&mut d).unwrap());
 659
 660         assert_eq!(d.toml, Some(Table(map! {
 661             a, Table(map! {
 662                 a, Table(map! {
 663                     b, Integer(2)
 664                 })
 665             })
 666         })));
 667     }
 668
 669     #[test]
 670     fn empty_arrays() {
 671         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 672         struct Foo { a: Vec<Bar> }
 673         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 674         struct Bar;
 675
 676         let v = Foo { a: vec![] };
 677         let mut d = Decoder::new(Table(map! {}));
 678         assert_eq!(v, Decodable::decode(&mut d).unwrap());
 679     }
 680
 681     #[test]
 682     fn empty_arrays2() {
 683         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 684         struct Foo { a: Option<Vec<Bar>> }
 685         #[derive(RustcEncodable, RustcDecodable, PartialEq, Debug)]
 686         struct Bar;
 687
 688         let v = Foo { a: None };
 689         let mut d = Decoder::new(Table(map! {}));
 690         assert_eq!(v, Decodable::decode(&mut d).unwrap());
 691
 692         let v = Foo { a: Some(vec![]) };
 693         let mut d = Decoder::new(Table(map! {
 694             a, Array(vec![])
 695         }));
 696         assert_eq!(v, Decodable::decode(&mut d).unwrap());
 697     }
 698
 699     #[test]
 700     fn round_trip() {
 701         let toml = r#"
 702               [test]
 703               foo = "bar"
 704
 705               [[values]]
 706               foo = "baz"
 707
 708               [[values]]
 709               foo = "qux"
 710         "#;
 711
 712         let value: Value = toml.parse().unwrap();
 713         let val2 = ::encode_str(&value).parse().unwrap();
 714         assert_eq!(value, val2);
 715     }
 716 }