diff --git a/commonmark-ext-autolink/src/test/java/org/commonmark/ext/autolink/AutolinkTest.java b/commonmark-ext-autolink/src/test/java/org/commonmark/ext/autolink/AutolinkTest.java
index 67fd69ab..338513f3 100644
--- a/commonmark-ext-autolink/src/test/java/org/commonmark/ext/autolink/AutolinkTest.java
+++ b/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
diff --git a/commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnoteHtmlRendererTest.java b/commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnoteHtmlRendererTest.java
index ce5fdd51..bc7d4f74 100644
--- a/commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnoteHtmlRendererTest.java
+++ b/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;
diff --git a/commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnoteMarkdownRendererTest.java b/commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnoteMarkdownRendererTest.java
index 9d567ece..be3af671 100644
--- a/commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnoteMarkdownRendererTest.java
+++ b/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) {
diff --git a/commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnotesTest.java b/commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnotesTest.java
index bef6d89c..3fa726d8 100644
--- a/commonmark-ext-footnotes/src/test/java/org/commonmark/ext/footnotes/FootnotesTest.java
+++ b/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,24 +39,24 @@ 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
@@ -65,8 +64,8 @@ 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,7 +119,7 @@ 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());
     }
 
@@ -128,13 +127,13 @@ public void testDefInterruptedByOthers() {
     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
@@ -142,13 +141,13 @@ 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
@@ -156,18 +155,18 @@ 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,22 +197,22 @@ 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
@@ -221,7 +220,7 @@ 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
@@ -229,7 +228,7 @@ 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,7 +268,7 @@ 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]");
         }
 
         {
@@ -277,7 +276,7 @@ public void testInlineFootnote() {
             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);
     }
 }
diff --git a/commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughMarkdownRendererTest.java b/commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughMarkdownRendererTest.java
index 507fc0a8..c497a4db 100644
--- a/commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughMarkdownRendererTest.java
+++ b/commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughMarkdownRendererTest.java
@@ -3,11 +3,11 @@
 import org.commonmark.Extension;
 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 StrikethroughMarkdownRendererTest {
 
@@ -30,6 +30,6 @@ protected String render(String source) {
 
     private void assertRoundTrip(String input) {
         String rendered = render(input);
-        assertEquals(input, rendered);
+        assertThat(rendered).isEqualTo(input);
     }
 }
diff --git a/commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughSpecTest.java b/commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughSpecTest.java
index 2ca5471b..f1199b52 100644
--- a/commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughSpecTest.java
+++ b/commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughSpecTest.java
@@ -7,30 +7,27 @@
 import org.commonmark.testutil.TestResources;
 import org.commonmark.testutil.example.Example;
 import org.commonmark.testutil.example.ExampleReader;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.Parameter;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.List;
 import java.util.Set;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+@MethodSource("data")
 public class StrikethroughSpecTest extends RenderingTestCase {
 
     private static final Set<Extension> EXTENSIONS = Set.of(StrikethroughExtension.create());
     private static final Parser PARSER = Parser.builder().extensions(EXTENSIONS).build();
     private static final HtmlRenderer RENDERER = HtmlRenderer.builder().extensions(EXTENSIONS).build();
 
-    private final Example example;
+    @Parameter
+    Example example;
 
-    public StrikethroughSpecTest(Example example) {
-        this.example = example;
-    }
-
-    @Parameters(name = "{0}")
-    public static List<Object[]> data() {
-        return ExampleReader.readExampleObjects(TestResources.getGfmSpec(), "strikethrough");
+    static List<Example> data() {
+        return ExampleReader.readExamples(TestResources.getGfmSpec(), "strikethrough");
     }
 
     @Test
diff --git a/commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughTest.java b/commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughTest.java
index cb301995..c29391cd 100644
--- a/commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughTest.java
+++ b/commonmark-ext-gfm-strikethrough/src/test/java/org/commonmark/ext/gfm/strikethrough/StrikethroughTest.java
@@ -12,12 +12,12 @@
 import org.commonmark.renderer.html.HtmlRenderer;
 import org.commonmark.renderer.text.TextContentRenderer;
 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.assertj.core.api.Assertions.assertThat;
 
 public class StrikethroughTest extends RenderingTestCase {
 
@@ -84,14 +84,14 @@ public void insideBlockQuote() {
     public void delimited() {
         Node document = PARSER.parse("~~foo~~");
         Strikethrough strikethrough = (Strikethrough) document.getFirstChild().getFirstChild();
-        assertEquals("~~", strikethrough.getOpeningDelimiter());
-        assertEquals("~~", strikethrough.getClosingDelimiter());
+        assertThat(strikethrough.getOpeningDelimiter()).isEqualTo("~~");
+        assertThat(strikethrough.getClosingDelimiter()).isEqualTo("~~");
     }
 
     @Test
     public void textContentRenderer() {
         Node document = PARSER.parse("~~foo~~");
-        assertEquals("/foo/", CONTENT_RENDERER.render(document));
+        assertThat(CONTENT_RENDERER.render(document)).isEqualTo("/foo/");
     }
 
     @Test
@@ -104,7 +104,7 @@ public void requireTwoTildesOption() {
                 .build();
 
         Node document = parser.parse("~foo~ ~~bar~~");
-        assertEquals("(sub)foo(/sub) /bar/", CONTENT_RENDERER.render(document));
+        assertThat(CONTENT_RENDERER.render(document)).isEqualTo("(sub)foo(/sub) /bar/");
     }
 
     @Test
@@ -117,8 +117,7 @@ public void sourceSpans() {
         Node document = parser.parse("hey ~~there~~\n");
         Paragraph block = (Paragraph) document.getFirstChild();
         Node strikethrough = block.getLastChild();
-        assertEquals(List.of(SourceSpan.of(0, 4, 4, 9)),
-                strikethrough.getSourceSpans());
+        assertThat(strikethrough.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 4, 4, 9)));
     }
 
     @Override
diff --git a/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TableMarkdownRendererTest.java b/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TableMarkdownRendererTest.java
index 16303b58..85c11206 100644
--- a/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TableMarkdownRendererTest.java
+++ b/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TableMarkdownRendererTest.java
@@ -3,11 +3,11 @@
 import org.commonmark.Extension;
 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 TableMarkdownRendererTest {
 
@@ -70,6 +70,6 @@ protected String render(String source) {
 
     private void assertRoundTrip(String input) {
         String rendered = render(input);
-        assertEquals(input, rendered);
+        assertThat(rendered).isEqualTo(input);
     }
 }
diff --git a/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TablesSpecTest.java b/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TablesSpecTest.java
index d5ea8c83..e7f3db4d 100644
--- a/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TablesSpecTest.java
+++ b/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TablesSpecTest.java
@@ -7,30 +7,27 @@
 import org.commonmark.testutil.TestResources;
 import org.commonmark.testutil.example.Example;
 import org.commonmark.testutil.example.ExampleReader;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.Parameter;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.List;
 import java.util.Set;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+@MethodSource("data")
 public class TablesSpecTest extends RenderingTestCase {
 
     private static final Set<Extension> EXTENSIONS = Set.of(TablesExtension.create());
     private static final Parser PARSER = Parser.builder().extensions(EXTENSIONS).build();
     private static final HtmlRenderer RENDERER = HtmlRenderer.builder().extensions(EXTENSIONS).build();
 
-    private final Example example;
+    @Parameter
+    Example example;
 
-    public TablesSpecTest(Example example) {
-        this.example = example;
-    }
-
-    @Parameters(name = "{0}")
-    public static List<Object[]> data() {
-        return ExampleReader.readExampleObjects(TestResources.getGfmSpec(), "table");
+    static List<Example> data() {
+        return ExampleReader.readExamples(TestResources.getGfmSpec(), "table");
     }
 
     @Test
diff --git a/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TablesTest.java b/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TablesTest.java
index 57f4a4ae..3135b4d8 100644
--- a/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TablesTest.java
+++ b/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TablesTest.java
@@ -10,13 +10,13 @@
 import org.commonmark.renderer.html.AttributeProviderFactory;
 import org.commonmark.renderer.html.HtmlRenderer;
 import org.commonmark.testutil.RenderingTestCase;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import java.util.*;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class TablesTest extends RenderingTestCase {
 
@@ -730,7 +730,7 @@ public void setAttributes(Node node, String tagName, Map<String, String> attribu
                 .extensions(EXTENSIONS)
                 .build();
         String rendered = renderer.render(PARSER.parse("Abc|Def\n---|---\n1|2"));
-        assertThat(rendered, is("<table test=\"block\">\n" +
+        assertThat(rendered).isEqualTo("<table test=\"block\">\n" +
                 "<thead test=\"head\">\n" +
                 "<tr test=\"row\">\n" +
                 "<th test=\"cell\">Abc</th>\n" +
@@ -743,7 +743,7 @@ public void setAttributes(Node node, String tagName, Map<String, String> attribu
                 "<td test=\"cell\">2</td>\n" +
                 "</tr>\n" +
                 "</tbody>\n" +
-                "</table>\n"));
+                "</table>\n");
     }
 
     @Test
@@ -766,7 +766,7 @@ public void setAttributes(Node node, String tagName, Map<String, String> attribu
                 .extensions(EXTENSIONS)
                 .build();
         String rendered = renderer.render(PARSER.parse("Abc|Def\n-----|---\n1|2"));
-        assertThat(rendered, is("<table>\n" +
+        assertThat(rendered).isEqualTo("<table>\n" +
                 "<thead>\n" +
                 "<tr>\n" +
                 "<th width=\"5em\">Abc</th>\n" +
@@ -779,7 +779,7 @@ public void setAttributes(Node node, String tagName, Map<String, String> attribu
                 "<td>2</td>\n" +
                 "</tr>\n" +
                 "</tbody>\n" +
-                "</table>\n"));
+                "</table>\n");
     }
 
     @Test
@@ -791,49 +791,48 @@ public void sourceSpans() {
         Node document = parser.parse("Abc|Def\n---|---\n|1|2\n 3|four|\n|||\n");
 
         TableBlock block = (TableBlock) document.getFirstChild();
-        assertEquals(List.of(SourceSpan.of(0, 0, 0, 7), SourceSpan.of(1, 0, 8, 7),
-                        SourceSpan.of(2, 0, 16, 4), SourceSpan.of(3, 0, 21, 8), SourceSpan.of(4, 0, 30, 3)),
-                block.getSourceSpans());
+        assertThat(block.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 7), SourceSpan.of(1, 0, 8, 7),
+                SourceSpan.of(2, 0, 16, 4), SourceSpan.of(3, 0, 21, 8), SourceSpan.of(4, 0, 30, 3)));
 
         TableHead head = (TableHead) block.getFirstChild();
-        assertEquals(List.of(SourceSpan.of(0, 0, 0, 7)), head.getSourceSpans());
+        assertThat(head.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 7)));
 
         TableRow headRow = (TableRow) head.getFirstChild();
-        assertEquals(List.of(SourceSpan.of(0, 0, 0, 7)), headRow.getSourceSpans());
+        assertThat(headRow.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 7)));
         TableCell headRowCell1 = (TableCell) headRow.getFirstChild();
         TableCell headRowCell2 = (TableCell) headRow.getLastChild();
-        assertEquals(List.of(SourceSpan.of(0, 0, 0, 3)), headRowCell1.getSourceSpans());
-        assertEquals(List.of(SourceSpan.of(0, 0, 0, 3)), headRowCell1.getFirstChild().getSourceSpans());
-        assertEquals(List.of(SourceSpan.of(0, 4, 4, 3)), headRowCell2.getSourceSpans());
-        assertEquals(List.of(SourceSpan.of(0, 4, 4, 3)), headRowCell2.getFirstChild().getSourceSpans());
+        assertThat(headRowCell1.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 3)));
+        assertThat(headRowCell1.getFirstChild().getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 3)));
+        assertThat(headRowCell2.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 4, 4, 3)));
+        assertThat(headRowCell2.getFirstChild().getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 4, 4, 3)));
 
         TableBody body = (TableBody) block.getLastChild();
-        assertEquals(List.of(SourceSpan.of(2, 0, 16, 4), SourceSpan.of(3, 0, 21, 8), SourceSpan.of(4, 0, 30, 3)), body.getSourceSpans());
+        assertThat(body.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(2, 0, 16, 4), SourceSpan.of(3, 0, 21, 8), SourceSpan.of(4, 0, 30, 3)));
 
         TableRow bodyRow1 = (TableRow) body.getFirstChild();
-        assertEquals(List.of(SourceSpan.of(2, 0, 16, 4)), bodyRow1.getSourceSpans());
+        assertThat(bodyRow1.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(2, 0, 16, 4)));
         TableCell bodyRow1Cell1 = (TableCell) bodyRow1.getFirstChild();
         TableCell bodyRow1Cell2 = (TableCell) bodyRow1.getLastChild();
-        assertEquals(List.of(SourceSpan.of(2, 1, 17, 1)), bodyRow1Cell1.getSourceSpans());
-        assertEquals(List.of(SourceSpan.of(2, 1, 17, 1)), bodyRow1Cell1.getFirstChild().getSourceSpans());
-        assertEquals(List.of(SourceSpan.of(2, 3, 19, 1)), bodyRow1Cell2.getSourceSpans());
-        assertEquals(List.of(SourceSpan.of(2, 3, 19, 1)), bodyRow1Cell2.getFirstChild().getSourceSpans());
+        assertThat(bodyRow1Cell1.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(2, 1, 17, 1)));
+        assertThat(bodyRow1Cell1.getFirstChild().getSourceSpans()).isEqualTo(List.of(SourceSpan.of(2, 1, 17, 1)));
+        assertThat(bodyRow1Cell2.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(2, 3, 19, 1)));
+        assertThat(bodyRow1Cell2.getFirstChild().getSourceSpans()).isEqualTo(List.of(SourceSpan.of(2, 3, 19, 1)));
 
         TableRow bodyRow2 = (TableRow) body.getFirstChild().getNext();
-        assertEquals(List.of(SourceSpan.of(3, 0, 21, 8)), bodyRow2.getSourceSpans());
+        assertThat(bodyRow2.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(3, 0, 21, 8)));
         TableCell bodyRow2Cell1 = (TableCell) bodyRow2.getFirstChild();
         TableCell bodyRow2Cell2 = (TableCell) bodyRow2.getLastChild();
-        assertEquals(List.of(SourceSpan.of(3, 1, 22, 1)), bodyRow2Cell1.getSourceSpans());
-        assertEquals(List.of(SourceSpan.of(3, 1, 22, 1)), bodyRow2Cell1.getFirstChild().getSourceSpans());
-        assertEquals(List.of(SourceSpan.of(3, 3, 24, 4)), bodyRow2Cell2.getSourceSpans());
-        assertEquals(List.of(SourceSpan.of(3, 3, 24, 4)), bodyRow2Cell2.getFirstChild().getSourceSpans());
+        assertThat(bodyRow2Cell1.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(3, 1, 22, 1)));
+        assertThat(bodyRow2Cell1.getFirstChild().getSourceSpans()).isEqualTo(List.of(SourceSpan.of(3, 1, 22, 1)));
+        assertThat(bodyRow2Cell2.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(3, 3, 24, 4)));
+        assertThat(bodyRow2Cell2.getFirstChild().getSourceSpans()).isEqualTo(List.of(SourceSpan.of(3, 3, 24, 4)));
 
         TableRow bodyRow3 = (TableRow) body.getLastChild();
-        assertEquals(List.of(SourceSpan.of(4, 0, 30, 3)), bodyRow3.getSourceSpans());
+        assertThat(bodyRow3.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(4, 0, 30, 3)));
         TableCell bodyRow3Cell1 = (TableCell) bodyRow3.getFirstChild();
         TableCell bodyRow3Cell2 = (TableCell) bodyRow3.getLastChild();
-        assertEquals(List.of(), bodyRow3Cell1.getSourceSpans());
-        assertEquals(List.of(), bodyRow3Cell2.getSourceSpans());
+        assertThat(bodyRow3Cell1.getSourceSpans()).isEqualTo(List.of());
+        assertThat(bodyRow3Cell2.getSourceSpans()).isEqualTo(List.of());
     }
 
     @Override
diff --git a/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TablesTextContentTest.java b/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TablesTextContentTest.java
index c5ef8cb5..966f097f 100644
--- a/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TablesTextContentTest.java
+++ b/commonmark-ext-gfm-tables/src/test/java/org/commonmark/ext/gfm/tables/TablesTextContentTest.java
@@ -5,7 +5,7 @@
 import org.commonmark.renderer.text.LineBreakRendering;
 import org.commonmark.renderer.text.TextContentRenderer;
 import org.commonmark.testutil.Asserts;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Set;
 
diff --git a/commonmark-ext-heading-anchor/src/test/java/org/commonmark/ext/heading/anchor/HeadingAnchorConfigurationTest.java b/commonmark-ext-heading-anchor/src/test/java/org/commonmark/ext/heading/anchor/HeadingAnchorConfigurationTest.java
index af2ae13c..438a3a9b 100644
--- a/commonmark-ext-heading-anchor/src/test/java/org/commonmark/ext/heading/anchor/HeadingAnchorConfigurationTest.java
+++ b/commonmark-ext-heading-anchor/src/test/java/org/commonmark/ext/heading/anchor/HeadingAnchorConfigurationTest.java
@@ -3,12 +3,11 @@
 import org.commonmark.Extension;
 import org.commonmark.parser.Parser;
 import org.commonmark.renderer.html.HtmlRenderer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
