PR #38 mv test suites from main crate

Merge branch 'test_crates'

Author: hellux

.github/workflows/ci.yml

@@ -34,8 +34,8 @@ jobs:
             RUSTDOCFLAGS: -D warnings
         run: |
           make check
-  suite:
-    name: Build and run external tests
+  test_html:
+    name: Build and run HTML tests
     runs-on: ubuntu-latest
     steps:
       - name: "Checkout repo"
@@ -44,14 +44,14 @@ jobs:
         run: |
           rustup update 1.56
           rustup default 1.56
-      - name: "Run unit tests"
-        run: make suite
+      - name: "Run HTML unit tests"
+        run: make test_html_ut
       - name: "Setup node"
         uses: actions/setup-node@v3
         with:
           node-version: 18
-      - name: "Compare benchmark files"
-        run: make suite_bench
+      - name: "Compare HTML with reference implementation"
+        run: make test_html_ref
   lint:
     name: Lint
     runs-on: ubuntu-latest

Cargo.lock

@@ -26,6 +26,8 @@ members = [
     "bench/iai",
     "bench/input",
     "examples/jotdown_wasm",
+    "tests/html-ref",
+    "tests/html-ut",
 ]
 exclude = [
     "tests/afl",
@@ -39,6 +41,4 @@ doc = false
 [features]
 default = ["html"]
 html = [] # html renderer and minimal cli binary
-suite = [] # test suite
-suite_bench = [] # bench test suite
 deterministic = [] # for stable fuzzing

Cargo.toml

@@ -15,34 +15,34 @@ docs:
 
 .PHONY: lint
 lint:
+	cargo clippy --workspace -- -D warnings
+	cargo clippy --workspace --no-default-features -- -D warnings
+	cargo clippy --workspace --all-features -- -D warnings
 	cargo fmt --all -- --check
-	cargo clippy -- -D warnings
-	cargo clippy --no-default-features -- -D warnings
-	cargo clippy --all-features -- -D warnings
 
 .PHONY: check
 check:
 	cargo test --workspace
 	cargo test --workspace --no-default-features
 
-.PHONY: suite
-suite:
+.PHONY: test_html_ut
+test_html_ut:
 	git submodule update --init modules/djot.js
 	for f in $$(find modules/djot.js/test -name '*.test' | xargs basename -a); do \
-		ln -fs ../../modules/djot.js/test/$$f tests/suite/djot_js_$$f; \
+		ln -fs ../../../modules/djot.js/test/$$f tests/html-ut/ut/djot_js_$$f; \
 	done
-	(cd tests/suite && make)
-	cargo test --features suite suite::
+	cargo test -p test-html-ut
+	cargo test -p test-html-ut -- --ignored 2>/dev/null | grep -q 'test result: FAILED. 0 passed'
 
-.PHONY: suite_bench
-suite_bench:
+.PHONY: test_html_ref
+test_html_ref:
 	git submodule update --init modules/djot.js
 	for f in $$(find modules/djot.js/bench -name '*.dj' | xargs basename -a); do \
 		dst=$$(echo $$f | sed 's/-/_/g'); \
-		ln -fs ../../modules/djot.js/bench/$$f tests/bench/$$dst; \
+		ln -fs ../../modules/djot.js/bench/$$f tests/html-ref/$$dst; \
 	done
-	(cd tests/bench && make)
-	cargo test --features suite_bench bench::
+	cargo test -p test-html-ref
+	cargo test -p test-html-ref -- --ignored 2>/dev/null | grep -q 'test result: FAILED. 0 passed'
 
 .PHONY: bench
 bench:
@@ -52,9 +52,6 @@ bench:
 		ln -fs ../../modules/djot.js/bench/$$f bench/input/$$dst; \
 	done
 
-cov: suite suite_bench
-	LLVM_COV=llvm-cov LLVM_PROFDATA=llvm-profdata cargo llvm-cov --features=suite,suite_bench --workspace --html --ignore-run-fail
-
 AFL_TARGET?=parse
 AFL_JOBS?=1
 AFL_TARGET_CRASH?=crashes
@@ -101,11 +98,12 @@ afl_tmin:
 
 clean:
 	cargo clean
+	rm -rf bench/iai/target
 	git submodule deinit -f --all
-	find tests -type l -path 'tests/suite/*.test' -print0 | xargs -0 rm -f
-	(cd tests/suite && make clean)
-	rm -f tests/bench/*.dj
-	(cd tests/bench && make clean)
+	find tests -type l -path 'tests/html-ut/ut/*.test' -print0 | xargs -0 rm -f
+	(cd tests/html-ut && make clean)
+	rm -f tests/html-ref/*.dj
+	(cd tests/html-ref && make clean)
 	find bench -type l -path 'bench/*.dj' -print0 | xargs -0 rm -f
 	rm -rf tests/afl/out
 	(cd examples/jotdown_wasm && make clean)

Makefile

@@ -121,19 +121,19 @@ including:
 - footnotes.
 
 The HTML output is in some cases not exactly identical to the [reference
-implementation][djot-js]. There are two test suites that compares Jotdown with
-the reference implementation. One uses the unit tests of the reference
-implementation and runs them with Jotdown. It can be run with:
+implementation][djot-js]. There are two test suites that compares Jotdown's
+HTML output with that of the reference implementation. One uses the unit tests
+of the reference implementation and runs them with Jotdown. It can be run with:
 
 ```
-$ make suite
+$ make test_html_ut
 ```
 
 Another target uses the reference implementation to generate html output for
 its benchmark files and compares it to the output of Jotdown:
 
 ```
-$ make suite_bench
+$ make test_html_ref
 ```
 
 Note that it requires node in order to run the reference implementation.

README.md

@@ -392,7 +392,10 @@ impl<'s> Writer<'s> {
             Event::Softbreak => out.write_char('\n')?,
             Event::Escape | Event::Blankline => {}
             Event::ThematicBreak(attrs) => {
-                out.write_str("\n<hr")?;
+                if self.not_first_line {
+                    out.write_char('\n')?;
+                }
+                out.write_str("<hr")?;
                 for (a, v) in attrs.iter() {
                     write!(out, r#" {}=""#, a)?;
                     v.parts().try_for_each(|part| write_attr(part, &mut out))?;

src/html.rs

@@ -0,0 +1,12 @@
+[package]
+name = "test-html-ref"
+description = "Reference implementation HTML output comparison tests"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+jotdown = { path = "../.." }
+
+[lib]
+name = "test_html_ref"
+path = "lib.rs"

tests/html-ref/Cargo.toml

@@ -6,8 +6,8 @@ TEST=${TEST_DJ:.dj=}
 DJOT_JS=../../modules/djot.js
 DJOT_JS_SRC=$(shell find ${DJOT_JS}/src -name '.ts')
 
-mod.rs: ${TEST_DJ} html
-	echo "use crate::suite_test;" > $@
+ref.rs: ${TEST_DJ} html
+	echo "use crate::compare;" > $@
 	for name in ${TEST}; do \
 		name_snake=$$(basename -a $$name); \
 		skip_reason=$$(grep -E "^$${name_snake}:" skip | cut -d: -f2); \
@@ -17,10 +17,8 @@ mod.rs: ${TEST_DJ} html
 		printf '    let src = r###"'; \
 		cat $$name.dj; \
 		echo '"###;'; \
-		printf '    let expected = r###"'; \
-		cat $$name.html; \
-		echo '"###;'; \
-		echo "    suite_test!(src, expected);"; \
+		printf '    let expected = "%s";' "$$name.html"; \
+		echo "    compare!(src, expected);"; \
 		echo "}"; \
 	done >> $@
 
@@ -36,6 +34,7 @@ djot-js: ${DJOT_JS_SRC}
 	chmod +x $@
 
 clean:
-	rm -f *.rs *.html
+	rm -f ref.rs
+	rm -f *.html
 	rm -f html
 	rm -f djot-js

tests/bench/Makefile tests/html-ref/Makefiletests/bench/Makefile renamed to tests/html-ref/Makefile

@@ -0,0 +1,17 @@
+fn main() {
+    let has_dj = std::fs::read_dir(".").unwrap().any(|e| {
+        e.map_or(false, |e| {
+            e.path()
+                .extension()
+                .map_or(false, |ext| ext.to_str() == Some("dj"))
+        })
+    });
+    if has_dj {
+        let status = std::process::Command::new("make")
+            .status()
+            .expect("failed to execute make");
+        assert!(status.success());
+    } else {
+        std::fs::write("ref.rs", &[b'\n']).unwrap();
+    }
+}

tests/html-ref/build.rs

@@ -0,0 +1,32 @@
+#[cfg(test)]
+mod r#ref;
+
+#[macro_export]
+macro_rules! compare {
+    ($src:expr, $expected:expr) => {
+        use jotdown::Render;
+        let src = $src;
+        let expected = std::fs::read_to_string($expected).expect("read failed");
+        let p = jotdown::Parser::new(src);
+        let mut actual = String::new();
+        jotdown::html::Renderer::default()
+            .push(p, &mut actual)
+            .unwrap();
+        assert_eq!(actual, expected, "\n{}", {
+            use std::io::Write;
+            let mut child = std::process::Command::new("diff")
+                .arg("--color=always")
+                .arg("-")
+                .arg($expected)
+                .stdin(std::process::Stdio::piped())
+                .stdout(std::process::Stdio::piped())
+                .spawn()
+                .expect("spawn diff failed");
+            let mut stdin = child.stdin.take().unwrap();
+            let actual = actual.clone();
+            std::thread::spawn(move || stdin.write_all(actual.as_bytes()).unwrap());
+            let stdout = child.wait_with_output().unwrap().stdout;
+            String::from_utf8(stdout).unwrap()
+        });
+    };
+}