From ec2d1bfb4232178fb3a6cba36f138bc6efbbf34a Mon Sep 17 00:00:00 2001
From: Titus Wormer <tituswormer@gmail.com>
Date: Thu, 13 Oct 2022 10:40:01 +0200
Subject: Rename crate to `markdown`

---
 tests/mdx_expression_text.rs | 84 +++++++++++++++++++++-----------------------
 1 file changed, 41 insertions(+), 43 deletions(-)

(limited to 'tests/mdx_expression_text.rs')

diff --git a/tests/mdx_expression_text.rs b/tests/mdx_expression_text.rs
index e0f1f3f..61f5170 100644
--- a/tests/mdx_expression_text.rs
+++ b/tests/mdx_expression_text.rs
@@ -1,8 +1,8 @@
-extern crate micromark;
+extern crate markdown;
 mod test_utils;
-use micromark::{
+use markdown::{
     mdast::{MdxTextExpression, Node, Paragraph, Root, Text},
-    micromark_to_mdast, micromark_with_options,
+    to_html_with_options, to_mdast,
     unist::Position,
     Constructs, Options, ParseOptions,
 };
@@ -22,123 +22,121 @@ fn mdx_expression_text_gnostic_core() -> Result<(), String> {
     };
 
     assert_eq!(
-        micromark_with_options("a {} b", &swc)?,
+        to_html_with_options("a {} b", &swc)?,
         "<p>a  b</p>",
         "should support an empty expression (1)"
     );
 
     assert_eq!(
-        micromark_with_options("a { \t\r\n} b", &swc)?,
+        to_html_with_options("a { \t\r\n} b", &swc)?,
         "<p>a  b</p>",
         "should support an empty expression (2)"
     );
 
     assert_eq!(
-        micromark_with_options("a {/**/} b", &swc)?,
+        to_html_with_options("a {/**/} b", &swc)?,
         "<p>a  b</p>",
         "should support a multiline comment (1)"
     );
 
     assert_eq!(
-        micromark_with_options("a {  /*\n*/\t} b", &swc)?,
+        to_html_with_options("a {  /*\n*/\t} b", &swc)?,
         "<p>a  b</p>",
         "should support a multiline comment (2)"
     );
 
     assert_eq!(
-        micromark_with_options("a {/*b*//*c*/} d", &swc)?,
+        to_html_with_options("a {/*b*//*c*/} d", &swc)?,
         "<p>a  d</p>",
         "should support a multiline comment (3)"
     );
 
     assert_eq!(
-        micromark_with_options("a {b/*c*/} d", &swc)?,
+        to_html_with_options("a {b/*c*/} d", &swc)?,
         "<p>a  d</p>",
         "should support a multiline comment (4)"
     );
 
     assert_eq!(
-        micromark_with_options("a {/*b*/c} d", &swc)?,
+        to_html_with_options("a {/*b*/c} d", &swc)?,
         "<p>a  d</p>",
         "should support a multiline comment (4)"
     );
 
     assert_eq!(
-        micromark_with_options("a {//} b", &swc).err().unwrap(),
+        to_html_with_options("a {//} b", &swc).err().unwrap(),
         "1:4: Could not parse expression with swc: Unexpected eof",
         "should crash on an incorrect line comment (1)"
     );
 
     assert_eq!(
-        micromark_with_options("a { // b } c", &swc).err().unwrap(),
+        to_html_with_options("a { // b } c", &swc).err().unwrap(),
         "1:4: Could not parse expression with swc: Unexpected eof",
         "should crash on an incorrect line comment (2)"
     );
 
     assert_eq!(
-        micromark_with_options("a {//\n} b", &swc)?,
+        to_html_with_options("a {//\n} b", &swc)?,
         "<p>a  b</p>",
         "should support a line comment followed by a line ending"
     );
 
     assert_eq!(
-        micromark_with_options("a {// b\nd} d", &swc)?,
+        to_html_with_options("a {// b\nd} d", &swc)?,
         "<p>a  d</p>",
         "should support a line comment followed by a line ending and an expression"
     );
 
     assert_eq!(
-        micromark_with_options("a {b// c\n} d", &swc)?,
+        to_html_with_options("a {b// c\n} d", &swc)?,
         "<p>a  d</p>",
         "should support an expression followed by a line comment and a line ending"
     );
 
     assert_eq!(
-        micromark_with_options("a {/*b*/ // c\n} d", &swc)?,
+        to_html_with_options("a {/*b*/ // c\n} d", &swc)?,
         "<p>a  d</p>",
         "should support comments (1)"
     );
 
     assert_eq!(
-        micromark_with_options("a {b.c} d", &swc)?,
+        to_html_with_options("a {b.c} d", &swc)?,
         "<p>a  d</p>",
         "should support expression statements (1)"
     );
 
     assert_eq!(
-        micromark_with_options("a {1 + 1} b", &swc)?,
+        to_html_with_options("a {1 + 1} b", &swc)?,
         "<p>a  b</p>",
         "should support expression statements (2)"
     );
 
     assert_eq!(
-        micromark_with_options("a {function () {}} b", &swc)?,
+        to_html_with_options("a {function () {}} b", &swc)?,
         "<p>a  b</p>",
         "should support expression statements (3)"
     );
 
     assert_eq!(
-        micromark_with_options("a {var b = \"c\"} d", &swc).err().unwrap(),
+        to_html_with_options("a {var b = \"c\"} d", &swc).err().unwrap(),
         "1:4: Could not parse expression with swc: Unexpected token `var`. Expected this, import, async, function, [ for array literal, { for object literal, @ for decorator, function, class, null, true, false, number, bigint, string, regexp, ` for template literal, (, or an identifier",
         "should crash on non-expressions"
     );
 
     assert_eq!(
-        micromark_with_options("> a {\n> b} c", &swc)?,
+        to_html_with_options("> a {\n> b} c", &swc)?,
         "<blockquote>\n<p>a  c</p>\n</blockquote>",
         "should support expressions in containers"
     );
 
     assert_eq!(
-        micromark_with_options("> a {\n> b<} c", &swc)
-            .err()
-            .unwrap(),
+        to_html_with_options("> a {\n> b<} c", &swc).err().unwrap(),
         "2:8: Could not parse expression with swc: Unexpected eof",
         "should crash on incorrect expressions in containers (1)"
     );
 
     assert_eq!(
-        micromark_with_options("> a {\n> b\n> c} d", &swc)
+        to_html_with_options("> a {\n> b\n> c} d", &swc)
             .err()
             .unwrap(),
         "3:3: Could not parse expression with swc: Unexpected content after expression",
@@ -159,25 +157,25 @@ fn mdx_expression_text_agnostic() -> Result<(), String> {
     };
 
     assert_eq!(
-        micromark_with_options("a {b} c", &mdx)?,
+        to_html_with_options("a {b} c", &mdx)?,
         "<p>a  c</p>",
         "should support an expression"
     );
 
     assert_eq!(
-        micromark_with_options("a {} b", &mdx)?,
+        to_html_with_options("a {} b", &mdx)?,
         "<p>a  b</p>",
         "should support an empty expression"
     );
 
     assert_eq!(
-        micromark_with_options("a {b c", &mdx).err().unwrap(),
+        to_html_with_options("a {b c", &mdx).err().unwrap(),
         "1:7: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
         "should crash if no closing brace is found (1)"
     );
 
     assert_eq!(
-        micromark_with_options("a {b { c } d", &mdx)
+        to_html_with_options("a {b { c } d", &mdx)
             .err()
             .unwrap(),
         "1:13: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
@@ -185,25 +183,25 @@ fn mdx_expression_text_agnostic() -> Result<(), String> {
     );
 
     assert_eq!(
-        micromark_with_options("a {\n} b", &mdx)?,
+        to_html_with_options("a {\n} b", &mdx)?,
         "<p>a  b</p>",
         "should support a line ending in an expression"
     );
 
     assert_eq!(
-        micromark_with_options("a } b", &mdx)?,
+        to_html_with_options("a } b", &mdx)?,
         "<p>a } b</p>",
         "should support just a closing brace"
     );
 
     assert_eq!(
-        micromark_with_options("{ a } b", &mdx)?,
+        to_html_with_options("{ a } b", &mdx)?,
         "<p> b</p>",
         "should support expressions as the first thing when following by other things"
     );
 
     assert_eq!(
-        micromark_to_mdast("a {alpha} b.", &mdx.parse)?,
+        to_mdast("a {alpha} b.", &mdx.parse)?,
         Node::Root(Root {
             children: vec![Node::Paragraph(Paragraph {
                 children: vec![
@@ -244,61 +242,61 @@ fn mdx_expression_text_gnostic() -> Result<(), String> {
     };
 
     assert_eq!(
-        micromark_with_options("a {b} c", &swc)?,
+        to_html_with_options("a {b} c", &swc)?,
         "<p>a  c</p>",
         "should support an expression"
     );
 
     assert_eq!(
-        micromark_with_options("a {??} b", &swc).err().unwrap(),
+        to_html_with_options("a {??} b", &swc).err().unwrap(),
         "1:9: Could not parse expression with swc: Unexpected eof",
         "should crash on an incorrect expression"
     );
 
     assert_eq!(
-        micromark_with_options("a {} b", &swc)?,
+        to_html_with_options("a {} b", &swc)?,
         "<p>a  b</p>",
         "should support an empty expression"
     );
 
     assert_eq!(
-        micromark_with_options("a {b c", &swc).err().unwrap(),
+        to_html_with_options("a {b c", &swc).err().unwrap(),
         "1:7: Unexpected end of file in expression, expected a corresponding closing brace for `{`",
         "should crash if no closing brace is found (1)"
     );
 
     assert_eq!(
-        micromark_with_options("a {b { c } d", &swc).err().unwrap(),
+        to_html_with_options("a {b { c } d", &swc).err().unwrap(),
         "1:6: Could not parse expression with swc: Unexpected content after expression",
         "should crash if no closing brace is found (2)"
     );
 
     assert_eq!(
-        micromark_with_options("a {\n} b", &swc)?,
+        to_html_with_options("a {\n} b", &swc)?,
         "<p>a  b</p>",
         "should support a line ending in an expression"
     );
 
     assert_eq!(
-        micromark_with_options("a } b", &swc)?,
+        to_html_with_options("a } b", &swc)?,
         "<p>a } b</p>",
         "should support just a closing brace"
     );
 
     assert_eq!(
-        micromark_with_options("{ a } b", &swc)?,
+        to_html_with_options("{ a } b", &swc)?,
         "<p> b</p>",
         "should support expressions as the first thing when following by other things"
     );
 
     assert_eq!(
-        micromark_with_options("a { /* { */ } b", &swc)?,
+        to_html_with_options("a { /* { */ } b", &swc)?,
         "<p>a  b</p>",
         "should support an unbalanced opening brace (if JS permits)"
     );
 
     assert_eq!(
-        micromark_with_options("a { /* } */ } b", &swc)?,
+        to_html_with_options("a { /* } */ } b", &swc)?,
         "<p>a  b</p>",
         "should support an unbalanced closing brace (if JS permits)"
     );
-- 
cgit