-import static org.hamcrest.CoreMatchers.equalTo;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class HeadingAnchorConfigurationTest {
 
@@ -30,25 +29,25 @@ public void testDefaultConfigurationHasNoAdditions() {
         HtmlRenderer renderer = HtmlRenderer.builder()
                 .extensions(List.of(HeadingAnchorExtension.create()))
                 .build();
-        assertThat(doRender(renderer, "# "), equalTo("<h1 id=\"id\"></h1>\n"));
+        assertThat(doRender(renderer, "# ")).isEqualTo("<h1 id=\"id\"></h1>\n");
     }
 
     @Test
     public void testDefaultIdWhenNoTextOnHeader() {
         HtmlRenderer renderer = buildRenderer("defid", "", "");
-        assertThat(doRender(renderer, "# "), equalTo("<h1 id=\"defid\"></h1>\n"));
+        assertThat(doRender(renderer, "# ")).isEqualTo("<h1 id=\"defid\"></h1>\n");
     }
 
     @Test
     public void testPrefixAddedToHeader() {
         HtmlRenderer renderer = buildRenderer("", "pre-", "");
-        assertThat(doRender(renderer, "# text"), equalTo("<h1 id=\"pre-text\">text</h1>\n"));
+        assertThat(doRender(renderer, "# text")).isEqualTo("<h1 id=\"pre-text\">text</h1>\n");
     }
 
     @Test
     public void testSuffixAddedToHeader() {
         HtmlRenderer renderer = buildRenderer("", "", "-post");
-        assertThat(doRender(renderer, "# text"), equalTo("<h1 id=\"text-post\">text</h1>\n"));
+        assertThat(doRender(renderer, "# text")).isEqualTo("<h1 id=\"text-post\">text</h1>\n");
     }
 
     private String doRender(HtmlRenderer renderer, String text) {
diff --git a/commonmark-ext-heading-anchor/src/test/java/org/commonmark/ext/heading/anchor/HeadingAnchorTest.java b/commonmark-ext-heading-anchor/src/test/java/org/commonmark/ext/heading/anchor/HeadingAnchorTest.java
index 872306be..3149542e 100644
--- a/commonmark-ext-heading-anchor/src/test/java/org/commonmark/ext/heading/anchor/HeadingAnchorTest.java
+++ b/commonmark-ext-heading-anchor/src/test/java/org/commonmark/ext/heading/anchor/HeadingAnchorTest.java
@@ -4,7 +4,7 @@
 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.Set;
 
diff --git a/commonmark-ext-image-attributes/src/test/java/org/commonmark/ext/image/attributes/ImageAttributesTest.java b/commonmark-ext-image-attributes/src/test/java/org/commonmark/ext/image/attributes/ImageAttributesTest.java
index b863bd4b..3edf8497 100644
--- a/commonmark-ext-image-attributes/src/test/java/org/commonmark/ext/image/attributes/ImageAttributesTest.java
+++ b/commonmark-ext-image-attributes/src/test/java/org/commonmark/ext/image/attributes/ImageAttributesTest.java
@@ -8,12 +8,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.assertj.core.api.Assertions.assertThat;
 
 public class ImageAttributesTest extends RenderingTestCase {
 
@@ -131,8 +131,7 @@ public void sourceSpans() {
         Node document = parser.parse("x{height=3 width=4}\n");
         Paragraph block = (Paragraph) document.getFirstChild();
         Node text = block.getFirstChild();
-        assertEquals(List.of(SourceSpan.of(0, 0, 0, 19)),
-                text.getSourceSpans());
+        assertThat(text.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 19)));
     }
 
     @Override
diff --git a/commonmark-ext-ins/src/test/java/org/commonmark/ext/ins/InsMarkdownRendererTest.java b/commonmark-ext-ins/src/test/java/org/commonmark/ext/ins/InsMarkdownRendererTest.java
index 28f2cd35..6fc9ead6 100644
--- a/commonmark-ext-ins/src/test/java/org/commonmark/ext/ins/InsMarkdownRendererTest.java
+++ b/commonmark-ext-ins/src/test/java/org/commonmark/ext/ins/InsMarkdownRendererTest.java
@@ -3,11 +3,11 @@
 import org.commonmark.Extension;
 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 InsMarkdownRendererTest {
 
@@ -28,6 +28,6 @@ protected String render(String source) {
 
     private void assertRoundTrip(String input) {
         String rendered = render(input);
-        assertEquals(input, rendered);
+        assertThat(rendered).isEqualTo(input);
     }
 }
diff --git a/commonmark-ext-ins/src/test/java/org/commonmark/ext/ins/InsTest.java b/commonmark-ext-ins/src/test/java/org/commonmark/ext/ins/InsTest.java
index 4603da60..a5c91a39 100644
--- a/commonmark-ext-ins/src/test/java/org/commonmark/ext/ins/InsTest.java
+++ b/commonmark-ext-ins/src/test/java/org/commonmark/ext/ins/InsTest.java
@@ -9,12 +9,12 @@
 import org.commonmark.renderer.html.HtmlRenderer;
 import org.commonmark.renderer.text.TextContentRenderer;
 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.assertj.core.api.Assertions.assertThat;
 
 public class InsTest extends RenderingTestCase {
 
@@ -82,14 +82,14 @@ public void insideBlockQuote() {
     public void delimited() {
         Node document = PARSER.parse("++foo++");
         Ins ins = (Ins) document.getFirstChild().getFirstChild();
-        assertEquals("++", ins.getOpeningDelimiter());
-        assertEquals("++", ins.getClosingDelimiter());
+        assertThat(ins.getOpeningDelimiter()).isEqualTo("++");
+        assertThat(ins.getClosingDelimiter()).isEqualTo("++");
     }
 
     @Test
     public void textContentRenderer() {
         Node document = PARSER.parse("++foo++");
-        assertEquals("foo", CONTENT_RENDERER.render(document));
+        assertThat(CONTENT_RENDERER.render(document)).isEqualTo("foo");
     }
 
     @Test
@@ -102,8 +102,7 @@ public void sourceSpans() {
         Node document = parser.parse("hey ++there++\n");
         Paragraph block = (Paragraph) document.getFirstChild();
         Node ins = block.getLastChild();
-        assertEquals(List.of(SourceSpan.of(0, 4, 4, 9)),
-                ins.getSourceSpans());
+        assertThat(ins.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 4, 4, 9)));
     }
 
     @Override
diff --git a/commonmark-ext-task-list-items/src/test/java/org/commonmark/ext/task/list/items/TaskListItemsTest.java b/commonmark-ext-task-list-items/src/test/java/org/commonmark/ext/task/list/items/TaskListItemsTest.java
index c13e10bb..0adc615a 100644
--- a/commonmark-ext-task-list-items/src/test/java/org/commonmark/ext/task/list/items/TaskListItemsTest.java
+++ b/commonmark-ext-task-list-items/src/test/java/org/commonmark/ext/task/list/items/TaskListItemsTest.java
@@ -4,7 +4,7 @@
 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.Set;
 
diff --git a/commonmark-ext-yaml-front-matter/src/test/java/org/commonmark/ext/front/matter/YamlFrontMatterTest.java b/commonmark-ext-yaml-front-matter/src/test/java/org/commonmark/ext/front/matter/YamlFrontMatterTest.java
index f46c11b3..db17d4a4 100644
--- a/commonmark-ext-yaml-front-matter/src/test/java/org/commonmark/ext/front/matter/YamlFrontMatterTest.java
+++ b/commonmark-ext-yaml-front-matter/src/test/java/org/commonmark/ext/front/matter/YamlFrontMatterTest.java
@@ -6,14 +6,13 @@
 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.Map;
 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 YamlFrontMatterTest extends RenderingTestCase {
     private static final Set<Extension> EXTENSIONS = Set.of(YamlFrontMatterExtension.create());
@@ -31,10 +30,10 @@ public void simpleValue() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertEquals(1, data.size());
-        assertEquals("hello", data.keySet().iterator().next());
-        assertEquals(1, data.get("hello").size());
-        assertEquals("world", data.get("hello").get(0));
+        assertThat(data).hasSize(1);
+        assertThat(data.keySet().iterator().next()).isEqualTo("hello");
+        assertThat(data.get("hello")).hasSize(1);
+        assertThat(data.get("hello").get(0)).isEqualTo("world");
 
         assertRendering(input, rendered);
     }
@@ -50,9 +49,9 @@ public void emptyValue() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertEquals(1, data.size());
-        assertEquals("key", data.keySet().iterator().next());
-        assertEquals(0, data.get("key").size());
+        assertThat(data).hasSize(1);
+        assertThat(data.keySet().iterator().next()).isEqualTo("key");
+        assertThat(data.get("key")).hasSize(0);
 
         assertRendering(input, rendered);
     }
@@ -70,11 +69,11 @@ public void listValues() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertEquals(1, data.size());
-        assertTrue(data.containsKey("list"));
-        assertEquals(2, data.get("list").size());
-        assertEquals("value1", data.get("list").get(0));
-        assertEquals("value2", data.get("list").get(1));
+        assertThat(data).hasSize(1);
+        assertThat(data).containsKey("list");
+        assertThat(data.get("list")).hasSize(2);
+        assertThat(data.get("list").get(0)).isEqualTo("value1");
+        assertThat(data.get("list").get(1)).isEqualTo("value2");
 
         assertRendering(input, rendered);
     }
@@ -92,10 +91,10 @@ public void literalValue1() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertEquals(1, data.size());
-        assertTrue(data.containsKey("literal"));
-        assertEquals(1, data.get("literal").size());
-        assertEquals("hello markdown!\nliteral thing...", data.get("literal").get(0));
+        assertThat(data).hasSize(1);
+        assertThat(data).containsKey("literal");
+        assertThat(data.get("literal")).hasSize(1);
+        assertThat(data.get("literal").get(0)).isEqualTo("hello markdown!\nliteral thing...");
 
         assertRendering(input, rendered);
     }
@@ -112,10 +111,10 @@ public void literalValue2() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertEquals(1, data.size());
-        assertTrue(data.containsKey("literal"));
-        assertEquals(1, data.get("literal").size());
-        assertEquals("- hello markdown!", data.get("literal").get(0));
+        assertThat(data).hasSize(1);
+        assertThat(data).containsKey("literal");
+        assertThat(data.get("literal")).hasSize(1);
+        assertThat(data.get("literal").get(0)).isEqualTo("- hello markdown!");
 
         assertRendering(input, rendered);
     }
@@ -137,20 +136,20 @@ public void complexValues() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertEquals(3, data.size());
+        assertThat(data).hasSize(3);
 
-        assertTrue(data.containsKey("simple"));
-        assertEquals(1, data.get("simple").size());
-        assertEquals("value", data.get("simple").get(0));
+        assertThat(data).containsKey("simple");
+        assertThat(data.get("simple")).hasSize(1);
+        assertThat(data.get("simple").get(0)).isEqualTo("value");
 
-        assertTrue(data.containsKey("literal"));
-        assertEquals(1, data.get("literal").size());
-        assertEquals("hello markdown!\n\nliteral literal", data.get("literal").get(0));
+        assertThat(data).containsKey("literal");
+        assertThat(data.get("literal")).hasSize(1);
+        assertThat(data.get("literal").get(0)).isEqualTo("hello markdown!\n\nliteral literal");
 
-        assertTrue(data.containsKey("list"));
-        assertEquals(2, data.get("list").size());
-        assertEquals("value1", data.get("list").get(0));
-        assertEquals("value2", data.get("list").get(1));
+        assertThat(data).containsKey("list");
+        assertThat(data.get("list")).hasSize(2);
+        assertThat(data.get("list").get(0)).isEqualTo("value1");
+        assertThat(data.get("list").get(1)).isEqualTo("value2");
 
         assertRendering(input, rendered);
     }
@@ -164,7 +163,7 @@ public void empty() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertTrue(data.isEmpty());
+        assertThat(data).isEmpty();
 
         assertRendering(input, rendered);
     }
@@ -180,7 +179,7 @@ public void yamlInParagraph() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertTrue(data.isEmpty());
+        assertThat(data).isEmpty();
 
         assertRendering(input, rendered);
     }
@@ -195,7 +194,7 @@ public void yamlOnSecondLine() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertTrue(data.isEmpty());
+        assertThat(data).isEmpty();
 
         assertRendering(input, rendered);
     }
@@ -208,7 +207,7 @@ public void nonMatchedStartTag() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertTrue(data.isEmpty());
+        assertThat(data).isEmpty();
 
         assertRendering(input, rendered);
     }
@@ -222,7 +221,7 @@ public void inList() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertTrue(data.isEmpty());
+        assertThat(data).isEmpty();
 
         assertRendering(input, rendered);
     }
@@ -240,9 +239,9 @@ public void visitorIgnoresOtherCustomNodes() {
         document.accept(visitor);
 
         Map<String, List<String>> data = visitor.getData();
-        assertEquals(1, data.size());
-        assertTrue(data.containsKey("hello"));
-        assertEquals(List.of("world"), data.get("hello"));
+        assertThat(data).hasSize(1);
+        assertThat(data).containsKey("hello");
+        assertThat(data.get("hello")).isEqualTo(List.of("world"));
     }
 
     @Test
@@ -261,9 +260,9 @@ public void nodesCanBeModified() {
         document.accept(visitor);
 
         Map<String, List<String>> data = visitor.getData();
-        assertEquals(1, data.size());
-        assertTrue(data.containsKey("see"));
-        assertEquals(List.of("you"), data.get("see"));
+        assertThat(data).hasSize(1);
+        assertThat(data).containsKey("see");
+        assertThat(data.get("see")).isEqualTo(List.of("you"));
     }
 
     @Test
@@ -275,10 +274,10 @@ public void dotInKeys() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertEquals(1, data.size());
-        assertEquals("ms.author", data.keySet().iterator().next());
-        assertEquals(1, data.get("ms.author").size());
-        assertEquals("author", data.get("ms.author").get(0));
+        assertThat(data).hasSize(1);
+        assertThat(data.keySet().iterator().next()).isEqualTo("ms.author");
+        assertThat(data.get("ms.author")).hasSize(1);
+        assertThat(data.get("ms.author").get(0)).isEqualTo("author");
     }
 
     @Test
@@ -292,9 +291,9 @@ public void singleQuotedLiterals() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertEquals(2, data.size());
-        assertEquals("It's me", data.get("string").get(0));
-        assertEquals("I'm here", data.get("list").get(0));
+        assertThat(data).hasSize(2);
+        assertThat(data.get("string").get(0)).isEqualTo("It's me");
+        assertThat(data.get("list").get(0)).isEqualTo("I'm here");
     }
 
     @Test
@@ -308,9 +307,9 @@ public void doubleQuotedLiteral() {
 
         Map<String, List<String>> data = getFrontMatter(input);
 
-        assertEquals(2, data.size());
-        assertEquals("backslash: \\ quote: \"", data.get("string").get(0));
-        assertEquals("hey", data.get("list").get(0));
+        assertThat(data).hasSize(2);
+        assertThat(data.get("string").get(0)).isEqualTo("backslash: \\ quote: \"");
+        assertThat(data.get("list").get(0)).isEqualTo("hey");
     }
 
     @Override
diff --git a/commonmark-integration-test/src/test/java/org/commonmark/integration/BoundsIntegrationTest.java b/commonmark-integration-test/src/test/java/org/commonmark/integration/BoundsIntegrationTest.java
index 8ee15164..f1259b82 100644
--- a/commonmark-integration-test/src/test/java/org/commonmark/integration/BoundsIntegrationTest.java
+++ b/commonmark-integration-test/src/test/java/org/commonmark/integration/BoundsIntegrationTest.java
@@ -3,39 +3,30 @@
 import org.commonmark.node.Node;
 import org.commonmark.parser.Parser;
 import org.commonmark.testutil.TestResources;
-import org.commonmark.testutil.example.Example;
 import org.commonmark.testutil.example.ExampleReader;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.Parameter;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
-import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.Assert.assertNotNull;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests various substrings of the spec examples to check for out of bounds exceptions.
  */
