---

yaml
---
r: 14835
b: refs/heads/try
c: 9086c6f
h: refs/heads/master
i:
  14833: 6f1aa9d
  14831: 2012b5e
v: v3

Author: nikomatsakis

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: b30cb8e43a57f8f16065c37a664b26db0891f134
+refs/heads/try: 9086c6f5a2ac3e09c358d05700bfbcb18378bdf6
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/test/auxiliary/auto_serialize_lib.rs

@@ -0,0 +1,98 @@
+use std;
+
+// These tests used to be separate files, but I wanted to refactor all
+// the common code.
+
+import std::ebml;
+import io::writer;
+import std::prettyprint::serializer;
+import std::ebml::serializer;
+import std::ebml::deserializer;
+
+fn test_ser_and_deser<A>(a1: A,
+                         expected: str,
+                         ebml_ser_fn: fn(ebml::writer, A),
+                         ebml_deser_fn: fn(ebml::ebml_deserializer) -> A,
+                         io_ser_fn: fn(io::writer, A)) {
+
+    // check the pretty printer:
+    io_ser_fn(io::stdout(), a1);
+    let s = io::with_str_writer {|w| io_ser_fn(w, a1) };
+    #debug["s == %?", s];
+    assert s == expected;
+
+    // check the EBML serializer:
+    let buf = io::mem_buffer();
+    let w = ebml::writer(buf as io::writer);
+    ebml_ser_fn(w, a1);
+    let d = ebml::new_doc(@io::mem_buffer_buf(buf));
+    let a2 = ebml_deser_fn(ebml::ebml_deserializer(d));
+    io::print("\na1 = ");
+    io_ser_fn(io::stdout(), a1);
+    io::print("\na2 = ");
+    io_ser_fn(io::stdout(), a2);
+    io::print("\n");
+    assert a1 == a2;
+
+}
+
+#[auto_serialize]
+enum expr {
+    val(uint),
+    plus(@expr, @expr),
+    minus(@expr, @expr)
+}
+
+
+#[auto_serialize]
+type spanned<T> = {lo: uint, hi: uint, node: T};
+
+#[auto_serialize]
+type spanned_uint = spanned<uint>;
+
+#[auto_serialize]
+type some_rec = {v: uint_vec};
+
+#[auto_serialize]
+enum an_enum = some_rec;
+
+#[auto_serialize]
+type uint_vec = [uint];
+
+#[auto_serialize]
+type point = {x: uint, y: uint};
+
+fn main() {
+
+    test_ser_and_deser(plus(@minus(@val(3u), @val(10u)),
+                            @plus(@val(22u), @val(5u))),
+                       "plus(@minus(@val(3u), @val(10u)), \
+                        @plus(@val(22u), @val(5u)))",
+                       expr::serialize(_, _),
+                       expr::deserialize(_),
+                       expr::serialize(_, _));
+
+    test_ser_and_deser({lo: 0u, hi: 5u, node: 22u},
+                       "{lo: 0u, hi: 5u, node: 22u}",
+                       spanned_uint::serialize(_, _),
+                       spanned_uint::deserialize(_),
+                       spanned_uint::serialize(_, _));
+
+    test_ser_and_deser(an_enum({v: [1u, 2u, 3u]}),
+                       "an_enum({v: [1u, 2u, 3u]})",
+                       an_enum::serialize(_, _),
+                       an_enum::deserialize(_),
+                       an_enum::serialize(_, _));
+
+    test_ser_and_deser({x: 3u, y: 5u},
+                       "{x: 3u, y: 5u}",
+                       point::serialize(_, _),
+                       point::deserialize(_),
+                       point::serialize(_, _));
+
+    test_ser_and_deser([1u, 2u, 3u],
+                       "[1u, 2u, 3u]",
+                       uint_vec::serialize(_, _),
+                       uint_vec::deserialize(_),
+                       uint_vec::serialize(_, _));
+}