Break-up org reader test file

The org reader test file had grown large, to the point that editor
performance was negatively affected in some cases. The tests are spread
over multiple submodules, and re-combined into a tasty TestTree in the
main org reader test file.

5 files changed, 827 insertions, 0 deletions

diff --git a/test/Tests/Readers/Org/Block/CodeBlock.hs b/test/Tests/Readers/Org/Block/CodeBlock.hs
new file mode 100644
index 000000000..8fa822089
--- /dev/null
+++ b/test/Tests/Readers/Org/Block/CodeBlock.hs
@@ -0,0 +1,194 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Tests.Readers.Org.Block.CodeBlock (tests) where
+
+import Test.Tasty (TestTree)
+import Tests.Helpers ((=?>))
+import Tests.Readers.Org.Shared ((=:), spcSep)
+import Text.Pandoc.Builder
+import qualified Data.Text as T
+
+tests :: [TestTree]
+tests =
+  [ "Source block" =:
+       T.unlines [ "  #+BEGIN_SRC haskell"
+                 , "  main = putStrLn greeting"
+                 , "    where greeting = \"moin\""
+                 , "  #+END_SRC" ] =?>
+       let attr' = ("", ["haskell"], [])
+           code' = "main = putStrLn greeting\n" <>
+                   "  where greeting = \"moin\"\n"
+       in codeBlockWith attr' code'
+
+  , "Source block with indented code" =:
+       T.unlines [ "  #+BEGIN_SRC haskell"
+                 , "    main = putStrLn greeting"
+                 , "      where greeting = \"moin\""
+                 , "  #+END_SRC" ] =?>
+       let attr' = ("", ["haskell"], [])
+           code' = "main = putStrLn greeting\n" <>
+                   "  where greeting = \"moin\"\n"
+       in codeBlockWith attr' code'
+
+  , "Source block with tab-indented code" =:
+       T.unlines [ "\t#+BEGIN_SRC haskell"
+                 , "\tmain = putStrLn greeting"
+                 , "\t  where greeting = \"moin\""
+                 , "\t#+END_SRC" ] =?>
+       let attr' = ("", ["haskell"], [])
+           code' = "main = putStrLn greeting\n" <>
+                   "  where greeting = \"moin\"\n"
+       in codeBlockWith attr' code'
+
+  , "Empty source block" =:
+       T.unlines [ "  #+BEGIN_SRC haskell"
+                 , "  #+END_SRC" ] =?>
+       let attr' = ("", ["haskell"], [])
+           code' = ""
+       in codeBlockWith attr' code'
+
+  , "Source block between paragraphs" =:
+       T.unlines [ "Low German greeting"
+                 , "  #+BEGIN_SRC haskell"
+                 , "  main = putStrLn greeting"
+                 , "    where greeting = \"Moin!\""
+                 , "  #+END_SRC" ] =?>
+       let attr' = ("", ["haskell"], [])
+           code' = "main = putStrLn greeting\n" <>
+                    "  where greeting = \"Moin!\"\n"
+       in mconcat [ para $ spcSep [ "Low", "German", "greeting"  ]
+                  , codeBlockWith attr' code'
+                  ]
+  , "Source block with babel arguments" =:
+       T.unlines [ "#+BEGIN_SRC emacs-lisp :exports both"
+                 , "(progn (message \"Hello, World!\")"
+                 , "       (+ 23 42))"
+                 , "#+END_SRC" ] =?>
+       let classes = [ "commonlisp" ] -- as kate doesn't know emacs-lisp syntax
+           params = [ ("org-language", "emacs-lisp")
+                    , ("exports", "both")
+                    ]
+           code' = unlines [ "(progn (message \"Hello, World!\")"
+                           , "       (+ 23 42))" ]
+       in codeBlockWith ("", classes, params) code'
+
+  , "Source block with results and :exports both" =:
+       T.unlines [ "#+BEGIN_SRC emacs-lisp :exports both"
+                 , "(progn (message \"Hello, World!\")"
+                 , "       (+ 23 42))"
+                 , "#+END_SRC"
+                 , ""
+                 , "#+RESULTS:"
+                 , ": 65"] =?>
+       let classes = [ "commonlisp" ]
+           params = [ ("org-language", "emacs-lisp")
+                    , ("exports", "both")
+                    ]
+           code' = unlines [ "(progn (message \"Hello, World!\")"
+                           , "       (+ 23 42))" ]
+           results' = "65\n"
+       in codeBlockWith ("", classes, params) code'
+          <>
+          codeBlockWith ("", ["example"], []) results'
+
+  , "Source block with results and :exports code" =:
+       T.unlines [ "#+BEGIN_SRC emacs-lisp :exports code"
+                 , "(progn (message \"Hello, World!\")"
+                 , "       (+ 23 42))"
+                 , "#+END_SRC"
+                 , ""
+                 , "#+RESULTS:"
+                 , ": 65" ] =?>
+       let classes = [ "commonlisp" ]
+           params = [ ("org-language", "emacs-lisp")
+                    , ("exports", "code")
+                    ]
+           code' = unlines [ "(progn (message \"Hello, World!\")"
+                           , "       (+ 23 42))" ]
+       in codeBlockWith ("", classes, params) code'
+
+  , "Source block with results and :exports results" =:
+       T.unlines [ "#+BEGIN_SRC emacs-lisp :exports results"
+                 , "(progn (message \"Hello, World!\")"
+                 , "       (+ 23 42))"
+                 , "#+END_SRC"
+                 , ""
+                 , "#+RESULTS:"
+                 , ": 65" ] =?>
+       let results' = "65\n"
+       in codeBlockWith ("", ["example"], []) results'
+
+  , "Source block with results and :exports none" =:
+       T.unlines [ "#+BEGIN_SRC emacs-lisp :exports none"
+                 , "(progn (message \"Hello, World!\")"
+                 , "       (+ 23 42))"
+                 , "#+END_SRC"
+                 , ""
+                 , "#+RESULTS:"
+                 , ": 65" ] =?>
+       (mempty :: Blocks)
+
+  , "Source block with toggling header arguments" =:
+    T.unlines [ "#+BEGIN_SRC sh :noeval"
+              , "echo $HOME"
+              , "#+END_SRC"
+              ] =?>
+    let classes = [ "bash" ]
+        params = [ ("org-language", "sh"), ("noeval", "yes") ]
+    in codeBlockWith ("", classes, params) "echo $HOME\n"
+
+  , "Source block with line number switch" =:
+    T.unlines [ "#+BEGIN_SRC sh -n 10"
+              , ":() { :|:& };:"
+              , "#+END_SRC"
+              ] =?>
+    let classes = [ "bash", "numberLines" ]
+        params = [ ("org-language", "sh"), ("startFrom", "10") ]
+    in codeBlockWith ("", classes, params) ":() { :|:& };:\n"
+
+  , "Source block with multi-word parameter values" =:
+    T.unlines [ "#+BEGIN_SRC dot :cmdline -Kdot -Tpng "
+              , "digraph { id [label=\"ID\"] }"
+              , "#+END_SRC"
+              ] =?>
+    let classes = [ "dot" ]
+        params = [ ("cmdline", "-Kdot -Tpng") ]
+    in codeBlockWith ("", classes, params) "digraph { id [label=\"ID\"] }\n"
+
+  , "Example block" =:
+       T.unlines [ "#+begin_example"
+                 , "A chosen representation of"
+                 , "a rule."
+                 , "#+eND_exAMPle"
+                 ] =?>
+       codeBlockWith ("", ["example"], [])
+                     "A chosen representation of\na rule.\n"
+
+  , "Code block with caption" =:
+      T.unlines [ "#+CAPTION: Functor laws in Haskell"
+                , "#+NAME: functor-laws"
+                , "#+BEGIN_SRC haskell"
+                , "fmap id = id"
+                , "fmap (p . q) = (fmap p) . (fmap q)"
+                , "#+END_SRC"
+                ] =?>
+      divWith
+         nullAttr
+         (mappend
+          (plain $ spanWith ("", ["label"], [])
+                            (spcSep [ "Functor", "laws", "in", "Haskell" ]))
+          (codeBlockWith ("functor-laws", ["haskell"], [])
+                         (unlines [ "fmap id = id"
+                                  , "fmap (p . q) = (fmap p) . (fmap q)"
+                                  ])))
+
+  , "Non-letter chars in source block parameters" =:
+      T.unlines [ "#+BEGIN_SRC C :tangle xxxx.c :city Zürich"
+                , "code body"
+                , "#+END_SRC"
+                ] =?>
+      let params  = [ ("org-language", "C")
+                    , ("tangle", "xxxx.c")
+                    , ("city", "Zürich")
+                    ]
+      in codeBlockWith ( "", ["c"], params) "code body\n"
+  ]
diff --git a/test/Tests/Readers/Org/Block/Figure.hs b/test/Tests/Readers/Org/Block/Figure.hs
new file mode 100644
index 000000000..cae6ef179
--- /dev/null
+++ b/test/Tests/Readers/Org/Block/Figure.hs
@@ -0,0 +1,57 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Tests.Readers.Org.Block.Figure (tests) where
+
+import Test.Tasty (TestTree)
+import Tests.Helpers ((=?>))
+import Tests.Readers.Org.Shared ((=:))
+import Text.Pandoc.Builder (image, imageWith, para)
+import qualified Data.Text as T
+
+tests :: [TestTree]
+tests =
+  [ "Figure" =:
+      T.unlines [ "#+caption: A very courageous man."
+                , "#+name: goodguy"
+                , "[[file:edward.jpg]]"
+                ] =?>
+      para (image "edward.jpg" "fig:goodguy" "A very courageous man.")
+
+  , "Figure with no name" =:
+      T.unlines [ "#+caption: I've been through the desert on this"
+                , "[[file:horse.png]]"
+                ] =?>
+      para (image "horse.png" "fig:" "I've been through the desert on this")
+
+  , "Figure with `fig:` prefix in name" =:
+      T.unlines [ "#+caption: Used as a metapher in evolutionary biology."
+                , "#+name: fig:redqueen"
+                , "[[./the-red-queen.jpg]]"
+                ] =?>
+      para (image "./the-red-queen.jpg" "fig:redqueen"
+                  "Used as a metapher in evolutionary biology.")
+
+  , "Figure with HTML attributes" =:
+      T.unlines [ "#+CAPTION: mah brain just explodid"
+                , "#+NAME: lambdacat"
+                , "#+ATTR_HTML: :style color: blue :role button"
+                , "[[file:lambdacat.jpg]]"
+                ] =?>
+      let kv = [("style", "color: blue"), ("role", "button")]
+          name = "fig:lambdacat"
+          caption = "mah brain just explodid"
+      in para (imageWith (mempty, mempty, kv) "lambdacat.jpg" name caption)
+
+  , "Labelled figure" =:
+      T.unlines [ "#+CAPTION: My figure"
+                , "#+LABEL: fig:myfig"
+                , "[[file:blub.png]]"
+                ] =?>
+      let attr = ("fig:myfig", mempty, mempty)
+      in para (imageWith attr "blub.png" "fig:" "My figure")
+
+  , "Figure with empty caption" =:
+      T.unlines [ "#+CAPTION:"
+                , "[[file:guess.jpg]]"
+                ] =?>
+      para (image "guess.jpg" "fig:" "")
+  ]
diff --git a/test/Tests/Readers/Org/Block/Header.hs b/test/Tests/Readers/Org/Block/Header.hs
new file mode 100644
index 000000000..d895c86e2
--- /dev/null
+++ b/test/Tests/Readers/Org/Block/Header.hs
@@ -0,0 +1,182 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Tests.Readers.Org.Block.Header (tests) where
+
+import Test.Tasty (TestTree, testGroup)
+import Tests.Helpers ((=?>))
+import Tests.Readers.Org.Shared ((=:), spcSep, tagSpan)
+import Text.Pandoc.Builder
+import qualified Data.Text as T
+
+tests :: [TestTree]
+tests =
+  [ "First Level Header" =:
+      "* Headline\n" =?>
+      headerWith ("headline", [], []) 1 "Headline"
+
+  , "Third Level Header" =:
+      "*** Third Level Headline\n" =?>
+      headerWith ("third-level-headline", [], [])
+                 3
+                 ("Third" <> space <> "Level" <> space <> "Headline")
+
+  , "Compact Headers with Paragraph" =:
+      T.unlines [ "* First Level"
+                , "** Second Level"
+                , "   Text"
+                ] =?>
+      mconcat [ headerWith ("first-level", [], [])
+                           1
+                           ("First" <> space <> "Level")
+              , headerWith ("second-level", [], [])
+                           2
+                           ("Second" <> space <> "Level")
+              , para "Text"
+              ]
+
+  , "Separated Headers with Paragraph" =:
+      T.unlines [ "* First Level"
+                , ""
+                , "** Second Level"
+                , ""
+                , "   Text"
+                ] =?>
+      mconcat [ headerWith ("first-level", [], [])
+                           1
+                           ("First" <> space <> "Level")
+              , headerWith ("second-level", [], [])
+                           2
+                           ("Second" <> space <> "Level")
+              , para "Text"
+              ]
+
+  , "Headers not preceded by a blank line" =:
+      T.unlines [ "** eat dinner"
+                , "Spaghetti and meatballs tonight."
+                , "** walk dog"
+                ] =?>
+      mconcat [ headerWith ("eat-dinner", [], [])
+                           2
+                           ("eat" <> space <> "dinner")
+              , para $ spcSep [ "Spaghetti", "and", "meatballs", "tonight." ]
+              , headerWith ("walk-dog", [], [])
+                           2
+                           ("walk" <> space <> "dog")
+              ]
+
+  , testGroup "Todo keywords"
+    [ "Header with known todo keyword" =:
+        "* TODO header" =?>
+        let todoSpan = spanWith ("", ["todo", "TODO"], []) "TODO"
+        in headerWith ("header", [], []) 1 (todoSpan <> space <> "header")
+
+    , "Header marked as done" =:
+        "* DONE header" =?>
+        let todoSpan = spanWith ("", ["done", "DONE"], []) "DONE"
+        in headerWith ("header", [], []) 1 (todoSpan <> space <> "header")
+
+    , "Header with unknown todo keyword" =:
+        "* WAITING header" =?>
+        headerWith ("waiting-header", [], []) 1 "WAITING header"
+
+    , "Custom todo keywords" =:
+        T.unlines [ "#+TODO: WAITING CANCELLED"
+                  , "* WAITING compile"
+                  , "* CANCELLED lunch"
+                  ] =?>
+        let todoSpan = spanWith ("", ["todo", "WAITING"], []) "WAITING"
+            doneSpan = spanWith ("", ["done", "CANCELLED"], []) "CANCELLED"
+        in headerWith ("compile", [], []) 1 (todoSpan <> space <> "compile")
+        <> headerWith ("lunch", [], []) 1 (doneSpan <> space <> "lunch")
+
+    , "Custom todo keywords with multiple done-states" =:
+        T.unlines [ "#+TODO: WAITING | DONE CANCELLED "
+                  , "* WAITING compile"
+                  , "* CANCELLED lunch"
+                  , "* DONE todo-feature"
+                  ] =?>
+        let waiting = spanWith ("", ["todo", "WAITING"], []) "WAITING"
+            cancelled = spanWith ("", ["done", "CANCELLED"], []) "CANCELLED"
+            done = spanWith ("", ["done", "DONE"], []) "DONE"
+        in headerWith ("compile", [], []) 1 (waiting <> space <> "compile")
+        <> headerWith ("lunch", [], []) 1 (cancelled <> space <> "lunch")
+        <> headerWith ("todo-feature", [], []) 1 (done <> space <> "todo-feature")
+    ]
+
+  , "Tagged headers" =:
+      T.unlines [ "* Personal       :PERSONAL:"
+                , "** Call Mom      :@PHONE:"
+                , "** Call John     :@PHONE:JOHN: "
+                ] =?>
+      mconcat [ headerWith ("personal", [], [])
+                           1
+                           ("Personal " <> tagSpan "PERSONAL")
+              , headerWith ("call-mom", [], [])
+                           2
+                           ("Call Mom " <> tagSpan "@PHONE")
+              , headerWith ("call-john", [], [])
+                           2
+                           ("Call John " <> tagSpan "@PHONE" <> "\160" <> tagSpan "JOHN")
+              ]
+
+  , "Untagged header containing colons" =:
+      "* This: is not: tagged" =?>
+      headerWith ("this-is-not-tagged", [], []) 1 "This: is not: tagged"
+
+  , "Header starting with strokeout text" =:
+      T.unlines [ "foo"
+                , ""
+                , "* +thing+ other thing"
+                ] =?>
+      mconcat [ para "foo"
+              , headerWith ("thing-other-thing", [], [])
+                           1
+                           ((strikeout "thing") <> " other thing")
+              ]
+
+  , "Comment Trees" =:
+      T.unlines [ "* COMMENT A comment tree"
+                , "  Not much going on here"
+                , "** This will be dropped"
+                , "* Comment tree above"
+                ] =?>
+      headerWith ("comment-tree-above", [], []) 1 "Comment tree above"
+
+  , "Nothing but a COMMENT header" =:
+      "* COMMENT Test" =?>
+      (mempty::Blocks)
+
+  , "Tree with :noexport:" =:
+      T.unlines [ "* Should be ignored :archive:noexport:old:"
+                , "** Old stuff"
+                , "   This is not going to be exported"
+                ] =?>
+      (mempty::Blocks)
+
+  , "Subtree with :noexport:" =:
+      T.unlines [ "* Exported"
+                , "** This isn't exported :noexport:"
+                , "*** This neither"
+                , "** But this is"
+                ] =?>
+      mconcat [ headerWith ("exported", [], []) 1 "Exported"
+              , headerWith ("but-this-is", [], []) 2 "But this is"
+              ]
+
+  , "Preferences are treated as header attributes" =:
+      T.unlines [ "* foo"
+                , "  :PROPERTIES:"
+                , "  :custom_id: fubar"
+                , "  :bar: baz"
+                , "  :END:"
+                ] =?>
+      headerWith ("fubar", [], [("bar", "baz")]) 1 "foo"
+
+
+  , "Headers marked with a unnumbered property get a class of the same name" =:
+      T.unlines [ "* Not numbered"
+                , "  :PROPERTIES:"
+                , "  :UNNUMBERED: t"
+                , "  :END:"
+                ] =?>
+      headerWith ("not-numbered", ["unnumbered"], []) 1 "Not numbered"
+  ]
diff --git a/test/Tests/Readers/Org/Block/List.hs b/test/Tests/Readers/Org/Block/List.hs
new file mode 100644
index 000000000..32bb13294
--- /dev/null
+++ b/test/Tests/Readers/Org/Block/List.hs
@@ -0,0 +1,244 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Tests.Readers.Org.Block.List (tests) where
+
+import Test.Tasty (TestTree)
+import Tests.Helpers ((=?>))
+import Tests.Readers.Org.Shared ((=:), spcSep)
+import Text.Pandoc.Builder
+import qualified Data.Text as T
+
+tests :: [TestTree]
+tests =
+  [ "Simple Bullet Lists" =:
+      ("- Item1\n" <>
+       "- Item2\n") =?>
+      bulletList [ plain "Item1"
+                 , plain "Item2"
+                 ]
+
+  , "Indented Bullet Lists" =:
+      ("   - Item1\n" <>
+       "   - Item2\n") =?>
+      bulletList [ plain "Item1"
+                 , plain "Item2"
+                 ]
+
+  , "Unindented *" =:
+      ("- Item1\n" <>
+       "* Item2\n") =?>
+      bulletList [ plain "Item1"
+                 ] <>
+      headerWith ("item2", [], []) 1 "Item2"
+
+  , "Multi-line Bullet Lists" =:
+      ("- *Fat\n" <>
+       "  Tony*\n" <>
+       "- /Sideshow\n" <>
+       " Bob/") =?>
+      bulletList [ plain $ strong ("Fat" <> softbreak <> "Tony")
+                 , plain $ emph ("Sideshow" <> softbreak <> "Bob")
+                 ]
+
+  , "Nested Bullet Lists" =:
+      ("- Discovery\n" <>
+       "  + One More Time\n" <>
+       "  + Harder, Better, Faster, Stronger\n" <>
+       "- Homework\n" <>
+       "  + Around the World\n"<>
+       "- Human After All\n" <>
+       "  + Technologic\n" <>
+       "  + Robot Rock\n") =?>
+      bulletList [ mconcat
+                   [ plain "Discovery"
+                   , bulletList [ plain ("One" <> space <>
+                                         "More" <> space <>
+                                         "Time")
+                                , plain ("Harder," <> space <>
+                                         "Better," <> space <>
+                                         "Faster," <> space <>
+                                         "Stronger")
+                                ]
+                   ]
+                 , mconcat
+                   [ plain "Homework"
+                   , bulletList [ plain ("Around" <> space <>
+                                         "the" <> space <>
+                                         "World")
+                                ]
+                   ]
+                 , mconcat
+                   [ plain ("Human" <> space <> "After" <> space <> "All")
+                   , bulletList [ plain "Technologic"
+                                , plain ("Robot" <> space <> "Rock")
+                                ]
+                   ]
+                 ]
+
+  , "Bullet List with Decreasing Indent" =:
+       ("  - Discovery\n\
+        \ - Human After All\n") =?>
+       mconcat [ bulletList [ plain "Discovery" ]
+               , bulletList [ plain ("Human" <> space <> "After" <> space <> "All")]
+               ]
+
+  , "Header follows Bullet List" =:
+      ("  - Discovery\n\
+       \  - Human After All\n\
+       \* Homework") =?>
+      mconcat [ bulletList [ plain "Discovery"
+                           , plain ("Human" <> space <> "After" <> space <> "All")
+                           ]
+              , headerWith ("homework", [], []) 1 "Homework"
+              ]
+
+  , "Bullet List Unindented with trailing Header" =:
+      ("- Discovery\n\
+       \- Homework\n\
+       \* NotValidListItem") =?>
+      mconcat [ bulletList [ plain "Discovery"
+                           , plain "Homework"
+                           ]
+              , headerWith ("notvalidlistitem", [], []) 1 "NotValidListItem"
+              ]
+
+  , "Empty bullet points" =:
+      T.unlines [ "-"
+                , "- "
+                ] =?>
+      bulletList [ plain "", plain "" ]
+
+  , "Simple Ordered List" =:
+      ("1. Item1\n" <>
+       "2. Item2\n") =?>
+      let listStyle = (1, DefaultStyle, DefaultDelim)
+          listStructure = [ plain "Item1"
+                          , plain "Item2"
+                          ]
+      in orderedListWith listStyle listStructure
+
+  , "Simple Ordered List with Parens" =:
+      ("1) Item1\n" <>
+       "2) Item2\n") =?>
+      let listStyle = (1, DefaultStyle, DefaultDelim)
+          listStructure = [ plain "Item1"
+                          , plain "Item2"
+                          ]
+      in orderedListWith listStyle listStructure
+
+  , "Indented Ordered List" =:
+      (" 1. Item1\n" <>
+       " 2. Item2\n") =?>
+      let listStyle = (1, DefaultStyle, DefaultDelim)
+          listStructure = [ plain "Item1"
+                          , plain "Item2"
+                          ]
+      in orderedListWith listStyle listStructure
+
+  , "Empty ordered list item" =:
+      T.unlines [ "1."
+                , "3. "
+                ] =?>
+      orderedList [ plain "", plain "" ]
+
+  , "Nested Ordered Lists" =:
+      ("1. One\n" <>
+       "   1. One-One\n" <>
+       "   2. One-Two\n" <>
+       "2. Two\n" <>
+       "   1. Two-One\n"<>
+       "   2. Two-Two\n") =?>
+      let listStyle = (1, DefaultStyle, DefaultDelim)
+          listStructure = [ mconcat
+                            [ plain "One"
+                            , orderedList [ plain "One-One"
+                                          , plain "One-Two"
+                                          ]
+                            ]
+                          , mconcat
+                            [ plain "Two"
+                            , orderedList [ plain "Two-One"
+                                          , plain "Two-Two"
+                                          ]
+                            ]
+                          ]
+      in orderedListWith listStyle listStructure
+
+  , "Ordered List in Bullet List" =:
+      ("- Emacs\n" <>
+       "  1. Org\n") =?>
+      bulletList [ (plain "Emacs") <>
+                   (orderedList [ plain "Org"])
+                 ]
+
+  , "Bullet List in Ordered List" =:
+      ("1. GNU\n" <>
+       "   - Freedom\n") =?>
+      orderedList [ (plain "GNU") <> bulletList [ (plain "Freedom") ] ]
+
+  , "Definition List" =:
+      T.unlines [ "- PLL :: phase-locked loop"
+                , "- TTL ::"
+                , "  transistor-transistor logic"
+                , "- PSK :: phase-shift keying"
+                , ""
+                , "  a digital modulation scheme"
+                ] =?>
+      definitionList [ ("PLL", [ plain $ "phase-locked" <> space <> "loop" ])
+                     , ("TTL", [ plain $ "transistor-transistor" <> space <>
+                                           "logic" ])
+                     , ("PSK", [ mconcat
+                                 [ para $ "phase-shift" <> space <> "keying"
+                                 , para $ spcSep [ "a", "digital"
+                                                 , "modulation", "scheme" ]
+                                 ]
+                               ])
+                     ]
+  , "Definition list with multi-word term" =:
+    " - Elijah Wood :: He plays Frodo" =?>
+     definitionList [ ("Elijah" <> space <> "Wood", [plain $ "He" <> space <> "plays" <> space <> "Frodo"])]
+  , "Compact definition list" =:
+       T.unlines [ "- ATP :: adenosine 5' triphosphate"
+                 , "- DNA :: deoxyribonucleic acid"
+                 , "- PCR :: polymerase chain reaction"
+                 , ""
+                 ] =?>
+      definitionList
+      [ ("ATP", [ plain $ spcSep [ "adenosine", "5'", "triphosphate" ] ])
+      , ("DNA", [ plain $ spcSep [ "deoxyribonucleic", "acid" ] ])
+      , ("PCR", [ plain $ spcSep [ "polymerase", "chain", "reaction" ] ])
+      ]
+
+  , "Definition List With Trailing Header" =:
+      "- definition :: list\n\
+      \- cool :: defs\n\
+      \* header" =?>
+      mconcat [ definitionList [ ("definition", [plain "list"])
+                               , ("cool", [plain "defs"])
+                               ]
+              , headerWith ("header", [], []) 1 "header"
+              ]
+
+  , "Definition lists double-colon markers must be surrounded by whitespace" =:
+      "- std::cout" =?>
+      bulletList [ plain "std::cout" ]
+
+  , "Loose bullet list" =:
+     T.unlines [ "- apple"
+               , ""
+               , "- orange"
+               , ""
+               , "- peach"
+               ] =?>
+      bulletList [ para "apple"
+                 , para "orange"
+                 , para "peach"
+                 ]
+
+  , "Recognize preceding paragraphs in non-list contexts" =:
+      T.unlines [ "CLOSED: [2015-10-19 Mon 15:03]"
+                , "- Note taken on [2015-10-19 Mon 13:24]"
+                ] =?>
+      mconcat [ para "CLOSED: [2015-10-19 Mon 15:03]"
+              , bulletList [ plain "Note taken on [2015-10-19 Mon 13:24]" ]
+              ]
+  ]
diff --git a/test/Tests/Readers/Org/Block/Table.hs b/test/Tests/Readers/Org/Block/Table.hs
new file mode 100644
index 000000000..db6e756f8
--- /dev/null
+++ b/test/Tests/Readers/Org/Block/Table.hs
@@ -0,0 +1,150 @@
+{-# LANGUAGE OverloadedStrings #-}
+module Tests.Readers.Org.Block.Table (tests) where
+
+import Test.Tasty (TestTree)
+import Tests.Helpers ((=?>))
+import Tests.Readers.Org.Shared ((=:), spcSep)
+import Text.Pandoc.Builder
+import qualified Data.Text as T
+
+simpleTable' :: Int
+             -> [Blocks]
+             -> [[Blocks]]
+             -> Blocks
+simpleTable' n = table "" (replicate n (AlignDefault, 0.0))
+
+tests :: [TestTree]
+tests =
+  [ "Single cell table" =:
+      "|Test|" =?>
+      simpleTable' 1 mempty [[plain "Test"]]
+
+  , "Multi cell table" =:
+      "| One | Two |" =?>
+       simpleTable' 2 mempty [ [ plain "One", plain "Two" ] ]
+
+  , "Multi line table" =:
+      T.unlines [ "| One   |"
+                , "| Two   |"
+                , "| Three |"
+                ] =?>
+       simpleTable' 1 mempty
+                    [ [ plain "One" ]
+                    , [ plain "Two" ]
+                    , [ plain "Three" ]
+                    ]
+
+  , "Empty table" =:
+      "||" =?>
+      simpleTable' 1 mempty [[mempty]]
+
+  , "Glider Table" =:
+      T.unlines [ "| 1 | 0 | 0 |"
+                , "| 0 | 1 | 1 |"
+                , "| 1 | 1 | 0 |"
+                ] =?>
+      simpleTable' 3 mempty
+                   [ [ plain "1", plain "0", plain "0" ]
+                   , [ plain "0", plain "1", plain "1" ]
+                   , [ plain "1", plain "1", plain "0" ]
+                   ]
+
+  , "Table between Paragraphs" =:
+      T.unlines [ "Before"
+                , "| One | Two |"
+                , "After"
+                ] =?>
+      mconcat [ para "Before"
+              , simpleTable' 2 mempty [ [ plain "One", plain "Two" ] ]
+              , para "After"
+              ]
+
+  , "Table with Header" =:
+      T.unlines [ "| Species      | Status       |"
+                , "|--------------+--------------|"
+                , "| cervisiae    | domesticated |"
+                , "| paradoxus    | wild         |"
+                ] =?>
+      simpleTable [ plain "Species", plain "Status" ]
+                  [ [ plain "cervisiae", plain "domesticated" ]
+                  , [ plain "paradoxus", plain "wild" ]
+                  ]
+
+  , "Table with final hline" =:
+      T.unlines [ "| cervisiae    | domesticated |"
+                , "| paradoxus    | wild         |"
+                , "|--------------+--------------|"
+                ] =?>
+      simpleTable' 2 mempty
+            [ [ plain "cervisiae", plain "domesticated" ]
+             , [ plain "paradoxus", plain "wild" ]
+            ]
+
+  , "Table in a box" =:
+      T.unlines [ "|---------|---------|"
+                , "| static  | Haskell |"
+                , "| dynamic | Lisp    |"
+                , "|---------+---------|"
+                ] =?>
+      simpleTable' 2 mempty
+            [ [ plain "static", plain "Haskell" ]
+            , [ plain "dynamic", plain "Lisp" ]
+            ]
+
+  , "Table with empty cells" =:
+      "|||c|" =?>
+      simpleTable' 3 mempty [[mempty, mempty, plain "c"]]
+
+  , "Table with empty rows" =:
+      T.unlines [ "| first  |"
+                , "|        |"
+                , "| third  |"
+                ] =?>
+      simpleTable' 1 mempty [[plain "first"], [mempty], [plain "third"]]
+
+  , "Table with alignment row" =:
+      T.unlines [ "| Numbers | Text | More |"
+                , "| <c>     | <r>  |      |"
+                , "| 1       | One  | foo  |"
+                , "| 2       | Two  | bar  |"
+                ] =?>
+      table "" (zip [AlignCenter, AlignRight, AlignDefault] [0, 0, 0])
+            []
+            [ [ plain "Numbers", plain "Text", plain "More" ]
+            , [ plain "1"      , plain "One" , plain "foo"  ]
+            , [ plain "2"      , plain "Two" , plain "bar"  ]
+            ]
+
+  , "Pipe within text doesn't start a table" =:
+      "Ceci n'est pas une | pipe " =?>
+      para (spcSep [ "Ceci", "n'est", "pas", "une", "|", "pipe" ])
+
+  , "Missing pipe at end of row" =:
+      "|incomplete-but-valid" =?>
+      simpleTable' 1 mempty [ [ plain "incomplete-but-valid" ] ]
+
+  , "Table with differing row lengths" =:
+      T.unlines [ "| Numbers | Text "
+                , "|-"
+                , "| <c>     | <r>  |"
+                , "| 1       | One  | foo  |"
+                , "| 2"
+                ] =?>
+      table "" (zip [AlignCenter, AlignRight] [0, 0])
+            [ plain "Numbers", plain "Text" ]
+            [ [ plain "1" , plain "One" , plain "foo" ]
+            , [ plain "2" ]
+            ]
+
+  , "Table with caption" =:
+      T.unlines [ "#+CAPTION: Hitchhiker's Multiplication Table"
+                , "| x |  6 |"
+                , "| 9 | 42 |"
+                ] =?>
+      table "Hitchhiker's Multiplication Table"
+            [(AlignDefault, 0), (AlignDefault, 0)]
+            []
+            [ [ plain "x", plain "6" ]
+            , [ plain "9", plain "42" ]
+            ]
+  ]