-@RunWith(Parameterized.class)
+@ParameterizedClass
+@MethodSource("data")
 public class BoundsIntegrationTest {
 
     private static final Parser PARSER = Parser.builder().build();
 
-    protected final String input;
+    @Parameter
+    String input;
 
-    public BoundsIntegrationTest(String input) {
-        this.input = input;
-    }
-
-    @Parameterized.Parameters(name = "{0}")
-    public static List<Object[]> data() {
-        List<Example> examples = ExampleReader.readExamples(TestResources.getSpec());
-        List<Object[]> data = new ArrayList<>();
-        for (Example example : examples) {
-            data.add(new Object[]{example.getSource()});
-        }
-        return data;
+    static List<String> data() {
+        return ExampleReader.readExampleSources(TestResources.getSpec());
     }
 
     @Test
@@ -54,7 +45,7 @@ private void parse(String input) {
         try {
             Node parsed = PARSER.parse(input);
             // Parsing should always return a node
-            assertNotNull(parsed);
+            assertThat(parsed).isNotNull();
         } catch (Exception e) {
             throw new AssertionError("Parsing failed, input: " + input, e);
         }
diff --git a/commonmark-integration-test/src/test/java/org/commonmark/integration/ExtensionsIntegrationTest.java b/commonmark-integration-test/src/test/java/org/commonmark/integration/ExtensionsIntegrationTest.java
index 64cf60ed..523154d2 100644
--- a/commonmark-integration-test/src/test/java/org/commonmark/integration/ExtensionsIntegrationTest.java
+++ b/commonmark-integration-test/src/test/java/org/commonmark/integration/ExtensionsIntegrationTest.java
@@ -3,7 +3,7 @@
 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;
 
 /**
  * Tests to ensure all extensions work well together.
diff --git a/commonmark-integration-test/src/test/java/org/commonmark/integration/MarkdownRendererIntegrationTest.java b/commonmark-integration-test/src/test/java/org/commonmark/integration/MarkdownRendererIntegrationTest.java
index f05efe1c..9ab5c32a 100644
--- a/commonmark-integration-test/src/test/java/org/commonmark/integration/MarkdownRendererIntegrationTest.java
+++ b/commonmark-integration-test/src/test/java/org/commonmark/integration/MarkdownRendererIntegrationTest.java
@@ -10,11 +10,11 @@
 import org.commonmark.ext.task.list.items.TaskListItemsExtension;
 import org.commonmark.parser.Parser;
 import org.commonmark.renderer.markdown.MarkdownRenderer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class MarkdownRendererIntegrationTest {
 
@@ -40,6 +40,6 @@ private String render(String source) {
 
     private void assertRoundTrip(String input) {
         String rendered = render(input);
-        assertEquals(input, rendered);
+        assertThat(rendered).isEqualTo(input);
     }
 }
diff --git a/commonmark-integration-test/src/test/java/org/commonmark/integration/SourceSpanIntegrationTest.java b/commonmark-integration-test/src/test/java/org/commonmark/integration/SourceSpanIntegrationTest.java
index a0649f53..171cc51b 100644
--- a/commonmark-integration-test/src/test/java/org/commonmark/integration/SourceSpanIntegrationTest.java
+++ b/commonmark-integration-test/src/test/java/org/commonmark/integration/SourceSpanIntegrationTest.java
@@ -14,10 +14,6 @@ public class SourceSpanIntegrationTest extends SpecIntegrationTest {
             .includeSourceSpans(IncludeSourceSpans.BLOCKS)
             .build();
 
-    public SourceSpanIntegrationTest(Example example) {
-        super(example);
-    }
-
     @Override
     protected String render(String source) {
         return RENDERER.render(PARSER.parse(source));
diff --git a/commonmark-integration-test/src/test/java/org/commonmark/integration/SpecIntegrationTest.java b/commonmark-integration-test/src/test/java/org/commonmark/integration/SpecIntegrationTest.java
index 2b615aa4..07853d40 100644
--- a/commonmark-integration-test/src/test/java/org/commonmark/integration/SpecIntegrationTest.java
+++ b/commonmark-integration-test/src/test/java/org/commonmark/integration/SpecIntegrationTest.java
@@ -4,7 +4,7 @@
 import org.commonmark.parser.Parser;
 import org.commonmark.testutil.example.Example;
 import org.commonmark.testutil.SpecTestCase;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.*;
 
@@ -20,10 +20,6 @@ public class SpecIntegrationTest extends SpecTestCase {
     protected static final HtmlRenderer RENDERER = HtmlRenderer.builder().extensions(Extensions.ALL_EXTENSIONS).percentEncodeUrls(true).build();
     protected static final Map<String, String> OVERRIDDEN_EXAMPLES = getOverriddenExamples();
 
-    public SpecIntegrationTest(Example example) {
-        super(example);
-    }
-
     @Test
     public void testHtmlRendering() {
         String expectedHtml = OVERRIDDEN_EXAMPLES.get(example.getSource());
diff --git a/commonmark-test-util/pom.xml b/commonmark-test-util/pom.xml
index 7fb4881f..d6a38f4a 100644
--- a/commonmark-test-util/pom.xml
+++ b/commonmark-test-util/pom.xml
@@ -13,8 +13,12 @@
 
     <dependencies>
         <dependency>
-            <groupId>junit</groupId>
-            <artifactId>junit</artifactId>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
         </dependency>
     </dependencies>
 
diff --git a/commonmark-test-util/src/main/java/module-info.java b/commonmark-test-util/src/main/java/module-info.java
index ef983a51..12980d80 100644
--- a/commonmark-test-util/src/main/java/module-info.java
+++ b/commonmark-test-util/src/main/java/module-info.java
@@ -2,5 +2,6 @@
     exports org.commonmark.testutil;
     exports org.commonmark.testutil.example;
 
-    requires junit;
+    requires org.assertj.core;
+    requires org.junit.jupiter.params;
 }
diff --git a/commonmark-test-util/src/main/java/org/commonmark/testutil/Asserts.java b/commonmark-test-util/src/main/java/org/commonmark/testutil/Asserts.java
index 64124b12..971a1b4e 100644
--- a/commonmark-test-util/src/main/java/org/commonmark/testutil/Asserts.java
+++ b/commonmark-test-util/src/main/java/org/commonmark/testutil/Asserts.java
@@ -1,13 +1,13 @@
 package org.commonmark.testutil;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class Asserts {
     public static void assertRendering(String source, String expectedRendering, String actualRendering) {
         // include source for better assertion errors
         String expected = showTabs(expectedRendering + "\n\n" + source);
         String actual = showTabs(actualRendering + "\n\n" + source);
-        assertEquals(expected, actual);
+        assertThat(actual).isEqualTo(expected);
     }
 
     private static String showTabs(String s) {
diff --git a/commonmark-test-util/src/main/java/org/commonmark/testutil/RenderingTestCase.java b/commonmark-test-util/src/main/java/org/commonmark/testutil/RenderingTestCase.java
index b585f460..f7da4c00 100644
--- a/commonmark-test-util/src/main/java/org/commonmark/testutil/RenderingTestCase.java
+++ b/commonmark-test-util/src/main/java/org/commonmark/testutil/RenderingTestCase.java
@@ -1,5 +1,7 @@
 package org.commonmark.testutil;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
 public abstract class RenderingTestCase {
 
     protected abstract String render(String source);
diff --git a/commonmark-test-util/src/main/java/org/commonmark/testutil/SpecTestCase.java b/commonmark-test-util/src/main/java/org/commonmark/testutil/SpecTestCase.java
index 2fb17577..c29a6a69 100644
--- a/commonmark-test-util/src/main/java/org/commonmark/testutil/SpecTestCase.java
+++ b/commonmark-test-util/src/main/java/org/commonmark/testutil/SpecTestCase.java
@@ -2,30 +2,22 @@
 
 import org.commonmark.testutil.example.Example;
 import org.commonmark.testutil.example.ExampleReader;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.params.Parameter;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.ArrayList;
 import java.util.List;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+@MethodSource("data")
 public abstract class SpecTestCase {
 
-    protected final Example example;
+    @Parameter
+    protected Example example;
 
-    public SpecTestCase(Example example) {
-        this.example = example;
+    static List<Example> data() {
+        return ExampleReader.readExamples(TestResources.getSpec());
     }
-
-    @Parameters(name = "{0}")
-    public static List<Object[]> data() {
-        List<Example> examples = ExampleReader.readExamples(TestResources.getSpec());
-        List<Object[]> data = new ArrayList<>();
-        for (Example example : examples) {
-            data.add(new Object[]{example});
-        }
-        return data;
-    }
-
 }
diff --git a/commonmark-test-util/src/main/java/org/commonmark/testutil/example/ExampleReader.java b/commonmark-test-util/src/main/java/org/commonmark/testutil/example/ExampleReader.java
index 6f5dd627..d40a10f6 100644
--- a/commonmark-test-util/src/main/java/org/commonmark/testutil/example/ExampleReader.java
+++ b/commonmark-test-util/src/main/java/org/commonmark/testutil/example/ExampleReader.java
@@ -7,6 +7,7 @@
 import java.util.List;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
 
 /**
  * Reader for files containing examples of CommonMark source and the expected HTML rendering (e.g. spec.txt).
@@ -42,15 +43,13 @@ public static List<Example> readExamples(URL url) {
         }
     }
 
+    public static List<Example> readExamples(URL url, String info) {
+        var examples = readExamples(url);
+        return examples.stream().filter(e -> e.getInfo().contains(info)).collect(Collectors.toList());
+    }
+
     public static List<Object[]> readExampleObjects(URL url, String info) {
-        List<Example> examples = readExamples(url);
-        List<Object[]> data = new ArrayList<>();
-        for (Example example : examples) {
-            if (example.getInfo().contains(info)) {
-                data.add(new Object[]{example});
-            }
-        }
-        return data;
+        return readExamples(url, info).stream().map(e -> new Object[]{e}).collect(Collectors.toList());
     }
 
     public static List<String> readExampleSources(URL url) {
diff --git a/commonmark/src/test/java/org/commonmark/internal/DocumentParserTest.java b/commonmark/src/test/java/org/commonmark/internal/DocumentParserTest.java
index 45143b85..a834665f 100644
--- a/commonmark/src/test/java/org/commonmark/internal/DocumentParserTest.java
+++ b/commonmark/src/test/java/org/commonmark/internal/DocumentParserTest.java
@@ -2,17 +2,15 @@
 
 import org.commonmark.node.*;
 import org.commonmark.parser.block.BlockParserFactory;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
 
-public class DocumentParserTest {
+class DocumentParserTest {
     private static final List<BlockParserFactory> CORE_FACTORIES = List.of(
             new BlockQuoteParser.Factory(),
             new HeadingParser.Factory(),
@@ -23,28 +21,28 @@ public class DocumentParserTest {
             new IndentedCodeBlockParser.Factory());
 
     @Test
-    public void calculateBlockParserFactories_givenAFullListOfAllowedNodes_includesAllCoreFactories() {
+    void calculateBlockParserFactories_givenAFullListOfAllowedNodes_includesAllCoreFactories() {
         List<BlockParserFactory> customParserFactories = List.of();
         var enabledBlockTypes = Set.of(BlockQuote.class, Heading.class, FencedCodeBlock.class, HtmlBlock.class, ThematicBreak.class, ListBlock.class, IndentedCodeBlock.class);
 
         List<BlockParserFactory> blockParserFactories = DocumentParser.calculateBlockParserFactories(customParserFactories, enabledBlockTypes);
-        assertThat(blockParserFactories.size(), is(CORE_FACTORIES.size()));
+        assertThat(blockParserFactories).hasSameSizeAs(CORE_FACTORIES);
 
         for (BlockParserFactory factory : CORE_FACTORIES) {
-            assertTrue(hasInstance(blockParserFactories, factory.getClass()));
+            assertThat(hasInstance(blockParserFactories, factory.getClass())).isTrue();
         }
     }
 
     @Test
-    public void calculateBlockParserFactories_givenAListOfAllowedNodes_includesAssociatedFactories() {
+    void calculateBlockParserFactories_givenAListOfAllowedNodes_includesAssociatedFactories() {
         List<BlockParserFactory> customParserFactories = List.of();
         Set<Class<? extends Block>> nodes = new HashSet<>();
         nodes.add(IndentedCodeBlock.class);
 
         List<BlockParserFactory> blockParserFactories = DocumentParser.calculateBlockParserFactories(customParserFactories, nodes);
 
-        assertThat(blockParserFactories.size(), is(1));
-        assertTrue(hasInstance(blockParserFactories, IndentedCodeBlockParser.Factory.class));
+        assertThat(blockParserFactories).hasSize(1);
+        assertThat(hasInstance(blockParserFactories, IndentedCodeBlockParser.Factory.class)).isTrue();
     }
 
     private boolean hasInstance(List<BlockParserFactory> blockParserFactories, Class<? extends BlockParserFactory> factoryClass) {
diff --git a/commonmark/src/test/java/org/commonmark/internal/LinkReferenceDefinitionParserTest.java b/commonmark/src/test/java/org/commonmark/internal/LinkReferenceDefinitionParserTest.java
index 3f22adac..b69ada0e 100644
--- a/commonmark/src/test/java/org/commonmark/internal/LinkReferenceDefinitionParserTest.java
+++ b/commonmark/src/test/java/org/commonmark/internal/LinkReferenceDefinitionParserTest.java
@@ -3,82 +3,82 @@
 import org.commonmark.internal.LinkReferenceDefinitionParser.State;
 import org.commonmark.node.LinkReferenceDefinition;
 import org.commonmark.parser.SourceLine;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
-public class LinkReferenceDefinitionParserTest {
+class LinkReferenceDefinitionParserTest {
 
     private final LinkReferenceDefinitionParser parser = new LinkReferenceDefinitionParser();
 
     @Test
-    public void testStartLabel() {
+    void testStartLabel() {
         assertState("[", State.LABEL, "[");
     }
 
     @Test
-    public void testStartNoLabel() {
+    void testStartNoLabel() {
         // Not a label
         assertParagraph("a");
         // Can not go back to parsing link reference definitions
         parse("a");
         parse("[");
-        assertEquals(State.PARAGRAPH, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.PARAGRAPH);
         assertParagraphLines("a\n[", parser);
     }
 
     @Test
-    public void testEmptyLabel() {
+    void testEmptyLabel() {
         assertParagraph("[]: /");
         assertParagraph("[ ]: /");
         assertParagraph("[ \t\n\u000B\f\r ]: /");
     }
 
     @Test
-    public void testLabelColon() {
+    void testLabelColon() {
         assertParagraph("[foo] : /");
     }
 
     @Test
-    public void testLabel() {
+    void testLabel() {
         assertState("[foo]:", State.DESTINATION, "[foo]:");
         assertState("[ foo ]:", State.DESTINATION, "[ foo ]:");
     }
 
     @Test
-    public void testLabelInvalid() {
+    void testLabelInvalid() {
         assertParagraph("[foo[]:");
     }
 
     @Test
-    public void testLabelMultiline() {
+    void testLabelMultiline() {
         parse("[two");
-        assertEquals(State.LABEL, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.LABEL);
         parse("lines]:");
-        assertEquals(State.DESTINATION, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.DESTINATION);
         parse("/url");
-        assertEquals(State.START_TITLE, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.START_TITLE);
         assertDef(parser.getDefinitions().get(0), "two\nlines", "/url", null);
     }
 
     @Test
-    public void testLabelStartsWithNewline() {
+    void testLabelStartsWithNewline() {
         parse("[");
-        assertEquals(State.LABEL, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.LABEL);
         parse("weird]:");
-        assertEquals(State.DESTINATION, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.DESTINATION);
         parse("/url");
-        assertEquals(State.START_TITLE, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.START_TITLE);
         assertDef(parser.getDefinitions().get(0), "\nweird", "/url", null);
     }
 
     @Test
-    public void testDestination() {
+    void testDestination() {
         parse("[foo]: /url");
-        assertEquals(State.START_TITLE, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.START_TITLE);
         assertParagraphLines("", parser);
 
-        assertEquals(1, parser.getDefinitions().size());
+        assertThat(parser.getDefinitions()).hasSize(1);
         assertDef(parser.getDefinitions().get(0), "foo", "/url", null);
 
         parse("[bar]: </url2>");
@@ -86,91 +86,91 @@ public void testDestination() {
     }
 
     @Test
-    public void testDestinationInvalid() {
+    void testDestinationInvalid() {
         assertParagraph("[foo]: <bar<>");
     }
 
     @Test
-    public void testTitle() {
+    void testTitle() {
         parse("[foo]: /url 'title'");
-        assertEquals(State.START_DEFINITION, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.START_DEFINITION);
         assertParagraphLines("", parser);
 
-        assertEquals(1, parser.getDefinitions().size());
+        assertThat(parser.getDefinitions()).hasSize(1);
         assertDef(parser.getDefinitions().get(0), "foo", "/url", "title");
     }
 
     @Test
-    public void testTitleStartWhitespace() {
+    void testTitleStartWhitespace() {
         parse("[foo]: /url");
-        assertEquals(State.START_TITLE, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.START_TITLE);
         assertParagraphLines("", parser);
 
         parse("   ");
 
-        assertEquals(State.START_DEFINITION, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.START_DEFINITION);
         assertParagraphLines("   ", parser);
 
-        assertEquals(1, parser.getDefinitions().size());
+        assertThat(parser.getDefinitions()).hasSize(1);
         assertDef(parser.getDefinitions().get(0), "foo", "/url", null);
     }
 
     @Test
-    public void testTitleMultiline() {
+    void testTitleMultiline() {
         parse("[foo]: /url 'two");
-        assertEquals(State.TITLE, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.TITLE);
         assertParagraphLines("[foo]: /url 'two", parser);
-        assertEquals(0, parser.getDefinitions().size());
+        assertThat(parser.getDefinitions()).isEmpty();
 
         parse("lines");
-        assertEquals(State.TITLE, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.TITLE);
         assertParagraphLines("[foo]: /url 'two\nlines", parser);
-        assertEquals(0, parser.getDefinitions().size());
+        assertThat(parser.getDefinitions()).isEmpty();
 
         parse("'");
-        assertEquals(State.START_DEFINITION, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.START_DEFINITION);
         assertParagraphLines("", parser);
 
-        assertEquals(1, parser.getDefinitions().size());
+        assertThat(parser.getDefinitions()).hasSize(1);
         assertDef(parser.getDefinitions().get(0), "foo", "/url", "two\nlines\n");
     }
 
     @Test
-    public void testTitleMultiline2() {
+    void testTitleMultiline2() {
         parse("[foo]: /url '");
-        assertEquals(State.TITLE, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.TITLE);
         parse("title'");
-        assertEquals(State.START_DEFINITION, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.START_DEFINITION);
 
         assertDef(parser.getDefinitions().get(0), "foo", "/url", "\ntitle");
     }
 
     @Test
-    public void testTitleMultiline3() {
+    void testTitleMultiline3() {
         parse("[foo]: /url");
-        assertEquals(State.START_TITLE, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.START_TITLE);
         // Note that this looks like a valid title until we parse "bad", at which point we need to treat the whole line
         // as a paragraph line and discard any already parsed title.
         parse("\"title\" bad");
-        assertEquals(State.PARAGRAPH, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.PARAGRAPH);
 
         assertDef(parser.getDefinitions().get(0), "foo", "/url", null);
     }
 
     @Test
-    public void testTitleMultiline4() {
+    void testTitleMultiline4() {
         parse("[foo]: /url");
-        assertEquals(State.START_TITLE, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.START_TITLE);
         parse("(title");
-        assertEquals(State.TITLE, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.TITLE);
         parse("foo(");
-        assertEquals(State.PARAGRAPH, parser.getState());
+        assertThat(parser.getState()).isEqualTo(State.PARAGRAPH);
 
         assertDef(parser.getDefinitions().get(0), "foo", "/url", null);
     }
 
     @Test
-    public void testTitleInvalid() {
+    void testTitleInvalid() {
         assertParagraph("[foo]: /url (invalid(");
         assertParagraph("[foo]: </url>'title'");
         assertParagraph("[foo]: /url 'title' INVALID");
@@ -188,18 +188,18 @@ private static void assertState(String input, State state, String paragraphConte
         LinkReferenceDefinitionParser parser = new LinkReferenceDefinitionParser();
         // TODO: Should we check things with source spans here?
         parser.parse(SourceLine.of(input, null));
-        assertEquals(state, parser.getState());
+        assertThat(parser.getState()).isEqualTo(state);
         assertParagraphLines(paragraphContent, parser);
     }
 
     private static void assertDef(LinkReferenceDefinition def, String label, String destination, String title) {
-        assertEquals(label, def.getLabel());
-        assertEquals(destination, def.getDestination());
-        assertEquals(title, def.getTitle());
+        assertThat(def.getLabel()).isEqualTo(label);
+        assertThat(def.getDestination()).isEqualTo(destination);
+        assertThat(def.getTitle()).isEqualTo(title);
     }
 
     private static void assertParagraphLines(String expectedContent, LinkReferenceDefinitionParser parser) {
         String actual = parser.getParagraphLines().getContent();
-        assertEquals(expectedContent, actual);
+        assertThat(actual).isEqualTo(expectedContent);
     }
 }
diff --git a/commonmark/src/test/java/org/commonmark/internal/util/EscapingTest.java b/commonmark/src/test/java/org/commonmark/internal/util/EscapingTest.java
index 9433eb7d..eb2f1a80 100644
--- a/commonmark/src/test/java/org/commonmark/internal/util/EscapingTest.java
+++ b/commonmark/src/test/java/org/commonmark/internal/util/EscapingTest.java
@@ -1,21 +1,21 @@
 package org.commonmark.internal.util;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
-public class EscapingTest {
+class EscapingTest {
 
     @Test
-    public void testEscapeHtml() {
-        assertEquals("nothing to escape", Escaping.escapeHtml("nothing to escape"));
-        assertEquals("&amp;", Escaping.escapeHtml("&"));
-        assertEquals("&lt;", Escaping.escapeHtml("<"));
-        assertEquals("&gt;", Escaping.escapeHtml(">"));
-        assertEquals("&quot;", Escaping.escapeHtml("\""));
-        assertEquals("&lt; start", Escaping.escapeHtml("< start"));
-        assertEquals("end &gt;", Escaping.escapeHtml("end >"));
-        assertEquals("&lt; both &gt;", Escaping.escapeHtml("< both >"));
-        assertEquals("&lt; middle &amp; too &gt;", Escaping.escapeHtml("< middle & too >"));
+    void testEscapeHtml() {
+        assertThat(Escaping.escapeHtml("nothing to escape")).isEqualTo("nothing to escape");
+        assertThat(Escaping.escapeHtml("&")).isEqualTo("&amp;");
+        assertThat(Escaping.escapeHtml("<")).isEqualTo("&lt;");
+        assertThat(Escaping.escapeHtml(">")).isEqualTo("&gt;");
+        assertThat(Escaping.escapeHtml("\"")).isEqualTo("&quot;");
+        assertThat(Escaping.escapeHtml("< start")).isEqualTo("&lt; start");
+        assertThat(Escaping.escapeHtml("end >")).isEqualTo("end &gt;");
+        assertThat(Escaping.escapeHtml("< both >")).isEqualTo("&lt; both &gt;");
+        assertThat(Escaping.escapeHtml("< middle & too >")).isEqualTo("&lt; middle &amp; too &gt;");
     }
 }
diff --git a/commonmark/src/test/java/org/commonmark/internal/util/LineReaderTest.java b/commonmark/src/test/java/org/commonmark/internal/util/LineReaderTest.java
index fc48623a..b5271384 100644
--- a/commonmark/src/test/java/org/commonmark/internal/util/LineReaderTest.java
+++ b/commonmark/src/test/java/org/commonmark/internal/util/LineReaderTest.java
@@ -1,6 +1,6 @@
 package org.commonmark.internal.util;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.*;
 import java.nio.charset.StandardCharsets;
@@ -9,13 +9,14 @@
 import java.util.Objects;
 
 import static java.util.stream.Collectors.joining;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.commonmark.internal.util.LineReader.CHAR_BUFFER_SIZE;
-import static org.junit.Assert.*;
 
-public class LineReaderTest {
+class LineReaderTest {
 
     @Test
-    public void testReadLine() throws IOException {
+    void testReadLine() throws IOException {
         assertLines();
 
         assertLines("", "\n");
@@ -48,21 +49,16 @@ public void testReadLine() throws IOException {
     }
 
     @Test
-    public void testClose() throws IOException {
+    void testClose() throws IOException {
         var reader = new InputStreamReader(new ByteArrayInputStream("test".getBytes(StandardCharsets.UTF_8)));
         var lineReader = new LineReader(reader);
         lineReader.close();
         lineReader.close();
-        try {
-            reader.read();
-            fail("Expected read to throw after closing reader");
-        } catch (IOException e) {
-            // Expected
-        }
+        assertThatThrownBy(reader::read).isInstanceOf(IOException.class);
     }
 
     private void assertLines(String... s) throws IOException {
-        assertTrue("Expected parts needs to be even (pairs of content and terminator)", s.length % 2 == 0);
+        assertThat(s.length).as("Expected parts needs to be even (pairs of content and terminator)").isEven();
         var input = Arrays.stream(s).filter(Objects::nonNull).collect(joining(""));
 
         assertLines(new StringReader(input), s);
@@ -77,8 +73,8 @@ private static void assertLines(Reader reader, String... expectedParts) throws I
                 lines.add(line);
                 lines.add(lineReader.getLineTerminator());
             }
-            assertNull(lineReader.getLineTerminator());
-            assertEquals(Arrays.asList(expectedParts), lines);
+            assertThat(lineReader.getLineTerminator()).isNull();
+            assertThat(lines).containsExactly(expectedParts);
         }
     }
 
diff --git a/commonmark/src/test/java/org/commonmark/parser/InlineContentParserTest.java b/commonmark/src/test/java/org/commonmark/parser/InlineContentParserTest.java
index ed97b6f3..d0f45a6b 100644
--- a/commonmark/src/test/java/org/commonmark/parser/InlineContentParserTest.java
+++ b/commonmark/src/test/java/org/commonmark/parser/InlineContentParserTest.java
@@ -1,53 +1,51 @@
 package org.commonmark.parser;
 
-import org.commonmark.node.CustomNode;
-import org.commonmark.node.Heading;
-import org.commonmark.node.Image;
-import org.commonmark.node.Text;
+import org.commonmark.node.*;
 import org.commonmark.parser.beta.InlineContentParser;
 import org.commonmark.parser.beta.InlineContentParserFactory;
 import org.commonmark.parser.beta.InlineParserState;
 import org.commonmark.parser.beta.ParsedInline;
 import org.commonmark.test.Nodes;
-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 InlineContentParserTest {
+class InlineContentParserTest {
 
     @Test
-    public void customInlineContentParser() {
+    void customInlineContentParser() {
         var parser = Parser.builder().customInlineContentParserFactory(new DollarInlineParser.Factory()).build();
         var doc = parser.parse("Test: $hey *there*$ $you$\n\n# Heading $heading$\n");
         var inline1 = Nodes.find(doc, DollarInline.class);
-        assertEquals("hey *there*", inline1.getLiteral());
+        assertThat(inline1.getLiteral()).isEqualTo("hey *there*");
 
         var inline2 = (DollarInline) doc.getFirstChild().getLastChild();
-        assertEquals("you", inline2.getLiteral());
+        assertThat(inline2.getLiteral()).isEqualTo("you");
 
         var heading = Nodes.find(doc, Heading.class);
         var inline3 = (DollarInline) heading.getLastChild();
-        assertEquals("heading", inline3.getLiteral());
+        assertThat(inline3.getLiteral()).isEqualTo("heading");
 
         // Parser is created for each inline snippet, which is why the index resets for the second snippet.
-        assertEquals(0, inline1.getIndex());
-        assertEquals(1, inline2.getIndex());
-        assertEquals(0, inline3.getIndex());
+        assertThat(inline1.getIndex()).isEqualTo(0);
+        assertThat(inline2.getIndex()).isEqualTo(1);
+        assertThat(inline3.getIndex()).isEqualTo(0);
     }
 
     @Test
-    public void bangInlineContentParser() {
+    void bangInlineContentParser() {
         // See if using ! for a custom inline content parser works.
         // ![] is used for images, but if it's not followed by a [, it should be possible to parse it differently.
         var parser = Parser.builder().customInlineContentParserFactory(new BangInlineParser.Factory()).build();
         var doc = parser.parse("![image](url) !notimage");
         var image = Nodes.find(doc, Image.class);
-        assertEquals("url", image.getDestination());
-        assertEquals(" ", ((Text) image.getNext()).getLiteral());
-        assertEquals(BangInline.class, image.getNext().getNext().getClass());
-        assertEquals("notimage", ((Text) image.getNext().getNext().getNext()).getLiteral());
+        assertThat(image.getDestination()).isEqualTo("url");
+        assertThat(((Text) image.getNext()).getLiteral()).isEqualTo(" ");
+        // Class
+        assertThat(image.getNext().getNext()).isInstanceOf(BangInline.class);
+        assertThat(((Text) image.getNext().getNext().getNext()).getLiteral()).isEqualTo("notimage");
     }
 
     private static class DollarInline extends CustomNode {
diff --git a/commonmark/src/test/java/org/commonmark/parser/beta/LinkProcessorTest.java b/commonmark/src/test/java/org/commonmark/parser/beta/LinkProcessorTest.java
index 6209ac9a..ef873912 100644
--- a/commonmark/src/test/java/org/commonmark/parser/beta/LinkProcessorTest.java
+++ b/commonmark/src/test/java/org/commonmark/parser/beta/LinkProcessorTest.java
@@ -4,13 +4,14 @@
 import org.commonmark.node.Text;
 import org.commonmark.parser.Parser;
 import org.commonmark.test.Nodes;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
+
+class LinkProcessorTest {
 
-public class LinkProcessorTest {
     @Test
-    public void testLinkMarkerShouldNotBeIncludedByDefault() {
+    void testLinkMarkerShouldNotBeIncludedByDefault() {
         // If a link marker is registered but is not processed, the built-in link processor shouldn't consume it.
         // And I think by default, other processors shouldn't consume it either (by accident).
         // So requiring processors to opt into including the marker is better than requiring them to opt out,
@@ -19,7 +20,7 @@ public void testLinkMarkerShouldNotBeIncludedByDefault() {
         var parser = Parser.builder().linkMarker('^').build();
         var doc = parser.parse("^[test](url)");
         var link = Nodes.find(doc, Link.class);
-        assertEquals("url", link.getDestination());
-        assertEquals("^", ((Text) link.getPrevious()).getLiteral());
+        assertThat(link.getDestination()).isEqualTo("url");
+        assertThat(((Text) link.getPrevious()).getLiteral()).isEqualTo("^");
     }
 }
diff --git a/commonmark/src/test/java/org/commonmark/parser/beta/ScannerTest.java b/commonmark/src/test/java/org/commonmark/parser/beta/ScannerTest.java
index 14c118ab..bd74cab0 100644
--- a/commonmark/src/test/java/org/commonmark/parser/beta/ScannerTest.java
+++ b/commonmark/src/test/java/org/commonmark/parser/beta/ScannerTest.java
@@ -3,87 +3,87 @@
 import org.commonmark.node.SourceSpan;
 import org.commonmark.parser.SourceLine;
 import org.commonmark.parser.SourceLines;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
 
-public class ScannerTest {
+class ScannerTest {
 
     @Test
-    public void testNext() {
+    void testNext() {
         Scanner scanner = new Scanner(List.of(
                 SourceLine.of("foo bar", null)),
                 0, 4);
-        assertEquals('b', scanner.peek());
+        assertThat(scanner.peek()).isEqualTo('b');
         scanner.next();
-        assertEquals('a', scanner.peek());
+        assertThat(scanner.peek()).isEqualTo('a');
         scanner.next();
-        assertEquals('r', scanner.peek());
+        assertThat(scanner.peek()).isEqualTo('r');
         scanner.next();
-        assertEquals('\0', scanner.peek());
+        assertThat(scanner.peek()).isEqualTo('\0');
     }
 
     @Test
-    public void testMultipleLines() {
+    void testMultipleLines() {
         Scanner scanner = new Scanner(List.of(
                 SourceLine.of("ab", null),
                 SourceLine.of("cde", null)),
                 0, 0);
-        assertTrue(scanner.hasNext());
-        assertEquals('\0', scanner.peekPreviousCodePoint());
-        assertEquals('a', scanner.peek());
+        assertThat(scanner.hasNext()).isTrue();
+        assertThat(scanner.peekPreviousCodePoint()).isEqualTo('\0');
+        assertThat(scanner.peek()).isEqualTo('a');
         scanner.next();
 
-        assertTrue(scanner.hasNext());
-        assertEquals('a', scanner.peekPreviousCodePoint());
-        assertEquals('b', scanner.peek());
+        assertThat(scanner.hasNext()).isTrue();
+        assertThat(scanner.peekPreviousCodePoint()).isEqualTo('a');
+        assertThat(scanner.peek()).isEqualTo('b');
         scanner.next();
 
-        assertTrue(scanner.hasNext());
-        assertEquals('b', scanner.peekPreviousCodePoint());
-        assertEquals('\n', scanner.peek());
+        assertThat(scanner.hasNext()).isTrue();
+        assertThat(scanner.peekPreviousCodePoint()).isEqualTo('b');
+        assertThat(scanner.peek()).isEqualTo('\n');
         scanner.next();
 
-        assertTrue(scanner.hasNext());
-        assertEquals('\n', scanner.peekPreviousCodePoint());
-        assertEquals('c', scanner.peek());
+        assertThat(scanner.hasNext()).isTrue();
+        assertThat(scanner.peekPreviousCodePoint()).isEqualTo('\n');
+        assertThat(scanner.peek()).isEqualTo('c');
         scanner.next();
 
-        assertTrue(scanner.hasNext());
-        assertEquals('c', scanner.peekPreviousCodePoint());
-        assertEquals('d', scanner.peek());
+        assertThat(scanner.hasNext()).isTrue();
+        assertThat(scanner.peekPreviousCodePoint()).isEqualTo('c');
+        assertThat(scanner.peek()).isEqualTo('d');
         scanner.next();
 
-        assertTrue(scanner.hasNext());
-        assertEquals('d', scanner.peekPreviousCodePoint());
-        assertEquals('e', scanner.peek());
+        assertThat(scanner.hasNext()).isTrue();
+        assertThat(scanner.peekPreviousCodePoint()).isEqualTo('d');
+        assertThat(scanner.peek()).isEqualTo('e');
         scanner.next();
 
-        assertFalse(scanner.hasNext());
-        assertEquals('e', scanner.peekPreviousCodePoint());
-        assertEquals('\0', scanner.peek());
+        assertThat(scanner.hasNext()).isFalse();
+        assertThat(scanner.peekPreviousCodePoint()).isEqualTo('e');
+        assertThat(scanner.peek()).isEqualTo('\0');
     }
 
     @Test
-    public void testCodePoints() {
+    void testCodePoints() {
         Scanner scanner = new Scanner(List.of(SourceLine.of("\uD83D\uDE0A", null)), 0, 0);
 
-        assertTrue(scanner.hasNext());
-        assertEquals('\0', scanner.peekPreviousCodePoint());
-        assertEquals(128522, scanner.peekCodePoint());
+        assertThat(scanner.hasNext()).isTrue();
+        assertThat(scanner.peekPreviousCodePoint()).isEqualTo('\0');
+        assertThat(scanner.peekCodePoint()).isEqualTo(128522);
         scanner.next();
         // This jumps chars, not code points. So jump two here
         scanner.next();
 
-        assertFalse(scanner.hasNext());
-        assertEquals(128522, scanner.peekPreviousCodePoint());
-        assertEquals('\0', scanner.peekCodePoint());
+        assertThat(scanner.hasNext()).isFalse();
+        assertThat(scanner.peekPreviousCodePoint()).isEqualTo(128522);
+        assertThat(scanner.peekCodePoint()).isEqualTo('\0');
     }
 
     @Test
-    public void testTextBetween() {
+    void testTextBetween() {
         Scanner scanner = new Scanner(List.of(
                 SourceLine.of("ab", SourceSpan.of(10, 3, 13, 2)),
                 SourceLine.of("cde", SourceSpan.of(11, 4, 20, 3))),
@@ -139,20 +139,20 @@ public void testTextBetween() {
     }
 
     private void assertSourceLines(SourceLines sourceLines, String expectedContent, SourceSpan... expectedSourceSpans) {
-        assertEquals(expectedContent, sourceLines.getContent());
-        assertEquals(List.of(expectedSourceSpans), sourceLines.getSourceSpans());
+        assertThat(sourceLines.getContent()).isEqualTo(expectedContent);
+        assertThat(sourceLines.getSourceSpans()).isEqualTo(List.of(expectedSourceSpans));
     }
 
     @Test
-    public void nextString() {
+    void nextString() {
         Scanner scanner = Scanner.of(SourceLines.of(List.of(
                 SourceLine.of("hey ya", null),
                 SourceLine.of("hi", null))));
-        assertFalse(scanner.next("hoy"));
-        assertTrue(scanner.next("hey"));
-        assertTrue(scanner.next(' '));
-        assertFalse(scanner.next("yo"));
-        assertTrue(scanner.next("ya"));
-        assertFalse(scanner.next(" "));
+        assertThat(scanner.next("hoy")).isFalse();
+        assertThat(scanner.next("hey")).isTrue();
+        assertThat(scanner.next(' ')).isTrue();
+        assertThat(scanner.next("yo")).isFalse();
+        assertThat(scanner.next("ya")).isTrue();
+        assertThat(scanner.next(" ")).isFalse();
     }
 }
diff --git a/commonmark/src/test/java/org/commonmark/renderer/markdown/MarkdownRendererTest.java b/commonmark/src/test/java/org/commonmark/renderer/markdown/MarkdownRendererTest.java
index 36a5b528..36b8adad 100644
--- a/commonmark/src/test/java/org/commonmark/renderer/markdown/MarkdownRendererTest.java
+++ b/commonmark/src/test/java/org/commonmark/renderer/markdown/MarkdownRendererTest.java
@@ -3,15 +3,12 @@
 import org.commonmark.node.*;
 import org.commonmark.parser.Parser;
 import org.commonmark.renderer.NodeRenderer;
-import org.commonmark.renderer.html.HtmlNodeRendererContext;
-import org.commonmark.renderer.html.HtmlNodeRendererFactory;
-import org.commonmark.renderer.html.HtmlRenderer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Set;
 
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.commonmark.testutil.Asserts.assertRendering;
-import static org.junit.Assert.assertEquals;
 
 public class MarkdownRendererTest {
 
@@ -31,7 +28,7 @@ public void testThematicBreaks() {
 
         // Apply fallback for null literal
         ThematicBreak node = new ThematicBreak();
-        assertEquals("___", render(node));
+        assertThat(render(node)).isEqualTo("___");
     }
 
     @Test
@@ -255,7 +252,7 @@ public void testEmphasis() {
         Emphasis e2 = new Emphasis();
         e1.appendChild(e2);
         e2.appendChild(new Text("hi"));
-        assertEquals("*_hi_*\n", render(doc));
+        assertThat(render(doc)).isEqualTo("*_hi_*\n");
     }
 
     @Test
@@ -332,12 +329,12 @@ public Set<Character> getSpecialCharacters() {
 
         MarkdownRenderer renderer = MarkdownRenderer.builder().nodeRendererFactory(nodeRendererFactory).build();
         String rendered = renderer.render(parse("# Hello"));
-        assertEquals("# Custom heading\n", rendered);
+        assertThat(rendered).isEqualTo("# Custom heading\n");
     }
 
     private void assertRoundTrip(String input) {
         String rendered = parseAndRender(input);
-        assertEquals(input, rendered);
+        assertThat(rendered).isEqualTo(input);
     }
 
     private String parseAndRender(String source) {
diff --git a/commonmark/src/test/java/org/commonmark/renderer/markdown/SpecMarkdownRendererTest.java b/commonmark/src/test/java/org/commonmark/renderer/markdown/SpecMarkdownRendererTest.java
index 5df2e5c8..3b88df55 100644
--- a/commonmark/src/test/java/org/commonmark/renderer/markdown/SpecMarkdownRendererTest.java
+++ b/commonmark/src/test/java/org/commonmark/renderer/markdown/SpecMarkdownRendererTest.java
@@ -6,15 +6,14 @@
 import org.commonmark.testutil.TestResources;
 import org.commonmark.testutil.example.Example;
 import org.commonmark.testutil.example.ExampleReader;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
 
 /**
  * Tests Markdown rendering using the examples in the spec like this:
@@ -63,9 +62,8 @@ public void testCoverage() {
             System.out.println();
         }
 
-        int expectedPassed = 652;
-        assertTrue("Expected at least " + expectedPassed + " examples to pass but was " + passes.size(), passes.size() >= expectedPassed);
-        assertEquals(0, fails.size());
+        assertThat(passes).hasSizeGreaterThanOrEqualTo(652);
+        assertThat(fails).isEmpty();
     }
 
     private static void printCountsBySection(List<Example> examples) {
diff --git a/commonmark/src/test/java/org/commonmark/test/AbstractVisitorTest.java b/commonmark/src/test/java/org/commonmark/test/AbstractVisitorTest.java
index b3b60fa3..edb6936f 100644
--- a/commonmark/src/test/java/org/commonmark/test/AbstractVisitorTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/AbstractVisitorTest.java
@@ -1,10 +1,9 @@
 package org.commonmark.test;
 
 import org.commonmark.node.*;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class AbstractVisitorTest {
 
@@ -26,13 +25,13 @@ public void visit(Text text) {
 
         assertCode("foo", paragraph.getFirstChild());
         assertCode("bar", paragraph.getFirstChild().getNext());
-        assertNull(paragraph.getFirstChild().getNext().getNext());
+        assertThat(paragraph.getFirstChild().getNext().getNext()).isNull();
         assertCode("bar", paragraph.getLastChild());
     }
 
     private static void assertCode(String expectedLiteral, Node node) {
-        assertEquals("Expected node to be a Code node: " + node, Code.class, node.getClass());
+        assertThat(node).isInstanceOf(Code.class);
         Code code = (Code) node;
-        assertEquals(expectedLiteral, code.getLiteral());
+        assertThat(code.getLiteral()).isEqualTo(expectedLiteral);
     }
 }
diff --git a/commonmark/src/test/java/org/commonmark/test/DelimitedTest.java b/commonmark/src/test/java/org/commonmark/test/DelimitedTest.java
index a34a32c4..3f2f0d61 100644
--- a/commonmark/src/test/java/org/commonmark/test/DelimitedTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/DelimitedTest.java
@@ -2,12 +2,12 @@
 
 import org.commonmark.node.*;
 import org.commonmark.parser.Parser;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class DelimitedTest {
 
@@ -35,20 +35,20 @@ public void visit(StrongEmphasis node) {
         };
         document.accept(visitor);
 
-        assertEquals(4, list.size());
+        assertThat(list).hasSize(4);
 
         Delimited emphasis = list.get(0);
         Delimited strong = list.get(1);
         Delimited important = list.get(2);
         Delimited critical = list.get(3);
 
-        assertEquals("*", emphasis.getOpeningDelimiter());
-        assertEquals("*", emphasis.getClosingDelimiter());
-        assertEquals("**", strong.getOpeningDelimiter());
-        assertEquals("**", strong.getClosingDelimiter());
-        assertEquals("_", important.getOpeningDelimiter());
-        assertEquals("_", important.getClosingDelimiter());
-        assertEquals("__", critical.getOpeningDelimiter());
-        assertEquals("__", critical.getClosingDelimiter());
+        assertThat(emphasis.getOpeningDelimiter()).isEqualTo("*");
+        assertThat(emphasis.getClosingDelimiter()).isEqualTo("*");
+        assertThat(strong.getOpeningDelimiter()).isEqualTo("**");
+        assertThat(strong.getClosingDelimiter()).isEqualTo("**");
+        assertThat(important.getOpeningDelimiter()).isEqualTo("_");
+        assertThat(important.getClosingDelimiter()).isEqualTo("_");
+        assertThat(critical.getOpeningDelimiter()).isEqualTo("__");
+        assertThat(critical.getClosingDelimiter()).isEqualTo("__");
     }
 }
diff --git a/commonmark/src/test/java/org/commonmark/test/DelimiterProcessorTest.java b/commonmark/src/test/java/org/commonmark/test/DelimiterProcessorTest.java
index 680c40bf..e4920120 100644
--- a/commonmark/src/test/java/org/commonmark/test/DelimiterProcessorTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/DelimiterProcessorTest.java
@@ -11,12 +11,13 @@
 import org.commonmark.renderer.html.HtmlNodeRendererFactory;
 import org.commonmark.renderer.html.HtmlRenderer;
 import org.commonmark.testutil.RenderingTestCase;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Locale;
 import java.util.Set;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 public class DelimiterProcessorTest extends RenderingTestCase {
 
@@ -29,8 +30,8 @@ public void delimiterProcessorWithInvalidDelimiterUse() {
                 .customDelimiterProcessor(new CustomDelimiterProcessor(':', 0))
                 .customDelimiterProcessor(new CustomDelimiterProcessor(';', -1))
                 .build();
-        assertEquals("<p>:test:</p>\n", RENDERER.render(parser.parse(":test:")));
-        assertEquals("<p>;test;</p>\n", RENDERER.render(parser.parse(";test;")));
+        assertThat(RENDERER.render(parser.parse(":test:"))).isEqualTo("<p>:test:</p>\n");
+        assertThat(RENDERER.render(parser.parse(";test;"))).isEqualTo("<p>;test;</p>\n");
     }
 
     @Test
@@ -54,16 +55,17 @@ public void multipleDelimitersWithDifferentLengths() {
                 .customDelimiterProcessor(new OneDelimiterProcessor())
                 .customDelimiterProcessor(new TwoDelimiterProcessor())
                 .build();
-        assertEquals("<p>(1)one(/1) (2)two(/2)</p>\n", RENDERER.render(parser.parse("+one+ ++two++")));
-        assertEquals("<p>(1)(2)both(/2)(/1)</p>\n", RENDERER.render(parser.parse("+++both+++")));
+        assertThat(RENDERER.render(parser.parse("+one+ ++two++"))).isEqualTo("<p>(1)one(/1) (2)two(/2)</p>\n");
+        assertThat(RENDERER.render(parser.parse("+++both+++"))).isEqualTo("<p>(1)(2)both(/2)(/1)</p>\n");
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void multipleDelimitersWithSameLengthConflict() {
-        Parser.builder()
-                .customDelimiterProcessor(new OneDelimiterProcessor())
-                .customDelimiterProcessor(new OneDelimiterProcessor())
-                .build();
+        assertThatThrownBy(() ->
+                Parser.builder()
+                        .customDelimiterProcessor(new OneDelimiterProcessor())
+                        .customDelimiterProcessor(new OneDelimiterProcessor())
+                        .build()).isInstanceOf(IllegalArgumentException.class);
     }
 
     @Override
diff --git a/commonmark/src/test/java/org/commonmark/test/FencedCodeBlockParserTest.java b/commonmark/src/test/java/org/commonmark/test/FencedCodeBlockParserTest.java
index 774c6ff0..443b0fa5 100644
--- a/commonmark/src/test/java/org/commonmark/test/FencedCodeBlockParserTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/FencedCodeBlockParserTest.java
@@ -5,9 +5,9 @@
 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 static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class FencedCodeBlockParserTest extends RenderingTestCase {
 
@@ -18,8 +18,8 @@ public class FencedCodeBlockParserTest extends RenderingTestCase {
     public void backtickInfo() {
         Node document = PARSER.parse("```info ~ test\ncode\n```");
         FencedCodeBlock codeBlock = (FencedCodeBlock) document.getFirstChild();
-        assertEquals("info ~ test", codeBlock.getInfo());
-        assertEquals("code\n", codeBlock.getLiteral());
+        assertThat(codeBlock.getInfo()).isEqualTo("info ~ test");
+        assertThat(codeBlock.getLiteral()).isEqualTo("code\n");
     }
 
     @Test
diff --git a/commonmark/src/test/java/org/commonmark/test/HeadingParserTest.java b/commonmark/src/test/java/org/commonmark/test/HeadingParserTest.java
index a5b179a8..f7bf35a4 100644
--- a/commonmark/src/test/java/org/commonmark/test/HeadingParserTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/HeadingParserTest.java
@@ -3,7 +3,7 @@
 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;
 
 public class HeadingParserTest extends RenderingTestCase {
 
diff --git a/commonmark/src/test/java/org/commonmark/test/HtmlInlineParserTest.java b/commonmark/src/test/java/org/commonmark/test/HtmlInlineParserTest.java
index 965a2f18..8e1fd979 100644
--- a/commonmark/src/test/java/org/commonmark/test/HtmlInlineParserTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/HtmlInlineParserTest.java
@@ -1,6 +1,6 @@
 package org.commonmark.test;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class HtmlInlineParserTest extends CoreRenderingTestCase {
 
diff --git a/commonmark/src/test/java/org/commonmark/test/HtmlRendererTest.java b/commonmark/src/test/java/org/commonmark/test/HtmlRendererTest.java
index 8e5a8f30..413bb9d8 100644
--- a/commonmark/src/test/java/org/commonmark/test/HtmlRendererTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/HtmlRendererTest.java
@@ -5,59 +5,54 @@
 import org.commonmark.renderer.NodeRenderer;
 import org.commonmark.renderer.html.*;
 import org.commonmark.testutil.TestResources;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
-import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class HtmlRendererTest {
 
     @Test
     public void htmlAllowingShouldNotEscapeInlineHtml() {
         String rendered = htmlAllowingRenderer().render(parse("paragraph with <span id='foo' class=\"bar\">inline &amp; html</span>"));
-        assertEquals("<p>paragraph with <span id='foo' class=\"bar\">inline &amp; html</span></p>\n", rendered);
+        assertThat(rendered).isEqualTo("<p>paragraph with <span id='foo' class=\"bar\">inline &amp; html</span></p>\n");
     }
 
     @Test
     public void htmlAllowingShouldNotEscapeBlockHtml() {
         String rendered = htmlAllowingRenderer().render(parse("<div id='foo' class=\"bar\">block &amp;</div>"));
-        assertEquals("<div id='foo' class=\"bar\">block &amp;</div>\n", rendered);
+        assertThat(rendered).isEqualTo("<div id='foo' class=\"bar\">block &amp;</div>\n");
     }
 
     @Test
     public void htmlEscapingShouldEscapeInlineHtml() {
         String rendered = htmlEscapingRenderer().render(parse("paragraph with <span id='foo' class=\"bar\">inline &amp; html</span>"));
         // Note that &amp; is not escaped, as it's a normal text node, not part of the inline HTML.
-        assertEquals("<p>paragraph with &lt;span id='foo' class=&quot;bar&quot;&gt;inline &amp; html&lt;/span&gt;</p>\n", rendered);
+        assertThat(rendered).isEqualTo("<p>paragraph with &lt;span id='foo' class=&quot;bar&quot;&gt;inline &amp; html&lt;/span&gt;</p>\n");
     }
 
     @Test
     public void htmlEscapingShouldEscapeHtmlBlocks() {
         String rendered = htmlEscapingRenderer().render(parse("<div id='foo' class=\"bar\">block &amp;</div>"));
-        assertEquals("<p>&lt;div id='foo' class=&quot;bar&quot;&gt;block &amp;amp;&lt;/div&gt;</p>\n", rendered);
+        assertThat(rendered).isEqualTo("<p>&lt;div id='foo' class=&quot;bar&quot;&gt;block &amp;amp;&lt;/div&gt;</p>\n");
     }
 
     @Test
     public void textEscaping() {
         String rendered = defaultRenderer().render(parse("escaping: & < > \" '"));
-        assertEquals("<p>escaping: &amp; &lt; &gt; &quot; '</p>\n", rendered);
+        assertThat(rendered).isEqualTo("<p>escaping: &amp; &lt; &gt; &quot; '</p>\n");
     }
 
     @Test
     public void characterReferencesWithoutSemicolonsShouldNotBeParsedShouldBeEscaped() {
         String input = "[example](&#x6A&#x61&#x76&#x61&#x73&#x63&#x72&#x69&#x70&#x74&#x3A&#x61&#x6C&#x65&#x72&#x74&#x28&#x27&#x58&#x53&#x53&#x27&#x29)";
         String rendered = defaultRenderer().render(parse(input));
-        assertEquals("<p><a href=\"&amp;#x6A&amp;#x61&amp;#x76&amp;#x61&amp;#x73&amp;#x63&amp;#x72&amp;#x69&amp;#x70&amp;#x74&amp;#x3A&amp;#x61&amp;#x6C&amp;#x65&amp;#x72&amp;#x74&amp;#x28&amp;#x27&amp;#x58&amp;#x53&amp;#x53&amp;#x27&amp;#x29\">example</a></p>\n", rendered);
+        assertThat(rendered).isEqualTo("<p><a href=\"&amp;#x6A&amp;#x61&amp;#x76&amp;#x61&amp;#x73&amp;#x63&amp;#x72&amp;#x69&amp;#x70&amp;#x74&amp;#x3A&amp;#x61&amp;#x6C&amp;#x65&amp;#x72&amp;#x74&amp;#x28&amp;#x27&amp;#x58&amp;#x53&amp;#x53&amp;#x27&amp;#x29\">example</a></p>\n");
     }
 
     @Test
@@ -66,7 +61,7 @@ public void attributeEscaping() {
         Link link = new Link();
         link.setDestination("&colon;");
         paragraph.appendChild(link);
-        assertEquals("<p><a href=\"&amp;colon;\"></a></p>\n", defaultRenderer().render(paragraph));
+        assertThat(defaultRenderer().render(paragraph)).isEqualTo("<p><a href=\"&amp;colon;\"></a></p>\n");
     }
 
     @Test
@@ -75,7 +70,7 @@ public void rawUrlsShouldNotFilterDangerousProtocols() {
         Link link = new Link();
         link.setDestination("javascript:alert(5);");
         paragraph.appendChild(link);
-        assertEquals("<p><a href=\"javascript:alert(5);\"></a></p>\n", rawUrlsRenderer().render(paragraph));
+        assertThat(rawUrlsRenderer().render(paragraph)).isEqualTo("<p><a href=\"javascript:alert(5);\"></a></p>\n");
     }
 
     @Test
@@ -84,13 +79,13 @@ public void sanitizedUrlsShouldSetRelNoFollow() {
         Link link = new Link();
         link.setDestination("/exampleUrl");
         paragraph.appendChild(link);
-        assertEquals("<p><a rel=\"nofollow\" href=\"/exampleUrl\"></a></p>\n", sanitizeUrlsRenderer().render(paragraph));
+        assertThat(sanitizeUrlsRenderer().render(paragraph)).isEqualTo("<p><a rel=\"nofollow\" href=\"/exampleUrl\"></a></p>\n");
 
         paragraph = new Paragraph();
         link = new Link();
         link.setDestination("https://google.com");
         paragraph.appendChild(link);
-        assertEquals("<p><a rel=\"nofollow\" href=\"https://google.com\"></a></p>\n", sanitizeUrlsRenderer().render(paragraph));
+        assertThat(sanitizeUrlsRenderer().render(paragraph)).isEqualTo("<p><a rel=\"nofollow\" href=\"https://google.com\"></a></p>\n");
     }
 
     @Test
@@ -99,26 +94,26 @@ public void sanitizedUrlsShouldAllowSafeProtocols() {
         Link link = new Link();
         link.setDestination("http://google.com");
         paragraph.appendChild(link);
-        assertEquals("<p><a rel=\"nofollow\" href=\"http://google.com\"></a></p>\n", sanitizeUrlsRenderer().render(paragraph));
+        assertThat(sanitizeUrlsRenderer().render(paragraph)).isEqualTo("<p><a rel=\"nofollow\" href=\"http://google.com\"></a></p>\n");
 
         paragraph = new Paragraph();
         link = new Link();
         link.setDestination("https://google.com");
         paragraph.appendChild(link);
-        assertEquals("<p><a rel=\"nofollow\" href=\"https://google.com\"></a></p>\n", sanitizeUrlsRenderer().render(paragraph));
+        assertThat(sanitizeUrlsRenderer().render(paragraph)).isEqualTo("<p><a rel=\"nofollow\" href=\"https://google.com\"></a></p>\n");
 
         paragraph = new Paragraph();
         link = new Link();
         link.setDestination("mailto:foo@bar.example.com");
         paragraph.appendChild(link);
-        assertEquals("<p><a rel=\"nofollow\" href=\"mailto:foo@bar.example.com\"></a></p>\n", sanitizeUrlsRenderer().render(paragraph));
+        assertThat(sanitizeUrlsRenderer().render(paragraph)).isEqualTo("<p><a rel=\"nofollow\" href=\"mailto:foo@bar.example.com\"></a></p>\n");
 
         String image = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUAAAAFCAYAAACNbyblAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAAFiUAABYlAUlSJPAAAAAQSURBVBhXY/iPBVBf8P9/AG8TY51nJdgkAAAAAElFTkSuQmCC";
         paragraph = new Paragraph();
         link = new Link();
         link.setDestination(image);
         paragraph.appendChild(link);
-        assertEquals("<p><a rel=\"nofollow\" href=\"" + image + "\"></a></p>\n", sanitizeUrlsRenderer().render(paragraph));
+        assertThat(sanitizeUrlsRenderer().render(paragraph)).isEqualTo("<p><a rel=\"nofollow\" href=\"" + image + "\"></a></p>\n");
     }
 
     @Test
@@ -127,45 +122,42 @@ public void sanitizedUrlsShouldFilterDangerousProtocols() {
         Link link = new Link();
         link.setDestination("javascript:alert(5);");
         paragraph.appendChild(link);
-        assertEquals("<p><a rel=\"nofollow\" href=\"\"></a></p>\n", sanitizeUrlsRenderer().render(paragraph));
+        assertThat(sanitizeUrlsRenderer().render(paragraph)).isEqualTo("<p><a rel=\"nofollow\" href=\"\"></a></p>\n");
 
         paragraph = new Paragraph();
         link = new Link();
         link.setDestination("ftp://google.com");
         paragraph.appendChild(link);
-        assertEquals("<p><a rel=\"nofollow\" href=\"\"></a></p>\n", sanitizeUrlsRenderer().render(paragraph));
+        assertThat(sanitizeUrlsRenderer().render(paragraph)).isEqualTo("<p><a rel=\"nofollow\" href=\"\"></a></p>\n");
     }
 
     @Test
     public void percentEncodeUrlDisabled() {
-        assertEquals("<p><a href=\"foo&amp;bar\">a</a></p>\n", defaultRenderer().render(parse("[a](foo&amp;bar)")));
-        assertEquals("<p><a href=\"ä\">a</a></p>\n", defaultRenderer().render(parse("[a](ä)")));
-        assertEquals("<p><a href=\"foo%20bar\">a</a></p>\n", defaultRenderer().render(parse("[a](foo%20bar)")));
+        assertThat(defaultRenderer().render(parse("[a](foo&amp;bar)"))).isEqualTo("<p><a href=\"foo&amp;bar\">a</a></p>\n");
+        assertThat(defaultRenderer().render(parse("[a](ä)"))).isEqualTo("<p><a href=\"ä\">a</a></p>\n");
+        assertThat(defaultRenderer().render(parse("[a](foo%20bar)"))).isEqualTo("<p><a href=\"foo%20bar\">a</a></p>\n");
     }
 
     @Test
     public void percentEncodeUrl() {
         // Entities are escaped anyway
-        assertEquals("<p><a href=\"foo&amp;bar\">a</a></p>\n", percentEncodingRenderer().render(parse("[a](foo&amp;bar)")));
+        assertThat(percentEncodingRenderer().render(parse("[a](foo&amp;bar)"))).isEqualTo("<p><a href=\"foo&amp;bar\">a</a></p>\n");
         // Existing encoding is preserved
-        assertEquals("<p><a href=\"foo%20bar\">a</a></p>\n", percentEncodingRenderer().render(parse("[a](foo%20bar)")));
-        assertEquals("<p><a href=\"foo%61\">a</a></p>\n", percentEncodingRenderer().render(parse("[a](foo%61)")));
+        assertThat(percentEncodingRenderer().render(parse("[a](foo%20bar)"))).isEqualTo("<p><a href=\"foo%20bar\">a</a></p>\n");
+        assertThat(percentEncodingRenderer().render(parse("[a](foo%61)"))).isEqualTo("<p><a href=\"foo%61\">a</a></p>\n");
         // Invalid encoding is escaped
-        assertEquals("<p><a href=\"foo%25\">a</a></p>\n", percentEncodingRenderer().render(parse("[a](foo%)")));
-        assertEquals("<p><a href=\"foo%25a\">a</a></p>\n", percentEncodingRenderer().render(parse("[a](foo%a)")));
-        assertEquals("<p><a href=\"foo%25a_\">a</a></p>\n", percentEncodingRenderer().render(parse("[a](foo%a_)")));
-        assertEquals("<p><a href=\"foo%25xx\">a</a></p>\n", percentEncodingRenderer().render(parse("[a](foo%xx)")));
+        assertThat(percentEncodingRenderer().render(parse("[a](foo%)"))).isEqualTo("<p><a href=\"foo%25\">a</a></p>\n");
+        assertThat(percentEncodingRenderer().render(parse("[a](foo%a)"))).isEqualTo("<p><a href=\"foo%25a\">a</a></p>\n");
+        assertThat(percentEncodingRenderer().render(parse("[a](foo%a_)"))).isEqualTo("<p><a href=\"foo%25a_\">a</a></p>\n");
+        assertThat(percentEncodingRenderer().render(parse("[a](foo%xx)"))).isEqualTo("<p><a href=\"foo%25xx\">a</a></p>\n");
         // Reserved characters are preserved, except for '[' and ']'
-        assertEquals("<p><a href=\"!*'();:@&amp;=+$,/?#%5B%5D\">a</a></p>\n", percentEncodingRenderer().render(parse("[a](!*'();:@&=+$,/?#[])")));
+        assertThat(percentEncodingRenderer().render(parse("[a](!*'();:@&=+$,/?#[])"))).isEqualTo("<p><a href=\"!*'();:@&amp;=+$,/?#%5B%5D\">a</a></p>\n");
         // Unreserved characters are preserved
-        assertEquals("<p><a href=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~\">a</a></p>\n",
-                percentEncodingRenderer().render(parse("[a](ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~)")));
+        assertThat(percentEncodingRenderer().render(parse("[a](ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~)"))).isEqualTo("<p><a href=\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.~\">a</a></p>\n");
         // Other characters are percent-encoded (LATIN SMALL LETTER A WITH DIAERESIS)
-        assertEquals("<p><a href=\"%C3%A4\">a</a></p>\n",
-                percentEncodingRenderer().render(parse("[a](ä)")));
+        assertThat(percentEncodingRenderer().render(parse("[a](ä)"))).isEqualTo("<p><a href=\"%C3%A4\">a</a></p>\n");
         // Other characters are percent-encoded (MUSICAL SYMBOL G CLEF, surrogate pair in UTF-16)
-        assertEquals("<p><a href=\"%F0%9D%84%9E\">a</a></p>\n",
-                percentEncodingRenderer().render(parse("[a](\uD834\uDD1E)")));
+        assertThat(percentEncodingRenderer().render(parse("[a](\uD834\uDD1E)"))).isEqualTo("<p><a href=\"%F0%9D%84%9E\">a</a></p>\n");
     }
 
     @Test
@@ -192,10 +184,10 @@ public void setAttributes(Node node, String tagName, Map<String, String> attribu
 
         HtmlRenderer renderer = HtmlRenderer.builder().attributeProviderFactory(custom).build();
         String rendered = renderer.render(parse("```info\ncontent\n```"));
-        assertEquals("<pre data-code-block=\"fenced\"><code data-custom=\"info\">content\n</code></pre>\n", rendered);
+        assertThat(rendered).isEqualTo("<pre data-code-block=\"fenced\"><code data-custom=\"info\">content\n</code></pre>\n");
 
         String rendered2 = renderer.render(parse("```evil\"\ncontent\n```"));
-        assertEquals("<pre data-code-block=\"fenced\"><code data-custom=\"evil&quot;\">content\n</code></pre>\n", rendered2);
+        assertThat(rendered2).isEqualTo("<pre data-code-block=\"fenced\"><code data-custom=\"evil&quot;\">content\n</code></pre>\n");
     }
 
     @Test
@@ -217,7 +209,7 @@ public void setAttributes(Node node, String tagName, Map<String, String> attribu
 
         HtmlRenderer renderer = HtmlRenderer.builder().attributeProviderFactory(custom).build();
         String rendered = renderer.render(parse("![foo](/url)\n"));
-        assertEquals("<p><img src=\"/url\" test=\"hey\" /></p>\n", rendered);
+        assertThat(rendered).isEqualTo("<p><img src=\"/url\" test=\"hey\" /></p>\n");
     }
 
     @Test
@@ -240,7 +232,7 @@ public void setAttributes(Node node, String tagName, Map<String, String> attribu
         HtmlRenderer renderer = HtmlRenderer.builder().attributeProviderFactory(factory).build();
         String rendered = renderer.render(parse("text node"));
         String secondPass = renderer.render(parse("text node"));
-        assertEquals(rendered, secondPass);
+        assertThat(secondPass).isEqualTo(rendered);
     }
 
     @Test
@@ -264,30 +256,27 @@ public void render(Node node) {
 
         HtmlRenderer renderer = HtmlRenderer.builder().nodeRendererFactory(nodeRendererFactory).build();
         String rendered = renderer.render(parse("foo [bar](/url)"));
-        assertEquals("<p>foo test</p>\n", rendered);
+        assertThat(rendered).isEqualTo("<p>foo test</p>\n");
     }
 
     @Test
     public void orderedListStartZero() {
-        assertEquals("<ol start=\"0\">\n<li>Test</li>\n</ol>\n", defaultRenderer().render(parse("0. Test\n")));
+        assertThat(defaultRenderer().render(parse("0. Test\n"))).isEqualTo("<ol start=\"0\">\n<li>Test</li>\n</ol>\n");
     }
 
     @Test
     public void imageAltTextWithSoftLineBreak() {
-        assertEquals("<p><img src=\"/url\" alt=\"foo\nbar\" /></p>\n",
-                defaultRenderer().render(parse("![foo\nbar](/url)\n")));
+        assertThat(defaultRenderer().render(parse("![foo\nbar](/url)\n"))).isEqualTo("<p><img src=\"/url\" alt=\"foo\nbar\" /></p>\n");
     }
 
     @Test
     public void imageAltTextWithHardLineBreak() {
-        assertEquals("<p><img src=\"/url\" alt=\"foo\nbar\" /></p>\n",
-                defaultRenderer().render(parse("![foo  \nbar](/url)\n")));
+        assertThat(defaultRenderer().render(parse("![foo  \nbar](/url)\n"))).isEqualTo("<p><img src=\"/url\" alt=\"foo\nbar\" /></p>\n");
     }
 
     @Test
     public void imageAltTextWithEntities() {
-        assertEquals("<p><img src=\"/url\" alt=\"foo \u00E4\" /></p>\n",
-                defaultRenderer().render(parse("![foo &auml;](/url)\n")));
+        assertThat(defaultRenderer().render(parse("![foo &auml;](/url)\n"))).isEqualTo("<p><img src=\"/url\" alt=\"foo \u00E4\" /></p>\n");
     }
 
     @Test
@@ -304,41 +293,35 @@ public void canRenderContentsOfSingleParagraph() {
             document.appendChild(current);
         }
 
-        assertEquals("Here I have a test <a href=\"http://www.google.com\">link</a>",
-                defaultRenderer().render(document));
+        assertThat(defaultRenderer().render(document)).isEqualTo("Here I have a test <a href=\"http://www.google.com\">link</a>");
     }
 
     @Test
     public void omitSingleParagraphP() {
         var renderer = HtmlRenderer.builder().omitSingleParagraphP(true).build();
-        assertEquals("hi <em>there</em>", renderer.render(parse("hi *there*")));
+        assertThat(renderer.render(parse("hi *there*"))).isEqualTo("hi <em>there</em>");
     }
 
     @Test
     public void threading() throws Exception {
-        Parser parser = Parser.builder().build();
-        String spec = TestResources.readAsString(TestResources.getSpec());
-        final Node document = parser.parse(spec);
+        var parser = Parser.builder().build();
+        var spec = TestResources.readAsString(TestResources.getSpec());
+        var document = parser.parse(spec);
 
-        final HtmlRenderer htmlRenderer = HtmlRenderer.builder().build();
-        String expectedRendering = htmlRenderer.render(document);
+        var htmlRenderer = HtmlRenderer.builder().build();
+        var expectedRendering = htmlRenderer.render(document);
 
         // Render in parallel using the same HtmlRenderer instance.
-        List<Future<String>> futures = new ArrayList<>();
-        ExecutorService executorService = Executors.newFixedThreadPool(4);
+        var futures = new ArrayList<Future<String>>();
+        var executorService = Executors.newFixedThreadPool(4);
         for (int i = 0; i < 40; i++) {
-            Future<String> future = executorService.submit(new Callable<String>() {
-                @Override
-                public String call() throws Exception {
-                    return htmlRenderer.render(document);
-                }
-            });
+            var future = executorService.submit(() -> htmlRenderer.render(document));
             futures.add(future);
         }
 
-        for (Future<String> future : futures) {
-            String rendering = future.get();
-            assertThat(rendering, is(expectedRendering));
+        for (var future : futures) {
+            var rendering = future.get();
+            assertThat(rendering).isEqualTo(expectedRendering);
         }
     }
 
diff --git a/commonmark/src/test/java/org/commonmark/test/InlineParserContextTest.java b/commonmark/src/test/java/org/commonmark/test/InlineParserContextTest.java
index 2f2463cc..c05cac2d 100644
--- a/commonmark/src/test/java/org/commonmark/test/InlineParserContextTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/InlineParserContextTest.java
@@ -10,13 +10,13 @@
 import org.commonmark.parser.Parser;
 import org.commonmark.parser.delimiter.DelimiterProcessor;
 import org.commonmark.renderer.html.HtmlRenderer;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Set;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class InlineParserContextTest {
 
@@ -30,10 +30,10 @@ public void labelShouldBeOriginalNotNormalized() {
         String rendered = HtmlRenderer.builder().build().render(parser.parse(input));
 
         // Lookup should pass original label to context
-        assertEquals(List.of("FooBarBaz"), inlineParserFactory.lookups);
+        assertThat(inlineParserFactory.lookups).isEqualTo(List.of("FooBarBaz"));
 
         // Context should normalize label for finding reference
-        assertEquals("<p><a href=\"/url\">link with special label</a></p>\n", rendered);
+        assertThat(rendered).isEqualTo("<p><a href=\"/url\">link with special label</a></p>\n");
     }
 
     static class CapturingInlineParserFactory implements InlineParserFactory {
diff --git a/commonmark/src/test/java/org/commonmark/test/LinkReferenceDefinitionNodeTest.java b/commonmark/src/test/java/org/commonmark/test/LinkReferenceDefinitionNodeTest.java
index 81a71ee6..8410ff02 100644
--- a/commonmark/src/test/java/org/commonmark/test/LinkReferenceDefinitionNodeTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/LinkReferenceDefinitionNodeTest.java
@@ -2,13 +2,11 @@
 
 import org.commonmark.node.*;
 import org.commonmark.parser.Parser;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.List;
 
-import static org.hamcrest.CoreMatchers.instanceOf;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class LinkReferenceDefinitionNodeTest {
 
@@ -17,12 +15,12 @@ public void testDefinitionWithoutParagraph() {
         Node document = parse("This is a paragraph with a [foo] link.\n\n[foo]: /url 'title'");
         List<Node> nodes = Nodes.getChildren(document);
 
-        assertThat(nodes.size(), is(2));
-        assertThat(nodes.get(0), instanceOf(Paragraph.class));
+        assertThat(nodes).hasSize(2);
+        assertThat(nodes.get(0)).isInstanceOf(Paragraph.class);
         LinkReferenceDefinition definition = assertDef(nodes.get(1), "foo");
 
-        assertThat(definition.getDestination(), is("/url"));
-        assertThat(definition.getTitle(), is("title"));
+        assertThat(definition.getDestination()).isEqualTo("/url");
+        assertThat(definition.getTitle()).isEqualTo("title");
     }
 
     @Test
@@ -30,10 +28,10 @@ public void testDefinitionWithParagraph() {
         Node document = parse("[foo]: /url\nThis is a paragraph with a [foo] link.");
         List<Node> nodes = Nodes.getChildren(document);
 
-        assertThat(nodes.size(), is(2));
+        assertThat(nodes).hasSize(2);
         // Note that definition is not part of the paragraph, it's a sibling
-        assertThat(nodes.get(0), instanceOf(LinkReferenceDefinition.class));
-        assertThat(nodes.get(1), instanceOf(Paragraph.class));
+        assertThat(nodes.get(0)).isInstanceOf(LinkReferenceDefinition.class);
+        assertThat(nodes.get(1)).isInstanceOf(Paragraph.class);
     }
 
     @Test
@@ -41,8 +39,8 @@ public void testMultipleDefinitions() {
         Node document = parse("This is a paragraph with a [foo] link.\n\n[foo]: /url\n[bar]: /url");
         List<Node> nodes = Nodes.getChildren(document);
 
-        assertThat(nodes.size(), is(3));
-        assertThat(nodes.get(0), instanceOf(Paragraph.class));
+        assertThat(nodes).hasSize(3);
+        assertThat(nodes.get(0)).isInstanceOf(Paragraph.class);
         assertDef(nodes.get(1), "foo");
         assertDef(nodes.get(2), "bar");
     }
@@ -52,14 +50,14 @@ public void testMultipleDefinitionsWithSameLabel() {
         Node document = parse("This is a paragraph with a [foo] link.\n\n[foo]: /url1\n[foo]: /url2");
         List<Node> nodes = Nodes.getChildren(document);
 
-        assertThat(nodes.size(), is(3));
-        assertThat(nodes.get(0), instanceOf(Paragraph.class));
+        assertThat(nodes).hasSize(3);
+        assertThat(nodes.get(0)).isInstanceOf(Paragraph.class);
         LinkReferenceDefinition def1 = assertDef(nodes.get(1), "foo");
-        assertThat(def1.getDestination(), is("/url1"));
+        assertThat(def1.getDestination()).isEqualTo("/url1");
         // When there's multiple definitions with the same label, the first one "wins", as in reference links will use
         // that. But we still want to preserve the original definitions in the document.
         LinkReferenceDefinition def2 = assertDef(nodes.get(2), "foo");
-        assertThat(def2.getDestination(), is("/url2"));
+        assertThat(def2.getDestination()).isEqualTo("/url2");
     }
 
     @Test
@@ -67,42 +65,42 @@ public void testDefinitionOfReplacedBlock() {
         Node document = parse("[foo]: /url\nHeading\n=======");
         List<Node> nodes = Nodes.getChildren(document);
 
-        assertThat(nodes.size(), is(2));
+        assertThat(nodes).hasSize(2);
         assertDef(nodes.get(0), "foo");
-        assertThat(nodes.get(1), instanceOf(Heading.class));
+        assertThat(nodes.get(1)).isInstanceOf(Heading.class);
     }
 
     @Test
     public void testDefinitionInListItem() {
         Node document = parse("* [foo]: /url\n  [foo]\n");
-        assertThat(document.getFirstChild(), instanceOf(BulletList.class));
+        assertThat(document.getFirstChild()).isInstanceOf(BulletList.class);
         Node item = document.getFirstChild().getFirstChild();
-        assertThat(item, instanceOf(ListItem.class));
+        assertThat(item).isInstanceOf(ListItem.class);
 
         List<Node> nodes = Nodes.getChildren(item);
-        assertThat(nodes.size(), is(2));
+        assertThat(nodes).hasSize(2);
         assertDef(nodes.get(0), "foo");
-        assertThat(nodes.get(1), instanceOf(Paragraph.class));
+        assertThat(nodes.get(1)).isInstanceOf(Paragraph.class);
     }
 
     @Test
     public void testDefinitionInListItem2() {
         Node document = parse("* [foo]: /url\n* [foo]\n");
-        assertThat(document.getFirstChild(), instanceOf(BulletList.class));
+        assertThat(document.getFirstChild()).isInstanceOf(BulletList.class);
 
         List<Node> items = Nodes.getChildren(document.getFirstChild());
-        assertThat(items.size(), is(2));
+        assertThat(items).hasSize(2);
         Node item1 = items.get(0);
         Node item2 = items.get(1);
 
-        assertThat(item1, instanceOf(ListItem.class));
-        assertThat(item2, instanceOf(ListItem.class));
+        assertThat(item1).isInstanceOf(ListItem.class);
+        assertThat(item2).isInstanceOf(ListItem.class);
 
-        assertThat(Nodes.getChildren(item1).size(), is(1));
+        assertThat(Nodes.getChildren(item1)).hasSize(1);
         assertDef(item1.getFirstChild(), "foo");
 
-        assertThat(Nodes.getChildren(item2).size(), is(1));
-        assertThat(item2.getFirstChild(), instanceOf(Paragraph.class));
+        assertThat(Nodes.getChildren(item2)).hasSize(1);
+        assertThat(item2.getFirstChild()).isInstanceOf(Paragraph.class);
     }
 
     @Test
@@ -110,8 +108,8 @@ public void testDefinitionLabelCaseIsPreserved() {
         Node document = parse("This is a paragraph with a [foo] link.\n\n[fOo]: /url 'title'");
         List<Node> nodes = Nodes.getChildren(document);
 
-        assertThat(nodes.size(), is(2));
-        assertThat(nodes.get(0), instanceOf(Paragraph.class));
+        assertThat(nodes).hasSize(2);
+        assertThat(nodes.get(0)).isInstanceOf(Paragraph.class);
         assertDef(nodes.get(1), "fOo");
     }
 
@@ -121,9 +119,9 @@ private static Node parse(String input) {
     }
 
     private static LinkReferenceDefinition assertDef(Node node, String label) {
-        assertThat(node, instanceOf(LinkReferenceDefinition.class));
+        assertThat(node).isInstanceOf(LinkReferenceDefinition.class);
         LinkReferenceDefinition def = (LinkReferenceDefinition) node;
-        assertThat(def.getLabel(), is(label));
+        assertThat(def.getLabel()).isEqualTo(label);
         return def;
     }
 }
diff --git a/commonmark/src/test/java/org/commonmark/test/ListBlockParserTest.java b/commonmark/src/test/java/org/commonmark/test/ListBlockParserTest.java
index 4a38bc41..02ac3abf 100644
--- a/commonmark/src/test/java/org/commonmark/test/ListBlockParserTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/ListBlockParserTest.java
@@ -3,9 +3,9 @@
 import org.commonmark.node.ListItem;
 import org.commonmark.node.Node;
 import org.commonmark.parser.Parser;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class ListBlockParserTest {
 
@@ -59,7 +59,7 @@ public void testOrderedListIndents() {
     private void assertListItemIndents(String input, int expectedMarkerIndent, int expectedContentIndent) {
         Node doc = PARSER.parse(input);
         ListItem listItem = Nodes.find(doc, ListItem.class);
-        assertEquals(expectedMarkerIndent, (int) listItem.getMarkerIndent());
-        assertEquals(expectedContentIndent, (int) listItem.getContentIndent());
+        assertThat((int) listItem.getMarkerIndent()).isEqualTo(expectedMarkerIndent);
+        assertThat((int) listItem.getContentIndent()).isEqualTo(expectedContentIndent);
     }
 }
diff --git a/commonmark/src/test/java/org/commonmark/test/ListTightLooseTest.java b/commonmark/src/test/java/org/commonmark/test/ListTightLooseTest.java
index 4889bb9a..c6bda31e 100644
--- a/commonmark/src/test/java/org/commonmark/test/ListTightLooseTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/ListTightLooseTest.java
@@ -1,6 +1,6 @@
 package org.commonmark.test;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class ListTightLooseTest extends CoreRenderingTestCase {
 
diff --git a/commonmark/src/test/java/org/commonmark/test/ParserTest.java b/commonmark/src/test/java/org/commonmark/test/ParserTest.java
index 447a50c3..3b9ef09e 100644
--- a/commonmark/src/test/java/org/commonmark/test/ParserTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/ParserTest.java
@@ -5,7 +5,7 @@
 import org.commonmark.parser.block.*;
 import org.commonmark.renderer.html.HtmlRenderer;
 import org.commonmark.testutil.TestResources;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -20,9 +20,8 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 
-import static org.hamcrest.CoreMatchers.*;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 public class ParserTest {
 
@@ -40,7 +39,7 @@ public void ioReaderTest() throws IOException {
         Node document2 = parser.parse(spec);
 
         HtmlRenderer renderer = HtmlRenderer.builder().escapeHtml(true).build();
-        assertEquals(renderer.render(document2), renderer.render(document1));
+        assertThat(renderer.render(document1)).isEqualTo(renderer.render(document2));
     }
 
     @Test
@@ -50,9 +49,9 @@ public void customBlockParserFactory() {
         // The dashes would normally be a ThematicBreak
         Node document = parser.parse("hey\n\n---\n");
 
-        assertThat(document.getFirstChild(), instanceOf(Paragraph.class));
-        assertEquals("hey", ((Text) document.getFirstChild().getFirstChild()).getLiteral());
-        assertThat(document.getLastChild(), instanceOf(DashBlock.class));
+        assertThat(document.getFirstChild()).isInstanceOf(Paragraph.class);
+        assertThat(((Text) document.getFirstChild().getFirstChild()).getLiteral()).isEqualTo("hey");
+        assertThat(document.getLastChild()).isInstanceOf(DashBlock.class);
     }
 
     @Test
@@ -61,24 +60,25 @@ public void enabledBlockTypes() {
 
         Parser parser = Parser.builder().build(); // all core parsers by default
         Node document = parser.parse(given);
-        assertThat(document.getFirstChild(), instanceOf(Heading.class));
+        assertThat(document.getFirstChild()).isInstanceOf(Heading.class);
 
         Set<Class<? extends Block>> headersOnly = new HashSet<>();
         headersOnly.add(Heading.class);
         parser = Parser.builder().enabledBlockTypes(headersOnly).build();
         document = parser.parse(given);
-        assertThat(document.getFirstChild(), instanceOf(Heading.class));
+        assertThat(document.getFirstChild()).isInstanceOf(Heading.class);
 
         Set<Class<? extends Block>> noCoreTypes = new HashSet<>();
         parser = Parser.builder().enabledBlockTypes(noCoreTypes).build();
         document = parser.parse(given);
-        assertThat(document.getFirstChild(), not(instanceOf(Heading.class)));
+        assertThat(document.getFirstChild()).isNotInstanceOf(Heading.class);
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void enabledBlockTypesThrowsWhenGivenUnknownClass() {
         // BulletList can't be enabled separately at the moment, only all ListBlock types
-        Parser.builder().enabledBlockTypes(Set.of(Heading.class, BulletList.class)).build();
+        assertThatThrownBy(() ->
+                Parser.builder().enabledBlockTypes(Set.of(Heading.class, BulletList.class)).build()).isInstanceOf(IllegalArgumentException.class);
     }
 
     @Test
@@ -87,19 +87,19 @@ public void indentation() {
         Parser parser = Parser.builder().build();
         Node document = parser.parse(given);
 
-        assertThat(document.getFirstChild(), instanceOf(BulletList.class));
+        assertThat(document.getFirstChild()).isInstanceOf(BulletList.class);
 
         Node list = document.getFirstChild(); // first level list
-        assertEquals("expect one child", list.getFirstChild(), list.getLastChild());
-        assertEquals("1 space", firstText(list.getFirstChild()));
+        assertThat(list.getLastChild()).as("expect one child").isEqualTo(list.getFirstChild());
+        assertThat(firstText(list.getFirstChild())).isEqualTo("1 space");
 
         list = list.getFirstChild().getLastChild(); // second level list
-        assertEquals("expect one child", list.getFirstChild(), list.getLastChild());
-        assertEquals("3 spaces", firstText(list.getFirstChild()));
+        assertThat(list.getLastChild()).as("expect one child").isEqualTo(list.getFirstChild());
+        assertThat(firstText(list.getFirstChild())).isEqualTo("3 spaces");
 
         list = list.getFirstChild().getLastChild(); // third level list
-        assertEquals("5 spaces", firstText(list.getFirstChild()));
-        assertEquals("tab + space", firstText(list.getFirstChild().getNext()));
+        assertThat(firstText(list.getFirstChild())).isEqualTo("5 spaces");
+        assertThat(firstText(list.getFirstChild().getNext())).isEqualTo("tab + space");
     }
 
     @Test
@@ -122,39 +122,34 @@ public InlineParser create(InlineParserContext inlineParserContext) {
         Parser parser = Parser.builder().inlineParserFactory(fakeInlineParserFactory).build();
         String input = "**bold** **bold** ~~strikethrough~~";
 
-        assertThat(parser.parse(input).getFirstChild().getFirstChild(), instanceOf(ThematicBreak.class));
+        assertThat(parser.parse(input).getFirstChild().getFirstChild()).isInstanceOf(ThematicBreak.class);
     }
 
     @Test
     public void threading() throws Exception {
-        final Parser parser = Parser.builder().build();
-        final String spec = TestResources.readAsString(TestResources.getSpec());
+        var parser = Parser.builder().build();
+        var spec = TestResources.readAsString(TestResources.getSpec());
 
-        HtmlRenderer renderer = HtmlRenderer.builder().build();
-        String expectedRendering = renderer.render(parser.parse(spec));
+        var renderer = HtmlRenderer.builder().build();
+        var expectedRendering = renderer.render(parser.parse(spec));
 
         // Parse in parallel using the same Parser instance.
-        List<Future<Node>> futures = new ArrayList<>();
-        ExecutorService executorService = Executors.newFixedThreadPool(4);
+        var futures = new ArrayList<Future<Node>>();
+        var executorService = Executors.newFixedThreadPool(4);
         for (int i = 0; i < 40; i++) {
-            Future<Node> future = executorService.submit(new Callable<Node>() {
-                @Override
-                public Node call() throws Exception {
-                    return parser.parse(spec);
-                }
-            });
+            var future = executorService.submit(() -> parser.parse(spec));
             futures.add(future);
         }
 
-        for (Future<Node> future : futures) {
-            Node node = future.get();
-            assertThat(renderer.render(node), is(expectedRendering));
+        for (var future : futures) {
+            var node = future.get();
+            assertThat(renderer.render(node)).isEqualTo(expectedRendering);
         }
     }
 
     private String firstText(Node n) {
         while (!(n instanceof Text)) {
-            assertThat(n, notNullValue());
+            assertThat(n).isNotNull();
             n = n.getFirstChild();
         }
         return ((Text) n).getLiteral();
diff --git a/commonmark/src/test/java/org/commonmark/test/PathologicalTest.java b/commonmark/src/test/java/org/commonmark/test/PathologicalTest.java
index ae1310ed..66d39de2 100644
--- a/commonmark/src/test/java/org/commonmark/test/PathologicalTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/PathologicalTest.java
@@ -1,34 +1,21 @@
 package org.commonmark.test;
 
-import org.junit.FixMethodOrder;
-import org.junit.Rule;
-import org.junit.Test;
-import org.junit.rules.Stopwatch;
-import org.junit.rules.Timeout;
-import org.junit.runner.Description;
-import org.junit.runners.MethodSorters;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.Timeout;
 
 import java.util.concurrent.TimeUnit;
 
 /**
  * Pathological input cases (from commonmark.js).
  */
-@FixMethodOrder(MethodSorters.NAME_ASCENDING)
+@Timeout(value = 3, unit = TimeUnit.SECONDS)
+@TestMethodOrder(MethodOrderer.MethodName.class)
 public class PathologicalTest extends CoreRenderingTestCase {
 
     private int x = 100_000;
 
-    @Rule
-    public Timeout timeout = new Timeout(3, TimeUnit.SECONDS);
-
-    @Rule
-    public Stopwatch stopwatch = new Stopwatch() {
-        @Override
-        protected void finished(long nanos, Description description) {
-            System.err.println(description.getDisplayName() + " took " + (nanos / 1000000) + " ms");
-        }
-    };
-
     @Test
     public void nestedStrongEmphasis() {
         // this is limited by the stack size because visitor is recursive
diff --git a/commonmark/src/test/java/org/commonmark/test/RegressionTest.java b/commonmark/src/test/java/org/commonmark/test/RegressionTest.java
index 94b3a743..900a6518 100644
--- a/commonmark/src/test/java/org/commonmark/test/RegressionTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/RegressionTest.java
@@ -6,18 +6,18 @@
 import org.commonmark.testutil.TestResources;
 import org.commonmark.testutil.example.Example;
 import org.commonmark.testutil.example.ExampleReader;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.junit.runners.Parameterized;
-import org.junit.runners.Parameterized.Parameters;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.Parameter;
+import org.junit.jupiter.params.ParameterizedClass;
+import org.junit.jupiter.params.provider.MethodSource;
 
-import java.net.URL;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-@RunWith(Parameterized.class)
+@ParameterizedClass
+@MethodSource("data")
 public class RegressionTest extends RenderingTestCase {
 
     private static final Parser PARSER = Parser.builder().build();
@@ -26,20 +26,13 @@ public class RegressionTest extends RenderingTestCase {
 
     private static final Map<String, String> OVERRIDDEN_EXAMPLES = getOverriddenExamples();
 
-    private final Example example;
+    @Parameter
+    Example example;
 
-    public RegressionTest(Example example) {
-        this.example = example;
-    }
-
-    @Parameters(name = "{0}")
-    public static List<Object[]> data() {
-        List<Object[]> data = new ArrayList<>();
-        for (URL regressionResource : TestResources.getRegressions()) {
-            List<Example> examples = ExampleReader.readExamples(regressionResource);
-            for (Example example : examples) {
-                data.add(new Object[]{example});
-            }
+    static List<Example> data() {
+        var data = new ArrayList<Example>();
+        for (var regressionResource : TestResources.getRegressions()) {
+            data.addAll(ExampleReader.readExamples(regressionResource));
         }
         return data;
     }
diff --git a/commonmark/src/test/java/org/commonmark/test/SourceLineTest.java b/commonmark/src/test/java/org/commonmark/test/SourceLineTest.java
index 3fb95d38..5d34bf41 100644
--- a/commonmark/src/test/java/org/commonmark/test/SourceLineTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/SourceLineTest.java
@@ -2,9 +2,10 @@
 
 import org.commonmark.node.SourceSpan;
 import org.commonmark.parser.SourceLine;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 public class SourceLineTest {
 
@@ -25,18 +26,20 @@ public void testSubstring() {
         assertSourceLine(line.substring(4, 4), "", null);
     }
 
-    @Test(expected = StringIndexOutOfBoundsException.class)
+    @Test
     public void testSubstringBeginOutOfBounds() {
-        SourceLine.of("abcd", SourceSpan.of(3, 10, 13, 4)).substring(3, 2);
+        var sourceLine = SourceLine.of("abcd", SourceSpan.of(3, 10, 13, 4));
+        assertThatThrownBy(() -> sourceLine.substring(3, 2)).isInstanceOf(StringIndexOutOfBoundsException.class);
     }
 
-    @Test(expected = StringIndexOutOfBoundsException.class)
+    @Test
     public void testSubstringEndOutOfBounds() {
-        SourceLine.of("abcd", SourceSpan.of(3, 10, 13, 4)).substring(0, 5);
+        var sourceLine = SourceLine.of("abcd", SourceSpan.of(3, 10, 13, 4));
+        assertThatThrownBy(() -> sourceLine.substring(0, 5)).isInstanceOf(StringIndexOutOfBoundsException.class);
     }
 
     private static void assertSourceLine(SourceLine sourceLine, String expectedContent, SourceSpan expectedSourceSpan) {
-        assertEquals(expectedContent, sourceLine.getContent());
-        assertEquals(expectedSourceSpan, sourceLine.getSourceSpan());
+        assertThat(sourceLine.getContent()).isEqualTo(expectedContent);
+        assertThat(sourceLine.getSourceSpan()).isEqualTo(expectedSourceSpan);
     }
 }
diff --git a/commonmark/src/test/java/org/commonmark/test/SourceSpanTest.java b/commonmark/src/test/java/org/commonmark/test/SourceSpanTest.java
index 57048b90..f1bb231f 100644
--- a/commonmark/src/test/java/org/commonmark/test/SourceSpanTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/SourceSpanTest.java
@@ -1,10 +1,10 @@
 package org.commonmark.test;
 
 import org.commonmark.node.SourceSpan;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertSame;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 public class SourceSpanTest {
 
@@ -12,52 +12,57 @@ public class SourceSpanTest {
     public void testSubSpan() {
         var span = SourceSpan.of(1, 2, 3, 5);
 
-        assertSame(span.subSpan(0), span);
-        assertSame(span.subSpan(0, 5), span);
+        assertThat(span.subSpan(0)).isSameAs(span);
+        assertThat(span.subSpan(0, 5)).isSameAs(span);
 
-        assertEquals(SourceSpan.of(1, 3, 4, 4), span.subSpan(1));
-        assertEquals(SourceSpan.of(1, 4, 5, 3), span.subSpan(2));
-        assertEquals(SourceSpan.of(1, 5, 6, 2), span.subSpan(3));
-        assertEquals(SourceSpan.of(1, 6, 7, 1), span.subSpan(4));
+        assertThat(span.subSpan(1)).isEqualTo(SourceSpan.of(1, 3, 4, 4));
+        assertThat(span.subSpan(2)).isEqualTo(SourceSpan.of(1, 4, 5, 3));
+        assertThat(span.subSpan(3)).isEqualTo(SourceSpan.of(1, 5, 6, 2));
+        assertThat(span.subSpan(4)).isEqualTo(SourceSpan.of(1, 6, 7, 1));
         // Not sure if empty spans are useful, but it probably makes sense to mirror how substrings work
-        assertEquals(SourceSpan.of(1, 7, 8, 0), span.subSpan(5));
-        assertEquals("", "abcde".substring(5));
-
-        assertEquals(SourceSpan.of(1, 2, 3, 5), span.subSpan(0, 5));
-        assertEquals(SourceSpan.of(1, 2, 3, 4), span.subSpan(0, 4));
-        assertEquals(SourceSpan.of(1, 2, 3, 3), span.subSpan(0, 3));
-        assertEquals(SourceSpan.of(1, 2, 3, 2), span.subSpan(0, 2));
-        assertEquals(SourceSpan.of(1, 2, 3, 1), span.subSpan(0, 1));
-        assertEquals(SourceSpan.of(1, 2, 3, 0), span.subSpan(0, 0));
-        assertEquals("a", "abcde".substring(0, 1));
-        assertEquals("", "abcde".substring(0, 0));
-
-        assertEquals(SourceSpan.of(1, 3, 4, 3), span.subSpan(1, 4));
-        assertEquals(SourceSpan.of(1, 4, 5, 1), span.subSpan(2, 3));
+        assertThat(span.subSpan(5)).isEqualTo(SourceSpan.of(1, 7, 8, 0));
+        assertThat("abcde".substring(5)).isEqualTo("");
+
+        assertThat(span.subSpan(0, 5)).isEqualTo(SourceSpan.of(1, 2, 3, 5));
+        assertThat(span.subSpan(0, 4)).isEqualTo(SourceSpan.of(1, 2, 3, 4));
+        assertThat(span.subSpan(0, 3)).isEqualTo(SourceSpan.of(1, 2, 3, 3));
+        assertThat(span.subSpan(0, 2)).isEqualTo(SourceSpan.of(1, 2, 3, 2));
+        assertThat(span.subSpan(0, 1)).isEqualTo(SourceSpan.of(1, 2, 3, 1));
+        assertThat(span.subSpan(0, 0)).isEqualTo(SourceSpan.of(1, 2, 3, 0));
+        assertThat("abcde".substring(0, 1)).isEqualTo("a");
+        assertThat("abcde".substring(0, 0)).isEqualTo("");
+
+        assertThat(span.subSpan(1, 4)).isEqualTo(SourceSpan.of(1, 3, 4, 3));
+        assertThat(span.subSpan(2, 3)).isEqualTo(SourceSpan.of(1, 4, 5, 1));
     }
 
-    @Test(expected = IndexOutOfBoundsException.class)
+    @Test
     public void testSubSpanBeginIndexNegative() {
-        SourceSpan.of(1, 2, 3, 5).subSpan(-1);
+        var sourceSpan = SourceSpan.of(1, 2, 3, 5);
+        assertThatThrownBy(() -> sourceSpan.subSpan(-1)).isInstanceOf(IndexOutOfBoundsException.class);
     }
 
-    @Test(expected = IndexOutOfBoundsException.class)
+    @Test
     public void testSubSpanBeginIndexOutOfBounds() {
-        SourceSpan.of(1, 2, 3, 5).subSpan(6);
+        var sourceSpan = SourceSpan.of(1, 2, 3, 5);
+        assertThatThrownBy(() -> sourceSpan.subSpan(6)).isInstanceOf(IndexOutOfBoundsException.class);
     }
 
-    @Test(expected = IndexOutOfBoundsException.class)
+    @Test
     public void testSubSpanEndIndexNegative() {
-        SourceSpan.of(1, 2, 3, 5).subSpan(0, -1);
+        var sourceSpan = SourceSpan.of(1, 2, 3, 5);
+        assertThatThrownBy(() -> sourceSpan.subSpan(0, -1)).isInstanceOf(IndexOutOfBoundsException.class);
     }
 
-    @Test(expected = IndexOutOfBoundsException.class)
+    @Test
     public void testSubSpanEndIndexOutOfBounds() {
-        SourceSpan.of(1, 2, 3, 5).subSpan(0, 6);
+        var sourceSpan = SourceSpan.of(1, 2, 3, 5);
+        assertThatThrownBy(() -> sourceSpan.subSpan(0, 6)).isInstanceOf(IndexOutOfBoundsException.class);
     }
 
-    @Test(expected = IndexOutOfBoundsException.class)
+    @Test
     public void testSubSpanBeginIndexGreaterThanEndIndex() {
-        SourceSpan.of(1, 2, 3, 5).subSpan(2, 1);
+        var sourceSpan = SourceSpan.of(1, 2, 3, 5);
+        assertThatThrownBy(() -> sourceSpan.subSpan(2, 1)).isInstanceOf(IndexOutOfBoundsException.class);
     }
 }
diff --git a/commonmark/src/test/java/org/commonmark/test/SourceSpansTest.java b/commonmark/src/test/java/org/commonmark/test/SourceSpansTest.java
index 23249d93..f4e9d0a1 100644
--- a/commonmark/src/test/java/org/commonmark/test/SourceSpansTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/SourceSpansTest.java
@@ -3,7 +3,7 @@
 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.io.IOException;
 import java.io.StringReader;
@@ -11,7 +11,7 @@
 import java.util.Deque;
 import java.util.List;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class SourceSpansTest {
 
@@ -90,7 +90,7 @@ public void fencedCodeBlock() {
 
         Node document = PARSER.parse("```\nfoo\n```\nbar\n");
         Paragraph paragraph = (Paragraph) document.getLastChild();
-        assertEquals(List.of(SourceSpan.of(3, 0, 12, 3)), paragraph.getSourceSpans());
+        assertThat(paragraph.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(3, 0, 12, 3)));
     }
 
     @Test
@@ -133,7 +133,7 @@ public void listBlock() {
 
         Node document = PARSER.parse("* foo\n  * bar\n");
         ListBlock listBlock = (ListBlock) document.getFirstChild().getFirstChild().getLastChild();
-        assertEquals(List.of(SourceSpan.of(1, 2, 8, 5)), listBlock.getSourceSpans());
+        assertThat(listBlock.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(1, 2, 8, 5)));
     }
 
     @Test
@@ -158,10 +158,10 @@ public void linkReferenceDefinition() {
         Node document = PARSER.parse("[foo]: /url\ntext\n");
 
         LinkReferenceDefinition linkReferenceDefinition = (LinkReferenceDefinition) document.getFirstChild();
-        assertEquals(List.of(SourceSpan.of(0, 0, 0, 11)), linkReferenceDefinition.getSourceSpans());
+        assertThat(linkReferenceDefinition.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 11)));
 
         Paragraph paragraph = (Paragraph) document.getLastChild();
-        assertEquals(List.of(SourceSpan.of(1, 0, 12, 4)), paragraph.getSourceSpans());
+        assertThat(paragraph.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(1, 0, 12, 4)));
     }
 
     @Test
@@ -169,8 +169,8 @@ public void linkReferenceDefinitionMultiple() {
         var doc = PARSER.parse("[foo]: /foo\n[bar]: /bar\n");
         var def1 = (LinkReferenceDefinition) doc.getFirstChild();
         var def2 = (LinkReferenceDefinition) doc.getLastChild();
-        assertEquals(List.of(SourceSpan.of(0, 0, 0, 11)), def1.getSourceSpans());
-        assertEquals(List.of(SourceSpan.of(1, 0, 12, 11)), def2.getSourceSpans());
+        assertThat(def1.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 11)));
+        assertThat(def2.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(1, 0, 12, 11)));
     }
 
     @Test
@@ -178,8 +178,8 @@ public void linkReferenceDefinitionWithTitle() {
         var doc = PARSER.parse("[1]: #not-code \"Text\"\n[foo]: /foo\n");
         var def1 = (LinkReferenceDefinition) doc.getFirstChild();
         var def2 = (LinkReferenceDefinition) doc.getLastChild();
-        assertEquals(List.of(SourceSpan.of(0, 0, 0, 21)), def1.getSourceSpans());
-        assertEquals(List.of(SourceSpan.of(1, 0, 22, 11)), def2.getSourceSpans());
+        assertThat(def1.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 21)));
+        assertThat(def2.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(1, 0, 22, 11)));
     }
 
     @Test
