rustdoc: Refactor tests

8 files changed, 246 insertions, 530 deletions

diff --git a/src/rustdoc/attr_pass.rs b/src/rustdoc/attr_pass.rs
index 1c96eea5cda..4e0c85c8ac3 100644
--- a/src/rustdoc/attr_pass.rs
+++ b/src/rustdoc/attr_pass.rs
@@ -56,11 +56,7 @@ fn fold_crate(
 
 #[test]
 fn should_replace_top_module_name_with_crate_name() {
-    let source = "#[link(name = \"bond\")];";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let fold = fold::default_seq_fold(srv);
-    let doc = fold_crate(fold, doc);
+    let doc = test::mk_doc("#[link(name = \"bond\")];");
     assert doc.topmod.name == "bond";
 }
 
@@ -106,22 +102,14 @@ fn fold_mod(fold: fold::fold<astsrv::srv>, doc: doc::moddoc) -> doc::moddoc {
 
 #[test]
 fn fold_mod_should_extract_mod_attributes() {
-    let source = "#[doc = \"test\"] mod a { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let fold = fold::default_seq_fold(srv);
-    let doc = fold_mod(fold, doc.topmod.mods()[0]);
-    assert doc.desc == some("test");
+    let doc = test::mk_doc("#[doc = \"test\"] mod a { }");
+    assert doc.topmod.mods()[0].desc == some("test");
 }
 
 #[test]
 fn fold_mod_should_extract_top_mod_attributes() {
-    let source = "#[doc = \"test\"];";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let fold = fold::default_seq_fold(srv);
-    let doc = fold_mod(fold, doc.topmod);
-    assert doc.desc == some("test");
+    let doc = test::mk_doc("#[doc = \"test\"];");
+    assert doc.topmod.desc == some("test");
 }
 
 fn fold_fn(
@@ -182,22 +170,14 @@ fn merge_ret_attrs(
 
 #[test]
 fn fold_fn_should_extract_fn_attributes() {
-    let source = "#[doc = \"test\"] fn a() -> int { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let fold = fold::default_seq_fold(srv);
-    let doc = fold_fn(fold, doc.topmod.fns()[0]);
-    assert doc.desc == some("test");
+    let doc = test::mk_doc("#[doc = \"test\"] fn a() -> int { }");
+    assert doc.topmod.fns()[0].desc == some("test");
 }
 
 #[test]
 fn fold_fn_should_extract_arg_attributes() {
-    let source = "#[doc(args(a = \"b\"))] fn c(a: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let fold = fold::default_seq_fold(srv);
-    let doc = fold_fn(fold, doc.topmod.fns()[0]);
-    assert doc.args[0].desc == some("b");
+    let doc = test::mk_doc("#[doc(args(a = \"b\"))] fn c(a: bool) { }");
+    assert doc.topmod.fns()[0].args[0].desc == some("b");
 }
 
 #[test]
@@ -224,12 +204,8 @@ fn fold_fn_should_preserve_sig() {
 
 #[test]
 fn fold_fn_should_extract_failure_conditions() {
-    let source = "#[doc(failure = \"what\")] fn a() { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let fold = fold::default_seq_fold(srv);
-    let doc = fold_fn(fold, doc.topmod.fns()[0]);
-    assert doc.failure == some("what");
+    let doc = test::mk_doc("#[doc(failure = \"what\")] fn a() { }");
+    assert doc.topmod.fns()[0].failure == some("what");
 }
 
 fn fold_const(
@@ -248,14 +224,10 @@ fn fold_const(
 
 #[test]
 fn fold_const_should_extract_docs() {
-    let source = "#[doc(brief = \"foo\", desc = \"bar\")]\
-                  const a: bool = true;";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let fold = fold::default_seq_fold(srv);
-    let doc = fold_const(fold, doc.topmod.consts()[0]);
-    assert doc.brief == some("foo");
-    assert doc.desc == some("bar");
+    let doc = test::mk_doc("#[doc(brief = \"foo\", desc = \"bar\")]\
+                            const a: bool = true;");
+    assert doc.topmod.consts()[0].brief == some("foo");
+    assert doc.topmod.consts()[0].desc == some("bar");
 }
 
 fn fold_enum(
@@ -296,24 +268,16 @@ fn fold_enum(
 
 #[test]
 fn fold_enum_should_extract_docs() {
-    let source = "#[doc(brief = \"a\", desc = \"b\")]\
-                  enum a { v }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let fold = fold::default_seq_fold(srv);
-    let doc = fold_enum(fold, doc.topmod.enums()[0]);
-    assert doc.brief == some("a");
-    assert doc.desc == some("b");
+    let doc = test::mk_doc("#[doc(brief = \"a\", desc = \"b\")]\
+                            enum a { v }");
+    assert doc.topmod.enums()[0].brief == some("a");
+    assert doc.topmod.enums()[0].desc == some("b");
 }
 
 #[test]
 fn fold_enum_should_extract_variant_docs() {
-    let source = "enum a { #[doc = \"c\"] v }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let fold = fold::default_seq_fold(srv);
-    let doc = fold_enum(fold, doc.topmod.enums()[0]);
-    assert doc.variants[0].desc == some("c");
+    let doc = test::mk_doc("enum a { #[doc = \"c\"] v }");
+    assert doc.topmod.enums()[0].variants[0].desc == some("c");
 }
 
 fn fold_res(
@@ -346,26 +310,18 @@ fn fold_res(
 
 #[test]
 fn fold_res_should_extract_docs() {
-    let source = "#[doc(brief = \"a\", desc = \"b\")]\
-                  resource r(b: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let fold = fold::default_seq_fold(srv);
-    let doc = fold_res(fold, doc.topmod.resources()[0]);
-    assert doc.brief == some("a");
-    assert doc.desc == some("b");
+    let doc = test::mk_doc("#[doc(brief = \"a\", desc = \"b\")]\
+                            resource r(b: bool) { }");
+    assert doc.topmod.resources()[0].brief == some("a");
+    assert doc.topmod.resources()[0].desc == some("b");
 }
 
 #[test]
 fn fold_res_should_extract_arg_docs() {
-    let source = "#[doc(args(a = \"b\"))]\
-                  resource r(a: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let fold = fold::default_seq_fold(srv);
-    let doc = fold_res(fold, doc.topmod.resources()[0]);
-    assert doc.args[0].name == "a";
-    assert doc.args[0].desc == some("b");
+    let doc = test::mk_doc("#[doc(args(a = \"b\"))]\
+                            resource r(a: bool) { }");
+    assert doc.topmod.resources()[0].args[0].name == "a";
+    assert doc.topmod.resources()[0].args[0].desc == some("b");
 }
 
 fn fold_iface(
@@ -427,27 +383,22 @@ fn merge_method_attrs(
 
 #[test]
 fn should_extract_iface_docs() {
-    let source = "#[doc = \"whatever\"] iface i { fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc = \"whatever\"] iface i { fn a(); }");
     assert doc.topmod.ifaces()[0].desc == some("whatever");
 }
 
 #[test]
 fn should_extract_iface_method_docs() {
-    let source = "iface i {\
-                  #[doc(\
-                  brief = \"brief\",\
-                  desc = \"desc\",\
-                  args(a = \"a\"),\
-                  return = \"return\",\
-                  failure = \"failure\")]\
-                  fn f(a: bool) -> bool;\
-                  }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc(
+        "iface i {\
+         #[doc(\
+         brief = \"brief\",\
+         desc = \"desc\",\
+         args(a = \"a\"),\
+         return = \"return\",\
+         failure = \"failure\")]\
+         fn f(a: bool) -> bool;\
+         }");
     assert doc.topmod.ifaces()[0].methods[0].brief == some("brief");
     assert doc.topmod.ifaces()[0].methods[0].desc == some("desc");
     assert doc.topmod.ifaces()[0].methods[0].args[0].desc == some("a");
@@ -474,30 +425,35 @@ fn fold_impl(
 
 #[test]
 fn should_extract_impl_docs() {
-    let source = "#[doc = \"whatever\"] impl i for int { fn a() { } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc(
+        "#[doc = \"whatever\"] impl i for int { fn a() { } }");
     assert doc.topmod.impls()[0].desc == some("whatever");
 }
 
 #[test]
 fn should_extract_impl_method_docs() {
-    let source = "impl i for int {\
-                  #[doc(\
-                  brief = \"brief\",\
-                  desc = \"desc\",\
-                  args(a = \"a\"),\
-                  return = \"return\",\
-                  failure = \"failure\")]\
-                  fn f(a: bool) -> bool { }\
-                  }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc(
+        "impl i for int {\
+         #[doc(\
+         brief = \"brief\",\
+         desc = \"desc\",\
+         args(a = \"a\"),\
+         return = \"return\",\
+         failure = \"failure\")]\
+         fn f(a: bool) -> bool { }\
+         }");
     assert doc.topmod.impls()[0].methods[0].brief == some("brief");
     assert doc.topmod.impls()[0].methods[0].desc == some("desc");
     assert doc.topmod.impls()[0].methods[0].args[0].desc == some("a");
     assert doc.topmod.impls()[0].methods[0].return.desc == some("return");
     assert doc.topmod.impls()[0].methods[0].failure == some("failure");
 }
+
+#[cfg(test)]
+mod test {
+    fn mk_doc(source: str) -> doc::cratedoc {
+        let srv = astsrv::mk_srv_from_str(source);
+        let doc = extract::from_srv(srv, "");
+        run(srv, doc)
+    }
+}
\ No newline at end of file
diff --git a/src/rustdoc/desc_pass.rs b/src/rustdoc/desc_pass.rs
index c2ebde8b1a0..ff561cf0a90 100644
--- a/src/rustdoc/desc_pass.rs
+++ b/src/rustdoc/desc_pass.rs
@@ -128,130 +128,95 @@ fn fold_iface(fold: fold::fold<op>, doc: doc::ifacedoc) -> doc::ifacedoc {
 
 #[test]
 fn should_execute_op_on_enum_brief() {
-    let source = "#[doc(brief = \" a \")] enum a { b }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc("#[doc(brief = \" a \")] enum a { b }");
     assert doc.topmod.enums()[0].brief == some("a");
 }
 
 #[test]
 fn should_execute_op_on_enum_desc() {
-    let source = "#[doc(desc = \" a \")] enum a { b }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc("#[doc(desc = \" a \")] enum a { b }");
     assert doc.topmod.enums()[0].desc == some("a");
 }
 
 #[test]
 fn should_execute_op_on_variant_desc() {
-    let source = "enum a { #[doc = \" a \"] b }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc("enum a { #[doc = \" a \"] b }");
     assert doc.topmod.enums()[0].variants[0].desc == some("a");
 }
 
 #[test]
 fn should_execute_op_on_resource_brief() {
-    let source = "#[doc(brief = \" a \")] resource r(a: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc("#[doc(brief = \" a \")] resource r(a: bool) { }");
     assert doc.topmod.resources()[0].brief == some("a");
 }
 
 #[test]
 fn should_execute_op_on_resource_desc() {
-    let source = "#[doc(desc = \" a \")] resource r(a: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc("#[doc(desc = \" a \")] resource r(a: bool) { }");
     assert doc.topmod.resources()[0].desc == some("a");
 }
 
 #[test]
 fn should_execute_op_on_resource_args() {
-    let source = "#[doc(args(a = \" a \"))] resource r(a: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc(
+        "#[doc(args(a = \" a \"))] resource r(a: bool) { }");
     assert doc.topmod.resources()[0].args[0].desc == some("a");
 }
 
 #[test]
 fn should_execute_op_on_iface_brief() {
-    let source = "#[doc(brief = \" a \")] iface i { fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc(
+        "#[doc(brief = \" a \")] iface i { fn a(); }");
     assert doc.topmod.ifaces()[0].brief == some("a");
 }
 
 #[test]
 fn should_execute_op_on_iface_desc() {
-    let source = "#[doc(desc = \" a \")] iface i { fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc(
+        "#[doc(desc = \" a \")] iface i { fn a(); }");
     assert doc.topmod.ifaces()[0].desc == some("a");
 }
 
 #[test]
 fn should_execute_op_on_iface_method_brief() {
-    let source = "iface i { #[doc(brief = \" a \")] fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc(
+        "iface i { #[doc(brief = \" a \")] fn a(); }");
     assert doc.topmod.ifaces()[0].methods[0].brief == some("a");
 }
 
 #[test]
 fn should_execute_op_on_iface_method_desc() {
-    let source = "iface i { #[doc(desc = \" a \")] fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc(
+        "iface i { #[doc(desc = \" a \")] fn a(); }");
     assert doc.topmod.ifaces()[0].methods[0].desc == some("a");
 }
 
 #[test]
 fn should_execute_op_on_iface_method_args() {
-    let source = "iface i { #[doc(args(a = \" a \"))] fn a(a: bool); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc(
+        "iface i { #[doc(args(a = \" a \"))] fn a(a: bool); }");
     assert doc.topmod.ifaces()[0].methods[0].args[0].desc == some("a");
 }
 
 #[test]
 fn should_execute_op_on_iface_method_return() {
-    let source = "iface i { #[doc(return = \" a \")] fn a() -> int; }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc(
+        "iface i { #[doc(return = \" a \")] fn a() -> int; }");
     assert doc.topmod.ifaces()[0].methods[0].return.desc == some("a");
 }
 
 #[test]
 fn should_execute_op_on_iface_method_failure_condition() {
-    let source = "iface i { #[doc(failure = \" a \")] fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass(str::trim)(srv, doc);
+    let doc = test::mk_doc("iface i { #[doc(failure = \" a \")] fn a(); }");
     assert doc.topmod.ifaces()[0].methods[0].failure == some("a");
 }
+
+#[cfg(test)]
+mod test {
+    fn mk_doc(source: str) -> doc::cratedoc {
+        let srv = astsrv::mk_srv_from_str(source);
+        let doc = extract::from_srv(srv, "");
+        let doc = attr_pass::mk_pass()(srv, doc);
+        mk_pass(str::trim)(srv, doc)
+    }
+}
\ No newline at end of file
diff --git a/src/rustdoc/desc_to_brief_pass.rs b/src/rustdoc/desc_to_brief_pass.rs
index 2ab9a86db4a..00d1d6ba14a 100644
--- a/src/rustdoc/desc_to_brief_pass.rs
+++ b/src/rustdoc/desc_to_brief_pass.rs
@@ -106,81 +106,64 @@ fn fold_iface(fold: fold::fold<()>, doc: doc::ifacedoc) -> doc::ifacedoc {
 
 #[test]
 fn should_promote_mod_desc() {
-    let source = "#[doc(desc = \"desc\")] mod m { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc(desc = \"desc\")] mod m { }");
     assert doc.topmod.mods()[0].brief == some("desc");
     assert doc.topmod.mods()[0].desc == none;
 }
 
 #[test]
 fn should_promote_const_desc() {
-    let source = "#[doc(desc = \"desc\")] const a: bool = true;";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc(desc = \"desc\")] const a: bool = true;");
     assert doc.topmod.consts()[0].brief == some("desc");
     assert doc.topmod.consts()[0].desc == none;
 }
 
 #[test]
 fn should_promote_fn_desc() {
-    let source = "#[doc(desc = \"desc\")] fn a() { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc(desc = \"desc\")] fn a() { }");
     assert doc.topmod.fns()[0].brief == some("desc");
     assert doc.topmod.fns()[0].desc == none;
 }
 
 #[test]
 fn should_promote_enum_desc() {
-    let source = "#[doc(desc = \"desc\")] enum a { b }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc(desc = \"desc\")] enum a { b }");
     assert doc.topmod.enums()[0].brief == some("desc");
     assert doc.topmod.enums()[0].desc == none;
 }
 
 #[test]
 fn should_promote_resource_desc() {
-    let source = "#[doc(desc = \"desc\")] resource r(a: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc(
+        "#[doc(desc = \"desc\")] resource r(a: bool) { }");
     assert doc.topmod.resources()[0].brief == some("desc");
     assert doc.topmod.resources()[0].desc == none;
 }
 
 #[test]
 fn should_promote_iface_desc() {
-    let source = "#[doc(desc = \"desc\")] iface i { fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc(desc = \"desc\")] iface i { fn a(); }");
     assert doc.topmod.ifaces()[0].brief == some("desc");
     assert doc.topmod.ifaces()[0].desc == none;
 }
 
 #[test]
 fn should_promote_iface_method_desc() {
-    let source = "iface i { #[doc(desc = \"desc\")] fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("iface i { #[doc(desc = \"desc\")] fn a(); }");
     assert doc.topmod.ifaces()[0].methods[0].brief == some("desc");
     assert doc.topmod.ifaces()[0].methods[0].desc == none;
 }
 
+#[cfg(test)]
+mod test {
+    fn mk_doc(source: str) -> doc::cratedoc {
+        let srv = astsrv::mk_srv_from_str(source);
+        let doc = extract::from_srv(srv, "");
+        let doc = attr_pass::mk_pass()(srv, doc);
+        run(srv, doc)
+    }
+}
+
 fn modify(
     brief: option<str>,
     desc: option<str>
diff --git a/src/rustdoc/extract.rs b/src/rustdoc/extract.rs
index f350d830401..a36536fd3e8 100644
--- a/src/rustdoc/extract.rs
+++ b/src/rustdoc/extract.rs
@@ -145,9 +145,7 @@ fn constdoc_from_const(
 
 #[test]
 fn should_extract_const_name_and_id() {
-    let source = "const a: int = 0;";
-    let ast = parse::from_str(source);
-    let doc = extract(ast, "");
+    let doc = test::mk_doc("const a: int = 0;");
     assert doc.topmod.consts()[0].id != 0;
     assert doc.topmod.consts()[0].name == "a";
 }
@@ -182,18 +180,14 @@ fn variantdoc_from_variant(variant: ast::variant) -> doc::variantdoc {
 
 #[test]
 fn should_extract_enums() {
-    let source = "enum e { v }";
-    let ast = parse::from_str(source);
-    let doc = extract(ast, "");
+    let doc = test::mk_doc("enum e { v }");
     assert doc.topmod.enums()[0].id != 0;
     assert doc.topmod.enums()[0].name == "e";
 }
 
 #[test]
 fn should_extract_enum_variants() {
-    let source = "enum e { v }";
-    let ast = parse::from_str(source);
-    let doc = extract(ast, "");
+    let doc = test::mk_doc("enum e { v }");
     assert doc.topmod.enums()[0].variants[0].name == "v";
 }
 
@@ -214,18 +208,14 @@ fn resdoc_from_resource(
 
 #[test]
 fn should_extract_resources() {
-    let source = "resource r(b: bool) { }";
-    let ast = parse::from_str(source);
-    let doc = extract(ast, "");
+    let doc = test::mk_doc("resource r(b: bool) { }");
     assert doc.topmod.resources()[0].id != 0;
     assert doc.topmod.resources()[0].name == "r";
 }
 
 #[test]
 fn should_extract_resource_args() {
-    let source = "resource r(b: bool) { }";
-    let ast = parse::from_str(source);
-    let doc = extract(ast, "");
+    let doc = test::mk_doc("resource r(b: bool) { }");
     assert doc.topmod.resources()[0].args[0].name == "b";
 }
 
@@ -258,25 +248,19 @@ fn ifacedoc_from_iface(
 
 #[test]
 fn should_extract_ifaces() {
-    let source = "iface i { fn f(); }";
-    let ast = parse::from_str(source);
-    let doc = extract(ast, "");
+    let doc = test::mk_doc("iface i { fn f(); }");
     assert doc.topmod.ifaces()[0].name == "i";
 }
 
 #[test]
 fn should_extract_iface_methods() {
-    let source = "iface i { fn f(); }";
-    let ast = parse::from_str(source);
-    let doc = extract(ast, "");
+    let doc = test::mk_doc("iface i { fn f(); }");
     assert doc.topmod.ifaces()[0].methods[0].name == "f";
 }
 
 #[test]
 fn should_extract_iface_method_args() {
-    let source = "iface i { fn f(a: bool); }";
-    let ast = parse::from_str(source);
-    let doc = extract(ast, "");
+    let doc = test::mk_doc("iface i { fn f(a: bool); }");
     assert doc.topmod.ifaces()[0].methods[0].args[0].name == "a";
 }
 
@@ -311,53 +295,46 @@ fn impldoc_from_impl(
 
 #[test]
 fn should_extract_impls_with_names() {
-    let source = "impl i for int { fn a() { } }";
-    let ast = parse::from_str(source);
-    let doc = extract(ast, "");
+    let doc = test::mk_doc("impl i for int { fn a() { } }");
     assert doc.topmod.impls()[0].name == "i";
 }
 
 #[test]
 fn should_extract_impls_without_names() {
-    let source = "impl of i for int { fn a() { } }";
-    let ast = parse::from_str(source);
-    let doc = extract(ast, "");
+    let doc = test::mk_doc("impl of i for int { fn a() { } }");
     assert doc.topmod.impls()[0].name == "i";
 }
 
 #[test]
 fn should_extract_impl_methods() {
-    let source = "impl i for int { fn f() { } }";
-    let ast = parse::from_str(source);
-    let doc = extract(ast, "");
+    let doc = test::mk_doc("impl i for int { fn f() { } }");
     assert doc.topmod.impls()[0].methods[0].name == "f";
 }
 
 #[test]
 fn should_extract_impl_method_args() {
-    let source = "impl i for int { fn f(a: bool) { } }";
-    let ast = parse::from_str(source);
-    let doc = extract(ast, "");
+    let doc = test::mk_doc("impl i for int { fn f(a: bool) { } }");
     assert doc.topmod.impls()[0].methods[0].args[0].name == "a";
 }
 
 #[cfg(test)]
-mod tests {
+mod test {
+
+    fn mk_doc(source: str) -> doc::cratedoc {
+        let ast = parse::from_str(source);
+        extract(ast, "")
+    }
 
     #[test]
     fn extract_empty_crate() {
-        let source = ""; // empty crate
-        let ast = parse::from_str(source);
-        let doc = extract(ast, "");
+        let doc = mk_doc("");
         assert vec::is_empty(doc.topmod.mods());
         assert vec::is_empty(doc.topmod.fns());
     }
 
     #[test]
     fn extract_mods() {
-        let source = "mod a { mod b { } mod c { } }";
-        let ast = parse::from_str(source);
-        let doc = extract(ast, "");
+        let doc = mk_doc("mod a { mod b { } mod c { } }");
         assert doc.topmod.mods()[0].name == "a";
         assert doc.topmod.mods()[0].mods()[0].name == "b";
         assert doc.topmod.mods()[0].mods()[1].name == "c";
@@ -365,36 +342,28 @@ mod tests {
 
     #[test]
     fn extract_mods_deep() {
-        let source = "mod a { mod b { mod c { } } }";
-        let ast = parse::from_str(source);
-        let doc = extract(ast, "");
+        let doc = mk_doc("mod a { mod b { mod c { } } }");
         assert doc.topmod.mods()[0].mods()[0].mods()[0].name == "c";
     }
 
     #[test]
     fn extract_should_set_mod_ast_id() {
-        let source = "mod a { }";
-        let ast = parse::from_str(source);
-        let doc = extract(ast, "");
+        let doc = mk_doc("mod a { }");
         assert doc.topmod.mods()[0].id != 0;
     }
 
     #[test]
     fn extract_fns() {
-        let source =
+        let doc = mk_doc(
             "fn a() { } \
-             mod b { fn c() { } }";
-        let ast = parse::from_str(source);
-        let doc = extract(ast, "");
+             mod b { fn c() { } }");
         assert doc.topmod.fns()[0].name == "a";
         assert doc.topmod.mods()[0].fns()[0].name == "c";
     }
 
     #[test]
     fn extract_should_set_fn_ast_id() {
-        let source = "fn a() { }";
-        let ast = parse::from_str(source);
-        let doc = extract(ast, "");
+        let doc = mk_doc("fn a() { }");
         assert doc.topmod.fns()[0].id != 0;
     }
 
diff --git a/src/rustdoc/prune_undoc_pass.rs b/src/rustdoc/prune_undoc_pass.rs
index a68477058c1..c14eb2773bd 100644
--- a/src/rustdoc/prune_undoc_pass.rs
+++ b/src/rustdoc/prune_undoc_pass.rs
@@ -138,21 +138,13 @@ fn prune_return(doc: doc::retdoc) -> doc::retdoc {
 
 #[test]
 fn should_elide_undocumented_arguments() {
-    let source = "#[doc = \"hey\"] fn a(b: int) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc = \"hey\"] fn a(b: int) { }");
     assert vec::is_empty(doc.topmod.fns()[0].args);
 }
 
 #[test]
 fn should_not_elide_fns_with_documented_arguments() {
-    let source = "#[doc(args(a = \"b\"))] fn a(a: int) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc(args(a = \"b\"))] fn a(a: int) { }");
     assert vec::is_not_empty(doc.topmod.fns());
 }
 
@@ -169,49 +161,31 @@ fn should_elide_undocumented_return_values() {
 
 #[test]
 fn should_not_elide_fns_with_documented_failure_conditions() {
-    let source = "#[doc(failure = \"yup\")] fn a() { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc(failure = \"yup\")] fn a() { }");
     assert vec::is_not_empty(doc.topmod.fns());
 }
 
 #[test]
 fn should_elide_undocumented_mods() {
-    let source = "mod a { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("mod a { }");
     assert vec::is_empty(doc.topmod.mods());
 }
 
 #[test]
 fn should_not_elide_undocument_mods_with_documented_mods() {
-    let source = "mod a { #[doc = \"b\"] mod b { } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("mod a { #[doc = \"b\"] mod b { } }");
     assert vec::is_not_empty(doc.topmod.mods());
 }
 
 #[test]
 fn should_not_elide_undocument_mods_with_documented_fns() {
-    let source = "mod a { #[doc = \"b\"] fn b() { } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("mod a { #[doc = \"b\"] fn b() { } }");
     assert vec::is_not_empty(doc.topmod.mods());
 }
 
 #[test]
 fn should_elide_undocumented_fns() {
-    let source = "fn a() { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("fn a() { }");
     assert vec::is_empty(doc.topmod.fns());
 }
 
@@ -228,10 +202,7 @@ fn fold_const(
 
 #[test]
 fn should_elide_undocumented_consts() {
-    let source = "const a: bool = true;";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("const a: bool = true;");
     assert vec::is_empty(doc.topmod.consts());
 }
 
@@ -255,31 +226,19 @@ fn fold_enum(fold: fold::fold<ctxt>, doc: doc::enumdoc) -> doc::enumdoc {
 
 #[test]
 fn should_elide_undocumented_enums() {
-    let source = "enum a { b }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("enum a { b }");
     assert vec::is_empty(doc.topmod.enums());
 }
 
 #[test]
 fn should_elide_undocumented_variants() {
-    let source = "#[doc = \"a\"] enum a { b }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc = \"a\"] enum a { b }");
     assert vec::is_empty(doc.topmod.enums()[0].variants);
 }
 
 #[test]
 fn should_not_elide_enums_with_documented_variants() {
-    let source = "enum a { #[doc = \"a\"] b }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("enum a { #[doc = \"a\"] b }");
     assert vec::is_not_empty(doc.topmod.enums());
 }
 
@@ -303,32 +262,21 @@ fn fold_res(fold: fold::fold<ctxt>, doc: doc::resdoc) -> doc::resdoc {
 
 #[test]
 fn should_elide_undocumented_resources() {
-    let source = "resource r(a: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("resource r(a: bool) { }");
     assert vec::is_empty(doc.topmod.resources());
 }
 
 #[test]
 fn should_elide_undocumented_resource_args() {
-    let source = "#[doc = \"drunk\"]\
-                  resource r(a: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc = \"drunk\"]\
+                            resource r(a: bool) { }");
     assert vec::is_empty(doc.topmod.resources()[0].args);
 }
 
 #[test]
 fn should_not_elide_resources_with_documented_args() {
-    let source = "#[doc(args(a = \"drunk\"))]\
-                  resource r(a: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc(args(a = \"drunk\"))]\
+                            resource r(a: bool) { }");
     assert vec::is_not_empty(doc.topmod.resources());
 }
 
@@ -364,60 +312,46 @@ fn fold_iface(
 
 #[test]
 fn should_elide_undocumented_ifaces() {
-    let source = "iface i { fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("iface i { fn a(); }");
     assert vec::is_empty(doc.topmod.ifaces());
 }
 
 #[test]
 fn should_not_elide_documented_ifaces() {
-    let source = "#[doc = \"hey\"] iface i { fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc = \"hey\"] iface i { fn a(); }");
     assert vec::is_not_empty(doc.topmod.ifaces());
 }
 
 #[test]
 fn should_not_elide_ifaces_with_documented_methods() {
-    let source = "iface i { #[doc = \"hey\"] fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("iface i { #[doc = \"hey\"] fn a(); }");
     assert vec::is_not_empty(doc.topmod.ifaces());
 }
 
 #[test]
 fn should_not_elide_undocumented_methods() {
-    let source = "#[doc = \"hey\"] iface i { fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc = \"hey\"] iface i { fn a(); }");
     assert vec::is_not_empty(doc.topmod.ifaces()[0].methods);
 }
 
 #[test]
 fn should_elide_undocumented_method_args() {
-    let source = "#[doc = \"hey\"] iface i { fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc = \"hey\"] iface i { fn a(); }");
     assert vec::is_empty(doc.topmod.ifaces()[0].methods[0].args);
 }
 
 #[test]
 fn should_elide_undocumented_method_return_values() {
-    let source = "#[doc = \"hey\"] iface i { fn a() -> int; }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("#[doc = \"hey\"] iface i { fn a() -> int; }");
     assert doc.topmod.ifaces()[0].methods[0].return.ty == none;
-}
\ No newline at end of file
+}
+
+#[cfg(test)]
+mod test {
+    fn mk_doc(source: str) -> doc::cratedoc {
+        let srv = astsrv::mk_srv_from_str(source);
+        let doc = extract::from_srv(srv, "");
+        let doc = attr_pass::mk_pass()(srv, doc);
+        run(srv, doc)
+    }
+}
diff --git a/src/rustdoc/prune_unexported_pass.rs b/src/rustdoc/prune_unexported_pass.rs
index 096c259b713..94e7332e2cc 100644
--- a/src/rustdoc/prune_unexported_pass.rs
+++ b/src/rustdoc/prune_unexported_pass.rs
@@ -132,128 +132,99 @@ fn is_exported_from_crate(
 
 #[test]
 fn should_prune_unexported_fns() {
-    let source = "mod b { export a; fn a() { } fn b() { } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("mod b { export a; fn a() { } fn b() { } }");
     assert vec::len(doc.topmod.mods()[0].fns()) == 1u;
 }
 
 #[test]
 fn should_prune_unexported_fns_from_top_mod() {
-    let source = "export a; fn a() { } fn b() { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("export a; fn a() { } fn b() { }");
     assert vec::len(doc.topmod.fns()) == 1u;
 }
 
 #[test]
 fn should_prune_unexported_modules() {
-    let source = "mod a { export a; mod a { } mod b { } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("mod a { export a; mod a { } mod b { } }");
     assert vec::len(doc.topmod.mods()[0].mods()) == 1u;
 }
 
 #[test]
 fn should_prune_unexported_modules_from_top_mod() {
-    let source = "export a; mod a { } mod b { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("export a; mod a { } mod b { }");
     assert vec::len(doc.topmod.mods()) == 1u;
 }
 
 #[test]
 fn should_prune_unexported_consts() {
-    let source = "mod a { export a; \
-                  const a: bool = true; \
-                  const b: bool = true; }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc(
+        "mod a { export a; \
+         const a: bool = true; \
+         const b: bool = true; }");
     assert vec::len(doc.topmod.mods()[0].consts()) == 1u;
 }
 
 #[test]
 fn should_prune_unexported_consts_from_top_mod() {
-    let source = "export a; const a: bool = true; const b: bool = true;";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc(
+        "export a; const a: bool = true; const b: bool = true;");
     assert vec::len(doc.topmod.consts()) == 1u;
 }
 
 #[test]
 fn should_prune_unexported_enums_from_top_mod() {
-    let source = "export a; mod a { } enum b { c }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("export a; mod a { } enum b { c }");
     assert vec::len(doc.topmod.enums()) == 0u;
 }
 
 #[test]
 fn should_prune_unexported_enums() {
-    let source = "mod a { export a; mod a { } enum b { c } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("mod a { export a; mod a { } enum b { c } }");
     assert vec::len(doc.topmod.mods()[0].enums()) == 0u;
 }
 
 #[test]
 fn should_prune_unexported_variants_from_top_mod() {
-    let source = "export b::{}; enum b { c }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("export b::{}; enum b { c }");
     assert vec::len(doc.topmod.enums()[0].variants) == 0u;
 }
 
 #[test]
 fn should_prune_unexported_variants() {
-    let source = "mod a { export b::{}; enum b { c } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("mod a { export b::{}; enum b { c } }");
     assert vec::len(doc.topmod.mods()[0].enums()[0].variants) == 0u;
 }
 
 #[test]
 fn should_prune_unexported_resources_from_top_mod() {
-    let source = "export a; mod a { } resource r(a: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("export a; mod a { } resource r(a: bool) { }");
     assert vec::is_empty(doc.topmod.resources());
 }
 
 #[test]
 fn should_prune_unexported_resources() {
-    let source = "mod a { export a; mod a { } resource r(a: bool) { } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc(
+        "mod a { export a; mod a { } resource r(a: bool) { } }");
     assert vec::is_empty(doc.topmod.mods()[0].resources());
 }
 
 #[test]
 fn should_prune_unexported_ifaces_from_top_mod() {
-    let source = "export a; mod a { } iface b { fn c(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("export a; mod a { } iface b { fn c(); }");
     assert vec::is_empty(doc.topmod.ifaces());
 }
 
 #[test]
 fn should_prune_unexported_impls_from_top_mod() {
-    let source = "export a; mod a { } impl b for int { fn c() { } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc(
+        "export a; mod a { } impl b for int { fn c() { } }");
     assert vec::is_empty(doc.topmod.impls())
+}
+
+#[cfg(test)]
+mod test {
+    fn mk_doc(source: str) -> doc::cratedoc {
+        let srv = astsrv::mk_srv_from_str(source);
+        let doc = extract::from_srv(srv, "");
+        run(srv, doc)
+    }
 }
\ No newline at end of file
diff --git a/src/rustdoc/trim_pass.rs b/src/rustdoc/trim_pass.rs
index f315be73c59..bec08afdbd2 100644
--- a/src/rustdoc/trim_pass.rs
+++ b/src/rustdoc/trim_pass.rs
@@ -15,69 +15,55 @@ fn mk_pass() -> pass {
 
 #[test]
 fn should_trim_mod() {
-    let source = "#[doc(brief = \"\nbrief\n\", \
-                  desc = \"\ndesc\n\")] \
-                  mod m { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass()(srv, doc);
+    let doc = test::mk_doc("#[doc(brief = \"\nbrief\n\", \
+                            desc = \"\ndesc\n\")] \
+                            mod m { }");
     assert doc.topmod.mods()[0].brief == some("brief");
     assert doc.topmod.mods()[0].desc == some("desc");
 }
 
 #[test]
 fn should_trim_const() {
-    let source = "#[doc(brief = \"\nbrief\n\", \
-                  desc = \"\ndesc\n\")] \
-                  const a: bool = true;";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass()(srv, doc);
+    let doc = test::mk_doc("#[doc(brief = \"\nbrief\n\", \
+                            desc = \"\ndesc\n\")] \
+                            const a: bool = true;");
     assert doc.topmod.consts()[0].brief == some("brief");
     assert doc.topmod.consts()[0].desc == some("desc");
 }
 
 #[test]
 fn should_trim_fn() {
-    let source = "#[doc(brief = \"\nbrief\n\", \
-                  desc = \"\ndesc\n\")] \
-                  fn a() { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass()(srv, doc);
+    let doc = test::mk_doc("#[doc(brief = \"\nbrief\n\", \
+                            desc = \"\ndesc\n\")] \
+                            fn a() { }");
     assert doc.topmod.fns()[0].brief == some("brief");
     assert doc.topmod.fns()[0].desc == some("desc");
 }
 
 #[test]
 fn should_trim_args() {
-    let source = "#[doc(args(a = \"\na\n\"))] fn a(a: int) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass()(srv, doc);
+    let doc = test::mk_doc("#[doc(args(a = \"\na\n\"))] fn a(a: int) { }");
     assert doc.topmod.fns()[0].args[0].desc == some("a");
 }
 
 #[test]
 fn should_trim_ret() {
-    let source = "#[doc(return = \"\na\n\")] fn a() -> int { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass()(srv, doc);
+    let doc = test::mk_doc("#[doc(return = \"\na\n\")] fn a() -> int { }");
     assert doc.topmod.fns()[0].return.desc == some("a");
 }
 
 #[test]
 fn should_trim_failure_conditions() {
-    let source = "#[doc(failure = \"\na\n\")] fn a() -> int { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = attr_pass::mk_pass()(srv, doc);
-    let doc = mk_pass()(srv, doc);
+    let doc = test::mk_doc("#[doc(failure = \"\na\n\")] fn a() -> int { }");
     assert doc.topmod.fns()[0].failure == some("a");
 }
+
+#[cfg(test)]
+mod test {
+    fn mk_doc(source: str) -> doc::cratedoc {
+        let srv = astsrv::mk_srv_from_str(source);
+        let doc = extract::from_srv(srv, "");
+        let doc = attr_pass::mk_pass()(srv, doc);
+        mk_pass()(srv, doc)
+    }
+}
\ No newline at end of file
diff --git a/src/rustdoc/tystr_pass.rs b/src/rustdoc/tystr_pass.rs
index 94e07f07a73..604e411dde0 100644
--- a/src/rustdoc/tystr_pass.rs
+++ b/src/rustdoc/tystr_pass.rs
@@ -60,10 +60,7 @@ fn get_fn_sig(srv: astsrv::srv, fn_id: doc::ast_id) -> option<str> {
 
 #[test]
 fn should_add_fn_sig() {
-    let source = "fn a() -> int { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("fn a() -> int { }");
     assert doc.topmod.fns()[0].sig == some("fn a() -> int");
 }
 
@@ -107,19 +104,13 @@ fn ret_ty_to_str(decl: ast::fn_decl) -> option<str> {
 
 #[test]
 fn should_add_fn_ret_types() {
-    let source = "fn a() -> int { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("fn a() -> int { }");
     assert doc.topmod.fns()[0].return.ty == some("int");
 }
 
 #[test]
 fn should_not_add_nil_ret_type() {
-    let source = "fn a() { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("fn a() { }");
     assert doc.topmod.fns()[0].return.ty == none;
 }
 
@@ -165,10 +156,7 @@ fn decl_arg_tys(decl: ast::fn_decl) -> [(str, str)] {
 
 #[test]
 fn should_add_arg_types() {
-    let source = "fn a(b: int, c: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("fn a(b: int, c: bool) { }");
     let fn_ = doc.topmod.fns()[0];
     assert fn_.args[0].ty == some("int");
     assert fn_.args[1].ty == some("bool");
@@ -199,10 +187,7 @@ fn fold_const(
 
 #[test]
 fn should_add_const_types() {
-    let source = "const a: bool = true;";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("const a: bool = true;");
     assert doc.topmod.consts()[0].ty == some("bool");
 }
 
@@ -241,10 +226,7 @@ fn fold_enum(
 
 #[test]
 fn should_add_variant_sigs() {
-    let source = "enum a { b(int) }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("enum a { b(int) }");
     assert doc.topmod.enums()[0].variants[0].sig == some("b(int)");
 }
 
@@ -272,19 +254,13 @@ fn fold_res(
 
 #[test]
 fn should_add_resource_sigs() {
-    let source = "resource r(b: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("resource r(b: bool) { }");
     assert doc.topmod.resources()[0].sig == some("resource r(b: bool)");
 }
 
 #[test]
 fn should_add_resource_arg_tys() {
-    let source = "resource r(a: bool) { }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("resource r(a: bool) { }");
     assert doc.topmod.resources()[0].args[0].ty == some("bool");
 }
 
@@ -464,37 +440,25 @@ fn get_method_arg_tys(
 
 #[test]
 fn should_add_iface_method_sigs() {
-    let source = "iface i { fn a() -> int; }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("iface i { fn a() -> int; }");
     assert doc.topmod.ifaces()[0].methods[0].sig == some("fn a() -> int");
 }
 
 #[test]
 fn should_add_iface_method_ret_types() {
-    let source = "iface i { fn a() -> int; }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("iface i { fn a() -> int; }");
     assert doc.topmod.ifaces()[0].methods[0].return.ty == some("int");
 }
 
 #[test]
 fn should_not_add_iface_method_nil_ret_type() {
-    let source = "iface i { fn a(); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("iface i { fn a(); }");
     assert doc.topmod.ifaces()[0].methods[0].return.ty == none;
 }
 
 #[test]
 fn should_add_iface_method_arg_types() {
-    let source = "iface i { fn a(b: int, c: bool); }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("iface i { fn a(b: int, c: bool); }");
     let fn_ = doc.topmod.ifaces()[0].methods[0];
     assert fn_.args[0].ty == some("int");
     assert fn_.args[1].ty == some("bool");
@@ -531,65 +495,53 @@ fn fold_impl(
 
 #[test]
 fn should_add_impl_iface_ty() {
-    let source = "impl i of j for int { fn a() { } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("impl i of j for int { fn a() { } }");
     assert doc.topmod.impls()[0].iface_ty == some("j");
 }
 
 #[test]
 fn should_not_add_impl_iface_ty_if_none() {
-    let source = "impl i for int { fn a() { } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("impl i for int { fn a() { } }");
     assert doc.topmod.impls()[0].iface_ty == none;
 }
 
 #[test]
 fn should_add_impl_self_ty() {
-    let source = "impl i for int { fn a() { } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("impl i for int { fn a() { } }");
     assert doc.topmod.impls()[0].self_ty == some("int");
 }
 
 #[test]
 fn should_add_impl_method_sigs() {
-    let source = "impl i for int { fn a() -> int { fail } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("impl i for int { fn a() -> int { fail } }");
     assert doc.topmod.impls()[0].methods[0].sig == some("fn a() -> int");
 }
 
 #[test]
 fn should_add_impl_method_ret_types() {
-    let source = "impl i for int { fn a() -> int { fail } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("impl i for int { fn a() -> int { fail } }");
     assert doc.topmod.impls()[0].methods[0].return.ty == some("int");
 }
 
 #[test]
 fn should_not_add_impl_method_nil_ret_type() {
-    let source = "impl i for int { fn a() { } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("impl i for int { fn a() { } }");
     assert doc.topmod.impls()[0].methods[0].return.ty == none;
 }
 
 #[test]
 fn should_add_impl_method_arg_types() {
-    let source = "impl i for int { fn a(b: int, c: bool) { } }";
-    let srv = astsrv::mk_srv_from_str(source);
-    let doc = extract::from_srv(srv, "");
-    let doc = run(srv, doc);
+    let doc = test::mk_doc("impl i for int { fn a(b: int, c: bool) { } }");
     let fn_ = doc.topmod.impls()[0].methods[0];
     assert fn_.args[0].ty == some("int");
     assert fn_.args[1].ty == some("bool");
 }
+
+#[cfg(test)]
+mod test {
+    fn mk_doc(source: str) -> doc::cratedoc {
+        let srv = astsrv::mk_srv_from_str(source);
+        let doc = extract::from_srv(srv, "");
+        run(srv, doc)
+    }
+}
\ No newline at end of file