content: {-# LANGUAGE OverloadedStrings   #-}
  {-# LANGUAGE QuasiQuotes         #-}
  {-# LANGUAGE RankNTypes          #-}
  {-# LANGUAGE ScopedTypeVariables #-}
  
  module Test.Prelude.Tuple (tests) where
  
  
  
  import qualified Data.Tuple as T
  
  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 "Tuple"
      [ testFst
      , testSnd
      , testCurry
      , testUncurry
      , testSwap
      ]
  
  testFst :: TestTree
  testFst = marshalledValueTest defSpec
      { testName = "fst"
      , sourceSpec = \(tuple :: (Integer, Integer)) -> MarshalSourceSpec
          { resultVar = "main"
          , expectedValue = fst tuple
          , source = mconcat
              [ toStg "tuple" tuple
              , Stg.fst
              , [stg| main = \ => fst tuple |] ]}}
  
  testSnd :: TestTree
  testSnd = marshalledValueTest defSpec
      { testName = "snd"
      , sourceSpec = \(tuple :: (Integer, Integer)) -> MarshalSourceSpec
          { resultVar = "main"
          , expectedValue = snd tuple
          , source = mconcat
              [ toStg "tuple" tuple
              , Stg.snd
              , [stg| main = \ => snd tuple |] ]}}
  
  testCurry :: TestTree
  testCurry = marshalledValueTest defSpec
      { testName = "curry"
      , sourceSpec = \(x,y :: Integer) -> MarshalSourceSpec
          { resultVar = "main"
          , expectedValue = x+y
          , source = mconcat
              [ toStg "x" x
              , toStg "y" y
              , Stg.curry
              , Stg.add
              , [stg|
              addPair = \tuple -> case tuple of
                  Pair a b -> add a b;
                  badPair  -> Error_addPair badTuple;
  
              main = \ => curry addPair x y
              |] ]}}
  
  testUncurry :: TestTree
  testUncurry = marshalledValueTest defSpec
      { testName = "uncurry"
      , sourceSpec = \(tuple :: (Integer, Integer)) -> MarshalSourceSpec
          { resultVar = "main"
          , expectedValue = uncurry (+) tuple
          , source = mconcat
              [ toStg "tuple" tuple
              , Stg.uncurry
              , Stg.add
              , [stg| main = \ => uncurry add tuple |] ]}}
  
  testSwap :: TestTree
  testSwap = marshalledValueTest defSpec
      { testName = "swap"
      , sourceSpec = \(tuple :: (Integer, Integer)) -> MarshalSourceSpec
          { resultVar = "main"
          , expectedValue = T.swap tuple
          , source = mconcat
              [ toStg "tuple" tuple
              , Stg.swap
              , Stg.equals_Pair_Int
              , [stg| main = \ => swap tuple |] ]}}
  