@@ -187,8 +187,8 @@ public void linkReferenceDefinitionWithTitleInvalid() {
         var doc = PARSER.parse("[foo]: /url\n\"title\" ok\n");
         var def = Nodes.find(doc, LinkReferenceDefinition.class);
         var paragraph = Nodes.find(doc, Paragraph.class);
-        assertEquals(List.of(SourceSpan.of(0, 0, 0, 11)), def.getSourceSpans());
-        assertEquals(List.of(SourceSpan.of(1, 0, 12, 10)), paragraph.getSourceSpans());
+        assertThat(def.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 11)));
+        assertThat(paragraph.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(1, 0, 12, 10)));
     }
 
     @Test
@@ -198,10 +198,10 @@ public void linkReferenceDefinitionHeading() {
         Node document = PARSER.parse("[foo]: /url\nHeading\n===\n");
 
         LinkReferenceDefinition linkReferenceDefinition = (LinkReferenceDefinition) document.getFirstChild();
-        assertEquals(List.of(SourceSpan.of(0, 0, 0, 11)), linkReferenceDefinition.getSourceSpans());
+        assertThat(linkReferenceDefinition.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 11)));
 
         Heading heading = (Heading) document.getLastChild();
-        assertEquals(List.of(SourceSpan.of(1, 0, 12, 7), SourceSpan.of(2, 0, 20, 3)), heading.getSourceSpans());
+        assertThat(heading.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(1, 0, 12, 7), SourceSpan.of(2, 0, 20, 3)));
     }
 
     @Test
