diff --git a/Cargo.lock b/Cargo.lock
index 558e041..0520efa 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -70,11 +70,7 @@ name = "exile"
 version = "0.0.2"
 dependencies = [
  "cargo-readme",
- "lazy_static",
- "serde_json",
- "serde_plain",
  "xdoc",
- "xtest",
 ]
 
 [[package]]
diff --git a/exile/Cargo.toml b/exile/Cargo.toml
index 4a15455..13db32d 100644
--- a/exile/Cargo.toml
+++ b/exile/Cargo.toml
@@ -14,11 +14,4 @@ readme = "README.md"
 xdoc = { path = "../xdoc", version = "0.0.2" }
 
 [build-dependencies]
-cargo-readme = "3.2.0"
-xtest = { path = "../xtest", version = "0.0.2" }
-
-[dev-dependencies]
-lazy_static = "1.4.0"
-serde_json = "1.0.48"
-serde_plain = "0.3.0"
-xtest = { path = "../xtest", version = "0.0.2" }
\ No newline at end of file
+cargo-readme = "3.2.0"
\ No newline at end of file
diff --git a/exile/build.rs b/exile/build.rs
index f0ab289..777972c 100644
--- a/exile/build.rs
+++ b/exile/build.rs
@@ -3,12 +3,10 @@
 use std::env;
 use std::fs::File;
 use std::io::Write;
-use std::path::{Path, PathBuf};
+use std::path::PathBuf;
 
 fn main() {
-    sir_watch_alot();
     generate_readme();
-    generate_tests();
 }
 
 fn generate_readme() {
@@ -41,84 +39,3 @@ fn generate_readme() {
         std::fs::copy(&this_readme_path, &top_readme_path).unwrap();
     }
 }
-
-fn generate_tests() {
-    // Check for environment variable "SKIP_TEST_GENERATION". If it is set, skip test generation.
-    if env::var_os("EXILE_GENERATE_TESTS").is_none() {
-        println!("skipping test generation...");
-        return;
-    }
-    println!("generating tests...");
-    let test_file_path = integ_test_dir().join("parse_tests.rs");
-    xtest::gen::generate_tests(test_file_path);
-}
-
-fn integ_test_dir() -> PathBuf {
-    let mycrate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    mycrate_dir.join("tests")
-}
-
-fn xtest_test_dir() -> PathBuf {
-    let mut mycrate_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    mycrate_dir.pop();
-    mycrate_dir.join("xtest")
-}
-
-fn exile_dir() -> PathBuf {
-    PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-}
-
-// path walking helpers for watching files
-
-fn list_dir(p: &Path) -> Vec<String> {
-    if !p.is_dir() {
-        panic!("{} is not a dir", p.display());
-    }
-    let mut vec = Vec::new();
-    let paths = std::fs::read_dir(p).unwrap();
-    for path in paths {
-        vec.append(&mut list_files_recursively(&path.unwrap().path()));
-    }
-    vec
-}
-
-fn list_files_recursively(p: &Path) -> Vec<String> {
-    let mut vec = Vec::new();
-    if p.is_file() {
-        if let Some(ext) = p.extension() {
-            let ext = ext.to_str().unwrap();
-            if ext == "rs" || ext == "json" || ext == "xml" {
-                vec.push(p.canonicalize().unwrap().to_str().unwrap().to_owned());
-            }
-        }
-    } else if p.is_dir() {
-        vec.append(&mut list_dir(p));
-    } else {
-        panic!("unknown path type {}", p.display());
-    }
-    vec
-}
-
-fn lib_rs() -> PathBuf {
-    exile_dir().join("src").join("lib.rs")
-}
-
-fn readme_template() -> PathBuf {
-    exile_dir().join("readme.template")
-}
-
-fn sir_watch_alot() {
-    let tests = xtest_test_dir();
-    if !tests.is_dir() {
-        // The tests aren't there, so there's nothing to watch, or to do.
-        return;
-    }
-    let mut vec = list_files_recursively(&tests);
-    vec.push(lib_rs().to_str().unwrap().to_owned());
-    vec.push(readme_template().to_str().unwrap().to_owned());
-    for file in &vec {
-        println!("cargo:rerun-if-changed={}", file);
-    }
-    println!("cargo:rerun-if-env-changed=EXILE_GENERATE_TESTS");
-    println!("cargo:rerun-if-env-changed=EXILE_GENERATE_README");
-}
diff --git a/exile/tests/generated/exile_angle_in_attribute_value.rs b/exile/tests/generated/exile_angle_in_attribute_value.rs
new file mode 100644
index 0000000..3f0b374
--- /dev/null
+++ b/exile/tests/generated/exile_angle_in_attribute_value.rs
@@ -0,0 +1,32 @@
+// generated file, do not edit
+
+use std::path::PathBuf;
+
+const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
+const INPUT_DATA: &str = "input_data";
+const INPUT_FILE: &str = "exile_angle_in_attribute_value.xml";
+
+fn path(filename: &str) -> PathBuf {
+    let p = PathBuf::from(MANIFEST_DIR)
+        .join("tests")
+        .join(INPUT_DATA)
+        .join(filename);
+    p.canonicalize()
+        .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
+}
+
+#[test]
+/// unescaped angle bracket in an attribute value
+fn angle_in_attribute_value_test() {
+    let result = exile::load(path(INPUT_FILE));
+    assert!(result.is_err());
+    let e = result.err().unwrap();
+    match e {
+        exile::error::Error::Parse(parse_error) => {
+            assert_eq!(51, parse_error.xml_site.position);
+            assert_eq!(2, parse_error.xml_site.line);
+            assert_eq!(12, parse_error.xml_site.column);
+        }
+        _ => panic!("expected parse error."),
+    }
+}
diff --git a/exile/tests/generated/exile_cd_catalog.rs b/exile/tests/generated/exile_cd_catalog.rs
index 74f88e8..fc7a775 100644
--- a/exile/tests/generated/exile_cd_catalog.rs
+++ b/exile/tests/generated/exile_cd_catalog.rs
@@ -8,33 +8,44 @@ use xdoc::Version;
 
 const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const INPUT_DATA: &str = "input_data";
-const FILENAME: &str = "exile_cd_catalog.xml";
+const INPUT_FILE: &str = "exile_cd_catalog.xml";
+const OUTPUT_FILE: &str = "exile_cd_catalog.output.xml";
 
