content: {-# Language LambdaCase #-}
  {-# Language NamedFieldPuns #-}
  {-# Language OverloadedStrings #-}
  {-# Language PatternSynonyms #-}
  {-# Language RecordWildCards #-}
  {-# Language ViewPatterns #-}
  
  import Restless.Git
  
  import Test.Tasty
  import Test.Tasty.HUnit
  
  import Data.ByteString        (ByteString)
  import Data.Set               (toList)
  import System.IO.Temp         (withSystemTempDirectory)
  import Text.Read              (readMaybe)
  
  import qualified Data.ByteString.Char8  as C8
  import qualified Data.Set               as Set
  
  main :: IO ()
  main = defaultMain tests
  
  tests :: TestTree
  tests = testGroup "roundtrip"
    [ testCase "simple example" roundtripExample ]
  
  data Example = Example
    { foo :: Int
    , bar :: Int
    } deriving (Eq, Show)
  
  readBytesMaybe :: Read a => ByteString -> Maybe a
  readBytesMaybe = readMaybe . C8.unpack
  
  pattern Reads :: Read a => a -> ByteString
  pattern Reads x <- (readBytesMaybe -> Just x)
  
  class Filing a where
    fromFiles :: [File] -> a
    toFiles   :: a -> [File]
  
  instance Filing Example where
    fromFiles = foldl f (Example 0 0)
      where
        f :: Example -> File -> Example
        f x = \case
          File (Path ["example", "foo"] "x") (Reads foo) ->
            x { foo }
          File (Path ["example", "bar"] "x") (Reads bar) ->
            x { bar }
          _ ->
            x
    toFiles Example {..} =
      [ File (Path ["example", "foo"] "x") (C8.pack (show foo))
      , File (Path ["example", "bar"] "x") (C8.pack (show bar))
      ]
  
  roundtripExample :: Assertion
  roundtripExample = do
    let x = Example 5 7
    y <- withSystemTempDirectory "restless-git-test" $ \path -> do
      make path
      save path "hello" (Set.fromList (toFiles x))
      (fromFiles . toList) <$> load path
    assertEqual "roundtrip failed" x y
  