From 1d45873f1e89098363eb6f75b778b478bc1516fa Mon Sep 17 00:00:00 2001
From: Ty Overby <ty@pre-alpha.com>
Date: Sat, 2 May 2015 12:23:27 -0700
Subject: [PATCH] cleaned up refbox implementation and added tests

---
 src/refbox.rs | 25 ++++++-------------------
 src/test.rs   | 31 +++++++++++++++++++++++++++++--
 src/writer.rs |  2 +-
 3 files changed, 36 insertions(+), 22 deletions(-)

diff --git a/src/refbox.rs b/src/refbox.rs
index 939aed7..8f72c35 100644
--- a/src/refbox.rs
+++ b/src/refbox.rs
@@ -218,30 +218,17 @@ impl <T: Decodable> Decodable for SliceBox<'static, T> {
 
 impl <'a, A: Encodable + ?Sized, B: Encodable> Encodable for RefBoxInner<'a, A, B> {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_enum("RefBox", |s| {
-            s.emit_enum_variant("Box", 1, 1, |s| {
-                s.emit_enum_variant_arg(0, |s| {
-                    match self {
-                        &RefBoxInner::Ref(ref r) => r.encode(s),
-                        &RefBoxInner::Box(ref b) => b.encode(s)
-                    }
-                })
-            })
-        })
+        match self {
+            &RefBoxInner::Ref(ref r) => r.encode(s),
+            &RefBoxInner::Box(ref b) => b.encode(s)
+        }
     }
 }
 
 impl <A: ?Sized, B: Decodable> Decodable for RefBoxInner<'static, A, B> {
     fn decode<D: Decoder>(d: &mut D) -> Result<RefBoxInner<'static, A, B>, D::Error> {
-        d.read_enum("RefBox", |d| {
-            d.read_enum_variant(&["Ref", "Box"], |d, i| {
-                assert!(i == 1);
-                d.read_enum_variant_arg(0, |d| {
-                    let decoded = try!(Decodable::decode(d));
-                    Ok(RefBoxInner::Box(decoded))
-                })
-            })
-        })
+        let decoded = try!(Decodable::decode(d));
+        Ok(RefBoxInner::Box(decoded))
     }
 }
 
diff --git a/src/test.rs b/src/test.rs
index e05ac8c..449eded 100644
--- a/src/test.rs
+++ b/src/test.rs
@@ -4,8 +4,17 @@ use std::ops::Deref;
 
 use rustc_serialize::{Encoder, Decoder, Encodable, Decodable};
 
-use super::{encode, decode, decode_from, encoded_size, DecodingError,
-            DecodingResult, RefBox};
+use super::{
+    encode,
+    decode,
+    decode_from,
+    encoded_size,
+    DecodingError,
+    DecodingResult,
+    RefBox,
+    StrBox,
+    SliceBox,
+};
 
 use super::SizeLimit::{Infinite, Bounded};
 
@@ -288,6 +297,24 @@ fn test_refbox() {
     }
 }
 
+#[test]
+fn test_strbox() {
+    let strx: &'static str = "hello world";
+    let encoded = encode(&StrBox::new(strx), Infinite).unwrap();
+    let decoded: (StrBox<'static>, _) = decode(&encoded[..]).unwrap();
+    let stringx: String = decoded.0.take();
+    assert!(strx == &stringx[..]);
+}
+
+#[test]
+fn test_slicebox() {
+    let slice = [1u32, 2, 3 ,4, 5];
+    let encoded = encode(&SliceBox::new(&slice), Infinite).unwrap();
+    let decoded: (SliceBox<'static, u32>, _) = decode(&encoded[..]).unwrap();
+    let vecx: Vec<u32> = decoded.0.take();
+    assert!(slice == &vecx[..]);
+}
+
 #[test]
 fn test_multi_strings() {
     assert!(encode(&("foo", "bar", "baz"), Infinite).is_ok());
diff --git a/src/writer.rs b/src/writer.rs
index 68f8b41..adc966f 100644
--- a/src/writer.rs
+++ b/src/writer.rs
@@ -21,7 +21,7 @@ pub enum EncodingError {
     ///
     /// This error is returned before any bytes are written to the
     /// output `Writer`.
-    SizeLimit
+    SizeLimit,
 }
 
 /// An Encoder that encodes values directly into a Writer.