phi

 
module Test.Data.Array where


import Test.QuickCheck (TestGroup(..), TestResult, quickCheck)
import Prelude
import Data.Array as A

propArrayFt :: [Integer] -> Boolean
propArrayFt xs = A.toList (A.fromList xs) == xs

baseArray :: A.Array Integer
baseArray = A.fromList [1,3,4,5]

propArrayToList :: A.Array Int -> Bool
propArrayToList arr = (A.fromList $ A.toList arr) == arr

propListToArray :: [Int] -> Bool
propListToArray xs =(A.toList $ A.fromList xs) == xs

propRelax :: A.Array Int->Bool
propRelax arr = (A.isFix $ A.relax arr) == false

propFix :: A.Array Int->Bool
propFix arr = (A.isFix $ A.fix arr) == true

propFoldl :: String -> Bool
propFoldl s = (foldl (\b a -> [a|b]) [] $ A.fromList  s ) == reverse  s

propFoldr :: String -> Bool
propFoldr s = (foldr (\a b -> [a|b]) [] $ A.fromList  s ) == s

propResize :: Int->A.Array Int->Bool
propResize n arr = (A.size $ A.resize n' arr) == n'
   where n' = if n <0 then (-n) else n

propSize :: Int->Int->A.Array Int->Bool
propSize n e arr = (A.size $ (A.set n e arr)) == (A.size arr)

propSet :: Bool
propSet = [1,0,3,4] == A.toList(A.set 1 0 baseArray)

plus :: Int->Int->Int->Int
plus _ a b = a + b

propMonad :: Bool
propMonad = 
  (A.fromList [1, 3, 4, 5] >>= (\x -> A.fromList [x, x + 2])) == 
  A.fromList [1, 3, 3, 5, 4, 6, 5, 7]

test :: TestGroup (Integer -> IO TestResult)
test = Exe [ quickCheck "fromList_toList "  propArrayFt
           , quickCheck "fromList"  (A.toList baseArray == [1,3,4,5])
           , quickCheck "get"  (A.get 0 baseArray == 1)
           , quickCheck "set"  (A.set 0 10 baseArray == A.fromList [10,3,4,5])
           , quickCheck "foldl" propFoldl
           , quickCheck "foldr" propFoldr
           , quickCheck "size"  (A.size baseArray == 4)
           , quickCheck "Array to List" (propArrayToList)
           , quickCheck "List to Array" (propListToArray)
           , quickCheck "relax" propRelax
           , quickCheck "fix" propFix
           , quickCheck "Resize" propResize
           , quickCheck "foldl" ((A.sparseFoldl plus 0 baseArray) == 13)
           , quickCheck "foldr" ((A.sparseFoldr plus 0 baseArray) == 13)
           , quickCheck "map" (A.sparseMap (\_ x -> x + 1) baseArray == (A.fromList [2,4,5,6]))
           , quickCheck "default" (A.default  (A.new [A.Size 10, A.Default 1]) == 1)
           , quickCheck "Monad"  propMonad
           ]