content: {-# LANGUAGE TemplateHaskell, UnboxedTuples, ScopedTypeVariables #-}
  module Parsley.Char.Test where
  import Test.Tasty
  import Test.Tasty.HUnit
  import TestUtils
  import qualified Parsley.Char.Parsers as Parsers
  
  import Prelude hiding ((*>))
  import Parsley ((*>))
  import Parsley.Char (char, item)
  
  tests :: TestTree
  tests = testGroup "Char" [ stringTests
                           , oneOfTests
                           , noneOfTests
                           , tokenTests
                           , charTests
                           , itemTests
                           ]
  
  stringTests :: TestTree
  stringTests = testGroup "string should" []
  
  nothing :: String -> Maybe Char
  nothing = $$(runParserMocked Parsers.nothing [||Parsers.nothing||])
  
  abc :: String -> Maybe Char
  abc = $$(runParserMocked Parsers.abc [||Parsers.abc||])
  
  oneOfTests :: TestTree
  oneOfTests = testGroup "oneOf should"
    [ testCase "handle no options no input" $ nothing "" @?= Nothing
    , testCase "handle no options with input" $ nothing "a" @?= Nothing
    , testCase "parse any of characters" $ do
        abc "a" @?= Just 'a'
        abc "b" @?= Just 'b'
        abc "c" @?= Just 'c'
    , testCase "fail otherwise" $ abc "d" @?= Nothing
    ]
  
  noneOfTests :: TestTree
  noneOfTests = testGroup "noneOf should" []
  
  tokenTests :: TestTree
  tokenTests = testGroup "token should" []
  
  charA :: String -> Maybe Char
  charA = $$(runParserMocked (char 'a') [||char 'a'||])
  
  charTests :: TestTree
  charTests = testGroup "char should"
    [ testCase "fail on empty input" $ charA "" @?= Nothing
    , testCase "succeed on correct char" $ charA "a" @?= Just 'a'
    , testCase "fail on wrong char" $ charA "b" @?= Nothing
    ]
  
  itemTests :: TestTree
  itemTests = testGroup "item should" []
  