@@ -212,13 +212,13 @@ public void lazyContinuationLines() {
             var doc = PARSER.parse("> > > foo\nbar\n");
 
             var bq1 = (BlockQuote) doc.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 0, 0, 9), SourceSpan.of(1, 0, 10, 3)), bq1.getSourceSpans());
+            assertThat(bq1.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 9), SourceSpan.of(1, 0, 10, 3)));
             var bq2 = (BlockQuote) bq1.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 2, 2, 7), SourceSpan.of(1, 0, 10, 3)), bq2.getSourceSpans());
+            assertThat(bq2.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 2, 2, 7), SourceSpan.of(1, 0, 10, 3)));
             var bq3 = (BlockQuote) bq2.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 4, 4, 5), SourceSpan.of(1, 0, 10, 3)), bq3.getSourceSpans());
+            assertThat(bq3.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 4, 4, 5), SourceSpan.of(1, 0, 10, 3)));
             var paragraph = (Paragraph) bq3.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 6, 6, 3), SourceSpan.of(1, 0, 10, 3)), paragraph.getSourceSpans());
+            assertThat(paragraph.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 6, 6, 3), SourceSpan.of(1, 0, 10, 3)));
         }
 
         {
@@ -226,13 +226,13 @@ public void lazyContinuationLines() {
             var doc = PARSER.parse("> > > foo\nbars\n");
 
             var bq1 = (BlockQuote) doc.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 0, 0, 9), SourceSpan.of(1, 0, 10, 4)), bq1.getSourceSpans());
