module Main (main) where

import Test.HUnit
import Lib

testPars :: Test
testPars = TestCase (assertEqual "() -> [TokLPar,TokRPar]"
                     [Lib.TokLPar, Lib.TokRPar]
                     (lexStr "()"))

testSymbol :: Test
testSymbol = TestCase (assertEqual "hello world -> [TokSymbol \"hello\", TokSymbol \"world\"]"
                       [Lib.TokSymbol "hello", Lib.TokSymbol "world"]
                       (lexStr "hello world"))

testQuotedPars :: Test
testQuotedPars = TestCase (assertEqual "'() -> [TokQuote,TokLPar,TokRPar]"
                           [Lib.TokQuote, Lib.TokLPar, Lib.TokRPar]
                           (lexStr "'()"))

testLoneQuoteIsSymbol :: Test
testLoneQuoteIsSymbol = TestCase (assertEqual "'  ' -> [TokSymbol \"'\", TokSymbol \"'\"]"
                                  [Lib.TokSymbol "'", Lib.TokSymbol "'"]
                                  (lexStr "'  '"))

testCharacter :: Test
testCharacter = TestCase (assertEqual "'a' -> [TokCharacter 'a']"
                          [Lib.TokCharacter 'a']
                          (lexStr "'a'"))

testQuotedSymbol :: Test
testQuotedSymbol = TestCase (assertEqual "'hello -> [TokQuote,TokSymbol \"hello\"]"
                             [Lib.TokQuote, Lib.TokSymbol "hello"]
                             (lexStr "'hello"))

testUnicodeCharacter :: Test
testUnicodeCharacter = TestCase (assertEqual "'📎' -> [TokCharacter '📎']"
                                 [Lib.TokCharacter '📎']
                                 (lexStr "'📎'"))

testSimpleIntegers :: Test
testSimpleIntegers = TestCase (assertEqual "42 -> [TokNumber 42]"
                               [Lib.TokNumber 42]
                               (lexStr "42"))

testFractionalNumber :: Test
testFractionalNumber = TestCase (assertEqual "42.123 -> [TokNumber 42.123]"
                                 [Lib.TokNumber 42.123]
                                 (lexStr "42.123"))

testExponentialInteger :: Test
testExponentialInteger = TestCase (assertEqual "42e123 -> [TokNumber 42e123]"
                                   [Lib.TokNumber 42e123]
                                   (lexStr "42e123"))

testExponential :: Test
testExponential = TestCase (assertEqual "42.03E+12 -> [TokNumber 42.03e12]"
                            [Lib.TokNumber 42.03e12]
                            (lexStr "42.03E+12"))

testNegativeNumber :: Test
testNegativeNumber = TestCase (assertEqual "-42.03e-12 -> [TokNumber -42.03e-12]"
                               [Lib.TokNumber (-42.03e-12)]
                               (lexStr "-42.03e-12"))

testStringsAreRecognized :: Test
testStringsAreRecognized = TestCase (assertEqual
                                     "can strings be recognized?"
                                     [Lib.TokStr "\43981asdf\b\f\r\n\t\\/"]
                                     (lexStr "\"\\uabcdasdf\\b\\f\\r\\n\\t\\\\\\/\""))

testUnclosedStringsAreSymbols :: Test
testUnclosedStringsAreSymbols = TestCase (assertEqual
                                          "this would make for a terrible symbol, but it can hypothetically start with a double quote"
                                          [Lib.TokSymbol "\"hello", Lib.TokSymbol "world"]
                                          (lexStr "\"hello world"))

tests :: Test
tests = TestList [
  TestLabel "test paretheses are detected" testPars,
  TestLabel "test symbols are recognized" testSymbol,
  TestLabel "test quoted parentheses are detected" testQuotedPars,
  TestLabel "test single quotes without symbols or characters are symbols themselves" testLoneQuoteIsSymbol,
  TestLabel "test characters are recognized" testCharacter,
  TestLabel "test quoted symbols are recognized" testQuotedSymbol,
  TestLabel "test unicode characters are recognized" testUnicodeCharacter,
  TestLabel "test simple integers are recognized" testSimpleIntegers,
  TestLabel "test fractional numbers are recognized" testFractionalNumber,
  TestLabel "test integers with exponential component are recognized" testExponentialInteger,
  TestLabel "test exponential number is recognized" testExponential,
  TestLabel "test negative numbers are recognized" testNegativeNumber,
  TestLabel "test strings are recognized" testStringsAreRecognized,
  TestLabel "test unclosed strings are symbols" testUnclosedStringsAreSymbols
  ]

main :: IO ()
main = do
  c <- runTestTT tests
  putStrLn (showCounts c)