summaryrefslogtreecommitdiffhomepage
path: root/dlang/test
diff options
context:
space:
mode:
Diffstat (limited to 'dlang/test')
-rw-r--r--dlang/test/agree.d84
-rw-r--r--dlang/test/dump.d35
2 files changed, 119 insertions, 0 deletions
diff --git a/dlang/test/agree.d b/dlang/test/agree.d
new file mode 100644
index 0000000..bdf1b2e
--- /dev/null
+++ b/dlang/test/agree.d
@@ -0,0 +1,84 @@
+/++
+ Do the two loaders agree?
+
+ The library's whole purpose is that a writer cannot tell which
+ serialisation it was handed. That is only true if loading a document's
+ .ssp and loading its .ocda.db give the same model, so this asks.
+
+ Usage: agree <doc>.ssp <doc>.ocda.db [lang]
++/
+import std.conv : to;
+import std.stdio;
+import ocda.model;
+import ocda.load;
+
+int main(string[] args) {
+ if (args.length < 3) {
+ stderr.writeln("usage: agree <doc>.ssp <doc>.ocda.db [lang]");
+ return 2;
+ }
+ string lang = (args.length > 3) ? args[3] : "";
+ OcdaDocument a, b;
+ try {
+ a = load(args[1]);
+ b = load(args[2], lang);
+ } catch (Exception e) {
+ stderr.writeln("error: ", e.msg);
+ return 2;
+ }
+
+ int differences = 0;
+ void differ(string what, string from_ssp, string from_db) {
+ writeln(" differ: ", what);
+ writeln(" .ssp: ", from_ssp);
+ writeln(" .ocda.db: ", from_db);
+ differences++;
+ }
+
+ if (a.format_version != b.format_version) {
+ differ("format_version", a.format_version, b.format_version);
+ }
+ if (a.source_filename != b.source_filename) {
+ differ("source_filename", a.source_filename, b.source_filename);
+ }
+
+ /+ ↓ the sections, object by object. Position within a section is the
+ identity to compare on: an ocn is not unique and 0 is shared +/
+ static immutable sections = ["head", "toc", "body", "endnotes", "glossary",
+ "bibliography", "bookindex", "blurb", "tail"];
+ foreach (name; sections) {
+ auto sa = a.sectionByName(name);
+ auto sb = b.sectionByName(name);
+ if (sa is null || sb is null) { continue; }
+ if ((*sa).length != (*sb).length) {
+ differ(name ~ " object count", (*sa).length.to!string, (*sb).length.to!string);
+ continue;
+ }
+ foreach (i, oa; *sa) {
+ auto ob = (*sb)[i];
+ string at = name ~ "[" ~ i.to!string ~ "]";
+ if (oa.ocn != ob.ocn) { differ(at ~ " ocn", oa.ocn.to!string, ob.ocn.to!string); }
+ if (oa.is_a != ob.is_a) { differ(at ~ " is_a", oa.is_a, ob.is_a); }
+ if (oa.is_of_type != ob.is_of_type) { differ(at ~ " is_of_type", oa.is_of_type, ob.is_of_type); }
+ if (oa.part != ob.part) { differ(at ~ " part", oa.part, ob.part); }
+ if (oa.parent_ocn != ob.parent_ocn) { differ(at ~ " parent", oa.parent_ocn.to!string, ob.parent_ocn.to!string); }
+ if (oa.heading_level != ob.heading_level) { differ(at ~ " level", oa.heading_level, ob.heading_level); }
+ if (oa.sha256 != ob.sha256) { differ(at ~ " sha256", oa.sha256, ob.sha256); }
+ if (oa.text != ob.text) { differ(at ~ " text", oa.text, ob.text); }
+ if (oa.ancestors != ob.ancestors) {
+ differ(at ~ " ancestors", oa.ancestors.to!string, ob.ancestors.to!string);
+ }
+ if (oa.images.length != ob.images.length) {
+ differ(at ~ " image count", oa.images.length.to!string, ob.images.length.to!string);
+ }
+ if (differences > 12) { writeln(" ... stopping after 12"); return 1; }
+ }
+ }
+
+ if (differences == 0) {
+ writeln("agree: the two loaders give the same model");
+ return 0;
+ }
+ writeln(differences, " difference(s)");
+ return 1;
+}
diff --git a/dlang/test/dump.d b/dlang/test/dump.d
new file mode 100644
index 0000000..17aa9bb
--- /dev/null
+++ b/dlang/test/dump.d
@@ -0,0 +1,35 @@
+/++
+ Write a loaded abstraction out canonically.
+
+ The oracle for everything that claims to implement this model: load a
+ .ssp or a .ocda.db and print the model, deterministically, so that two
+ implementations can be compared with diff.
+
+ Usage: ocda-dump [--unknown] <file>.ssp|<file>.ocda.db [lang]
++/
+import std.stdio;
+import ocda.model;
+import ocda.load;
+import ocda.dump;
+
+int main(string[] args) {
+ bool unknown = false;
+ string[] rest;
+ foreach (a; args[1 .. $]) {
+ if (a == "--unknown") { unknown = true; } else { rest ~= a; }
+ }
+ if (rest.length < 1) {
+ stderr.writeln("usage: ocda-dump [--unknown] <file>.ssp|<file>.ocda.db [lang]");
+ return 2;
+ }
+ string lang = (rest.length > 1) ? rest[1] : "";
+ OcdaDocument doc;
+ try {
+ doc = load(rest[0], lang);
+ } catch (Exception e) {
+ stderr.writeln("error: ", e.msg);
+ return 2;
+ }
+ write(unknown ? dumpUnknown(doc) : dumpDocument(doc));
+ return 0;
+}