+            assertThat(bq1.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 9), SourceSpan.of(1, 0, 10, 4)));
             var bq2 = (BlockQuote) bq1.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 2, 2, 7), SourceSpan.of(1, 0, 10, 4)), bq2.getSourceSpans());
+            assertThat(bq2.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 2, 2, 7), SourceSpan.of(1, 0, 10, 4)));
             var bq3 = (BlockQuote) bq2.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 4, 4, 5), SourceSpan.of(1, 0, 10, 4)), bq3.getSourceSpans());
+            assertThat(bq3.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 4, 4, 5), SourceSpan.of(1, 0, 10, 4)));
             var paragraph = (Paragraph) bq3.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 6, 6, 3), SourceSpan.of(1, 0, 10, 4)), paragraph.getSourceSpans());
+            assertThat(paragraph.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 6, 6, 3), SourceSpan.of(1, 0, 10, 4)));
         }
 
         {
@@ -240,15 +240,15 @@ public void lazyContinuationLines() {
             var doc = PARSER.parse("> 1. > Blockquote\ncontinued here.");
 
             var bq1 = (BlockQuote) doc.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 0, 0, 17), SourceSpan.of(1, 0, 18, 15)), bq1.getSourceSpans());
+            assertThat(bq1.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 17), SourceSpan.of(1, 0, 18, 15)));
             var orderedList = (OrderedList) bq1.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 2, 2, 15), SourceSpan.of(1, 0, 18, 15)), orderedList.getSourceSpans());
