{- -----------------------------------------------------------------------------
Copyright 2020-2021 Kevin P. Barry

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
----------------------------------------------------------------------------- -}

-- Author: Kevin P. Barry [ta0kira@gmail.com]

{-# LANGUAGE Safe #-}

module Test.TrackedErrors (tests) where

import Control.Arrow (first)
import Control.Monad.Writer

import Base.CompilerError
import Base.TrackedErrors


tests :: [IO (TrackedErrors ())]
tests :: [IO (TrackedErrors ())]
tests = [
    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' (forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a'),
    forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"error\n" (forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" :: TrackedErrorsIO Char),
    forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"" (forall (m :: * -> *) a. CollectErrorsM m => m a
emptyErrorM :: TrackedErrorsIO Char),

    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess [Char
'a',Char
'b']          (forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAllM [forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess []                 (forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAllM [] :: TrackedErrorsIO [Char]),
    forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError   [Char]
"error1\nerror2\n" (forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAllM [forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error1",forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error2"]),

    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess [Char]
"ab" (forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAnyM [forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess [Char]
""   (forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAnyM [] :: TrackedErrorsIO [Char]),
    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess [Char]
"b"  (forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAnyM [forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error1",forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error2"]),

    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' (forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m a
collectFirstM [forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError   [Char]
""  (forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m a
collectFirstM [] :: TrackedErrorsIO Char),
    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'b' (forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m a
collectFirstM [forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error1",forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error2"]),

    forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
"warning1\nwarning2\n" ()
      (forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning1" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return () forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning2"),
    forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
"warning1\n" [Char]
"error\n"
      (forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning1" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning2" :: TrackedErrorsIO ()),

    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess [Char
'a',Char
'b']  (forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a',forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b']),
    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess []         (forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [] :: TrackedErrorsIO [Char]),
    forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError   [Char]
"error1\n" (forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
sequence [forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error1",forall (m :: * -> *) a. Monad m => a -> m a
return Char
'b',forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error2"]),

    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' (forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a' forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`withContextM` [Char]
"message"),
    forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"message\n  error\n" (forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`withContextM` [Char]
"message" :: TrackedErrorsIO ()),
    forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
"message\n  warning\n" ()
      (forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning" forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`withContextM` [Char]
"message" :: TrackedErrorsIO ()),
    forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
"message\n  warning\n" [Char]
"message\n  error\n"
      ((forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error") forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`withContextM` [Char]
"message" :: TrackedErrorsIO ()),
    forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
"" () (forall (m :: * -> *) a. Monad m => a -> m a
return () forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`withContextM` [Char]
"message"),
    forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
"" [Char]
"message\n" (forall (m :: * -> *) a. CollectErrorsM m => m a
emptyErrorM forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`withContextM` [Char]
"message" :: TrackedErrorsIO ()),

    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' (forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a' forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`summarizeErrorsM` [Char]
"message"),
    forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"message\n  error\n" (forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`summarizeErrorsM` [Char]
"message" :: TrackedErrorsIO ()),
    forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
"warning\n" ()
      (forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning" forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`summarizeErrorsM` [Char]
"message" :: TrackedErrorsIO ()),
    forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
"warning\n" [Char]
"message\n  error\n"
      ((forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error") forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`summarizeErrorsM` [Char]
"message" :: TrackedErrorsIO ()),
    forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
"" () (forall (m :: * -> *) a. Monad m => a -> m a
return () forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`summarizeErrorsM` [Char]
"message"),
    forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
"" [Char]
"message\n" (forall (m :: * -> *) a. CollectErrorsM m => m a
emptyErrorM forall (m :: * -> *) a. ErrorContextM m => m a -> [Char] -> m a
`summarizeErrorsM` [Char]
"message" :: TrackedErrorsIO ()),

    forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
"error\n" ()
      (forall (m :: * -> *) a.
Monad m =>
TrackedErrors a -> TrackedErrorsT m ()
asCompilerWarnings forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" :: TrackedErrorsIO ()),
    forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
"" [Char]
"warning\n"
      (forall (m :: * -> *) a.
Monad m =>
TrackedErrors a -> TrackedErrorsT m ()
asCompilerError forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerWarningM [Char]
"warning" :: TrackedErrorsIO ()),

    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' (forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerBackgroundM [Char]
"background" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a'),
    forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"error\n  background\n"
      (forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerBackgroundM [Char]
"background" forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" :: TrackedErrorsIO ()),
    forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"error\n  background\n"
      (forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m [a]
collectAllM [forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerBackgroundM [Char]
"background"] forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" :: TrackedErrorsIO [()]),
    forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"error\n  background\n"
      (forall (m :: * -> *) (f :: * -> *) a.
(CollectErrorsM m, Foldable f) =>
f (m a) -> m a
collectFirstM [forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerBackgroundM [Char]
"background"] forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" :: TrackedErrorsIO ()),

    forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess Char
'a' ((forall (m :: * -> *) a. ErrorContextM m => m a -> m a
resetBackgroundM forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerBackgroundM [Char]
"background") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'a'),
    forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
"error\n"
      ((forall (m :: * -> *) a. ErrorContextM m => m a -> m a
resetBackgroundM forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). ErrorContextM m => [Char] -> m ()
compilerBackgroundM [Char]
"background") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"error" :: TrackedErrorsIO ()),

    forall a.
(Eq a, Show a) =>
(a, [Char])
-> TrackedErrorsT (Writer [Char]) a -> IO (TrackedErrors ())
checkWriterSuccess (Char
'x',[Char]
"ab") (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(ErrorContextT t, Monad m, ErrorContextM (t m)) =>
t m a -> m () -> m () -> t m a
ifElseSuccessT (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [Char]
"a") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return Char
'x') (forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [Char]
"b") (forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [Char]
"c")),
    forall a.
(Eq a, Show a) =>
([Char], [Char])
-> TrackedErrorsT (Writer [Char]) a -> IO (TrackedErrors ())
checkWriterFail ([Char]
"failed\n",[Char]
"ac") (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(ErrorContextT t, Monad m, ErrorContextM (t m)) =>
t m a -> m () -> m () -> t m a
ifElseSuccessT (forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [Char]
"a") forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM [Char]
"failed") (forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [Char]
"b") (forall w (m :: * -> *). MonadWriter w m => w -> m ()
tell [Char]
"c") :: TrackedErrorsT (Writer String) ())
  ]

checkWriterSuccess :: (Eq a, Show a) => (a,String) -> TrackedErrorsT (Writer String) a -> IO (TrackedErrors ())
checkWriterSuccess :: forall a.
(Eq a, Show a) =>
(a, [Char])
-> TrackedErrorsT (Writer [Char]) a -> IO (TrackedErrors ())
checkWriterSuccess (a, [Char])
x TrackedErrorsT (Writer [Char]) a
y = do
  let (Bool
failed,[Char]
_) = forall w a. Writer w a -> (a, w)
runWriter forall a b. (a -> b) -> a -> b
$ forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(ErrorContextT t, Monad m, ErrorContextM (t m)) =>
t m a -> m Bool
isCompilerErrorT TrackedErrorsT (Writer [Char]) a
y
  if Bool
failed
     then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a b. (a, b) -> a
fst forall a b. (a -> b) -> a -> b
$ forall w a. Writer w a -> (a, w)
runWriter forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors forall a b. (a -> b) -> a -> b
$ TrackedErrorsT (Writer [Char]) a
y forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else do
       let y' :: (a, [Char])
y' = forall w a. Writer w a -> (a, w)
runWriter forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => TrackedErrorsT m a -> m a
getCompilerSuccessT TrackedErrorsT (Writer [Char]) a
y
       if (a, [Char])
y' forall a. Eq a => a -> a -> Bool
== (a, [Char])
x
          then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ()
          else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM forall a b. (a -> b) -> a -> b
$ [Char]
"Expected value " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show (a, [Char])
x forall a. [a] -> [a] -> [a]
++ [Char]
" but got value " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show (a, [Char])
y'

checkWriterFail :: (Eq a, Show a) => (String,String) -> TrackedErrorsT (Writer String) a -> IO (TrackedErrors ())
checkWriterFail :: forall a.
(Eq a, Show a) =>
([Char], [Char])
-> TrackedErrorsT (Writer [Char]) a -> IO (TrackedErrors ())
checkWriterFail ([Char], [Char])
x TrackedErrorsT (Writer [Char]) a
y = do
  let (Bool
failed,[Char]
_) = forall w a. Writer w a -> (a, w)
runWriter forall a b. (a -> b) -> a -> b
$ forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(ErrorContextT t, Monad m, ErrorContextM (t m)) =>
t m a -> m Bool
isCompilerErrorT TrackedErrorsT (Writer [Char]) a
y
  if Bool
failed
     then do
       let y' :: ([Char], [Char])
y' = forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first forall a. Show a => a -> [Char]
show forall a b. (a -> b) -> a -> b
$ forall w a. Writer w a -> (a, w)
runWriter forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m CompilerMessage
getCompilerErrorT TrackedErrorsT (Writer [Char]) a
y
       if ([Char], [Char])
y' forall a. Eq a => a -> a -> Bool
== ([Char], [Char])
x
          then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ()
          else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM forall a b. (a -> b) -> a -> b
$ [Char]
"Expected error " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show ([Char], [Char])
x forall a. [a] -> [a] -> [a]
++ [Char]
" but got error " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show ([Char], [Char])
y'
     else do
       let y' :: (a, [Char])
y' = forall w a. Writer w a -> (a, w)
runWriter forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => TrackedErrorsT m a -> m a
getCompilerSuccessT TrackedErrorsT (Writer [Char]) a
y
       forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM forall a b. (a -> b) -> a -> b
$ [Char]
"Expected failure but got value " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show (a, [Char])
y'

checkSuccess :: (Eq a, Show a) => a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess :: forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess a
x TrackedErrorsIO a
y = do
  TrackedErrors a
y' <- forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors TrackedErrorsIO a
y
  if forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrors a
y' Bool -> Bool -> Bool
|| forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrors a
y' forall a. Eq a => a -> a -> Bool
== a
x
     then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ TrackedErrors a
y' forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM forall a b. (a -> b) -> a -> b
$ [Char]
"Expected value " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show a
x forall a. [a] -> [a] -> [a]
++ [Char]
" but got value " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show (forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrors a
y')

checkError :: (Eq a, Show a) => String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError :: forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
e TrackedErrorsIO a
y = do
  TrackedErrors a
y' <- forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors TrackedErrorsIO a
y
  if Bool -> Bool
not (forall (t :: (* -> *) -> * -> *) a.
(ErrorContextT t, ErrorContextM (t Identity)) =>
t Identity a -> Bool
isCompilerError TrackedErrors a
y')
     then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM forall a b. (a -> b) -> a -> b
$ [Char]
"Expected error \"" forall a. [a] -> [a] -> [a]
++ [Char]
e forall a. [a] -> [a] -> [a]
++ [Char]
"\" but got value " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show (forall a. TrackedErrors a -> a
getCompilerSuccess TrackedErrors a
y')
     else if forall a. Show a => a -> [Char]
show (forall a. TrackedErrors a -> CompilerMessage
getCompilerError TrackedErrors a
y') forall a. Eq a => a -> a -> Bool
== [Char]
e
          then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ()
          else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM forall a b. (a -> b) -> a -> b
$ [Char]
"Expected error \"" forall a. [a] -> [a] -> [a]
++ [Char]
e forall a. [a] -> [a] -> [a]
++ [Char]
"\" but got error \"" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show (forall a. TrackedErrors a -> CompilerMessage
getCompilerError TrackedErrors a
y') forall a. [a] -> [a] -> [a]
++ [Char]
"\""

checkSuccessAndWarnings :: (Eq a, Show a) => String -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings :: forall a.
(Eq a, Show a) =>
[Char] -> a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccessAndWarnings [Char]
w a
x TrackedErrorsIO a
y = do
  TrackedErrors a
y' <- forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors TrackedErrorsIO a
y
  TrackedErrors ()
outcome <- forall a.
(Eq a, Show a) =>
a -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkSuccess a
x TrackedErrorsIO a
y
  if forall a. Show a => a -> [Char]
show (forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrors a
y') forall a. Eq a => a -> a -> Bool
== [Char]
w
     then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ TrackedErrors ()
outcome forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM forall a b. (a -> b) -> a -> b
$ [Char]
"Expected warnings " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show [Char]
w forall a. [a] -> [a] -> [a]
++ [Char]
" but got warnings \"" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show (forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrors a
y') forall a. [a] -> [a] -> [a]
++ [Char]
"\""

checkErrorAndWarnings :: (Eq a, Show a) => String -> String -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings :: forall a.
(Eq a, Show a) =>
[Char] -> [Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkErrorAndWarnings [Char]
w [Char]
e TrackedErrorsIO a
y = do
  TrackedErrors a
y' <- forall (m :: * -> *) a.
Monad m =>
TrackedErrorsT m a -> m (TrackedErrors a)
toTrackedErrors TrackedErrorsIO a
y
  TrackedErrors ()
outcome <- forall a.
(Eq a, Show a) =>
[Char] -> TrackedErrorsIO a -> IO (TrackedErrors ())
checkError [Char]
e TrackedErrorsIO a
y
  if forall a. Show a => a -> [Char]
show (forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrors a
y') forall a. Eq a => a -> a -> Bool
== [Char]
w
     then forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ TrackedErrors ()
outcome forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()
     else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. ErrorContextM m => [Char] -> m a
compilerErrorM forall a b. (a -> b) -> a -> b
$ [Char]
"Expected warnings " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show [Char]
w forall a. [a] -> [a] -> [a]
++ [Char]
" but got warnings \"" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show (forall a. TrackedErrors a -> CompilerMessage
getCompilerWarnings TrackedErrors a
y') forall a. [a] -> [a] -> [a]
++ [Char]
"\""