Merge pull request #379 from commonmark/junit-5-assertj

Upgrade to JUnit 5 and AssertJ

Author: robinst

commonmark-ext-autolink/src/test/java/org/commonmark/ext/autolink/AutolinkTest.java

@@ -6,13 +6,12 @@
 import org.commonmark.parser.Parser;
 import org.commonmark.renderer.html.HtmlRenderer;
 import org.commonmark.testutil.RenderingTestCase;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.Set;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class AutolinkTest extends RenderingTestCase {
 
@@ -71,44 +70,37 @@ public void sourceSpans() {
 
         Paragraph paragraph = (Paragraph) document.getFirstChild();
         Text abc = (Text) paragraph.getFirstChild();
-        assertEquals(List.of(SourceSpan.of(0, 0, 0, 3)),
-                abc.getSourceSpans());
+        assertThat(abc.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 3)));
 
-        assertTrue(abc.getNext() instanceof SoftLineBreak);
+        assertThat(abc.getNext()).isInstanceOf(SoftLineBreak.class);
 
         Link one = (Link) abc.getNext().getNext();
-        assertEquals("http://example.com/one", one.getDestination());
-        assertEquals(List.of(SourceSpan.of(1, 0, 4, 22)),
-                one.getSourceSpans());
+        assertThat(one.getDestination()).isEqualTo("http://example.com/one");
+        assertThat(one.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(1, 0, 4, 22)));
 
-        assertTrue(one.getNext() instanceof SoftLineBreak);
+        assertThat(one.getNext()).isInstanceOf(SoftLineBreak.class);
 
         Text def = (Text) one.getNext().getNext();
-        assertEquals("def ", def.getLiteral());
-        assertEquals(List.of(SourceSpan.of(2, 0, 27, 4)),
-                def.getSourceSpans());
+        assertThat(def.getLiteral()).isEqualTo("def ");
+        assertThat(def.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(2, 0, 27, 4)));
 
         Link two = (Link) def.getNext();
-        assertEquals("http://example.com/two", two.getDestination());
-        assertEquals(List.of(SourceSpan.of(2, 4, 31, 22)),
-                two.getSourceSpans());
+        assertThat(two.getDestination()).isEqualTo("http://example.com/two");
+        assertThat(two.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(2, 4, 31, 22)));
 
-        assertTrue(two.getNext() instanceof SoftLineBreak);
+        assertThat(two.getNext()).isInstanceOf(SoftLineBreak.class);
 
         Text ghi = (Text) two.getNext().getNext();
-        assertEquals("ghi ", ghi.getLiteral());
-        assertEquals(List.of(SourceSpan.of(3, 0, 54, 4)),
-                ghi.getSourceSpans());
+        assertThat(ghi.getLiteral()).isEqualTo("ghi ");
+        assertThat(ghi.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(3, 0, 54, 4)));
 
         Link three = (Link) ghi.getNext();
-        assertEquals("http://example.com/three", three.getDestination());
-        assertEquals(List.of(SourceSpan.of(3, 4, 58, 24)),
-                three.getSourceSpans());
+        assertThat(three.getDestination()).isEqualTo("http://example.com/three");
+        assertThat(three.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(3, 4, 58, 24)));
 
         Text jkl = (Text) three.getNext();
-        assertEquals(" jkl", jkl.getLiteral());
-        assertEquals(List.of(SourceSpan.of(3, 28, 82, 4)),
-                jkl.getSourceSpans());
+        assertThat(jkl.getLiteral()).isEqualTo(" jkl");
+        assertThat(jkl.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(3, 28, 82, 4)));
     }
 
     @Override

commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnoteHtmlRendererTest.java

@@ -8,7 +8,7 @@
 import org.commonmark.renderer.html.HtmlRenderer;
 import org.commonmark.testutil.Asserts;
 import org.commonmark.testutil.RenderingTestCase;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 import java.util.Set;

commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnoteMarkdownRendererTest.java

