-- | Tests for dynamic int vectors

{-# LANGUAGE CPP,BangPatterns #-}
module Tests.IntVec where

--------------------------------------------------------------------------------

import Data.Int
import Data.List as L

import Data.Vector.Compact.IntVec as V

import Test.Tasty
import Test.Tasty.HUnit

#ifdef x86_64_HOST_ARCH
arch_bits = 64 
#elif i386_HOST_ARCH
arch_bits = 32
#else
arch_bits = 32
#endif

--------------------------------------------------------------------------------

all_tests = testGroup "unit tests for IntVec-s"
  [ tests_small
  , tests_bighead
  ]

tests_small = testGroup "unit tests for small dynamic int vectors"
  [ testCase "toList . fromList == id"    $ forall_ small_Lists   prop_from_to_list
  , testCase "fromList . toList == id"    $ forall_ small_Vecs    prop_to_from_vec
  , testCase "fromList vs. indexing"      $ forall_ small_Lists   prop_fromlist_vs_index
  , testCase "vec head vs. list head"     $ forall_ small_NELists prop_head_of_list
  , testCase "head vs. indexing"          $ forall_ small_NEVecs  prop_head_vs_index
  ]

tests_bighead = testGroup "unit tests for small dynamic int vectors with big heads"
  [ testCase "toList . fromList == id"    $ forall_ bighead_Lists   prop_from_to_list
  , testCase "fromList . toList == id"    $ forall_ bighead_Vecs    prop_to_from_vec
  , testCase "fromList vs. indexing"      $ forall_ bighead_Lists   prop_fromlist_vs_index
  , testCase "vec head vs. list head"     $ forall_ bighead_NELists prop_head_of_list
  , testCase "head vs. indexing"          $ forall_ bighead_NEVecs  prop_head_vs_index
  ]

forall_ :: [a] -> (a -> Bool) -> Assertion
forall_ xs cond = assertBool "failed" (and (map cond xs))

--------------------------------------------------------------------------------
-- * inputs
newtype List   = List   [Int]  deriving Show
newtype NEList = NEList [Int]  deriving Show

newtype Vec   = Vec   IntVec  deriving Show
newtype NEVec = NEVec IntVec  deriving Show

small_Lists :: [List]
small_Lists = List [] : [ List xs | NEList xs <- small_NELists ]

small_NELists :: [NEList]
small_NELists = [ NEList [ofs..ofs+len-1] | ofs<-[-25..25] , len<-[1..65] ]

small_Vecs :: [Vec]
small_Vecs = [ Vec (V.fromList xs) | List xs <- small_Lists ]

small_NEVecs :: [NEVec]
small_NEVecs = [ NEVec (V.fromList xs) | NEList xs <- small_NELists ]

--------------------------------------------------------------------------------

add_bighead :: List -> [List]
add_bighead (List xs) = 
  [ List (-2^k-1 : xs) | k<-[1..arch_bits-1] ] ++
  [ List (-2^k   : xs) | k<-[1..arch_bits-1] ] ++
  [ List (-2^k+1 : xs) | k<-[1..arch_bits-1] ] ++ 
  [ List ( 2^k-1 : xs) | k<-[1..arch_bits-1] ] ++
  [ List ( 2^k   : xs) | k<-[1..arch_bits-1] ] ++
  [ List ( 2^k+1 : xs) | k<-[1..arch_bits-1] ]
                                                       
bighead_Lists = concatMap add_bighead small_Lists                   :: [List]
bighead_Vecs  = [ Vec (V.fromList xs) | List xs <- bighead_Lists ]  :: [Vec]
bighead_NELists = [ NEList xs | List xs <- bighead_Lists ] :: [NEList]
bighead_NEVecs  = [ NEVec  v  | Vec  v  <- bighead_Vecs  ] :: [NEVec]

--------------------------------------------------------------------------------
-- * properties

prop_from_to_list (List list) = V.toList (V.fromList list) == list
prop_to_from_vec  (Vec  vec ) = V.fromList (V.toList vec ) == vec

prop_fromlist_vs_index (List list) = [ unsafeIndex i vec | i<-[0..n-1] ] == list where 
  vec = V.fromList list
  n   = V.vecLen   vec

prop_head_of_list  (NEList list) = V.head (V.fromList list) == L.head list
prop_head_vs_index (NEVec  vec ) = V.head vec == unsafeIndex 0 vec

--------------------------------------------------------------------------------