From 4c06c8554c35887f8f5147783953b2b7e7c2327f Mon Sep 17 00:00:00 2001
From: Titus Wormer <tituswormer@gmail.com>
Date: Wed, 8 Jun 2022 15:52:16 +0200
Subject: .

---
 tests/code_fenced.rs | 266 +++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 266 insertions(+)
 create mode 100644 tests/code_fenced.rs

(limited to 'tests/code_fenced.rs')

diff --git a/tests/code_fenced.rs b/tests/code_fenced.rs
new file mode 100644
index 0000000..46fa9cb
--- /dev/null
+++ b/tests/code_fenced.rs
@@ -0,0 +1,266 @@
+extern crate micromark;
+use micromark::micromark;
+
+#[test]
+fn code_fenced() {
+    assert_eq!(
+        micromark("```\n<\n >\n```"),
+        "<pre><code>&lt;\n &gt;\n</code></pre>",
+        "should support fenced code w/ grave accents"
+    );
+
+    assert_eq!(
+        micromark("~~~\n<\n >\n~~~"),
+        "<pre><code>&lt;\n &gt;\n</code></pre>",
+        "should support fenced code w/ tildes"
+    );
+
+    // To do: code (text).
+    // assert_eq!(
+    //     micromark("``\nfoo\n``"),
+    //     "<p><code>foo</code></p>",
+    //     "should not support fenced code w/ less than three markers"
+    // );
+
+    assert_eq!(
+        micromark("```\naaa\n~~~\n```"),
+        "<pre><code>aaa\n~~~\n</code></pre>",
+        "should not support a tilde closing sequence for a grave accent opening sequence"
+    );
+
+    assert_eq!(
+        micromark("~~~\naaa\n```\n~~~"),
+        "<pre><code>aaa\n```\n</code></pre>",
+        "should not support a grave accent closing sequence for a tilde opening sequence"
+    );
+
+    assert_eq!(
+        micromark("````\naaa\n```\n``````"),
+        "<pre><code>aaa\n```\n</code></pre>",
+        "should support a closing sequence longer, but not shorter than, the opening"
+    );
+
+    assert_eq!(
+        micromark("~~~~\naaa\n~~~\n~~~~"),
+        "<pre><code>aaa\n~~~\n</code></pre>",
+        "should support a closing sequence equal to, but not shorter than, the opening"
+    );
+
+    assert_eq!(
+        micromark("```"),
+        "<pre><code></code></pre>\n",
+        "should support an eof right after an opening sequence"
+    );
+
+    assert_eq!(
+        micromark("`````\n\n```\naaa\n"),
+        "<pre><code>\n```\naaa\n</code></pre>\n",
+        "should support an eof somewhere in content"
+    );
+
+    // To do: blockquote.
+    // assert_eq!(
+    //     micromark("> ```\n> aaa\n\nbbb"),
+    //     "<blockquote>\n<pre><code>aaa\n</code></pre>\n</blockquote>\n<p>bbb</p>",
+    //     "should support no closing sequence in a block quote"
+    // );
+
+    assert_eq!(
+        micromark("```\n\n  \n```"),
+        "<pre><code>\n  \n</code></pre>",
+        "should support blank lines in fenced code"
+    );
+
+    assert_eq!(
+        micromark("```\n```"),
+        "<pre><code></code></pre>",
+        "should support empty fenced code"
+    );
+
+    assert_eq!(
+      micromark(" ```\n aaa\naaa\n```"),
+      "<pre><code>aaa\naaa\n</code></pre>",
+      "should remove up to one space from the content if the opening sequence is indented w/ 1 space"
+    );
+
+    assert_eq!(
+      micromark("  ```\naaa\n  aaa\naaa\n  ```"),
+      "<pre><code>aaa\naaa\naaa\n</code></pre>",
+      "should remove up to two space from the content if the opening sequence is indented w/ 2 spaces"
+    );
+
+    assert_eq!(
+      micromark("   ```\n   aaa\n    aaa\n  aaa\n   ```"),
+      "<pre><code>aaa\n aaa\naaa\n</code></pre>",
+      "should remove up to three space from the content if the opening sequence is indented w/ 3 spaces"
+    );
+
+    assert_eq!(
+        micromark("    ```\n    aaa\n    ```"),
+        "<pre><code>```\naaa\n```\n</code></pre>",
+        "should not support indenteding the opening sequence w/ 4 spaces"
+    );
+
+    assert_eq!(
+        micromark("```\naaa\n  ```"),
+        "<pre><code>aaa\n</code></pre>",
+        "should support an indented closing sequence"
+    );
+
+    assert_eq!(
+        micromark("   ```\naaa\n  ```"),
+        "<pre><code>aaa\n</code></pre>",
+        "should support a differently indented closing sequence than the opening sequence"
+    );
+
+    assert_eq!(
+        micromark("```\naaa\n    ```\n"),
+        "<pre><code>aaa\n    ```\n</code></pre>\n",
+        "should not support an indented closing sequence w/ 4 spaces"
+    );
+
+    // To do: code (text).
+    // assert_eq!(
+    //     micromark("``` ```\naaa"),
+    //     "<p><code> </code>\naaa</p>",
+    //     "should not support grave accents in the opening fence after the opening sequence"
+    // );
+
+    assert_eq!(
+        micromark("~~~~~~\naaa\n~~~ ~~\n"),
+        "<pre><code>aaa\n~~~ ~~\n</code></pre>\n",
+        "should not support spaces in the closing sequence"
+    );
+
+    assert_eq!(
+        micromark("foo\n```\nbar\n```\nbaz"),
+        "<p>foo</p>\n<pre><code>bar\n</code></pre>\n<p>baz</p>",
+        "should support interrupting paragraphs"
+    );
+
+    // To do: setext.
+    // assert_eq!(
+    //     micromark("foo\n---\n~~~\nbar\n~~~\n# baz"),
+    //     "<h2>foo</h2>\n<pre><code>bar\n</code></pre>\n<h1>baz</h1>",
+    //     "should support interrupting other content"
+    // );
+
+    assert_eq!(
+        micromark("```ruby\ndef foo(x)\n  return 3\nend\n```"),
+        "<pre><code class=\"language-ruby\">def foo(x)\n  return 3\nend\n</code></pre>",
+        "should support the info string as a `language-` class (1)"
+    );
+
+    assert_eq!(
+        micromark("````;\n````"),
+        "<pre><code class=\"language-;\"></code></pre>",
+        "should support the info string as a `language-` class (2)"
+    );
+
+    assert_eq!(
+        micromark("~~~~    ruby startline=3 $%@#$\ndef foo(x)\n  return 3\nend\n~~~~~~~"),
+        "<pre><code class=\"language-ruby\">def foo(x)\n  return 3\nend\n</code></pre>",
+        "should support the info string as a `language-` class, but not the meta string"
+    );
+
+    // To do: code (text).
+    // assert_eq!(
+    //     micromark("``` aa ```\nfoo"),
+    //     "<p><code>aa</code>\nfoo</p>",
+    //     "should not support grave accents in the meta string"
+    // );
+
+    assert_eq!(
+        micromark("~~~ aa ``` ~~~\nfoo\n~~~"),
+        "<pre><code class=\"language-aa\">foo\n</code></pre>",
+        "should support grave accents and tildes in the meta string of tilde fenced code"
+    );
+
+    assert_eq!(
+        micromark("```\n``` aaa\n```"),
+        "<pre><code>``` aaa\n</code></pre>",
+        "should not support info string on closing sequences"
+    );
+
+    // Our own:
+    assert_eq!(
+        micromark("```  "),
+        "<pre><code></code></pre>\n",
+        "should support an eof after whitespace, after the start fence sequence"
+    );
+
+    assert_eq!(
+        micromark("```  js\nalert(1)\n```"),
+        "<pre><code class=\"language-js\">alert(1)\n</code></pre>",
+        "should support whitespace between the sequence and the info string"
+    );
+
+    assert_eq!(
+        micromark("```js"),
+        "<pre><code class=\"language-js\"></code></pre>\n",
+        "should support an eof after the info string"
+    );
+
+    assert_eq!(
+        micromark("```  js \nalert(1)\n```"),
+        "<pre><code class=\"language-js\">alert(1)\n</code></pre>",
+        "should support whitespace after the info string"
+    );
+
+    assert_eq!(
+        micromark("```\n  "),
+        "<pre><code>  \n</code></pre>\n",
+        "should support an eof after whitespace in content"
+    );
+
+    assert_eq!(
+        micromark("  ```\n "),
+        "<pre><code></code></pre>\n",
+        "should support an eof in the prefix, in content"
+    );
+
+    // To do: strings.
+    // assert_eq!(
+    //     micromark("```j\\+s&copy;"),
+    //     "<pre><code class=\"language-j+s©\"></code></pre>\n",
+    //     "should support character escapes and character references in info strings"
+    // );
+
+    assert_eq!(
+      micromark("   ```\naaa\n    ```"),
+      "<pre><code>aaa\n ```\n</code></pre>\n",
+      "should not support a closing sequence w/ too much indent, regardless of opening sequence (1)"
+    );
+
+    // To do: blockquote.
+    //     assert_eq!(
+    //   micromark("> ```\n>\n>\n>\n\na"),
+    //   "<blockquote>\n<pre><code>\n\n\n</code></pre>\n</blockquote>\n<p>a</p>",
+    //   "should not support a closing sequence w/ too much indent, regardless of opening sequence (2)"
+    // );
+
+    //     assert_eq!(
+    //         micromark("> ```a\nb"),
+    //         "<blockquote>\n<pre><code class=\"language-a\"></code></pre>\n</blockquote>\n<p>b</p>",
+    //         "should not support lazyness (1)"
+    //     );
+
+    //     assert_eq!(
+    //         micromark("> a\n```b"),
+    //         "<blockquote>\n<p>a</p>\n</blockquote>\n<pre><code class=\"language-b\"></code></pre>\n",
+    //         "should not support lazyness (2)"
+    //     );
+
+    //     assert_eq!(
+    //   micromark("> ```a\n```"),
+    //   "<blockquote>\n<pre><code class=\"language-a\"></code></pre>\n</blockquote>\n<pre><code></code></pre>\n",
+    //   "should not support lazyness (3)"
+    // );
+
+    // To do: extensions.
+    // assert_eq!(
+    //   micromark("```", {extensions: [{disable: {null: ["codeFenced"]}}]}),
+    //   "<p>```</p>",
+    //   "should support turning off code (fenced)"
+    // );
+}
-- 
cgit