@@ -4,11 +4,11 @@
 import org.commonmark.node.Node;
 import org.commonmark.parser.Parser;
 import org.commonmark.renderer.markdown.MarkdownRenderer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Set;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class FootnoteMarkdownRendererTest {
     private static final Set<Extension> EXTENSIONS = Set.of(FootnotesExtension.builder().inlineFootnotes(true).build());
@@ -43,7 +43,7 @@ public void testInline() {
 
     private void assertRoundTrip(String input) {
         String rendered = parseAndRender(input);
-        assertEquals(input, rendered);
+        assertThat(rendered).isEqualTo(input);
     }
 
     private String parseAndRender(String source) {

commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnotesTest.java

@@ -4,15 +4,14 @@
 import org.commonmark.node.*;
 import org.commonmark.parser.IncludeSourceSpans;
 import org.commonmark.parser.Parser;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.Set;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class FootnotesTest {
 
@@ -24,13 +23,13 @@ public void testDefBlockStart() {
         for (var s : List.of("1", "a", "^", "*", "\\a", "\uD83D\uDE42", "&0")) {
             var doc = PARSER.parse("[^" + s + "]: footnote\n");
             var def = find(doc, FootnoteDefinition.class);
-            assertEquals(s, def.getLabel());
+            assertThat(def.getLabel()).isEqualTo(s);
         }
 
         for (var s : List.of("", " ", "a b", "]", "\r", "\n", "\t")) {
             var input = "[^" + s + "]: footnote\n";
             var doc = PARSER.parse(input);
-            assertNull("input: " + input, tryFind(doc, FootnoteDefinition.class));
+            assertThat(tryFind(doc, FootnoteDefinition.class)).as("input: " + input).isNull();
         }
     }
 
@@ -40,33 +39,33 @@ public void testDefBlockStartInterrupts() {
         var doc = PARSER.parse("test\n[^1]: footnote\n");
         var paragraph = find(doc, Paragraph.class);
         var def = find(doc, FootnoteDefinition.class);
-        assertEquals("test", ((Text) paragraph.getLastChild()).getLiteral());
-        assertEquals("1", def.getLabel());
+        assertThat(((Text) paragraph.getLastChild()).getLiteral()).isEqualTo("test");
+        assertThat(def.getLabel()).isEqualTo("1");
     }
 
     @Test
     public void testDefBlockStartIndented() {
         var doc1 = PARSER.parse("   [^1]: footnote\n");
-        assertEquals("1", find(doc1, FootnoteDefinition.class).getLabel());
+        assertThat(find(doc1, FootnoteDefinition.class).getLabel()).isEqualTo("1");
         var doc2 = PARSER.parse("    [^1]: footnote\n");
-        assertNull(tryFind(doc2, FootnoteDefinition.class));
+        assertNone(doc2, FootnoteDefinition.class);
     }
 
     @Test
     public void testDefMultiple() {
         var doc = PARSER.parse("[^1]: foo\n[^2]: bar\n");
         var defs = findAll(doc, FootnoteDefinition.class);
-        assertEquals("1", defs.get(0).getLabel());
-        assertEquals("2", defs.get(1).getLabel());
+        assertThat(defs.get(0).getLabel()).isEqualTo("1");
+        assertThat(defs.get(1).getLabel()).isEqualTo("2");
     }
 
     @Test
     public void testDefBlockStartAfterLinkReferenceDefinition() {
         var doc = PARSER.parse("[foo]: /url\n[^1]: footnote\n");
         var linkReferenceDef = find(doc, LinkReferenceDefinition.class);
         var footnotesDef = find(doc, FootnoteDefinition.class);
-        assertEquals("foo", linkReferenceDef.getLabel());
-        assertEquals("1", footnotesDef.getLabel());
+        assertThat(linkReferenceDef.getLabel()).isEqualTo("foo");
+        assertThat(footnotesDef.getLabel()).isEqualTo("1");
     }
 
     @Test
@@ -90,14 +89,14 @@ public void testDefContainsIndentedCodeBlock() {
         var doc = PARSER.parse("[^1]:\n        code\n");
         var def = find(doc, FootnoteDefinition.class);
         var codeBlock = (IndentedCodeBlock) def.getFirstChild();
-        assertEquals("code\n", codeBlock.getLiteral());
+        assertThat(codeBlock.getLiteral()).isEqualTo("code\n");
     }
 
     @Test
     public void testDefContainsMultipleLines() {
         var doc = PARSER.parse("[^1]: footnote\nstill\n");
         var def = find(doc, FootnoteDefinition.class);
-        assertEquals("1", def.getLabel());
+        assertThat(def.getLabel()).isEqualTo("1");
         var paragraph = (Paragraph) def.getFirstChild();
         assertText("footnote", paragraph.getFirstChild());
         assertText("still", paragraph.getLastChild());
@@ -107,7 +106,7 @@ public void testDefContainsMultipleLines() {
     public void testDefContainsList() {
         var doc = PARSER.parse("[^1]: - foo\n    - bar\n");
         var def = find(doc, FootnoteDefinition.class);
-        assertEquals("1", def.getLabel());
+        assertThat(def.getLabel()).isEqualTo("1");
         var list = (BulletList) def.getFirstChild();
         var item1 = (ListItem) list.getFirstChild();
         var item2 = (ListItem) list.getLastChild();
@@ -120,54 +119,54 @@ public void testDefInterruptedByOthers() {
         var doc = PARSER.parse("[^1]: footnote\n# Heading\n");
         var def = find(doc, FootnoteDefinition.class);
         var heading = find(doc, Heading.class);
-        assertEquals("1", def.getLabel());
+        assertThat(def.getLabel()).isEqualTo("1");
         assertText("Heading", heading.getFirstChild());
     }
 
     @Test
     public void testReference() {
         var doc = PARSER.parse("Test [^foo]\n\n[^foo]: /url\n");
         var ref = find(doc, FootnoteReference.class);
-        assertEquals("foo", ref.getLabel());
+        assertThat(ref.getLabel()).isEqualTo("foo");
     }
 
     @Test
     public void testReferenceNoDefinition() {
         var doc = PARSER.parse("Test [^foo]\n");
-        assertNull(tryFind(doc, FootnoteReference.class));
+        assertNone(doc, FootnoteReference.class);
     }
 
     @Test
     public void testRefWithEmphasisInside() {
         // No emphasis inside footnote reference, should just be treated as text
         var doc = PARSER.parse("Test [^*foo*]\n\n[^*foo*]: def\n");
         var ref = find(doc, FootnoteReference.class);
-        assertEquals("*foo*", ref.getLabel());
-        assertNull(ref.getFirstChild());
+        assertThat(ref.getLabel()).isEqualTo("*foo*");
+        assertThat(ref.getFirstChild()).isNull();
         var paragraph = doc.getFirstChild();
         var text = (Text) paragraph.getFirstChild();
-        assertEquals("Test ", text.getLiteral());
-        assertEquals(ref, text.getNext());
-        assertEquals(ref, paragraph.getLastChild());
+        assertThat(text.getLiteral()).isEqualTo("Test ");
+        assertThat(text.getNext()).isEqualTo(ref);
+        assertThat(paragraph.getLastChild()).isEqualTo(ref);
     }
 
     @Test
     public void testRefWithEmphasisAround() {
         // Emphasis around footnote reference, the * inside needs to be removed from emphasis processing
         var doc = PARSER.parse("Test *abc [^foo*] def*\n\n[^foo*]: def\n");
         var ref = find(doc, FootnoteReference.class);
-        assertEquals("foo*", ref.getLabel());
+        assertThat(ref.getLabel()).isEqualTo("foo*");
         assertText("abc ", ref.getPrevious());
         assertText(" def", ref.getNext());
         var em = find(doc, Emphasis.class);
-        assertEquals(em, ref.getParent());
+        assertThat(ref.getParent()).isEqualTo(em);
     }
 
     @Test
     public void testRefAfterBang() {
         var doc = PARSER.parse("Test![^foo]\n\n[^foo]: def\n");
         var ref = find(doc, FootnoteReference.class);
-        assertEquals("foo", ref.getLabel());
+        assertThat(ref.getLabel()).isEqualTo("foo");
         var paragraph = doc.getFirstChild();
         assertText("Test!", paragraph.getFirstChild());
     }
@@ -178,7 +177,7 @@ public void testRefAsLabelOnly() {
         // resolve as footnotes. If `[foo][^bar]` fails to parse as a bracket, `[^bar]` by itself needs to be tried.
         var doc = PARSER.parse("Test [foo][^bar]\n\n[^bar]: footnote\n");
         var ref = find(doc, FootnoteReference.class);
-        assertEquals("bar", ref.getLabel());
+        assertThat(ref.getLabel()).isEqualTo("bar");
         var paragraph = doc.getFirstChild();
         assertText("Test [foo]", paragraph.getFirstChild());
     }
@@ -188,7 +187,7 @@ public void testRefWithEmptyLabel() {
         // [^bar] is a footnote but [] is just text, because collapsed reference links don't resolve as footnotes
         var doc = PARSER.parse("Test [^bar][]\n\n[^bar]: footnote\n");
         var ref = find(doc, FootnoteReference.class);
-        assertEquals("bar", ref.getLabel());
+        assertThat(ref.getLabel()).isEqualTo("bar");
         var paragraph = doc.getFirstChild();
         assertText("Test ", paragraph.getFirstChild());
         assertText("[]", paragraph.getLastChild());
@@ -198,38 +197,38 @@ public void testRefWithEmptyLabel() {
     public void testRefWithBracket() {
         // Not a footnote, [ needs to be escaped
         var doc = PARSER.parse("Test [^f[oo]\n\n[^f[oo]: /url\n");
-        assertNull(tryFind(doc, FootnoteReference.class));
+        assertNone(doc, FootnoteReference.class);
     }
 
     @Test
     public void testRefWithBackslash() {
         var doc = PARSER.parse("[^\\foo]\n\n[^\\foo]: note\n");
         var ref = find(doc, FootnoteReference.class);
-        assertEquals("\\foo", ref.getLabel());
+        assertThat(ref.getLabel()).isEqualTo("\\foo");
         var def = find(doc, FootnoteDefinition.class);
-        assertEquals("\\foo", def.getLabel());
+        assertThat(def.getLabel()).isEqualTo("\\foo");
     }
 
     @Test
     public void testPreferInlineLink() {
         var doc = PARSER.parse("Test [^bar](/url)\n\n[^bar]: footnote\n");
-        assertNull(tryFind(doc, FootnoteReference.class));
+        assertNone(doc, FootnoteReference.class);
     }
 
     @Test
     public void testPreferReferenceLink() {
         // This is tricky because `[^*foo*][foo]` is a valid link already. If `[foo]` was not defined, the first bracket
         // would be a footnote.
         var doc = PARSER.parse("Test [^*foo*][foo]\n\n[^*foo*]: /url\n\n[foo]: /url");
-        assertNull(tryFind(doc, FootnoteReference.class));
+        assertNone(doc, FootnoteReference.class);
     }
 
     @Test
     public void testReferenceLinkWithoutDefinition() {
         // Similar to previous test but there's no definition
         var doc = PARSER.parse("Test [^*foo*][foo]\n\n[^*foo*]: def\n");
         var ref = find(doc, FootnoteReference.class);
-        assertEquals("*foo*", ref.getLabel());
+        assertThat(ref.getLabel()).isEqualTo("*foo*");
         var paragraph = (Paragraph) doc.getFirstChild();
         assertText("Test ", paragraph.getFirstChild());
         assertText("[foo]", paragraph.getLastChild());
@@ -249,12 +248,12 @@ public void testInlineFootnote() {
 
         {
             var doc = parser.parse("Test \\^[not inline footnote]");
-            assertNull(tryFind(doc, InlineFootnote.class));
+            assertNone(doc, InlineFootnote.class);
         }
 
         {
             var doc = parser.parse("Test ^[not inline footnote");
-            assertNull(tryFind(doc, InlineFootnote.class));
+            assertNone(doc, InlineFootnote.class);
             var t = doc.getFirstChild().getFirstChild();
             assertText("Test ^[not inline footnote", t);
         }
@@ -269,15 +268,15 @@ public void testInlineFootnote() {
             var fn = find(doc, InlineFootnote.class);
             assertText("test ", fn.getFirstChild());
             var code = fn.getFirstChild().getNext();
-            assertEquals("bla]", ((Code) code).getLiteral());
+            assertThat(((Code) code).getLiteral()).isEqualTo("bla]");
         }
 
         {
             var doc = parser.parse("^[with a [link](url)]");
             var fn = find(doc, InlineFootnote.class);
             assertText("with a ", fn.getFirstChild());
             var link = fn.getFirstChild().getNext();
-            assertEquals("url", ((Link) link).getDestination());
+            assertThat(((Link) link).getDestination()).isEqualTo("url");
         }
     }
 
@@ -287,10 +286,14 @@ public void testSourcePositions() {
 
         var doc = parser.parse("Test [^foo]\n\n[^foo]: /url\n");
         var ref = find(doc, FootnoteReference.class);
-        assertEquals(ref.getSourceSpans(), List.of(SourceSpan.of(0, 5, 5, 6)));
+        assertThat(ref.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 5, 5, 6)));
 
         var def = find(doc, FootnoteDefinition.class);
-        assertEquals(def.getSourceSpans(), List.of(SourceSpan.of(2, 0, 13, 12)));
+        assertThat(def.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(2, 0, 13, 12)));
+    }
+
+    private static void assertNone(Node parent, Class<?> nodeClass) {
+        assertThat(tryFind(parent, nodeClass)).as(() -> "Node " + parent + " containing " + nodeClass).isNull();
     }
 
     private static <T> T find(Node parent, Class<T> nodeClass) {
@@ -315,6 +318,6 @@ private static <T> List<T> findAll(Node parent, Class<T> nodeClass) {
 
     private static void assertText(String expected, Node node) {
         var text = (Text) node;
-        assertEquals(expected, text.getLiteral());
+        assertThat(text.getLiteral()).isEqualTo(expected);
     }
 }