content: -- | A whole bunch of simple test cases
  --
  {-# LANGUAGE OverloadedStrings #-}
  module Text.Blaze.Html.Tests
      ( tests
      ) where
  
  import Prelude hiding (div, id)
  import Control.Monad (forM_)
  import Data.Monoid (mempty, mappend, mconcat)
  
  import Data.Text (Text)
  import Test.HUnit ((@=?))
  import Test.Framework.Providers.HUnit (testCase)
  import Test.Framework (Test)
  import qualified Data.ByteString.Lazy.Char8 as LBC
  
  import Text.Blaze.Html.Tests.Util
  import Text.Blaze.Html5 hiding (map)
  import Text.Blaze.Html5.Attributes
  import Text.Blaze.Internal
  import qualified Text.Blaze.Html5 as H
  
  -- | Type for a simple HTML test. This data type contains the expected output
  -- and the HTML template.
  --
  data HtmlTest = HtmlTest LBC.ByteString Html
  
  -- | Create tests from an HTML test
  --
  makeTests :: String -> HtmlTest -> [Test]
  makeTests baseName (HtmlTest expected h) =
      [ testCase (baseName ++ " (String)") $ expected @=? renderUsingString h
      , testCase (baseName ++ " (Text)") $ expected @=? renderUsingText h
      , testCase (baseName ++ " (Utf8)") $ expected @=? renderUsingUtf8 h
      ]
  
  -- | Actual tests
  --
  tests :: [Test]
  tests = concatMap (uncurry makeTests) $ zip names
      -- Simple cases
      [ HtmlTest "<div id=\"foo\"><p>banana</p><span>banana</span></div>" $
          div ! id "foo" $ do
              p "banana"
              H.span "banana"
  
      , HtmlTest "<img src=\"foo.png\" alt=\"bar\">" $
          img ! src "foo.png" ! alt "bar"
  
      -- Escaping cases
      , HtmlTest "&quot;&amp;&quot;" "\"&\""
  
      , HtmlTest "&lt;img&gt;" $ toHtml ("<img>" :: Text)
  
      , HtmlTest "&quot;&#39;&quot;" "\"'\""
  
      , HtmlTest "<img src=\"&amp;\">" $ img ! src "&"
  
      , HtmlTest "<u>hello</u>" $ H.u "hello"
  
      -- Pre-escaping cases
      , HtmlTest "<3 Haskell" $ preEscapedToMarkup ("<3 Haskell" :: String)
  
      , HtmlTest "<script />" $ preEscapedToMarkup ("<script />" :: Text)
  
      , HtmlTest "<p class=\"'&!;\">bad</p>" $
          p ! class_ (preEscapedToValue ("'&!;" :: String)) $ "bad"
  
      -- Unicode cases
      , HtmlTest "<span id=\"&amp;\">\206\187</span>" $
          H.span ! id "&" $ "λ"
  
      , HtmlTest "\226\136\128x. x \226\136\136 A"
          "∀x. x ∈ A"
  
      , HtmlTest "$6, \226\130\172\&7.01, \194\163\&75"
          "$6, €7.01, £75"
  
      -- Control cases
      , HtmlTest "<li>4</li><li>5</li><li>6</li>" $
          forM_ [4 :: Int .. 6] (li . toHtml)
  
      , HtmlTest "<br><img><area>" $
          sequence_ [br, img, area]
  
      -- Attribute tests
      , HtmlTest "<p data-foo=\"bar\">A paragraph</p>" $
          p ! (dataAttribute "foo" "bar") $ "A paragraph"
  
      , HtmlTest "<p>Hello</p>" $ p ! mempty $ "Hello"
  
      , HtmlTest "<img src=\"foo.png\" alt=\"foo\">" $
          img ! (src "foo.png" `mappend` alt "foo")
  
      -- ToHtml/ToValue tests
      , HtmlTest "12345678910" $ mconcat $ map toHtml [1 :: Int .. 10]
  
      , HtmlTest "<img src=\"funny-picture-4.png\">" $
          img ! src ("funny-picture-" `mappend` toValue (4 :: Integer)
                                      `mappend` ".png")
  
      , HtmlTest "abcdefghijklmnopqrstuvwxyz" $ forM_ ['a' .. 'z'] toHtml
  
      -- Custom elements/attributes tests
      , HtmlTest "<p>A paragraph</p>" $
          customParent "p" $ "A paragraph"
  
      , HtmlTest "<img src=\"foo.png\">" $
          customLeaf "img" False ! src "foo.png"
  
      , HtmlTest "<img />" $ customLeaf "img" True
  
      , HtmlTest "<p dojoType=\"select\">A paragraph</p>" $
          p ! (customAttribute "dojoType" "select") $ "A paragraph"
      ]
    where
      names = map (("Test case " ++) . show) [1 :: Int ..]
  