+            assertThat(orderedList.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 2, 2, 15), SourceSpan.of(1, 0, 18, 15)));
             var listItem = (ListItem) orderedList.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 2, 2, 15), SourceSpan.of(1, 0, 18, 15)), listItem.getSourceSpans());
+            assertThat(listItem.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 2, 2, 15), SourceSpan.of(1, 0, 18, 15)));
             var bq2 = (BlockQuote) listItem.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 5, 5, 12), SourceSpan.of(1, 0, 18, 15)), bq2.getSourceSpans());
+            assertThat(bq2.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 5, 5, 12), SourceSpan.of(1, 0, 18, 15)));
             var paragraph = (Paragraph) bq2.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 7, 7, 10), SourceSpan.of(1, 0, 18, 15)), paragraph.getSourceSpans());
+            assertThat(paragraph.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 7, 7, 10), SourceSpan.of(1, 0, 18, 15)));
         }
 
         {
@@ -256,11 +256,11 @@ public void lazyContinuationLines() {
             var doc = PARSER.parse("> > foo\n> bar\n");
 
             var bq1 = (BlockQuote) doc.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 0, 0, 7), SourceSpan.of(1, 0, 8, 5)), bq1.getSourceSpans());
+            assertThat(bq1.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 0, 0, 7), SourceSpan.of(1, 0, 8, 5)));
             var bq2 = (BlockQuote) bq1.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 2, 2, 5), SourceSpan.of(1, 2, 10, 3)), bq2.getSourceSpans());