-fn path() -> PathBuf {
+fn path(filename: &str) -> PathBuf {
     let p = PathBuf::from(MANIFEST_DIR)
         .join("tests")
         .join(INPUT_DATA)
-        .join(FILENAME);
+        .join(filename);
     p.canonicalize()
         .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
 }
 
 #[test]
-fn cd_catalog() {
-    let path = path();
-    let loaded = exile::load(&path).unwrap();
+/// cd_catalog example from https://www.w3schools.com/xml/xml_examples.asp
+fn cd_catalog_parse() {
+    let path = path(INPUT_FILE);
+    let actual = exile::load(&path).unwrap();
     let expected = expected();
-    if loaded != expected {
-        let loaded_str = loaded.to_string();
+    if actual != expected {
+        let actual_str = actual.to_string();
         let expected_str = expected.to_string();
-        if loaded_str != expected_str {
-            assert_eq!(loaded_str, expected_str);
+        if actual_str != expected_str {
+            assert_eq!(expected_str, actual_str);
         } else {
-            assert_eq!(loaded, expected);
+            assert_eq!(expected, actual);
         }
     }
 }
 
+#[test]
+/// Check that the serialization of this XML document matches what we expect.
+fn cd_catalog_serialize() {
+    let doc = expected();
+    let actual = doc.to_string();
+    let expected = std::fs::read_to_string(path(OUTPUT_FILE)).unwrap();
+    assert_eq!(expected, actual);
+}
+
 fn expected() -> Document {
     let mut doc = Document::new();
     doc.set_declaration(Declaration {
diff --git a/exile/tests/generated/exile_doctypes_comments_pis.rs b/exile/tests/generated/exile_doctypes_comments_pis.rs
index 3303547..3097ee0 100644
--- a/exile/tests/generated/exile_doctypes_comments_pis.rs
+++ b/exile/tests/generated/exile_doctypes_comments_pis.rs
@@ -7,29 +7,30 @@ use xdoc::Version;
 
 const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const INPUT_DATA: &str = "input_data";
-const FILENAME: &str = "exile_doctypes_comments_pis.xml";
+const INPUT_FILE: &str = "exile_doctypes_comments_pis.xml";
 
-fn path() -> PathBuf {
+fn path(filename: &str) -> PathBuf {
     let p = PathBuf::from(MANIFEST_DIR)
         .join("tests")
         .join(INPUT_DATA)
-        .join(FILENAME);
+        .join(filename);
     p.canonicalize()
         .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
 }
 
 #[test]
-fn doctypes_comments_pis() {
-    let path = path();
-    let loaded = exile::load(&path).unwrap();
+/// a file with doctypes, processing instructions and comments
+fn doctypes_comments_pis_parse() {
+    let path = path(INPUT_FILE);
+    let actual = exile::load(&path).unwrap();
     let expected = expected();
-    if loaded != expected {
-        let loaded_str = loaded.to_string();
+    if actual != expected {
+        let actual_str = actual.to_string();
         let expected_str = expected.to_string();
-        if loaded_str != expected_str {
-            assert_eq!(loaded_str, expected_str);
+        if actual_str != expected_str {
+            assert_eq!(expected_str, actual_str);
         } else {
-            assert_eq!(loaded, expected);
+            assert_eq!(expected, actual);
         }
     }
 }
diff --git a/exile/tests/generated/exile_escapes.rs b/exile/tests/generated/exile_escapes.rs
index 8a401b2..3de8c5a 100644
--- a/exile/tests/generated/exile_escapes.rs
+++ b/exile/tests/generated/exile_escapes.rs
@@ -7,33 +7,44 @@ use xdoc::Version;
 
 const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const INPUT_DATA: &str = "input_data";
-const FILENAME: &str = "exile_escapes.xml";
+const INPUT_FILE: &str = "exile_escapes.xml";
+const OUTPUT_FILE: &str = "exile_escapes.output.xml";
 
-fn path() -> PathBuf {
+fn path(filename: &str) -> PathBuf {
     let p = PathBuf::from(MANIFEST_DIR)
         .join("tests")
         .join(INPUT_DATA)
-        .join(FILENAME);
+        .join(filename);
     p.canonicalize()
         .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
 }
 
 #[test]
-fn escapes() {
-    let path = path();
-    let loaded = exile::load(&path).unwrap();
+/// escape sequences
+fn escapes_parse() {
+    let path = path(INPUT_FILE);
+    let actual = exile::load(&path).unwrap();
     let expected = expected();
-    if loaded != expected {
-        let loaded_str = loaded.to_string();
+    if actual != expected {
+        let actual_str = actual.to_string();
         let expected_str = expected.to_string();
-        if loaded_str != expected_str {
-            assert_eq!(loaded_str, expected_str);
+        if actual_str != expected_str {
+            assert_eq!(expected_str, actual_str);
         } else {
-            assert_eq!(loaded, expected);
+            assert_eq!(expected, actual);
         }
     }
 }
 
+#[test]
+/// Check that the serialization of this XML document matches what we expect.
+fn escapes_serialize() {
+    let doc = expected();
+    let actual = doc.to_string();
+    let expected = std::fs::read_to_string(path(OUTPUT_FILE)).unwrap();
+    assert_eq!(expected, actual);
+}
+
 fn expected() -> Document {
     let mut doc = Document::new();
     doc.set_declaration(Declaration {
diff --git a/exile/tests/generated/exile_e_file.rs b/exile/tests/generated/exile_ezfile.rs
similarity index 58%
rename from exile/tests/generated/exile_e_file.rs
rename to exile/tests/generated/exile_ezfile.rs
index f71c61e..666746e 100644
--- a/exile/tests/generated/exile_e_file.rs
+++ b/exile/tests/generated/exile_ezfile.rs
@@ -8,33 +8,44 @@ use xdoc::Version;
 
 const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const INPUT_DATA: &str = "input_data";
-const FILENAME: &str = "exile_e_file.xml";
+const INPUT_FILE: &str = "exile_ezfile.xml";
+const OUTPUT_FILE: &str = "exile_ezfile.output.xml";
 
-fn path() -> PathBuf {
+fn path(filename: &str) -> PathBuf {
     let p = PathBuf::from(MANIFEST_DIR)
         .join("tests")
         .join(INPUT_DATA)
-        .join(FILENAME);
+        .join(filename);
     p.canonicalize()
         .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
 }
 
 #[test]
-fn e_file() {
-    let path = path();
-    let loaded = exile::load(&path).unwrap();
+/// a simple, small, well-formed xml file
+fn ezfile_parse() {
+    let path = path(INPUT_FILE);
+    let actual = exile::load(&path).unwrap();
     let expected = expected();
-    if loaded != expected {
-        let loaded_str = loaded.to_string();
+    if actual != expected {
+        let actual_str = actual.to_string();
         let expected_str = expected.to_string();
-        if loaded_str != expected_str {
-            assert_eq!(loaded_str, expected_str);
+        if actual_str != expected_str {
+            assert_eq!(expected_str, actual_str);
         } else {
-            assert_eq!(loaded, expected);
+            assert_eq!(expected, actual);
         }
     }
 }
 
+#[test]
+/// Check that the serialization of this XML document matches what we expect.
+fn ezfile_serialize() {
+    let doc = expected();
+    let actual = doc.to_string();
+    let expected = std::fs::read_to_string(path(OUTPUT_FILE)).unwrap();
+    assert_eq!(expected, actual);
+}
+
 fn expected() -> Document {
     let mut doc = Document::new();
     doc.set_declaration(Declaration {
diff --git a/exile/tests/generated/exile_pi.rs b/exile/tests/generated/exile_pi.rs
index f203252..12cb557 100644
--- a/exile/tests/generated/exile_pi.rs
+++ b/exile/tests/generated/exile_pi.rs
@@ -8,29 +8,30 @@ use xdoc::Version;
 
 const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const INPUT_DATA: &str = "input_data";
-const FILENAME: &str = "exile_pi.xml";
+const INPUT_FILE: &str = "exile_pi.xml";
 
-fn path() -> PathBuf {
+fn path(filename: &str) -> PathBuf {
     let p = PathBuf::from(MANIFEST_DIR)
         .join("tests")
         .join(INPUT_DATA)
-        .join(FILENAME);
+        .join(filename);
     p.canonicalize()
         .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
 }
 
 #[test]
-fn pi() {
-    let path = path();
-    let loaded = exile::load(&path).unwrap();
+/// a simple file with processing instructions
+fn pi_parse() {
+    let path = path(INPUT_FILE);
+    let actual = exile::load(&path).unwrap();
     let expected = expected();
-    if loaded != expected {
-        let loaded_str = loaded.to_string();
+    if actual != expected {
+        let actual_str = actual.to_string();
         let expected_str = expected.to_string();
-        if loaded_str != expected_str {
-            assert_eq!(loaded_str, expected_str);
+        if actual_str != expected_str {
+            assert_eq!(expected_str, actual_str);
         } else {
-            assert_eq!(loaded, expected);
+            assert_eq!(expected, actual);
         }
     }
 }
diff --git a/exile/tests/generated/exile_simple_musicxml.rs b/exile/tests/generated/exile_simple_musicxml.rs
index 3e26e47..c2edff7 100644
--- a/exile/tests/generated/exile_simple_musicxml.rs
+++ b/exile/tests/generated/exile_simple_musicxml.rs
@@ -8,33 +8,44 @@ use xdoc::Version;
 
 const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const INPUT_DATA: &str = "input_data";
-const FILENAME: &str = "exile_simple_musicxml.xml";
+const INPUT_FILE: &str = "exile_simple_musicxml.xml";
+const OUTPUT_FILE: &str = "exile_simple_musicxml.output.xml";
 
-fn path() -> PathBuf {
+fn path(filename: &str) -> PathBuf {
     let p = PathBuf::from(MANIFEST_DIR)
         .join("tests")
         .join(INPUT_DATA)
-        .join(FILENAME);
+        .join(filename);
     p.canonicalize()
         .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
 }
 
 #[test]
-fn simple_musicxml() {
-    let path = path();
-    let loaded = exile::load(&path).unwrap();
+/// cd_catalog example from https://www.w3schools.com/xml/xml_examples.asp
+fn simple_musicxml_parse() {
+    let path = path(INPUT_FILE);
+    let actual = exile::load(&path).unwrap();
     let expected = expected();
-    if loaded != expected {
-        let loaded_str = loaded.to_string();
+    if actual != expected {
+        let actual_str = actual.to_string();
         let expected_str = expected.to_string();
-        if loaded_str != expected_str {
-            assert_eq!(loaded_str, expected_str);
+        if actual_str != expected_str {
+            assert_eq!(expected_str, actual_str);
         } else {
-            assert_eq!(loaded, expected);
+            assert_eq!(expected, actual);
         }
     }
 }
 
+#[test]
+/// Check that the serialization of this XML document matches what we expect.
+fn simple_musicxml_serialize() {
+    let doc = expected();
+    let actual = doc.to_string();
+    let expected = std::fs::read_to_string(path(OUTPUT_FILE)).unwrap();
+    assert_eq!(expected, actual);
+}
+
 fn expected() -> Document {
     let mut doc = Document::new();
     doc.set_declaration(Declaration {
diff --git a/exile/tests/generated/exile_single_quotes.rs b/exile/tests/generated/exile_single_quotes.rs
index b907b6f..4cc2101 100644
--- a/exile/tests/generated/exile_single_quotes.rs
+++ b/exile/tests/generated/exile_single_quotes.rs
@@ -8,29 +8,30 @@ use xdoc::Version;
 
 const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const INPUT_DATA: &str = "input_data";
-const FILENAME: &str = "exile_single_quotes.xml";
+const INPUT_FILE: &str = "exile_single_quotes.xml";
 
-fn path() -> PathBuf {
+fn path(filename: &str) -> PathBuf {
     let p = PathBuf::from(MANIFEST_DIR)
         .join("tests")
         .join(INPUT_DATA)
-        .join(FILENAME);
+        .join(filename);
     p.canonicalize()
         .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
 }
 
 #[test]
-fn single_quotes() {
-    let path = path();
-    let loaded = exile::load(&path).unwrap();
+/// a simple file with single-quoted attributes
+fn single_quotes_parse() {
+    let path = path(INPUT_FILE);
+    let actual = exile::load(&path).unwrap();
     let expected = expected();
-    if loaded != expected {
-        let loaded_str = loaded.to_string();
+    if actual != expected {
+        let actual_str = actual.to_string();
         let expected_str = expected.to_string();
-        if loaded_str != expected_str {
-            assert_eq!(loaded_str, expected_str);
+        if actual_str != expected_str {
+            assert_eq!(expected_str, actual_str);
         } else {
-            assert_eq!(loaded, expected);
+            assert_eq!(expected, actual);
         }
     }
 }
diff --git a/exile/tests/generated/exile_unescaped_angle.rs b/exile/tests/generated/exile_unescaped_angle.rs
new file mode 100644
index 0000000..5e01c3b
--- /dev/null
+++ b/exile/tests/generated/exile_unescaped_angle.rs
@@ -0,0 +1,32 @@
+// generated file, do not edit
+
+use std::path::PathBuf;
+
+const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
+const INPUT_DATA: &str = "input_data";
+const INPUT_FILE: &str = "exile_unescaped_angle.xml";
+
+fn path(filename: &str) -> PathBuf {
+    let p = PathBuf::from(MANIFEST_DIR)
+        .join("tests")
+        .join(INPUT_DATA)
+        .join(filename);
+    p.canonicalize()
+        .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
+}
+
+#[test]
+/// unescaped angle bracket inside element text
+fn unescaped_angle_test() {
+    let result = exile::load(path(INPUT_FILE));
+    assert!(result.is_err());
+    let e = result.err().unwrap();
+    match e {
+        exile::error::Error::Parse(parse_error) => {
+            assert_eq!(95, parse_error.xml_site.position);
+            assert_eq!(4, parse_error.xml_site.line);
+            assert_eq!(39, parse_error.xml_site.column);
+        }
+        _ => panic!("expected parse error."),
+    }
+}
diff --git a/exile/tests/generated/jclark_not_wf_sa_001.rs b/exile/tests/generated/jclark_not_wf_sa_001.rs
new file mode 100644
index 0000000..1d0a0ac
--- /dev/null
+++ b/exile/tests/generated/jclark_not_wf_sa_001.rs
@@ -0,0 +1,28 @@
+// generated file, do not edit
+
+use std::path::PathBuf;
+
+const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
+const INPUT_DATA: &str = "input_data";
+const INPUT_FILE: &str = "jclark_not_wf_sa_001.xml";
+
+fn path(filename: &str) -> PathBuf {
+    let p = PathBuf::from(MANIFEST_DIR)
+        .join("tests")
+        .join(INPUT_DATA)
+        .join(filename);
+    p.canonicalize()
+        .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
+}
+
+#[test]
+/// A not-well-formed test file from the W3C conformance test suite: not-wf-sa-001
+fn not_wf_sa_001_test() {
+    let result = exile::load(path(INPUT_FILE));
+    assert!(result.is_err());
+    let e = result.err().unwrap();
+    match e {
+        exile::error::Error::Parse(_) => {}
+        _ => panic!("expected parse error."),
+    }
+}
diff --git a/exile/tests/generated/jclark_not_wf_sa_002.rs b/exile/tests/generated/jclark_not_wf_sa_002.rs
new file mode 100644
index 0000000..3110f94
--- /dev/null
+++ b/exile/tests/generated/jclark_not_wf_sa_002.rs
@@ -0,0 +1,28 @@
+// generated file, do not edit
+
+use std::path::PathBuf;
+
+const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
+const INPUT_DATA: &str = "input_data";
+const INPUT_FILE: &str = "jclark_not_wf_sa_002.xml";
+
+fn path(filename: &str) -> PathBuf {
+    let p = PathBuf::from(MANIFEST_DIR)
+        .join("tests")
+        .join(INPUT_DATA)
+        .join(filename);
+    p.canonicalize()
+        .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
+}
+
+#[test]
+/// A not-well-formed test file from the W3C conformance test suite: not-wf-sa-002
+fn not_wf_sa_002_test() {
+    let result = exile::load(path(INPUT_FILE));
+    assert!(result.is_err());
+    let e = result.err().unwrap();
+    match e {
+        exile::error::Error::Parse(_) => {}
+        _ => panic!("expected parse error."),
+    }
+}
diff --git a/exile/tests/generated/jclark_not_wf_sa_003.rs b/exile/tests/generated/jclark_not_wf_sa_003.rs
new file mode 100644
index 0000000..4eaead6
--- /dev/null
+++ b/exile/tests/generated/jclark_not_wf_sa_003.rs
@@ -0,0 +1,28 @@
+// generated file, do not edit
+
+use std::path::PathBuf;
+
+const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
+const INPUT_DATA: &str = "input_data";
+const INPUT_FILE: &str = "jclark_not_wf_sa_003.xml";
+
+fn path(filename: &str) -> PathBuf {
+    let p = PathBuf::from(MANIFEST_DIR)
+        .join("tests")
+        .join(INPUT_DATA)
+        .join(filename);
+    p.canonicalize()
+        .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
+}
+
+#[test]
+/// A not-well-formed test file from the W3C conformance test suite: not-wf-sa-003
+fn not_wf_sa_003_test() {
+    let result = exile::load(path(INPUT_FILE));
+    assert!(result.is_err());
+    let e = result.err().unwrap();
+    match e {
+        exile::error::Error::Parse(_) => {}
+        _ => panic!("expected parse error."),
+    }
+}
diff --git a/exile/tests/generated/jclark_not_wf_sa_004.rs b/exile/tests/generated/jclark_not_wf_sa_004.rs
new file mode 100644
index 0000000..e05fbce
--- /dev/null
+++ b/exile/tests/generated/jclark_not_wf_sa_004.rs
@@ -0,0 +1,28 @@
+// generated file, do not edit
+
+use std::path::PathBuf;
+
+const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
+const INPUT_DATA: &str = "input_data";
+const INPUT_FILE: &str = "jclark_not_wf_sa_004.xml";
+
+fn path(filename: &str) -> PathBuf {
+    let p = PathBuf::from(MANIFEST_DIR)
+        .join("tests")
+        .join(INPUT_DATA)
+        .join(filename);
+    p.canonicalize()
+        .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
+}
+
+#[test]
+/// A not-well-formed test file from the W3C conformance test suite: not-wf-sa-004
+fn not_wf_sa_004_test() {
+    let result = exile::load(path(INPUT_FILE));
+    assert!(result.is_err());
+    let e = result.err().unwrap();
+    match e {
+        exile::error::Error::Parse(_) => {}
+        _ => panic!("expected parse error."),
+    }
+}
diff --git a/exile/tests/generated/jclark_not_wf_sa_005.rs b/exile/tests/generated/jclark_not_wf_sa_005.rs
new file mode 100644
index 0000000..4318b76
--- /dev/null
+++ b/exile/tests/generated/jclark_not_wf_sa_005.rs
@@ -0,0 +1,28 @@
+// generated file, do not edit
+
+use std::path::PathBuf;
+
+const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
+const INPUT_DATA: &str = "input_data";
+const INPUT_FILE: &str = "jclark_not_wf_sa_005.xml";
+
+fn path(filename: &str) -> PathBuf {
+    let p = PathBuf::from(MANIFEST_DIR)
+        .join("tests")
+        .join(INPUT_DATA)
+        .join(filename);
+    p.canonicalize()
+        .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
+}
+
+#[test]
+/// A not-well-formed test file from the W3C conformance test suite: not-wf-sa-005
+fn not_wf_sa_005_test() {
+    let result = exile::load(path(INPUT_FILE));
+    assert!(result.is_err());
+    let e = result.err().unwrap();
+    match e {
+        exile::error::Error::Parse(_) => {}
+        _ => panic!("expected parse error."),
+    }
+}
diff --git a/exile/tests/generated/jclark_valid_sa_001.rs b/exile/tests/generated/jclark_valid_sa_001.rs
index 9ac0338..75de259 100644
--- a/exile/tests/generated/jclark_valid_sa_001.rs
+++ b/exile/tests/generated/jclark_valid_sa_001.rs
@@ -6,29 +6,30 @@ use xdoc::Declaration;
 
 const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const INPUT_DATA: &str = "input_data";
-const FILENAME: &str = "jclark_valid_sa_001.xml";
+const INPUT_FILE: &str = "jclark_valid_sa_001.xml";
 
-fn path() -> PathBuf {
+fn path(filename: &str) -> PathBuf {
     let p = PathBuf::from(MANIFEST_DIR)
         .join("tests")
         .join(INPUT_DATA)
-        .join(FILENAME);
+        .join(filename);
     p.canonicalize()
         .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
 }
 
 #[test]
-fn valid_sa_001() {
-    let path = path();
-    let loaded = exile::load(&path).unwrap();
+/// A valid XML file from the W3C conformance test suite: valid-sa-001
+fn valid_sa_001_parse() {
+    let path = path(INPUT_FILE);
+    let actual = exile::load(&path).unwrap();
     let expected = expected();
-    if loaded != expected {
-        let loaded_str = loaded.to_string();
+    if actual != expected {
+        let actual_str = actual.to_string();
         let expected_str = expected.to_string();
-        if loaded_str != expected_str {
-            assert_eq!(loaded_str, expected_str);
+        if actual_str != expected_str {
+            assert_eq!(expected_str, actual_str);
         } else {
-            assert_eq!(loaded, expected);
+            assert_eq!(expected, actual);
         }
     }
 }
diff --git a/exile/tests/generated/jclark_valid_sa_002.rs b/exile/tests/generated/jclark_valid_sa_002.rs
index 50c4145..ebc4b52 100644
--- a/exile/tests/generated/jclark_valid_sa_002.rs
+++ b/exile/tests/generated/jclark_valid_sa_002.rs
@@ -6,29 +6,30 @@ use xdoc::Declaration;
 
 const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const INPUT_DATA: &str = "input_data";
-const FILENAME: &str = "jclark_valid_sa_002.xml";
+const INPUT_FILE: &str = "jclark_valid_sa_002.xml";
 
-fn path() -> PathBuf {
+fn path(filename: &str) -> PathBuf {
     let p = PathBuf::from(MANIFEST_DIR)
         .join("tests")
         .join(INPUT_DATA)
-        .join(FILENAME);
+        .join(filename);
     p.canonicalize()
         .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
 }
 
 #[test]
-fn valid_sa_002() {
-    let path = path();
-    let loaded = exile::load(&path).unwrap();
+/// A valid XML file from the W3C conformance test suite: valid-sa-002
+fn valid_sa_002_parse() {
+    let path = path(INPUT_FILE);
+    let actual = exile::load(&path).unwrap();
     let expected = expected();
-    if loaded != expected {
-        let loaded_str = loaded.to_string();
+    if actual != expected {
+        let actual_str = actual.to_string();
         let expected_str = expected.to_string();
-        if loaded_str != expected_str {
-            assert_eq!(loaded_str, expected_str);
+        if actual_str != expected_str {
+            assert_eq!(expected_str, actual_str);
         } else {
-            assert_eq!(loaded, expected);
+            assert_eq!(expected, actual);
         }
     }
 }
diff --git a/exile/tests/generated/jclark_valid_sa_003.rs b/exile/tests/generated/jclark_valid_sa_003.rs
index 79a3f58..6725a57 100644
--- a/exile/tests/generated/jclark_valid_sa_003.rs
+++ b/exile/tests/generated/jclark_valid_sa_003.rs
@@ -6,29 +6,30 @@ use xdoc::Declaration;
 
 const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const INPUT_DATA: &str = "input_data";
-const FILENAME: &str = "jclark_valid_sa_003.xml";
+const INPUT_FILE: &str = "jclark_valid_sa_003.xml";
 
-fn path() -> PathBuf {
+fn path(filename: &str) -> PathBuf {
     let p = PathBuf::from(MANIFEST_DIR)
         .join("tests")
         .join(INPUT_DATA)
-        .join(FILENAME);
+        .join(filename);
     p.canonicalize()
         .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
 }
 
 #[test]
-fn valid_sa_003() {
-    let path = path();
-    let loaded = exile::load(&path).unwrap();
+/// A valid XML file from the W3C conformance test suite: valid-sa-003
+fn valid_sa_003_parse() {
+    let path = path(INPUT_FILE);
+    let actual = exile::load(&path).unwrap();
     let expected = expected();
-    if loaded != expected {
-        let loaded_str = loaded.to_string();
+    if actual != expected {
+        let actual_str = actual.to_string();
         let expected_str = expected.to_string();
-        if loaded_str != expected_str {
-            assert_eq!(loaded_str, expected_str);
+        if actual_str != expected_str {
+            assert_eq!(expected_str, actual_str);
         } else {
-            assert_eq!(loaded, expected);
+            assert_eq!(expected, actual);
         }
     }
 }
diff --git a/exile/tests/generated/jclark_valid_sa_004.rs b/exile/tests/generated/jclark_valid_sa_004.rs
index fd8a717..61c425f 100644
--- a/exile/tests/generated/jclark_valid_sa_004.rs
+++ b/exile/tests/generated/jclark_valid_sa_004.rs
@@ -6,29 +6,30 @@ use xdoc::Declaration;
 
 const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const INPUT_DATA: &str = "input_data";
-const FILENAME: &str = "jclark_valid_sa_004.xml";
+const INPUT_FILE: &str = "jclark_valid_sa_004.xml";
 
-fn path() -> PathBuf {
+fn path(filename: &str) -> PathBuf {
     let p = PathBuf::from(MANIFEST_DIR)
         .join("tests")
         .join(INPUT_DATA)
-        .join(FILENAME);
+        .join(filename);
     p.canonicalize()
         .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
 }
 
 #[test]
-fn valid_sa_004() {
-    let path = path();
-    let loaded = exile::load(&path).unwrap();
+/// A valid XML file from the W3C conformance test suite: valid-sa-004
+fn valid_sa_004_parse() {
+    let path = path(INPUT_FILE);
+    let actual = exile::load(&path).unwrap();
     let expected = expected();
-    if loaded != expected {
-        let loaded_str = loaded.to_string();
+    if actual != expected {
+        let actual_str = actual.to_string();
         let expected_str = expected.to_string();
-        if loaded_str != expected_str {
-            assert_eq!(loaded_str, expected_str);
+        if actual_str != expected_str {
+            assert_eq!(expected_str, actual_str);
         } else {
-            assert_eq!(loaded, expected);
+            assert_eq!(expected, actual);
         }
     }
 }
diff --git a/exile/tests/generated/jclark_valid_sa_005.rs b/exile/tests/generated/jclark_valid_sa_005.rs
index 4c5a4d6..c01e9d5 100644
--- a/exile/tests/generated/jclark_valid_sa_005.rs
+++ b/exile/tests/generated/jclark_valid_sa_005.rs
@@ -6,29 +6,30 @@ use xdoc::Declaration;
 
 const MANIFEST_DIR: &str = env!("CARGO_MANIFEST_DIR");
 const INPUT_DATA: &str = "input_data";
-const FILENAME: &str = "jclark_valid_sa_005.xml";
+const INPUT_FILE: &str = "jclark_valid_sa_005.xml";
 
-fn path() -> PathBuf {
+fn path(filename: &str) -> PathBuf {
     let p = PathBuf::from(MANIFEST_DIR)
         .join("tests")
         .join(INPUT_DATA)
-        .join(FILENAME);
+        .join(filename);
     p.canonicalize()
         .unwrap_or_else(|e| panic!("bad path: {}: {}", p.display(), e))
 }
 
 #[test]
-fn valid_sa_005() {
-    let path = path();
-    let loaded = exile::load(&path).unwrap();
+/// A valid XML file from the W3C conformance test suite: valid-sa-005
+fn valid_sa_005_parse() {
+    let path = path(INPUT_FILE);
+    let actual = exile::load(&path).unwrap();
     let expected = expected();
-    if loaded != expected {
-        let loaded_str = loaded.to_string();
+    if actual != expected {
+        let actual_str = actual.to_string();
         let expected_str = expected.to_string();
-        if loaded_str != expected_str {
-            assert_eq!(loaded_str, expected_str);
+        if actual_str != expected_str {
+            assert_eq!(expected_str, actual_str);
         } else {
-            assert_eq!(loaded, expected);
+            assert_eq!(expected, actual);
         }
     }
 }
diff --git a/exile/tests/generated/mod.rs b/exile/tests/generated/mod.rs
index 354aacd..83d15a0 100644
--- a/exile/tests/generated/mod.rs
+++ b/exile/tests/generated/mod.rs
@@ -1,12 +1,19 @@
 // generated file, do not edit
 
+mod exile_angle_in_attribute_value;
 mod exile_cd_catalog;
 mod exile_doctypes_comments_pis;
-mod exile_e_file;
 mod exile_escapes;
+mod exile_ezfile;
 mod exile_pi;
 mod exile_simple_musicxml;
 mod exile_single_quotes;
+mod exile_unescaped_angle;
+mod jclark_not_wf_sa_001;
+mod jclark_not_wf_sa_002;
+mod jclark_not_wf_sa_003;
+mod jclark_not_wf_sa_004;
+mod jclark_not_wf_sa_005;
 mod jclark_valid_sa_001;
 mod jclark_valid_sa_002;
 mod jclark_valid_sa_003;
diff --git a/xtest/data/angle-in-attribute-value.metadata.json b/exile/tests/input_data/exile_angle_in_attribute_value.metadata.json
similarity index 100%
rename from xtest/data/angle-in-attribute-value.metadata.json
rename to exile/tests/input_data/exile_angle_in_attribute_value.metadata.json
diff --git a/xtest/data/angle-in-attribute-value.xml b/exile/tests/input_data/exile_angle_in_attribute_value.xml
similarity index 100%
rename from xtest/data/angle-in-attribute-value.xml
rename to exile/tests/input_data/exile_angle_in_attribute_value.xml
diff --git a/xtest/data/cd_catalog.metadata.json b/exile/tests/input_data/exile_cd_catalog.metadata.json
similarity index 100%
rename from xtest/data/cd_catalog.metadata.json
rename to exile/tests/input_data/exile_cd_catalog.metadata.json
diff --git a/xtest/data/cd_catalog.expected.xml b/exile/tests/input_data/exile_cd_catalog.output.xml
similarity index 100%
rename from xtest/data/cd_catalog.expected.xml
rename to exile/tests/input_data/exile_cd_catalog.output.xml
diff --git a/xtest/data/disabled.comment-before-declaration.xml b/exile/tests/input_data/exile_disabled.comment_before_declaration.xml
similarity index 100%
rename from xtest/data/disabled.comment-before-declaration.xml
rename to exile/tests/input_data/exile_disabled.comment_before_declaration.xml
diff --git a/xtest/data/disabled.difficult-nodes.metadata.json b/exile/tests/input_data/exile_disabled.difficult_nodes.metadata.json
similarity index 100%
rename from xtest/data/disabled.difficult-nodes.metadata.json
rename to exile/tests/input_data/exile_disabled.difficult_nodes.metadata.json
diff --git a/xtest/data/disabled.difficult-nodes.xml b/exile/tests/input_data/exile_disabled.difficult_nodes.xml
similarity index 100%
rename from xtest/data/disabled.difficult-nodes.xml
rename to exile/tests/input_data/exile_disabled.difficult_nodes.xml
diff --git a/xtest/data/disabled.note.xml b/exile/tests/input_data/exile_disabled.note.xml
similarity index 100%
rename from xtest/data/disabled.note.xml
rename to exile/tests/input_data/exile_disabled.note.xml
diff --git a/xtest/data/disabled.note_error.xml b/exile/tests/input_data/exile_disabled.note_error.xml
similarity index 100%
rename from xtest/data/disabled.note_error.xml
rename to exile/tests/input_data/exile_disabled.note_error.xml
diff --git a/xtest/data/disabled.pi-stray-text.metadata.json b/exile/tests/input_data/exile_disabled.pi_stray_text.metadata.json
similarity index 100%
rename from xtest/data/disabled.pi-stray-text.metadata.json
rename to exile/tests/input_data/exile_disabled.pi_stray_text.metadata.json
diff --git a/xtest/data/disabled.pi-stray-text.xml b/exile/tests/input_data/exile_disabled.pi_stray_text.xml
similarity index 100%
rename from xtest/data/disabled.pi-stray-text.xml
rename to exile/tests/input_data/exile_disabled.pi_stray_text.xml
diff --git a/xtest/data/disabled.plant_catalog.xml b/exile/tests/input_data/exile_disabled.plant_catalog.xml
similarity index 100%
rename from xtest/data/disabled.plant_catalog.xml
rename to exile/tests/input_data/exile_disabled.plant_catalog.xml
diff --git a/xtest/data/disabled.simple_food_menu.xml b/exile/tests/input_data/exile_disabled.simple_food_menu.xml
similarity index 100%
rename from xtest/data/disabled.simple_food_menu.xml
rename to exile/tests/input_data/exile_disabled.simple_food_menu.xml
diff --git a/xtest/data/doctypes-comments-pis.metadata.json b/exile/tests/input_data/exile_doctypes_comments_pis.metadata.json
similarity index 100%
rename from xtest/data/doctypes-comments-pis.metadata.json
rename to exile/tests/input_data/exile_doctypes_comments_pis.metadata.json
diff --git a/xtest/data/escapes.metadata.json b/exile/tests/input_data/exile_escapes.metadata.json
similarity index 100%
rename from xtest/data/escapes.metadata.json
rename to exile/tests/input_data/exile_escapes.metadata.json
diff --git a/xtest/data/escapes.expected.xml b/exile/tests/input_data/exile_escapes.output.xml
similarity index 100%
rename from xtest/data/escapes.expected.xml
rename to exile/tests/input_data/exile_escapes.output.xml
diff --git a/xtest/data/ezfile.metadata.json b/exile/tests/input_data/exile_ezfile.metadata.json
similarity index 100%
rename from xtest/data/ezfile.metadata.json
rename to exile/tests/input_data/exile_ezfile.metadata.json
diff --git a/xtest/data/ezfile.expected.xml b/exile/tests/input_data/exile_ezfile.output.xml
similarity index 100%
rename from xtest/data/ezfile.expected.xml
rename to exile/tests/input_data/exile_ezfile.output.xml
diff --git a/exile/tests/input_data/exile_e_file.xml b/exile/tests/input_data/exile_ezfile.xml
similarity index 100%
rename from exile/tests/input_data/exile_e_file.xml
rename to exile/tests/input_data/exile_ezfile.xml
diff --git a/xtest/data/pi.metadata.json b/exile/tests/input_data/exile_pi.metadata.json
similarity index 100%
rename from xtest/data/pi.metadata.json
rename to exile/tests/input_data/exile_pi.metadata.json
diff --git a/xtest/data/simple_musicxml.metadata.json b/exile/tests/input_data/exile_simple_musicxml.metadata.json
similarity index 100%
rename from xtest/data/simple_musicxml.metadata.json
rename to exile/tests/input_data/exile_simple_musicxml.metadata.json
diff --git a/xtest/data/simple_musicxml.expected.xml b/exile/tests/input_data/exile_simple_musicxml.output.xml
similarity index 100%
rename from xtest/data/simple_musicxml.expected.xml
rename to exile/tests/input_data/exile_simple_musicxml.output.xml
diff --git a/xtest/data/single_quotes.metadata.json b/exile/tests/input_data/exile_single_quotes.metadata.json
similarity index 100%
rename from xtest/data/single_quotes.metadata.json
rename to exile/tests/input_data/exile_single_quotes.metadata.json
diff --git a/xtest/data/unescaped-angle.metadata.json b/exile/tests/input_data/exile_unescaped_angle.metadata.json
similarity index 100%
rename from xtest/data/unescaped-angle.metadata.json
rename to exile/tests/input_data/exile_unescaped_angle.metadata.json
diff --git a/xtest/data/unescaped-angle.xml b/exile/tests/input_data/exile_unescaped_angle.xml
similarity index 100%
rename from xtest/data/unescaped-angle.xml
rename to exile/tests/input_data/exile_unescaped_angle.xml
diff --git a/exile/tests/input_data/jclark_not_wf_sa_001.xml b/exile/tests/input_data/jclark_not_wf_sa_001.xml
new file mode 100644
index 0000000..d33ec68
--- /dev/null
+++ b/exile/tests/input_data/jclark_not_wf_sa_001.xml
@@ -0,0 +1,5 @@
+<doc>
+<doc
+?
+<a</a>
+</doc>
diff --git a/exile/tests/input_data/jclark_not_wf_sa_002.xml b/exile/tests/input_data/jclark_not_wf_sa_002.xml
new file mode 100644
index 0000000..0a64d52
--- /dev/null
+++ b/exile/tests/input_data/jclark_not_wf_sa_002.xml
@@ -0,0 +1,4 @@
+<doc>
+<.doc></.doc>
+</doc>
+
diff --git a/exile/tests/input_data/jclark_not_wf_sa_003.xml b/exile/tests/input_data/jclark_not_wf_sa_003.xml
new file mode 100644
index 0000000..e0b8bae
--- /dev/null
+++ b/exile/tests/input_data/jclark_not_wf_sa_003.xml
@@ -0,0 +1 @@
+<doc><? ?></doc>
diff --git a/exile/tests/input_data/jclark_not_wf_sa_004.xml b/exile/tests/input_data/jclark_not_wf_sa_004.xml
new file mode 100644
index 0000000..e85bc96
--- /dev/null
+++ b/exile/tests/input_data/jclark_not_wf_sa_004.xml
@@ -0,0 +1 @@
+<doc><?target some data></doc>
diff --git a/exile/tests/input_data/jclark_not_wf_sa_005.xml b/exile/tests/input_data/jclark_not_wf_sa_005.xml
new file mode 100644
index 0000000..7cd44ef
--- /dev/null
+++ b/exile/tests/input_data/jclark_not_wf_sa_005.xml
@@ -0,0 +1 @@
+<doc><?target some data?</doc>
diff --git a/exile/tests/manually_written_tests.rs b/exile/tests/manually_written_tests.rs
deleted file mode 100644
index f85a76f..0000000
--- a/exile/tests/manually_written_tests.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-#[test]
-fn good_syntax_ezfile_test() {
-    let info = xtest::load("ezfile");
-    let xml_str = info.read_xml_file();
-    let parse_result = exile::parse(xml_str.as_str());
-    assert!(parse_result.is_ok());
-}
-
-/*
-// This is used for file generation and is checked-in while commented out intentionally.
-#[test]
-fn genstuff() {
-    use std::fs::{read_to_string, OpenOptions};
-    use std::io::Cursor;
-    use std::path::PathBuf;
-    use xtest::{Metadata, Syntax};
-    let name = "simple_musicxml";
-    let data_path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
-        .join("..")
-        .join("xtest")
-        .join("data")
-        .canonicalize()
-        .unwrap();
-
-    let inpath = data_path.join(format!("{}.xml", name));
-    let xmlout_path = data_path.join(format!("{}.expected.xml", name));
-    let jsonout_path = data_path.join(format!("{}.metadata.json", name));
-    println!("{}", inpath.display());
-    let xml = read_to_string(inpath).unwrap();
-    let doc = exile::parse(xml.as_str()).unwrap();
-    let md = xtest::Metadata {
-        description: "cd_catalog example from https://www.w3schools.com/xml/xml_examples.asp"
-            .to_string(),
-        syntax: xtest::Syntax::Good {},
-        expected: Some(doc.clone()),
-    };
-    let json = serde_json::to_string_pretty(&md).unwrap();
-    println!("{}", json);
-    let mut cursor = Cursor::new(Vec::new());
-    let result = doc.write(&mut cursor);
-    assert!(result.is_ok());
-    let data = cursor.into_inner();
-    {
-        let _ = std::fs::remove_file(&xmlout_path);
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(xmlout_path)
-            .unwrap();
-        file.write_all(data.as_slice()).unwrap();
-    }
-    {
-        let _ = std::fs::remove_file(&jsonout_path);
-        let mut file = OpenOptions::new()
-            .read(true)
-            .write(true)
-            .create(true)
-            .open(jsonout_path)
-            .unwrap();
-        file.write_all(json.as_bytes()).unwrap();
-    }
-}
-*/
diff --git a/exile/tests/parse_tests.rs b/exile/tests/parse_tests.rs
deleted file mode 100644
index f7142fd..0000000
--- a/exile/tests/parse_tests.rs
+++ /dev/null
@@ -1,193 +0,0 @@
-//! `parse_tests.rs` is generated by build.rs
-#[test]
-/// unescaped angle bracket in an attribute value
-fn bad_syntax_angle_in_attribute_value_test() {
-    let info = xtest::load("angle-in-attribute-value");
-    let xml_str = info.read_xml_file();
-    let parse_result = exile::parse(xml_str.as_str());
-    assert!(parse_result.is_err());
-    let err = parse_result.err().unwrap();
-    match err {
-        exile::error::Error::Parse(parse_error) => {
-            assert_eq!(51, parse_error.xml_site.position);
-            assert_eq!(2, parse_error.xml_site.line);
-            assert_eq!(12, parse_error.xml_site.column);
-        }
-        _ => panic!("Error was expected to be of type exile::error::Error::Parse, but was not."),
-    }
-}
-
-#[test]
-/// cd_catalog example from https://www.w3schools.com/xml/xml_examples.asp
-fn good_syntax_cd_catalog_test() {
-    let info = xtest::load("cd_catalog");
-    let xml_str = info.read_xml_file();
-    let parse_result = exile::parse(xml_str.as_str());
-    if let Err(e) = parse_result {
-        panic!("expected parse_result to be Ok, got Err: {}", e);
-    }
-    let got_doc = parse_result.as_ref().unwrap();
-    let want_doc = info.metadata.expected.as_ref().unwrap();
-    let equal = want_doc == got_doc;
-    if !equal {
-        let want = want_doc.to_string();
-        let got = got_doc.to_string();
-        if want != got {
-            assert_eq!(got, want);
-        } else {
-            assert!(equal);
-        }
-    }
-    let wanted_serialization = info.read_expected_write().unwrap();
-    assert_eq!(got_doc.to_string(), wanted_serialization);
-}
-
-#[test]
-/// a file with doctypes, processing instructions and comments
-fn good_syntax_doctypes_comments_pis_test() {
-    let info = xtest::load("doctypes-comments-pis");
-    let xml_str = info.read_xml_file();
-    let parse_result = exile::parse(xml_str.as_str());
-    if let Err(e) = parse_result {
-        panic!("expected parse_result to be Ok, got Err: {}", e);
-    }
-}
-
-#[test]
-/// escape sequences
-fn good_syntax_escapes_test() {
-    let info = xtest::load("escapes");
-    let xml_str = info.read_xml_file();
-    let parse_result = exile::parse(xml_str.as_str());
-    if let Err(e) = parse_result {
-        panic!("expected parse_result to be Ok, got Err: {}", e);
-    }
-    let got_doc = parse_result.as_ref().unwrap();
-    let want_doc = info.metadata.expected.as_ref().unwrap();
-    let equal = want_doc == got_doc;
-    if !equal {
-        let want = want_doc.to_string();
-        let got = got_doc.to_string();
-        if want != got {
-            assert_eq!(got, want);
-        } else {
-            assert!(equal);
-        }
-    }
-    let wanted_serialization = info.read_expected_write().unwrap();
-    assert_eq!(got_doc.to_string(), wanted_serialization);
-}
-
-#[test]
-/// a simple, small, well-formed xml file
-fn good_syntax_ezfile_test() {
-    let info = xtest::load("ezfile");
-    let xml_str = info.read_xml_file();
-    let parse_result = exile::parse(xml_str.as_str());
-    if let Err(e) = parse_result {
-        panic!("expected parse_result to be Ok, got Err: {}", e);
-    }
-    let got_doc = parse_result.as_ref().unwrap();
-    let want_doc = info.metadata.expected.as_ref().unwrap();
-    let equal = want_doc == got_doc;
-    if !equal {
-        let want = want_doc.to_string();
-        let got = got_doc.to_string();
-        if want != got {
-            assert_eq!(got, want);
-        } else {
-            assert!(equal);
-        }
-    }
-    let wanted_serialization = info.read_expected_write().unwrap();
-    assert_eq!(got_doc.to_string(), wanted_serialization);
-}
-
-#[test]
-/// a simple file with processing instructions
-fn good_syntax_pi_test() {
-    let info = xtest::load("pi");
-    let xml_str = info.read_xml_file();
-    let parse_result = exile::parse(xml_str.as_str());
-    if let Err(e) = parse_result {
-        panic!("expected parse_result to be Ok, got Err: {}", e);
-    }
-    let got_doc = parse_result.as_ref().unwrap();
-    let want_doc = info.metadata.expected.as_ref().unwrap();
-    let equal = want_doc == got_doc;
-    if !equal {
-        let want = want_doc.to_string();
-        let got = got_doc.to_string();
-        if want != got {
-            assert_eq!(got, want);
-        } else {
-            assert!(equal);
-        }
-    }
-}
-
-#[test]
-/// cd_catalog example from https://www.w3schools.com/xml/xml_examples.asp
-fn good_syntax_simple_musicxml_test() {
-    let info = xtest::load("simple_musicxml");
-    let xml_str = info.read_xml_file();
-    let parse_result = exile::parse(xml_str.as_str());
-    if let Err(e) = parse_result {
-        panic!("expected parse_result to be Ok, got Err: {}", e);
-    }
-    let got_doc = parse_result.as_ref().unwrap();
-    let want_doc = info.metadata.expected.as_ref().unwrap();
-    let equal = want_doc == got_doc;
-    if !equal {
-        let want = want_doc.to_string();
-        let got = got_doc.to_string();
-        if want != got {
-            assert_eq!(got, want);
-        } else {
-            assert!(equal);
-        }
-    }
-    let wanted_serialization = info.read_expected_write().unwrap();
-    assert_eq!(got_doc.to_string(), wanted_serialization);
-}
-
-#[test]
-/// a simple file with single-quoted attributes
-fn good_syntax_single_quotes_test() {
-    let info = xtest::load("single_quotes");
-    let xml_str = info.read_xml_file();
-    let parse_result = exile::parse(xml_str.as_str());
-    if let Err(e) = parse_result {
-        panic!("expected parse_result to be Ok, got Err: {}", e);
-    }
-    let got_doc = parse_result.as_ref().unwrap();
-    let want_doc = info.metadata.expected.as_ref().unwrap();
-    let equal = want_doc == got_doc;
-    if !equal {
-        let want = want_doc.to_string();
-        let got = got_doc.to_string();
-        if want != got {
-            assert_eq!(got, want);
-        } else {
-            assert!(equal);
-        }
-    }
-}
-
-#[test]
-/// unescaped angle bracket inside element text
-fn bad_syntax_unescaped_angle_test() {
-    let info = xtest::load("unescaped-angle");
-    let xml_str = info.read_xml_file();
-    let parse_result = exile::parse(xml_str.as_str());
-    assert!(parse_result.is_err());
-    let err = parse_result.err().unwrap();
-    match err {
-        exile::error::Error::Parse(parse_error) => {
-            assert_eq!(95, parse_error.xml_site.position);
-            assert_eq!(4, parse_error.xml_site.line);
-            assert_eq!(39, parse_error.xml_site.column);
-        }
-        _ => panic!("Error was expected to be of type exile::error::Error::Parse, but was not."),
-    }
-}
diff --git a/testgen/entrypoint.sh b/testgen/entrypoint.sh
index 0661359..67abc5e 100755
--- a/testgen/entrypoint.sh
+++ b/testgen/entrypoint.sh
@@ -18,9 +18,8 @@ d="--custom-schema /fake"
 e="--xml-outdir /workspace/exile/tests"
 f="--schema-outdir /fake"
 g="--rust-root /workspace"
-h="--exile-tests /workspace/xtest/data" # TODO - this will move
 
 # use maven to execute the program
 mvn exec:java \
   -Dexec.mainClass="com.matthewjamesbriggs.xmltestgen.App" \
-  -Dexec.args="${a} ${b} ${c} ${d} ${e} ${f} ${g} ${h}"
+  -Dexec.args="${a} ${b} ${c} ${d} ${e} ${f} ${g}"
diff --git a/testgen/xmltestgen/.idea/saveactions_settings.xml b/testgen/xmltestgen/.idea/saveactions_settings.xml
index 9de5690..241b920 100644
--- a/testgen/xmltestgen/.idea/saveactions_settings.xml
+++ b/testgen/xmltestgen/.idea/saveactions_settings.xml
@@ -24,7 +24,6 @@
         <option value="explicitTypeCanBeDiamond" />
         <option value="suppressAnnotation" />
         <option value="unnecessarySemicolon" />
-        <option value="accessCanBeTightened" />
       </set>
     </option>
     <option name="configurationPath" value="" />
diff --git a/testgen/xmltestgen/pom.xml b/testgen/xmltestgen/pom.xml
index 987af59..b538669 100644
--- a/testgen/xmltestgen/pom.xml
+++ b/testgen/xmltestgen/pom.xml
@@ -27,6 +27,11 @@
             <artifactId>lombok</artifactId>
             <version>1.18.14</version>
         </dependency>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.11</version>
+        </dependency>
         <dependency>
             <groupId>commons-io</groupId>
             <artifactId>commons-io</artifactId>
diff --git a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/App.java b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/App.java
index 3bebccb..f03e2f1 100644
--- a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/App.java
+++ b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/App.java
@@ -9,7 +9,6 @@ public class App {
     private static final int SUCCESS = 0;
     private static final int FAILURE = 1;
     private static final int BAD_USAGE = 2;
-    private static final int NUM_TESTS = 5;
 
     public static void main(String[] args) {
         ProgramOptions opts = null;
@@ -30,9 +29,9 @@ public static void main(String[] args) {
 
     private static void generateConfTests(ProgramOptions opts) throws TestGenException {
         List<ConfTest> confTests = ConfTestParser.parse(opts.getW3cXml().getPath());
-        List<ConfTest> exileTests = ConfTestParser.parseExileTests(opts.getExileTests());
+        List<ConfTest> exileTests = ConfTestParser.parseExileTests(opts.getRustDataDir());
         confTests.addAll(exileTests);
         ConfTestGenerator confTestGenerator = new ConfTestGenerator(confTests, opts);
-        confTestGenerator.generateTests(NUM_TESTS);
+        confTestGenerator.generateTests();
     }
 }
diff --git a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ConfTest.java b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ConfTest.java
index 5258f4d..f614fed 100644
--- a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ConfTest.java
+++ b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ConfTest.java
@@ -1,9 +1,11 @@
 package com.matthewjamesbriggs.xmltestgen;
 
 import lombok.AllArgsConstructor;
+import org.junit.Test;
 import org.w3c.dom.Element;
 import lombok.Getter;
 
+import java.io.File;
 import java.nio.file.Path;
 
 
@@ -30,6 +32,11 @@
     private final XmlVersion xmlVersion;
     @Getter
     private final String prefix;
+    /// This is an XML file that represents the serialization outcome that we expect. It might be null because we only
+    /// have these for a few tests.
+    private final File outputFile;
+    /// This is a JSON file that represents the metadata for an exile test.
+    private final File metdataFile;
 
     ConfTest(Element element, Path path, ConfTestCases confTestCases) throws TestGenException {
         this.path = path;
@@ -51,27 +58,11 @@
             xmlVersion = XmlVersion.V10;
         }
         prefix = confTestCases.getPrefix();
+        // this constructor is for w3c tests, none of which currently have output assertion files or metadata files
+        outputFile = null;
+        metdataFile = null;
     }
 
-    private static boolean isLetter(char c) {
-        return isLetterUpper(c) || isLetterLower(c);
-    }
-
-    public static boolean isAlphanumeric(char c) {
-        return isLetter(c) || isDigit(c);
-    }
-
-    private static boolean isLetterUpper(char c) {
-        return c >= 65 && c <= 90;
-    }
-
-    private static boolean isLetterLower(char c) {
-        return c >= 97 && c <= 121;
-    }
-
-    private static boolean isDigit(char c) {
-        return c >= 48 && c <= 57;
-    }
 
     @Override
     public String toString() {
@@ -93,35 +84,70 @@ public String toString() {
      * @return The ID in snake case.
      */
     String getSnakeCase() {
-        String s = getId();
-        StringBuilder result = new StringBuilder(s.length() + 4);
-        boolean wasUnderscore = false;
-        for (int i = 0, n = s.length(); i < n; i++) {
-            char c = s.charAt(i);
-            if (i == 0 && !isLetter(c)) {
-                result.append('x');
-                result.append('_');
-                wasUnderscore = true;
-            }
-            if (isLetter(c)) {
-                result.append(Character.toLowerCase(c));
-                wasUnderscore = false;
-            } else if (isDigit(c)) {
-                result.append(c);
-                wasUnderscore = false;
-            } else if (!wasUnderscore) {
-                result.append('_');
-                wasUnderscore = true;
-            }
-        }
-        return result.toString();
+        return S.getSnakeCase(getId());
     }
 
     String getTestName() {
-        return getPrefix() + "_" + getSnakeCase();
+        return getPrefix() + ExileConstants.SEPARATOR + getSnakeCase();
     }
 
-    String getFileRename() {
+    /**
+     * The name of the XML imput file as it will be in the exile/tests/input_data directory.
+     *
+     * @return The filename.
+     */
+    String getXmlFilename() {
         return getTestName() + ".xml";
     }
+
+    /**
+     * Returns true if this test is a 'custom' exile test, i.e. an exile test, and did not come from W3C.
+     */
+    boolean isExileTest() {
+        return getPrefix().equals(ExileConstants.EXILE);
+    }
+
+    /**
+     * True if there is an XML file that represents the expected serialization outcome for a test
+     *
+     * @return whether there is an output file.
+     */
+    public boolean hasOutputFile() {
+        return outputFile != null;
+    }
+
+    /**
+     * This will throw an exception if there is no XML output file. Call `hasOutputFile` first to check.
+     *
+     * @return the output file.
+     * @throws TestGenException if there is no output file.
+     */
+    public File getOutputFile() throws TestGenException {
+        if (outputFile == null) {
+            throw new TestGenException("%s has no outputFile", getId());
+        }
+        return outputFile;
+    }
+
+    /**
+     * True if there is an JSON metadata file for this test.
+     *
+     * @return whether there is an output file.
+     */
+    public boolean hasMetadataFile() {
+        return metdataFile != null;
+    }
+
+    /**
+     * This will throw an exception if there is no JSON metdata file. Call `hasMetadataFile` first to check.
+     *
+     * @return the output file.
+     * @throws TestGenException if there is no output file.
+     */
+    public File getMetadataFile() throws TestGenException {
+        if (metdataFile == null) {
+            throw new TestGenException("%s has no metdataFile", getId());
+        }
+        return metdataFile;
+    }
 }
diff --git a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ConfTestGenerator.java b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ConfTestGenerator.java
index 6b61fb3..63b3275 100644
--- a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ConfTestGenerator.java
+++ b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ConfTestGenerator.java
@@ -1,13 +1,12 @@
 package com.matthewjamesbriggs.xmltestgen;
 
+import com.google.gson.Gson;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
+import org.apache.commons.io.FileUtils;
 import org.w3c.dom.*;
 
-import java.io.File;
-import java.io.FileOutputStream;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
+import java.io.*;
 import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
@@ -18,6 +17,10 @@
 import java.util.regex.Pattern;
 
 class ConfTestGenerator {
+    /// The maximum number of W3C tests of ConfType.Valid that will be generated.
+    private static final int MAX_VALID = 5;
+    /// The maximum number of W3C tests of ConfType.NotWellFormed that will be generated.
+    private static final int MAX_NOT_WELL_FORMED = 5;
     /// The tests directory, e.g. exile_repo/exile/tests
     private final File outDir;
     /// The root of the generated tests, e.g. exile_repo/exile/tests/generated
@@ -30,14 +33,17 @@ class ConfTestGenerator {
     private final List<ConfTest> tests;
     /// The mod.rs file for our generated rust tests to be compiled, e.g. exile_repo/exile/tests/generated/mod.rs
     private final File modRs;
-
+    /// The number of W3C tests of ConfType.Valid that have been generated.
+    private int validTestCount;
+    /// The number of W3C tests of ConfType.NotWellFormed that have been generated.
+    private int notWellFormedTestCount;
 
     ConfTestGenerator(List<ConfTest> tests, ProgramOptions opts) throws TestGenException {
         outDir = F.canonicalize(opts.getXmlOutdir());
         F.checkDir(outDir);
         generatedDir = F.canonicalize(new File(opts.getXmlOutdir(), "generated"));
         F.checkDir(generatedDir);
-        testDataDir = F.canonicalize(new File(opts.getXmlOutdir(), "input_data"));
+        testDataDir = opts.getRustDataDir();
         F.checkDir(testDataDir);
         rustWorkspaceDir = F.canonicalize(opts.getRustRoot());
         F.checkDir(rustWorkspaceDir);
@@ -79,8 +85,27 @@ XmlVersion getVersion() throws TestGenException {
         private final List<String> instructions;
     }
 
-    void generateTests(int maxTests) throws TestGenException {
+    /**
+     * Filters the file list to include only those that are *non* permanent, custom, exile files. That is, a list of
+     * files that we should delete each time we generate tests.
+     */
+    private static class FilesToDelete implements FilenameFilter {
+        @Override
+        public boolean accept(File dir, String name) {
+            File f = new File(name);
+            if (!ExileConstants.isExile(f)) {
+                return false;
+            }
+            boolean isMetadata = ExileConstants.isExileMetadata(f);
+            boolean isOutput = ExileConstants.isExileOutput(f);
+            boolean isInput = ExileConstants.isExileInput(f);
+            return !isInput && !isOutput && !isMetadata;
+        }
+    }
+
+    void generateTests() throws TestGenException {
         F.createOrReplaceDir(generatedDir);
+        deleteNonExileXmlFiles(testDataDir);
 
         // create the mod.rs file
         OutputStreamWriter mod = F.createAndOpen(modRs);
@@ -88,20 +113,8 @@ void generateTests(int maxTests) throws TestGenException {
         F.writeln(mod, "");
 
         // create test files
-        int testCount = 0;
-        for (int i = 0; i < tests.size(); ++i) {
-            ConfTest t = tests.get(i);
-            if (t.getConfType() != ConfType.Valid) {
-                continue;
-            }
-            // we always generate all of our own custom tests, but if is a w3c test then we increment the testCount to
-            // ensure we only generate as many w3c tests as specified by 'maxTests'.
-            if (t.getPrefix() == "exile" && t.getConfType() == ConfType.Valid) {
-                generateValidTest(t, mod);
-            } else if (t.getConfType() == ConfType.Valid && testCount < maxTests) {
-                ++testCount;
-                generateValidTest(t, mod);
-            }
+        for (ConfTest t : tests) {
+            generateTest(t, mod);
         }
 
         F.writeln(mod, "");
@@ -110,9 +123,150 @@ void generateTests(int maxTests) throws TestGenException {
         Cmd.clippy(rustWorkspaceDir);
     }
 
+    private static void deleteNonExileXmlFiles(File testDataDir) throws TestGenException {
+        F.checkDir(testDataDir);
+        File[] files = testDataDir.listFiles(new FilesToDelete());
+        if (files == null) {
+            throw new TestGenException("null file list");
+        }
+        for (File file : files) {
+            FileUtils.deleteQuietly(file);
+        }
+    }
+
+    private void generateTest(ConfTest t, OutputStreamWriter mod) throws TestGenException {
+        // Copy W3C tests to the 'generated' directory.
+        if (!isMaxedOut(t) && !t.isExileTest()) {
+            copyXmlTestFile(t);
+        } else {
+            System.out.println("not copying the exile test " + t.getId());
+        }
+        switch (t.getConfType()) {
+            case Valid:
+                generateValidTest(t, mod);
+                break;
+            case NotWellFormed:
+                generateNotWellFormedTest(t, mod);
+                break;
+            case Invalid:
+            case Error:
+            default:
+                System.out.println(String.format("unsupported test type %s in %s",
+                        t.getConfType().toString(),
+                        t.getId()));
+        }
+    }
+
+    private boolean isMaxedOut(ConfTest t) {
+        if (t.isExileTest()) {
+            // we always generate all of the exile tests
+            return false;
+        }
+        switch (t.getConfType()) {
+            case Valid:
+                return validTestCount >= MAX_VALID;
+            case NotWellFormed:
+                return notWellFormedTestCount >= MAX_NOT_WELL_FORMED;
+            case Error:
+            case Invalid:
+            default:
+                return true;
+        }
+    }
+
+    private void incrementCount(ConfTest t) {
+        if (t.isExileTest()) {
+            // we generate all exile test and they don't could toward the max W3C test counts
+            return;
+        }
+        switch (t.getConfType()) {
+            case NotWellFormed:
+                notWellFormedTestCount++;
+                break;
+            case Valid:
+                validTestCount++;
+                break;
+            case Error:
+            case Invalid:
+            default:
+                break;
+        }
+    }
+
+    private void generateNotWellFormedTest(ConfTest t, OutputStreamWriter mod) throws TestGenException {
+        if (isMaxedOut(t)) {
+            return;
+        }
+        incrementCount(t);
+        if (t.getConfType() != ConfType.NotWellFormed) {
+            throw new TestGenException("wrong test type, expected '%s', got '%s'",
+                    ConfType.NotWellFormed,
+                    t.getConfType().toString());
+        }
+        ExileTestMetadata metadata = null;
+        if (t.hasMetadataFile()) {
+            File m = t.getMetadataFile();
+            Gson gson = new Gson();
+
+            try {
+                Reader reader = Files.newBufferedReader(m.toPath());
+                metadata = gson.fromJson(reader, ExileTestMetadata.class);
+            } catch (IOException e) {
+                throw new TestGenException(e, "unable to load %s", m.getPath());
+            }
+        }
+        String description =
+                String.format("A not-well-formed test file from the W3C conformance test suite: %s", t.getId());
+        if (metadata != null) {
+            description = metadata.getDescription();
+        }
+        File testFile = new File(generatedDir, t.getTestName() + ".rs");
+        OutputStreamWriter os = F.createAndOpen(testFile);
+        F.writeln(mod, "mod %s;", t.getTestName());
+        writeCodeFileHeader(os);
+        F.writeln(os, "");
+        F.writeln(os, "use std::path::PathBuf;");
+        F.writeln(os, "");
+        writeConstDeclarations(t, os);
+        F.writeln(os, "");
+        writePathFunction(t, os);
+        F.writeln(os, "");
+        F.writeln(os, "#[test]");
+        F.writeln(os, "/// %s", description);
+        F.writeln(os, "fn %s_test() {", t.getSnakeCase());
+        F.writeln(os, "    let result = exile::load(path(INPUT_FILE));");
+        F.writeln(os, "    assert!(result.is_err());");
+        F.writeln(os, "    let e = result.err().unwrap();");
+        F.writeln(os, "match e {");
+        boolean positionAsserted = false;
+        if (metadata != null) {
+            ExileTestMetadataBad bad = metadata.getSyntax().getBad();
+            if (bad != null) {
+                positionAsserted = true;
+                F.writeln(os, "exile::error::Error::Parse(parse_error) => {");
+                F.writeln(os, "assert_eq!(%d, parse_error.xml_site.position);", bad.getCharacterPosition());
+                F.writeln(os, "assert_eq!(%d, parse_error.xml_site.line);", bad.getLine());
+                F.writeln(os, "assert_eq!(%d, parse_error.xml_site.column);", bad.getColumn());
+            }
+        }
+        if (!positionAsserted) {
+            F.writeln(os, "exile::error::Error::Parse(_) => {");
+        }
+        F.writeln(os, "}");
+        F.writeln(os, "_ => panic!(\"expected parse error.\"),");
+        F.writeln(os, "}");
+        F.writeln(os, "}");
+    }
+
     private void generateValidTest(ConfTest t, OutputStreamWriter mod) throws TestGenException {
+        if (isMaxedOut(t)) {
+            return;
+        }
+        incrementCount(t);
         if (t.getConfType() != ConfType.Valid) {
-            throw new TestGenException("wrong test type, expected 'valid', got " + t.getConfType().toString());
+            throw new TestGenException("wrong test type, expected '%s', got '%s'",
+                    ConfType.Valid,
+                    t.getConfType().toString());
         }
         File testFile = new File(generatedDir, t.getTestName() + ".rs");
         OutputStreamWriter os = F.createAndOpen(testFile);
@@ -120,7 +274,7 @@ private void generateValidTest(ConfTest t, OutputStreamWriter mod) throws TestGe
         writeCodeFileHeader(os);
         F.writeln(os, "");
         FoundDecl foundDecl = findDecl(t);
-        writeUseStatements(foundDecl, os);
+        writeUseStatements(t, foundDecl, os);
         F.writeln(os, "");
         writeConstDeclarations(t, os);
         F.writeln(os, "");
@@ -128,8 +282,11 @@ private void generateValidTest(ConfTest t, OutputStreamWriter mod) throws TestGe
         F.writeln(os, "");
         writeTestFunction(t, os);
         F.writeln(os, "");
+        if (t.isExileTest() && t.hasOutputFile()) {
+            writeSerializationTestFunction(t, os);
+        }
+        F.writeln(os, "");
         writeExpectedFunction(t, foundDecl, os);
-        copyXmlTestFile(t);
 
         // close the stream, we are done writing to the test file
         F.closeStream(testFile, os);
@@ -139,10 +296,14 @@ private static void writeCodeFileHeader(OutputStreamWriter os) throws TestGenExc
         F.writeln(os, "// generated file, do not edit");
     }
 
-    private static void writeUseStatements(FoundDecl foundDecl, OutputStreamWriter os) throws TestGenException {
+    private static void writeUseStatements(ConfTest t,
+                                           FoundDecl foundDecl,
+                                           OutputStreamWriter os) throws TestGenException {
         F.writeln(os, "use exile::Document;");
         F.writeln(os, "use std::path::PathBuf;");
-        F.writeln(os, "use xdoc::Declaration;");
+        if (t.getConfType() != ConfType.NotWellFormed) {
+            F.writeln(os, "use xdoc::Declaration;");
+        }
         if (foundDecl.hasVersion()) {
             F.writeln(os, "use xdoc::Version;");
         }
@@ -154,38 +315,70 @@ private static void writeUseStatements(FoundDecl foundDecl, OutputStreamWriter o
     private static void writeConstDeclarations(ConfTest t, OutputStreamWriter os) throws TestGenException {
         F.writeln(os, "const MANIFEST_DIR: &str = env!(\"CARGO_MANIFEST_DIR\");");
         F.writeln(os, "const INPUT_DATA: &str = \"input_data\";");
-        F.writeln(os, "const FILENAME: &str = \"%s\";", t.getFileRename());
+        F.writeln(os, "const INPUT_FILE: &str = \"%s\";", t.getXmlFilename());
+        if (t.hasOutputFile()) {
+            F.writeln(os, "const OUTPUT_FILE: &str = \"%s\";", t.getOutputFile().getName());
+        }
     }
 
     private static void writePathFunction(ConfTest t, OutputStreamWriter os) throws TestGenException {
-        F.writeln(os, "fn path() -> PathBuf {");
+        F.writeln(os, "fn path(filename: &str) -> PathBuf {");
         F.writeln(os, "    let p = PathBuf::from(MANIFEST_DIR)");
         F.writeln(os, "        .join(\"tests\")");
         F.writeln(os, "        .join(INPUT_DATA)");
-        F.writeln(os, "        .join(FILENAME);");
+        F.writeln(os, "        .join(filename);");
         F.writeln(os, "    p.canonicalize()");
         F.writeln(os, "        .unwrap_or_else(|e| panic!(\"bad path: {}: {}\", p.display(), e))");
         F.writeln(os, "}");
     }
 
     private static void writeTestFunction(ConfTest t, OutputStreamWriter os) throws TestGenException {
+        ExileTestMetadata metadata = null;
+        if (t.hasMetadataFile()) {
+            File m = t.getMetadataFile();
+            Gson gson = new Gson();
+
+            try {
+                Reader reader = Files.newBufferedReader(m.toPath());
+                metadata = gson.fromJson(reader, ExileTestMetadata.class);
+            } catch (IOException e) {
+                throw new TestGenException(e, "unable to load %s", m.getPath());
+            }
+        }
+        String description = String.format("A valid XML file from the W3C conformance test suite: %s", t.getId());
+        if (metadata != null) {
+            description = metadata.getDescription();
+        }
         F.writeln(os, "#[test]");
-        F.writeln(os, "fn %s() {", t.getSnakeCase());
-        F.writeln(os, "    let path = path();");
-        F.writeln(os, "    let loaded = exile::load(&path).unwrap();");
+        F.writeln(os, "/// %s", description);
+        F.writeln(os, "fn %s_parse() {", t.getSnakeCase());
+        F.writeln(os, "    let path = path(INPUT_FILE);");
+        F.writeln(os, "    let actual = exile::load(&path).unwrap();");
         F.writeln(os, "    let expected = expected();");
-        F.writeln(os, "    if loaded != expected {");
-        F.writeln(os, "        let loaded_str = loaded.to_string();");
+        F.writeln(os, "    if actual != expected {");
+        F.writeln(os, "        let actual_str = actual.to_string();");
         F.writeln(os, "        let expected_str = expected.to_string();");
-        F.writeln(os, "        if loaded_str != expected_str {");
-        F.writeln(os, "            assert_eq!(loaded_str, expected_str);");
+        F.writeln(os, "        if actual_str != expected_str {");
+        F.writeln(os, "            assert_eq!(expected_str, actual_str);");
         F.writeln(os, "        } else {");
-        F.writeln(os, "            assert_eq!(loaded, expected);");
+        F.writeln(os, "            assert_eq!(expected, actual);");
         F.writeln(os, "        }");
         F.writeln(os, "    }");
         F.writeln(os, "}");
     }
 
+
+    private static void writeSerializationTestFunction(ConfTest t, OutputStreamWriter os) throws TestGenException {
+        F.writeln(os, "#[test]");
+        F.writeln(os, "/// Check that the serialization of this XML document matches what we expect.");
+        F.writeln(os, "fn %s_serialize() {", t.getSnakeCase());
+        F.writeln(os, "    let doc = expected();");
+        F.writeln(os, "    let actual = doc.to_string();");
+        F.writeln(os, "    let expected = std::fs::read_to_string(path(OUTPUT_FILE)).unwrap();");
+        F.writeln(os, "    assert_eq!(expected, actual);");
+        F.writeln(os, "}");
+    }
+
     private static void writeExpectedFunction(ConfTest t,
                                               FoundDecl foundDecl,
                                               OutputStreamWriter os) throws TestGenException {
@@ -219,12 +412,6 @@ private static void writeExpectedPrelude(List<Node> prelude, OutputStreamWriter
             }
 
         }
-        /*
-            doc.push_prolog_misc(xdoc::Misc::PI(PI {
-                target: "foo".into(),
-                instructions: vec!["".to_owned()],
-            }));
-         */
     }
 
     private static void writeExpectedPostlude(List<Node> postlude, OutputStreamWriter os) throws TestGenException {
@@ -413,7 +600,7 @@ private void copyXmlTestFile(ConfTest t) throws TestGenException {
         F.checkDir(testDataDir);
         File original = new File(t.getPath().toString());
         F.checkFile(original);
-        File copied = new File(testDataDir, t.getFileRename());
+        File copied = new File(testDataDir, t.getXmlFilename());
         F.copy(original, copied);
     }
 
diff --git a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ConfTestParser.java b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ConfTestParser.java
index 8639d59..6ce19ba 100644
--- a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ConfTestParser.java
+++ b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ConfTestParser.java
@@ -16,25 +16,6 @@
 import java.util.List;
 
 class ConfTestParser {
-    @Getter private static class ExileTestLocation {
-        private final String testName;
-        private final File xml;
-        private final File metadata;
-        private final File expected;
-
-        ExileTestLocation(File mainFile) throws TestGenException {
-            F.checkFile(mainFile);
-            xml = F.canonicalize(mainFile);
-            String filename = xml.toPath().getFileName().toString();
-            // remove .xml extension
-            testName = filename.substring(0, filename.length() - 4);
-            Path parent = xml.toPath().getParent();
-            metadata = new File(Paths.get(parent.toString(), testName + ".metadata.json").toString());
-            F.checkFile(metadata);
-            expected = new File(Paths.get(parent.toString(), testName + ".expected.xml").toString());
-        }
-    }
-
     static List<ConfTest> parse(String w3cXmlFilepath) throws TestGenException {
         Document doc = X.loadComplete(new File(w3cXmlFilepath));
         return parseDocument(doc);
@@ -143,26 +124,27 @@ private static ConfTest parseTest(Element element, ConfTestCases confTestCases)
     }
 
     static List<ConfTest> parseExileTests(File dir) throws TestGenException {
-        List<ExileTestLocation> locations = listExileTestFiles(dir);
+        List<ExileFiles> locations = listExileTestFiles(dir);
         List<ConfTest> exileTests = new ArrayList<>();
-        for (ExileTestLocation location : locations) {
+        for (ExileFiles location : locations) {
             ConfTest confTest = makeExileConfTest(location);
             exileTests.add(confTest);
         }
         return exileTests;
     }
 
-    private static List<ExileTestLocation> listExileTestFiles(File dir) throws TestGenException {
+    private static List<ExileFiles> listExileTestFiles(File dir) throws TestGenException {
         List<File> files = new ArrayList<>();
         try {
-            Files.list(dir.toPath()).limit(9999999).forEach(path -> {
-                if (!path.getFileName().toString().startsWith("disabled.") &&
-                        !path.toString().endsWith(".expected.xml") &&
-                        !path.toString().endsWith("metadata.json") &&
-                        path.toString().endsWith(".xml")) {
+            Files.list(dir.toPath()).forEach(path -> {
+                File f = path.getFileName().toFile();
+                if (ExileConstants.isEnabledExileInput(f)) {
                     files.add(new File(path.toString()));
-                    System.out.println(path);
+                    System.out.println(path + " is an exile input file.");
+                } else {
+                    System.out.println(path + " is NOT exile input file or is DISABLED.");
                 }
+
             });
         } catch (IOException e) {
             throw new TestGenException("Unable to list dir: " + dir.toString(), e);
@@ -170,27 +152,39 @@ private static List<ExileTestLocation> listExileTestFiles(File dir) throws TestG
         return listExileTestFiles(files);
     }
 
-    private static List<ExileTestLocation> listExileTestFiles(List<File> xmlFiles) throws TestGenException {
-        List<ExileTestLocation> exiles = new ArrayList<>();
+    private static List<ExileFiles> listExileTestFiles(List<File> xmlFiles) throws TestGenException {
+        List<ExileFiles> exiles = new ArrayList<>();
         for (File file : xmlFiles) {
-            exiles.add(new ExileTestLocation(file));
+            ExileFiles ef = new ExileFiles(file);
+            F.checkDir(ef.getDirectory());
+            F.checkFile(ef.getInputFile());
+            F.checkFile(ef.getMetadataFile());
+            exiles.add(ef);
         }
         return exiles;
     }
 
-    private static ConfTest makeExileConfTest(ExileTestLocation location) throws TestGenException {
+    private static ConfTest makeExileConfTest(ExileFiles location) throws TestGenException {
         Gson gson = new Gson();
-        ExileTestMetadata metadata = gson.fromJson(F.readFile(location.metadata), ExileTestMetadata.class);
-        ConfTestCases confTestCases = new ConfTestCases("exile", "exile");
-        Path path = location.getXml().toPath();
+        ExileTestMetadata metadata = gson.fromJson(F.readFile(location.getMetadataFile()), ExileTestMetadata.class);
+        ConfTestCases confTestCases = new ConfTestCases(ExileConstants.EXILE, ExileConstants.EXILE);
+        Path path = location.getInputFile().toPath();
         Entities entities = ExileTestMetadata.getEntities();
-        String id = location.getTestName();
+        String id = location.getCoreName();
         Recommendation recommendation = metadata.getRecommendation();
         final String sections = "N/A";
         boolean namespace = ExileTestMetadata.getNamespace();
         ConfType confType = metadata.getSyntax().getConfType();
         XmlVersion xmlVersion = metadata.getXmlVersion();
         String prefix = confTestCases.getPrefix();
+        File outputFile = location.getOutputFile();
+        if (!outputFile.exists() || !outputFile.isFile()) {
+            outputFile = null;
+        }
+        File metdataFile = location.getMetadataFile();
+        if (!metdataFile.exists() || !metdataFile.isFile()) {
+            metdataFile = null;
+        }
         return new ConfTest(confTestCases,
                 path,
                 entities,
@@ -201,6 +195,8 @@ private static ConfTest makeExileConfTest(ExileTestLocation location) throws Tes
                 namespace,
                 confType,
                 xmlVersion,
-                prefix);
+                prefix,
+                outputFile,
+                metdataFile);
     }
 }
diff --git a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ExileConstants.java b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ExileConstants.java
new file mode 100644
index 0000000..9fc783a
--- /dev/null
+++ b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ExileConstants.java
@@ -0,0 +1,123 @@
+package com.matthewjamesbriggs.xmltestgen;
+
+import org.apache.commons.io.FilenameUtils;
+
+import java.io.File;
+
+class ExileConstants {
+    static final String DIRECTORY = "input_data";
+    static final String EXILE = "exile";
+    static final String METADATA_FILE_SUFFIX = ".metadata.json";
+    static final String OUTPUT_FILE_SUFFIX = ".output.xml";
+    static final String DISABLED = "disabled";
+    static final String SEPARATOR = "_";
+    static final String EXILE_FILE_PREFIX = EXILE + SEPARATOR;
+    static final String EXILE_DISABLED = EXILE_FILE_PREFIX + DISABLED;
+    static final String EXILE_DISABLED_FILE_PREFIX = EXILE_DISABLED + ".";
+
+    /**
+     * Returns true if this file starts with the exile file prefix.
+     */
+    static boolean isExile(File file) {
+        return file.getName().startsWith(EXILE_FILE_PREFIX);
+    }
+
+    /**
+     * Returns true if this file starts with exile_disabled prefix.
+     */
+    static boolean isExileDisabled(File file) {
+        return file.getName().startsWith(EXILE_DISABLED_FILE_PREFIX);
+    }
+
+    /**
+     * Given a file, determines whether or not the file is the XML input file of a permanent exile test. This will
+     * return true for both enabled and disabled exile tests.
+     *
+     * @param file The file to query.
+     * @return true if the file is an enabled or disabled exile test input XML file.
+     */
+    static boolean isExileInput(File file) {
+        String ext = FilenameUtils.getExtension(file.getName());
+        if (!ext.equals("xml")) {
+            return false;
+        } else if (isExileOutput(file)) {
+            return false;
+        } else if (isExileMetadata(file)) {
+            return false;
+        } else {
+            return isExile(file) || isExileDisabled(file);
+        }
+    }
+
+    /**
+     * Given a file, determines whether or not the file is the XML input file of a *disabled* exile test.
+     *
+     * @param file The file to query.
+     * @return true if the file is a disabled exile test input XML file.
+     */
+    static boolean isExileDisabledInput(File file) {
+        if (!isExileInput(file)) {
+            return false;
+        } else {
+            return isExileDisabled(file);
+        }
+    }
+
+    /**
+     * Given a file, determines whether or not the file is the XML input file of a *enabled* exile test.
+     *
+     * @param file The file to query.
+     * @return true if the file is a enabled exile test input XML file.
+     */
+    static boolean isEnabledExileInput(File file) {
+        if (!isExileInput(file)) {
+            return false;
+        }
+        return !isExileDisabled(file);
+    }
+
+    /**
+     * Given a file, determines whether the file is the metadata JSON file for an exile test (enabled or disabled).
+     *
+     * @param file The file to query.
+     * @return true if the file is a enabled or disabled exile test JSON metadata file.
+     */
+    static boolean isExileMetadata(File file) {
+        if (!file.getName().startsWith(EXILE_FILE_PREFIX)) {
+            return false;
+        }
+        return file.getName().endsWith(METADATA_FILE_SUFFIX);
+    }
+
+    /**
+     * Given a file, determines whether the file is the expected output XML file for an exile test (enabled or disabled).
+     *
+     * @param file The file to query.
+     * @return true if the file is a enabled or disabled output XML file for an exile test.
+     */
+    static boolean isExileOutput(File file) {
+        if (!file.getName().startsWith(EXILE_FILE_PREFIX)) {
+            return false;
+        }
+        return file.getName().endsWith(OUTPUT_FILE_SUFFIX);
+    }
+
+    /**
+     * Given a valid exile test input filename, e.g. exile_foo.xml or exile_disabled.foo.xml, return `foo`.
+     *
+     * @param file The file to parse the core name from.
+     * @return The core name.
+     */
+    static String getCoreName(File file) throws TestGenException {
+        if (!isExileInput(file)) {
+            throw new TestGenException("not an exile input file '%s'", file.getName());
+        }
+        String coreName = file.getName();
+        if (isEnabledExileInput(file)) {
+            coreName = coreName.replaceFirst(EXILE_FILE_PREFIX, "");
+        } else {
+            coreName = coreName.replaceFirst(EXILE_DISABLED_FILE_PREFIX, "");
+        }
+        return FilenameUtils.removeExtension(coreName);
+    }
+}
diff --git a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ExileFiles.java b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ExileFiles.java
new file mode 100644
index 0000000..30168a7
--- /dev/null
+++ b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ExileFiles.java
@@ -0,0 +1,61 @@
+package com.matthewjamesbriggs.xmltestgen;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+import java.io.File;
+
+/**
+ * The data filenames associated with a custom exile test, e.g. exile_foo.xml, exile_foo.output.xml,
+ * exile_foo.metadata.json.
+ */
+@AllArgsConstructor public class ExileFiles {
+    @Getter
+    private final boolean isDisabled;
+    @Getter
+    private final String coreName;
+    @Getter
+    private final File directory;
+
+    ExileFiles(File file) throws TestGenException {
+        if (!ExileConstants.isExileInput(file)) {
+            throw new TestGenException("'%s' is not an exile input file", file.toString());
+        }
+        isDisabled = ExileConstants.isExileDisabledInput(file);
+        coreName = ExileConstants.getCoreName(file);
+        directory = F.canonicalize(new File(file.getParent()));
+        F.checkDir(directory);
+    }
+
+    String getFilenamePrefix() {
+        if (isDisabled) {
+            return ExileConstants.EXILE_DISABLED_FILE_PREFIX;
+        } else {
+            return ExileConstants.EXILE_FILE_PREFIX;
+        }
+    }
+
+    String getInputFilename() {
+        return getFilenamePrefix() + getCoreName() + ".xml";
+    }
+
+    String getOutputFilename() {
+        return getFilenamePrefix() + getCoreName() + ExileConstants.OUTPUT_FILE_SUFFIX;
+    }
+
+    String getMetadataFilename() {
+        return getFilenamePrefix() + getCoreName() + ExileConstants.METADATA_FILE_SUFFIX;
+    }
+
+    File getInputFile() {
+        return new File(directory, getInputFilename());
+    }
+
+    File getOutputFile() {
+        return new File(directory, getOutputFilename());
+    }
+
+    File getMetadataFile() {
+        return new File(directory, getMetadataFilename());
+    }
+}
diff --git a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/F.java b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/F.java
index 48dd7cf..ebbd990 100644
--- a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/F.java
+++ b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/F.java
@@ -166,10 +166,6 @@ static InputStreamReader readFile(File file) throws TestGenException {
 
 
     static void write(OutputStreamWriter os, String format, Object... args) throws TestGenException {
-        //        String x = new String(new byte[], StandardCharsets.UTF_8);
-
-
-        //        new Formatter()
         String line = String.format(format, args);
         try {
             os.write(line);
diff --git a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ProgramOptions.java b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ProgramOptions.java
index 59e3fe4..b10617f 100644
--- a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ProgramOptions.java
+++ b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/ProgramOptions.java
@@ -13,7 +13,6 @@ class ProgramOptions {
     private static final String OPT_XML_OUTDIR = "xml-outdir";
     private static final String OPT_SCHEMA_OUTDIR = "schema-outdir";
     private static final String OPT_RUST_ROOT = "rust-root";
-    private static final String OPT_EXILE_TESTS = "exile-tests";
 
     @Getter
     private final File w3cXml;
@@ -24,13 +23,12 @@ class ProgramOptions {
     @Getter
     private final File customSchema;
     @Getter
+    // TODO - rename, this is confusing
     private final File xmlOutdir;
     @Getter
     private final File schemaOutdir;
     @Getter
     private final File rustRoot;
-    @Getter
-    private final File exileTests;
 
     /**
      * Private all-args constructor. Use the static parse function to construct from command line arguments.
@@ -42,7 +40,6 @@ class ProgramOptions {
      * @param xmlOutdir:    the directory into which rust xml tests will be written.
      * @param schemaOutdir: the directory into which rust schema tests will be written.
      * @param rustRoot:     the path to the root of the Rust workspace containing the exile crate.
-     * @param exileTests:   the path to the to the custom XML tests created for the exile library.
      */
     private ProgramOptions(File w3cXml,
                            File w3cSchema,
@@ -50,8 +47,7 @@ private ProgramOptions(File w3cXml,
                            File customSchema,
                            File xmlOutdir,
                            File schemaOutdir,
-                           File rustRoot,
-                           File exileTests) {
+                           File rustRoot) {
         this.w3cXml = w3cXml;
         this.w3cSchema = w3cSchema;
         this.customXml = customXml;
@@ -59,7 +55,6 @@ private ProgramOptions(File w3cXml,
         this.xmlOutdir = xmlOutdir;
         this.schemaOutdir = schemaOutdir;
         this.rustRoot = rustRoot;
-        this.exileTests = exileTests;
     }
 
     /**
@@ -100,13 +95,6 @@ static ProgramOptions parse(String[] args) throws TestGenException {
         rr.setRequired(true);
         options.addOption(rr);
 
-        Option exile = new Option("h",
-                OPT_EXILE_TESTS,
-                true,
-                "directory where the custom XML tests, created for the exile library, reside");
-        exile.setRequired(true);
-        options.addOption(exile);
-
         CommandLineParser parser = new DefaultParser();
         HelpFormatter formatter = new HelpFormatter();
         CommandLine cmd;
@@ -126,7 +114,6 @@ static ProgramOptions parse(String[] args) throws TestGenException {
         File xmlOutdir = new File(cmd.getOptionValue(OPT_XML_OUTDIR));
         File schemaOutdir = new File(cmd.getOptionValue(OPT_SCHEMA_OUTDIR));
         File rustRoot = new File(cmd.getOptionValue(OPT_RUST_ROOT));
-        File exileTests = new File(cmd.getOptionValue(OPT_EXILE_TESTS));
 
         try {
             if (!w3cXml.exists() || !w3cXml.isFile()) {
@@ -141,22 +128,23 @@ static ProgramOptions parse(String[] args) throws TestGenException {
                 throw new TestGenException("Unable to verify " + OPT_XML_OUTDIR + ", " + xmlOutdir.getPath());
             }
             // TODO - verify schemaOutdir
-            if (!exileTests.exists() || !exileTests.isDirectory()) {
-                throw new TestGenException("Unable to verify " + OPT_EXILE_TESTS + ", " + exileTests.getPath());
-            }
         } catch (TestGenException e) {
             System.out.println(e.getMessage());
             formatter.printHelp("xmltestgen", options);
             throw e;
         }
 
-        return new ProgramOptions(w3cXml,
-                w3cSchema,
-                customXml,
-                customSchema,
-                xmlOutdir,
-                schemaOutdir,
-                rustRoot,
-                exileTests);
+        return new ProgramOptions(w3cXml, w3cSchema, customXml, customSchema, xmlOutdir, schemaOutdir, rustRoot);
+    }
+
+    /**
+     * This is the directory into which W3C test XML files will be copied, and in which custom Exile test files live
+     * permanently.
+     *
+     * @return The directory explained above.
+     * @throws TestGenException
+     */
+    File getRustDataDir() throws TestGenException {
+        return F.canonicalize(new File(xmlOutdir, ExileConstants.DIRECTORY));
     }
 }
diff --git a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/S.java b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/S.java
new file mode 100644
index 0000000..89e2bb3
--- /dev/null
+++ b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/S.java
@@ -0,0 +1,47 @@
+package com.matthewjamesbriggs.xmltestgen;
+
+public class S {
+    static String getSnakeCase(String s) {
+        StringBuilder result = new StringBuilder(s.length() + 4);
+        boolean wasUnderscore = false;
+        for (int i = 0, n = s.length(); i < n; i++) {
+            char c = s.charAt(i);
+            if (i == 0 && !isLetter(c)) {
+                result.append('x');
+                result.append(ExileConstants.SEPARATOR);
+                wasUnderscore = true;
+            }
+            if (isLetter(c)) {
+                result.append(Character.toLowerCase(c));
+                wasUnderscore = false;
+            } else if (isDigit(c)) {
+                result.append(c);
+                wasUnderscore = false;
+            } else if (!wasUnderscore) {
+                result.append(ExileConstants.SEPARATOR);
+                wasUnderscore = true;
+            }
+        }
+        return result.toString();
+    }
+
+    static boolean isLetter(char c) {
+        return isLetterUpper(c) || isLetterLower(c);
+    }
+
+    static boolean isAlphanumeric(char c) {
+        return isLetter(c) || isDigit(c);
+    }
+
+    static boolean isLetterUpper(char c) {
+        return c >= 65 && c <= 90;
+    }
+
+    static boolean isLetterLower(char c) {
+        return c >= 97 && c <= 122;
+    }
+
+    static boolean isDigit(char c) {
+        return c >= 48 && c <= 57;
+    }
+}
diff --git a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/TestGenException.java b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/TestGenException.java
index 77be029..448fd34 100644
--- a/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/TestGenException.java
+++ b/testgen/xmltestgen/src/main/java/com/matthewjamesbriggs/xmltestgen/TestGenException.java
@@ -1,5 +1,7 @@
 package com.matthewjamesbriggs.xmltestgen;
 
+import java.io.OutputStreamWriter;
+
 public class TestGenException extends Exception {
     private static final long serialVersionUID = -617463356193004953L;
 
@@ -10,4 +12,12 @@ public TestGenException(String message) {
     public TestGenException(String message, Throwable cause) {
         super(message, cause);
     }
+
+    public TestGenException(Throwable cause, String format, Object... args) {
+        super(String.format(format, args), cause);
+    }
+
+    public TestGenException(String format, Object... args) {
+        super(String.format(format, args));
+    }
 }
diff --git a/testgen/xmltestgen/src/test/java/com/matthewjamesbriggs/xmltestgen/ExileConstantsTest.java b/testgen/xmltestgen/src/test/java/com/matthewjamesbriggs/xmltestgen/ExileConstantsTest.java
new file mode 100644
index 0000000..de1d316
--- /dev/null
+++ b/testgen/xmltestgen/src/test/java/com/matthewjamesbriggs/xmltestgen/ExileConstantsTest.java
@@ -0,0 +1,50 @@
+package com.matthewjamesbriggs.xmltestgen;
+
+import org.junit.Test;
+
+import java.io.File;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
+
+public class ExileConstantsTest {
+    @Test
+    public void isExileTest() {
+        assertTrue(ExileConstants.isExile(new File("exile_x")));
+        assertFalse(ExileConstants.isExile(new File("exile")));
+        assertTrue(ExileConstants.isExileDisabled(new File("exile_disabled.")));
+        assertFalse(ExileConstants.isExileDisabled(new File("exile_disabled")));
+    }
+
+    @Test
+    public void isEnabledExileInputTest() {
+        assertTrue(ExileConstants.isExileInput(new File("exile_anything.xml")));
+        assertFalse(ExileConstants.isExileInput(new File("exile_anything.output.xml")));
+        assertFalse(ExileConstants.isExileInput(new File("exile_anything.metadata.json")));
+        assertFalse(ExileConstants.isExileInput(new File("exile_anything.weird")));
+        assertTrue(ExileConstants.isEnabledExileInput(new File("exile_anything.xml")));
+        assertFalse(ExileConstants.isEnabledExileInput(new File("exile_disabled.anything.xml")));
+        assertFalse(ExileConstants.isEnabledExileInput(new File("exile_anything.json")));
+        assertTrue(ExileConstants.isExileDisabledInput(new File("exile_disabled.anything.xml")));
+        assertTrue(ExileConstants.isExileDisabledInput(new File("exile_disabled.xml")));
+        assertFalse(ExileConstants.isExileDisabledInput(new File("exile_disabled_anything.xml")));
+        assertFalse(ExileConstants.isExileDisabledInput(new File("exile_anything.xml")));
+        assertFalse(ExileConstants.isExileDisabledInput(new File("exile_disabled_anything.output.xml")));
+    }
+
+
+    @Test
+    public void isMetadataTest() {
+        assertTrue(ExileConstants.isExileMetadata(new File("exile_anything.metadata.json")));
+        assertTrue(ExileConstants.isExileMetadata(new File("exile_disabled_anything.metadata.json")));
+        assertFalse(ExileConstants.isExileMetadata(new File("exile_disabled_anything.metadata.xml")));
+    }
+
+    @Test
+    public void isExileOutput() {
+        assertTrue(ExileConstants.isExileOutput(new File("exile_anything.output.xml")));
+        assertTrue(ExileConstants.isExileOutput(new File("exile_disabled_anything.output.xml")));
+        assertFalse(ExileConstants.isExileOutput(new File("exile_disabled_anything.output.json")));
+    }
+}
\ No newline at end of file
diff --git a/testgen/xmltestgen/src/test/java/com/matthewjamesbriggs/xmltestgen/STest.java b/testgen/xmltestgen/src/test/java/com/matthewjamesbriggs/xmltestgen/STest.java
new file mode 100644
index 0000000..daa5320
--- /dev/null
+++ b/testgen/xmltestgen/src/test/java/com/matthewjamesbriggs/xmltestgen/STest.java
@@ -0,0 +1,23 @@
+package com.matthewjamesbriggs.xmltestgen;
+
+import org.junit.Test;
+
+import static org.junit.Assert.*;
+
+public class STest {
+    @Test
+    public void getSnakeCaseTest() {
+        String result = S.getSnakeCase("ezfile");
+        assertEquals("ezfile", result);
+    }
+
+    public static void isLetterTest() {
+        assertTrue(S.isLetter('z'));
+        assertTrue(S.isLetter('Z'));
+        assertTrue(S.isLetter('a'));
+        assertTrue(S.isLetter('A'));
+        assertFalse(S.isLetter('0'));
+        assertFalse(S.isLetter('9'));
+        assertFalse(S.isLetter(' '));
+    }
+}
diff --git a/xtest/data/cd_catalog.xml b/xtest/data/cd_catalog.xml
deleted file mode 100644
index de15a6a..0000000
--- a/xtest/data/cd_catalog.xml
+++ /dev/null
@@ -1,211 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<CATALOG>
-  <CD>
-    <TITLE>Empire Burlesque</TITLE>
-    <ARTIST>Bob Dylan</ARTIST>
-    <COUNTRY>USA</COUNTRY>
-    <COMPANY>Columbia</COMPANY>
-    <PRICE>10.90</PRICE>
-    <YEAR>1985</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Hide your heart</TITLE>
-    <ARTIST>Bonnie Tyler</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>CBS Records</COMPANY>
-    <PRICE>9.90</PRICE>
-    <YEAR>1988</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Greatest Hits</TITLE>
-    <ARTIST>Dolly Parton</ARTIST>
-    <COUNTRY>USA</COUNTRY>
-    <COMPANY>RCA</COMPANY>
-    <PRICE>9.90</PRICE>
-    <YEAR>1982</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Still got the blues</TITLE>
-    <ARTIST>Gary Moore</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>Virgin records</COMPANY>
-    <PRICE>10.20</PRICE>
-    <YEAR>1990</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Eros</TITLE>
-    <ARTIST>Eros Ramazzotti</ARTIST>
-    <COUNTRY>EU</COUNTRY>
-    <COMPANY>BMG</COMPANY>
-    <PRICE>9.90</PRICE>
-    <YEAR>1997</YEAR>
-  </CD>
-  <CD>
-    <TITLE>One night only</TITLE>
-    <ARTIST>Bee Gees</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>Polydor</COMPANY>
-    <PRICE>10.90</PRICE>
-    <YEAR>1998</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Sylvias Mother</TITLE>
-    <ARTIST>Dr.Hook</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>CBS</COMPANY>
-    <PRICE>8.10</PRICE>
-    <YEAR>1973</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Maggie May</TITLE>
-    <ARTIST>Rod Stewart</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>Pickwick</COMPANY>
-    <PRICE>8.50</PRICE>
-    <YEAR>1990</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Romanza</TITLE>
-    <ARTIST>Andrea Bocelli</ARTIST>
-    <COUNTRY>EU</COUNTRY>
-    <COMPANY>Polydor</COMPANY>
-    <PRICE>10.80</PRICE>
-    <YEAR>1996</YEAR>
-  </CD>
-  <CD>
-    <TITLE>When a man loves a woman</TITLE>
-    <ARTIST>Percy Sledge</ARTIST>
-    <COUNTRY>USA</COUNTRY>
-    <COMPANY>Atlantic</COMPANY>
-    <PRICE>8.70</PRICE>
-    <YEAR>1987</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Black angel</TITLE>
-    <ARTIST>Savage Rose</ARTIST>
-    <COUNTRY>EU</COUNTRY>
-    <COMPANY>Mega</COMPANY>
-    <PRICE>10.90</PRICE>
-    <YEAR>1995</YEAR>
-  </CD>
-  <CD>
-    <TITLE>1999 Grammy Nominees</TITLE>
-    <ARTIST>Many</ARTIST>
-    <COUNTRY>USA</COUNTRY>
-    <COMPANY>Grammy</COMPANY>
-    <PRICE>10.20</PRICE>
-    <YEAR>1999</YEAR>
-  </CD>
-  <CD>
-    <TITLE>For the good times</TITLE>
-    <ARTIST>Kenny Rogers</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>Mucik Master</COMPANY>
-    <PRICE>8.70</PRICE>
-    <YEAR>1995</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Big Willie style</TITLE>
-    <ARTIST>Will Smith</ARTIST>
-    <COUNTRY>USA</COUNTRY>
-    <COMPANY>Columbia</COMPANY>
-    <PRICE>9.90</PRICE>
-    <YEAR>1997</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Tupelo Honey</TITLE>
-    <ARTIST>Van Morrison</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>Polydor</COMPANY>
-    <PRICE>8.20</PRICE>
-    <YEAR>1971</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Soulsville</TITLE>
-    <ARTIST>Jorn Hoel</ARTIST>
-    <COUNTRY>Norway</COUNTRY>
-    <COMPANY>WEA</COMPANY>
-    <PRICE>7.90</PRICE>
-    <YEAR>1996</YEAR>
-  </CD>
-  <CD>
-    <TITLE>The very best of</TITLE>
-    <ARTIST>Cat Stevens</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>Island</COMPANY>
-    <PRICE>8.90</PRICE>
-    <YEAR>1990</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Stop</TITLE>
-    <ARTIST>Sam Brown</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>A and M</COMPANY>
-    <PRICE>8.90</PRICE>
-    <YEAR>1988</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Bridge of Spies</TITLE>
-    <ARTIST>T'Pau</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>Siren</COMPANY>
-    <PRICE>7.90</PRICE>
-    <YEAR>1987</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Private Dancer</TITLE>
-    <ARTIST>Tina Turner</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>Capitol</COMPANY>
-    <PRICE>8.90</PRICE>
-    <YEAR>1983</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Midt om natten</TITLE>
-    <ARTIST>Kim Larsen</ARTIST>
-    <COUNTRY>EU</COUNTRY>
-    <COMPANY>Medley</COMPANY>
-    <PRICE>7.80</PRICE>
-    <YEAR>1983</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Pavarotti Gala Concert</TITLE>
-    <ARTIST>Luciano Pavarotti</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>DECCA</COMPANY>
-    <PRICE>9.90</PRICE>
-    <YEAR>1991</YEAR>
-  </CD>
-  <CD>
-    <TITLE>The dock of the bay</TITLE>
-    <ARTIST>Otis Redding</ARTIST>
-    <COUNTRY>USA</COUNTRY>
-    <COMPANY>Stax Records</COMPANY>
-    <PRICE>7.90</PRICE>
-    <YEAR>1968</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Picture book</TITLE>
-    <ARTIST>Simply Red</ARTIST>
-    <COUNTRY>EU</COUNTRY>
-    <COMPANY>Elektra</COMPANY>
-    <PRICE>7.20</PRICE>
-    <YEAR>1985</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Red</TITLE>
-    <ARTIST>The Communards</ARTIST>
-    <COUNTRY>UK</COUNTRY>
-    <COMPANY>London</COMPANY>
-    <PRICE>7.80</PRICE>
-    <YEAR>1987</YEAR>
-  </CD>
-  <CD>
-    <TITLE>Unchain my heart</TITLE>
-    <ARTIST>Joe Cocker</ARTIST>
-    <COUNTRY>USA</COUNTRY>
-    <COMPANY>EMI</COMPANY>
-    <PRICE>8.20</PRICE>
-    <YEAR>1987</YEAR>
-  </CD>
-</CATALOG>
diff --git a/xtest/data/doctypes-comments-pis.xml b/xtest/data/doctypes-comments-pis.xml
deleted file mode 100644
index f883e9b..0000000
--- a/xtest/data/doctypes-comments-pis.xml
+++ /dev/null
@@ -1,21 +0,0 @@
-<?xml version="1.0"?>
-<!-- comment before doctype -->
-<?pi before doctype ?>
-<!DOCTYPE note [
-<!ELEMENT note (to,from,heading,body)>
-<!ELEMENT to (#PCDATA)>
-<!ELEMENT from (#PCDATA)>
-<!ELEMENT heading (#PCDATA)>
-<!ELEMENT body (#PCDATA)>
-]>
-<!-- comment after doctype -->
-<?pi after doctype ?>
-<note>
-    <!-- comment as element node -->
-    <to>Tove</to>
-    <from>Jani<?pi in element ?></from>
-    <heading>Reminder</heading>
-    <body>Don't forget me this weekend</body>
-</note>
-<!-- at the end -->
-<?pi at the end ?>
diff --git a/xtest/data/escapes.xml b/xtest/data/escapes.xml
deleted file mode 100644
index a05e4bf..0000000
--- a/xtest/data/escapes.xml
+++ /dev/null
@@ -1,9 +0,0 @@
-<?xml version="1.0"       
-?>
-<escapes
-  >
-  <a s = "&lt;&#128515;&gt;"
-  />
-  <_b x
-    ="&amp;">&apos;&quot;&#38;</_b>
-</escapes>
diff --git a/xtest/data/ezfile.xml b/xtest/data/ezfile.xml
deleted file mode 100644
index d93969c..0000000
--- a/xtest/data/ezfile.xml
+++ /dev/null
@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<cats>
-  <cat name="bones"/>
-  <cat name="bishop">punks</cat>
-</cats>
diff --git a/xtest/data/pi.xml b/xtest/data/pi.xml
deleted file mode 100644
index d05a932..0000000
--- a/xtest/data/pi.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.1" encoding="UTF-8"?>
-<?a b?>
-<c>
-    <?d e?>
-    <f/>
-    <?g h?>
-</c>
-<?i j?>
\ No newline at end of file
diff --git a/xtest/data/simple_musicxml.xml b/xtest/data/simple_musicxml.xml
deleted file mode 100644
index 5de229a..0000000
--- a/xtest/data/simple_musicxml.xml
+++ /dev/null
@@ -1,11 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<score-partwise version="3.0">
-    <part-list>
-        <score-part id="P1">
-            <part-name>No Name</part-name>
-        </score-part>
-    </part-list>
-    <part id="P1">
-        <measure number="1"/>
-    </part>
-</score-partwise>
\ No newline at end of file
diff --git a/xtest/data/single_quotes.xml b/xtest/data/single_quotes.xml
deleted file mode 100644
index effd4f6..0000000
--- a/xtest/data/single_quotes.xml
+++ /dev/null
@@ -1,2 +0,0 @@
-<?xml version='1.1' encoding="UTF-8"?>
-<foo attr1="bones" attr2='bish'/>