content: {-# LANGUAGE OverloadedStrings   #-}
  {-# LANGUAGE QuasiQuotes         #-}
  {-# LANGUAGE ScopedTypeVariables #-}
  
  module Test.Prelude.Bool (tests) where
  
  
  
  import Data.Bool
  
  import           Stg.Marshal
  import           Stg.Parser.QuasiQuoter
  import qualified Stg.Prelude            as Stg
  
  import Test.Machine.Evaluate.TestTemplates.MarshalledValue
  import Test.Orphans                                        ()
  import Test.Tasty
  
  
  
  tests :: TestTree
  tests = testGroup "Bool"
      [ testAnd2
      , testOr2
      , testNot
      , testBool ]
  
  testAnd2 :: TestTree
  testAnd2 = marshalledValueTest defSpec
      { testName = "and2 (&&)"
      , sourceSpec = \(b1, b2) -> MarshalSourceSpec
          { resultVar = "main"
          , expectedValue = b1 && b2
          , source = mconcat
              [ toStg "b1" b1
              , toStg "b2" b2
              , Stg.and2
              , [stg| main = \ => and2 b1 b2 |] ]}}
  
  testOr2 :: TestTree
  testOr2 = marshalledValueTest defSpec
      { testName = "or2 (||)"
      , sourceSpec = \(b1, b2) -> MarshalSourceSpec
          { resultVar = "main"
          , expectedValue = b1 || b2
          , source = mconcat
              [ toStg "b1" b1
              , toStg "b2" b2
              , Stg.or2
              , [stg| main = \ => or2 b1 b2 |] ]}}
  
  testNot :: TestTree
  testNot = marshalledValueTest defSpec
      { testName = "not"
      , sourceSpec = \b -> MarshalSourceSpec
          { resultVar = "main"
          , expectedValue = not b
          , source = mconcat
              [ toStg "b" b
              , Stg.not
              , [stg| main = \ => not b |] ]}}
  
  testBool :: TestTree
  testBool = marshalledValueTest defSpec
      { testName = "bool"
      , maxSteps = 1024
      , failPredicate = const False
      , sourceSpec = \(t :: Integer, f, p) -> MarshalSourceSpec
          { resultVar = "main"
          , expectedValue = bool t f p
          , source = mconcat
              [ toStg "p" p
              , toStg "t" t
              , toStg "f" f
              , Stg.bool
              , [stg| main = \ => bool t f p |] ]}}
  