+            assertThat(bq2.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 2, 2, 5), SourceSpan.of(1, 2, 10, 3)));
             var paragraph = (Paragraph) bq2.getLastChild();
-            assertEquals(List.of(SourceSpan.of(0, 4, 4, 3), SourceSpan.of(1, 2, 10, 3)), paragraph.getSourceSpans());
+            assertThat(paragraph.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 4, 4, 3), SourceSpan.of(1, 2, 10, 3)));
         }
     }
 
@@ -354,7 +354,7 @@ public void inlineEmphasis() {
 
         Node document = INLINES_PARSER.parse("*hey**");
         Node lastText = document.getFirstChild().getLastChild();
-        assertEquals(List.of(SourceSpan.of(0, 5, 5, 1)), lastText.getSourceSpans());
+        assertThat(lastText.getSourceSpans()).isEqualTo(List.of(SourceSpan.of(0, 5, 5, 1)));
     }
 
     @Test
@@ -381,8 +381,8 @@ public void differentLineTerminators() {
 
     private void assertVisualize(String source, String expected) {
         var doc = PARSER.parse(source);
-        assertEquals(expected, SourceSpanRenderer.renderWithLineColumn(doc, source));
-        assertEquals(expected, SourceSpanRenderer.renderWithInputIndex(doc, source));
+        assertThat(SourceSpanRenderer.renderWithLineColumn(doc, source)).isEqualTo(expected);
+        assertThat(SourceSpanRenderer.renderWithInputIndex(doc, source)).isEqualTo(expected);
     }
 
     private static void assertSpans(String input, Class<? extends Node> nodeClass, SourceSpan... expectedSourceSpans) {
@@ -405,7 +405,7 @@ private static void assertInlineSpans(String input, Class<? extends Node> nodeCl
 
     private static void assertSpans(Node rootNode, Class<? extends Node> nodeClass, SourceSpan... expectedSourceSpans) {
         Node node = findNode(rootNode, nodeClass);
-        assertEquals(List.of(expectedSourceSpans), node.getSourceSpans());
+        assertThat(node.getSourceSpans()).isEqualTo(List.of(expectedSourceSpans));
     }
 
     private static Node findNode(Node rootNode, Class<? extends Node> nodeClass) {
diff --git a/commonmark/src/test/java/org/commonmark/test/SpecCoreTest.java b/commonmark/src/test/java/org/commonmark/test/SpecCoreTest.java
index 8d284c6f..fefd8fb3 100644
--- a/commonmark/src/test/java/org/commonmark/test/SpecCoreTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/SpecCoreTest.java
@@ -7,10 +7,10 @@
 import org.commonmark.renderer.html.HtmlRenderer;
 import org.commonmark.testutil.SpecTestCase;
 import org.commonmark.testutil.example.Example;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
+import static org.assertj.core.api.Assertions.fail;
 import static org.commonmark.testutil.Asserts.assertRendering;
-import static org.junit.Assert.fail;
 
 public class SpecCoreTest extends SpecTestCase {
 
@@ -18,10 +18,6 @@ public class SpecCoreTest extends SpecTestCase {
     // The spec says URL-escaping is optional, but the examples assume that it's enabled.
     private static final HtmlRenderer RENDERER = HtmlRenderer.builder().percentEncodeUrls(true).build();
 
-    public SpecCoreTest(Example example) {
-        super(example);
-    }
-
     @Test
     public void testTextNodesContiguous() {
         final String source = example.getSource();
diff --git a/commonmark/src/test/java/org/commonmark/test/SpecCrLfCoreTest.java b/commonmark/src/test/java/org/commonmark/test/SpecCrLfCoreTest.java
index ab0103e5..47ca3da4 100644
--- a/commonmark/src/test/java/org/commonmark/test/SpecCrLfCoreTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/SpecCrLfCoreTest.java
@@ -4,7 +4,7 @@
 import org.commonmark.renderer.html.HtmlRenderer;
 import org.commonmark.testutil.SpecTestCase;
 import org.commonmark.testutil.example.Example;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import static org.commonmark.testutil.Asserts.assertRendering;
 
@@ -17,10 +17,6 @@ public class SpecCrLfCoreTest extends SpecTestCase {
     // The spec says URL-escaping is optional, but the examples assume that it's enabled.
     private static final HtmlRenderer RENDERER = HtmlRenderer.builder().percentEncodeUrls(true).build();
 
-    public SpecCrLfCoreTest(Example example) {
-        super(example);
-    }
-
     @Test
     public void testHtmlRendering() {
         assertRendering(example.getSource(), example.getHtml(), render(example.getSource()));
diff --git a/commonmark/src/test/java/org/commonmark/test/SpecialInputTest.java b/commonmark/src/test/java/org/commonmark/test/SpecialInputTest.java
index 770a1aa2..2ebac171 100644
--- a/commonmark/src/test/java/org/commonmark/test/SpecialInputTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/SpecialInputTest.java
@@ -1,6 +1,6 @@
 package org.commonmark.test;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 public class SpecialInputTest extends CoreRenderingTestCase {
 
diff --git a/commonmark/src/test/java/org/commonmark/test/TextContentRendererTest.java b/commonmark/src/test/java/org/commonmark/test/TextContentRendererTest.java
index 93ca87d9..bc443e0e 100644
--- a/commonmark/src/test/java/org/commonmark/test/TextContentRendererTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/TextContentRendererTest.java
@@ -9,7 +9,7 @@
 import org.commonmark.renderer.text.TextContentRenderer;
 import org.commonmark.parser.Parser;
 import org.commonmark.testutil.Asserts;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
 import java.util.Set;
 
diff --git a/commonmark/src/test/java/org/commonmark/test/TextContentWriterTest.java b/commonmark/src/test/java/org/commonmark/test/TextContentWriterTest.java
index 0be668a7..a9f37792 100644
--- a/commonmark/src/test/java/org/commonmark/test/TextContentWriterTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/TextContentWriterTest.java
@@ -1,9 +1,9 @@
 package org.commonmark.test;
 
 import org.commonmark.renderer.text.TextContentWriter;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.*;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class TextContentWriterTest {
 
@@ -14,7 +14,7 @@ public void whitespace() throws Exception {
         writer.write("foo");
         writer.whitespace();
         writer.write("bar");
-        assertEquals("foo bar", stringBuilder.toString());
+        assertThat(stringBuilder.toString()).isEqualTo("foo bar");
     }
 
     @Test
@@ -24,7 +24,7 @@ public void colon() throws Exception {
         writer.write("foo");
         writer.colon();
         writer.write("bar");
-        assertEquals("foo:bar", stringBuilder.toString());
+        assertThat(stringBuilder.toString()).isEqualTo("foo:bar");
     }
 
     @Test
@@ -34,7 +34,7 @@ public void line() throws Exception {
         writer.write("foo");
         writer.line();
         writer.write("bar");
-        assertEquals("foo\nbar", stringBuilder.toString());
+        assertThat(stringBuilder.toString()).isEqualTo("foo\nbar");
     }
 
     @Test
@@ -42,7 +42,7 @@ public void writeStripped() throws Exception {
         StringBuilder stringBuilder = new StringBuilder();
         TextContentWriter writer = new TextContentWriter(stringBuilder);
         writer.writeStripped("foo\n bar");
-        assertEquals("foo bar", stringBuilder.toString());
+        assertThat(stringBuilder.toString()).isEqualTo("foo bar");
     }
 
     @Test
@@ -50,6 +50,6 @@ public void write() throws Exception {
         StringBuilder stringBuilder = new StringBuilder();
         TextContentWriter writer = new TextContentWriter(stringBuilder);
         writer.writeStripped("foo bar");
-        assertEquals("foo bar", stringBuilder.toString());
+        assertThat(stringBuilder.toString()).isEqualTo("foo bar");
     }
 }
diff --git a/commonmark/src/test/java/org/commonmark/test/ThematicBreakParserTest.java b/commonmark/src/test/java/org/commonmark/test/ThematicBreakParserTest.java
index 2b15f8ad..1d564cca 100644
--- a/commonmark/src/test/java/org/commonmark/test/ThematicBreakParserTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/ThematicBreakParserTest.java
@@ -2,9 +2,9 @@
 
 import org.commonmark.node.ThematicBreak;
 import org.commonmark.parser.Parser;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class ThematicBreakParserTest {
 
@@ -20,6 +20,6 @@ public void testLiteral() {
 
     private static void assertLiteral(String expected, String input) {
         var tb = Nodes.find(PARSER.parse(input), ThematicBreak.class);
-        assertEquals(expected, tb.getLiteral());
+        assertThat(tb.getLiteral()).isEqualTo(expected);
     }
 }
diff --git a/commonmark/src/test/java/org/commonmark/test/UsageExampleTest.java b/commonmark/src/test/java/org/commonmark/test/UsageExampleTest.java
index 63901a49..20cd9f5a 100644
--- a/commonmark/src/test/java/org/commonmark/test/UsageExampleTest.java
+++ b/commonmark/src/test/java/org/commonmark/test/UsageExampleTest.java
@@ -6,8 +6,8 @@
 import org.commonmark.renderer.NodeRenderer;
 import org.commonmark.renderer.html.*;
 import org.commonmark.renderer.markdown.MarkdownRenderer;
-import org.junit.Ignore;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
 
 import java.io.FileInputStream;
 import java.io.IOException;
@@ -16,7 +16,7 @@
 import java.util.Map;
 import java.util.Set;
 
-import static org.junit.Assert.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class UsageExampleTest {
 
@@ -25,7 +25,7 @@ public void parseAndRender() {
         Parser parser = Parser.builder().build();
         Node document = parser.parse("This is *Markdown*");
         HtmlRenderer renderer = HtmlRenderer.builder().escapeHtml(true).build();
-        assertEquals("<p>This is <em>Markdown</em></p>\n", renderer.render(document));
+        assertThat(renderer.render(document)).isEqualTo("<p>This is <em>Markdown</em></p>\n");
     }
 
     @Test
@@ -37,11 +37,11 @@ public void renderToMarkdown() {
         heading.appendChild(new Text("My title"));
         document.appendChild(heading);
 
-        assertEquals("## My title\n", renderer.render(document));
+        assertThat(renderer.render(document)).isEqualTo("## My title\n");
     }
 
     @Test
-    @Ignore
+    @Disabled
     public void parseReaderRender() throws IOException {
         Parser parser = Parser.builder().build();
         try (InputStreamReader reader = new InputStreamReader(new FileInputStream("file.md"), StandardCharsets.UTF_8)) {
@@ -56,7 +56,7 @@ public void visitor() {
         Node node = parser.parse("Example\n=======\n\nSome more text");
         WordCountVisitor visitor = new WordCountVisitor();
         node.accept(visitor);
-        assertEquals(4, visitor.wordCount);
+        assertThat(visitor.wordCount).isEqualTo(4);
     }
 
     @Test
@@ -67,11 +67,11 @@ public void sourcePositions() {
         var doc = parser.parse(source);
         var emphasis = doc.getLastChild().getLastChild();
         var s = emphasis.getSourceSpans().get(0);
-        assertEquals(2, s.getLineIndex());
-        assertEquals(4, s.getColumnIndex());
-        assertEquals(9, s.getInputIndex());
-        assertEquals(5, s.getLength());
-        assertEquals("*baz*", source.substring(s.getInputIndex(), s.getInputIndex() + s.getLength()));
+        assertThat(s.getLineIndex()).isEqualTo(2);
+        assertThat(s.getColumnIndex()).isEqualTo(4);
+        assertThat(s.getInputIndex()).isEqualTo(9);
+        assertThat(s.getLength()).isEqualTo(5);
+        assertThat(source.substring(s.getInputIndex(), s.getInputIndex() + s.getLength())).isEqualTo("*baz*");
     }
 
     @Test
@@ -87,8 +87,7 @@ public AttributeProvider create(AttributeProviderContext context) {
                 .build();
 
         Node document = parser.parse("![text](/url.png)");
-        assertEquals("<p><img src=\"/url.png\" alt=\"text\" class=\"border\" /></p>\n",
-                renderer.render(document));
+        assertThat(renderer.render(document)).isEqualTo("<p><img src=\"/url.png\" alt=\"text\" class=\"border\" /></p>\n");
     }
 
     @Test
@@ -104,7 +103,7 @@ public NodeRenderer create(HtmlNodeRendererContext context) {
                 .build();
 
         Node document = parser.parse("Example:\n\n    code");
-        assertEquals("<p>Example:</p>\n<pre>code\n</pre>\n", renderer.render(document));
+        assertThat(renderer.render(document)).isEqualTo("<p>Example:</p>\n<pre>code\n</pre>\n");
     }
 
     class WordCountVisitor extends AbstractVisitor {
diff --git a/commonmark/src/test/java/org/commonmark/text/CharactersTest.java b/commonmark/src/test/java/org/commonmark/text/CharactersTest.java
index a362cf53..99f510cb 100644
--- a/commonmark/src/test/java/org/commonmark/text/CharactersTest.java
+++ b/commonmark/src/test/java/org/commonmark/text/CharactersTest.java
@@ -1,9 +1,8 @@
 package org.commonmark.text;
 
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
 
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
+import static org.assertj.core.api.Assertions.assertThat;
 
 public class CharactersTest {
 
@@ -18,17 +17,17 @@ public void isPunctuation() {
         };
 
         for (char c : chars) {
-            assertTrue("Expected to be punctuation: " + c, Characters.isPunctuationCodePoint(c));
+            assertThat(Characters.isPunctuationCodePoint(c)).as("Expected to be punctuation: " + c).isTrue();
         }
     }
 
     @Test
     public void isBlank() {
-        assertTrue(Characters.isBlank(""));
-        assertTrue(Characters.isBlank(" "));
-        assertTrue(Characters.isBlank("\t"));
-        assertTrue(Characters.isBlank(" \t"));
-        assertFalse(Characters.isBlank("a"));
-        assertFalse(Characters.isBlank("\f"));
+        assertThat(Characters.isBlank("")).isTrue();
+        assertThat(Characters.isBlank(" ")).isTrue();
+        assertThat(Characters.isBlank("\t")).isTrue();
+        assertThat(Characters.isBlank(" \t")).isTrue();
+        assertThat(Characters.isBlank("a")).isFalse();
+        assertThat(Characters.isBlank("\f")).isFalse();
     }
 }
diff --git a/pom.xml b/pom.xml
index 29ca4ead..db4003e5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -79,7 +79,7 @@
                 <plugin>
                     <groupId>org.apache.maven.plugins</groupId>
                     <artifactId>maven-surefire-plugin</artifactId>
-                    <version>3.2.5</version>
+                    <version>3.5.3</version>
                 </plugin>
             </plugins>
         </pluginManagement>
@@ -182,9 +182,14 @@
 
             <!-- Common test dependencies -->
             <dependency>
-                <groupId>junit</groupId>
-                <artifactId>junit</artifactId>
-                <version>4.13.1</version>
+                <groupId>org.junit.jupiter</groupId>
+                <artifactId>junit-jupiter</artifactId>
+                <version>5.13.1</version>
+            </dependency>
+            <dependency>
+                <groupId>org.assertj</groupId>
+                <artifactId>assertj-core</artifactId>
+                <version>3.27.3</version>
             </dependency>
             <dependency>
                 <groupId>org.openjdk.jmh</groupId>