module Main where
import Prelude hiding (first, second)
import Control.Arrow
import Test.Tasty
import Test.Tasty.Runners
import Test.Tasty.HUnit
import Test.Tasty.QuickCheck
-- import Test.QuickCheck.Instances
import Test.QuickCheck.Instances.Time
import qualified ExpiringContainers.ExpiringSet as A
import qualified ExpiringContainers.ExpiringMap as B
import qualified Data.List as C
import Data.Maybe
import Data.Time
import Data.Foldable as F
import qualified Data.Set as D
import qualified Data.HashMap.Strict as E
import Timestamp
main =
defaultMain $
testGroup "All tests" $
[
expiringSet
,
expiringMap
]
expiringSet =
testGroup "Expiring Set" $
[
testProperty "list to list" $ \ (list :: [(UTCTime, Int)]) ->
(D.fromList $ C.nubBy (\(t1,v1) (t2,v2) -> v1 == v2) $ C.reverse $ map (\(t,a) -> (,) (timestampUtcTime $ utcTimeTimestamp t) a) list) ===
(D.fromList $ A.toList $ A.fromList list)
,
testProperty "delete" $ \ (list :: [(UTCTime, Int)], key :: UTCTime, value :: Int) ->
let list2 = C.nubBy (\(t1,k1) (t2,k2) -> k1 == k2) list
in (D.fromList $ fmap (\(t,a) -> (,) (timestampUtcTime $ utcTimeTimestamp t) a) $
C.deleteBy (\(_,v1) (_,v2) -> v1 == v2) (key, value) list2) ===
(D.fromList $ A.toList $ A.delete value $ A.fromList list2)
,
testProperty "insert and insert" $ \ (list :: [(UTCTime, Int)], key1 :: UTCTime, value1 :: Int, key2 :: UTCTime, value2 :: Int) ->
let set = A.fromList list
in if key1 == key2 || value1 == value2
then (A.insert key1 value1 $ A.insert key1 value2 set) === (A.insert key1 value1 set)
else (A.insert key1 value1 $ A.insert key2 value2 set) === (A.insert key2 value2 $ A.insert key1 value1 set)
,
testProperty "delete ans insert" $ \ (list :: [(UTCTime, Int)], key :: UTCTime, value1 :: Int, value2 :: Int) ->
let set = A.fromList list
in if value1 == value2
then (A.delete value1 $ A.insert key value1 set) === (A.delete value1 set)
else (A.delete value1 $ A.insert key value2 set) === (A.insert key value2 $ A.delete value1 set)
,
testProperty "member and insert" $ \ (list :: [(UTCTime, Int)], key :: UTCTime, value1 :: Int, value2 :: Int) ->
let set = A.fromList list
in if value1 == value2
then (A.member value1 $ A.insert key value1 set) === True
else (A.member value1 $ A.insert key value2 set) === (A.member value1 set)
,
testProperty "member and delete" $ \ (list :: [(UTCTime, Int)], value1 :: Int, value2 :: Int) ->
let set = A.fromList list
in if value1 == value2
then (A.member value1 $ A.delete value1 set) === False
else (A.member value1 $ A.delete value2 set) === (A.member value1 set)
,
testProperty "map" $ \ (list :: [(UTCTime, Int)], value1 :: Int, value2 :: Int) ->
let set = A.fromList list
in A.map id set === id set
,
testProperty "map insert" $ \ (list :: [(UTCTime, Int)], key :: UTCTime, value1 :: Int, fun :: (Fun Int Char)) ->
let set = A.fromList list
f = applyFun fun
in A.map f (A.insert key value1 set) === A.insert key (f value1) (A.map f set)
,
-- testProperty "map delete" $ \ (list :: [(UTCTime, Int)], key :: UTCTime, value1 :: Int, fun :: (Fun Int Char)) ->
-- let set = A.fromList list
-- f = applyFun fun
-- in A.map f (A.delete value1 set) === A.delete (f value1) (A.map f set)
-- ,
-- testProperty "clean" $ \ (list :: [(UTCTime, Int)], key :: UTCTime) ->
-- let (list1, expire) = A.clean key $ A.fromList list
-- in (D.fromList $ fmap (\(t,a) -> a) $ C.filter (\(t,a) -> t < key) list) === (D.fromList list1)
-- ,
-- testProperty "mapping" $ \ (list :: [(UTCTime, Int)]) ->
-- (D.fromList $ map (testFuncL . (\(t,a) -> (,) (timestampUtcTime $ utcTimeTimestamp t) a)) list) ===
-- (D.fromList $ A.toList $ A.map testFunc $ A.fromList list)
-- ,
testProperty "member" $ \ (list :: [(UTCTime, Int)], key :: UTCTime, value :: Int) ->
(A.member value $ A.delete value $ A.insert key value $ A.fromList list) === False
,
testProperty "lookup not found" $ \ (list :: [(UTCTime, Int)], key :: UTCTime, value :: Int) ->
(A.lookup value $ A.delete value $ A.insert key value $ A.fromList list) === Nothing
,
testProperty "lookup found" $ \ (list :: [(UTCTime, Int)], key :: UTCTime, value :: Int) ->
(A.lookup value $ A.insertForce key value $ A.fromList list) === (Just $ timestampUtcTime $ utcTimeTimestamp key)
]
expiringMap =
testGroup "Expiring Map" $
[
testProperty "list to list" $ \ (list :: [(UTCTime, Int, Int)]) ->
let list2 = C.nubBy (\(t1,k1,v1) (t2,k2,v2) -> k1 == k2) list
in (D.fromList $ fmap (\(t,a,b) -> (,,) (timestampUtcTime $ utcTimeTimestamp t) a b) list2) ===
(D.fromList $ B.toList $ B.fromList list2)
,
testProperty "delete" $ \ (list :: [(UTCTime, Int, Int)], time :: UTCTime, key :: Int, value :: Int) ->
let list2 = C.nubBy (\(t1,k1,v1) (t2,k2,v2) -> k1 == k2) list
in (D.fromList $
fmap (\(t,a,b) -> (,,) (timestampUtcTime $ utcTimeTimestamp t) a b) $
C.deleteBy (\(t1,k1,v1) (t2,k2,v2) -> k1 == k2) (time, key, value) list2) ===
(D.fromList $ B.toList $ B.delete key $ B.fromList list2)
,
testProperty "insert and insert" $ \ (list :: [(UTCTime, Int, Int)], time1 :: UTCTime, key1 :: Int, value1 :: Int, time2 :: UTCTime, key2 :: Int, value2 :: Int) ->
let map' = B.fromList list
in if time1 == time2 || key1 == key2
then (B.insert time1 key1 value1 $ B.insert time1 key1 value2 map') === (B.insert time1 key1 value1 map')
else (B.insert time1 key1 value1 $ B.insert time2 key2 value2 map') === (B.insert time2 key2 value2 $ B.insert time1 key1 value1 map')
,
testProperty "delete and insert" $ \ (list :: [(UTCTime, Int, Int)], time :: UTCTime, key1 :: Int, key2 :: Int, value :: Int) ->
let map' = B.fromList list
in if key1 == key2
then (B.delete key1 $ B.insert time key1 value map') === (B.delete key1 map')
else (B.delete key1 $ B.insert time key2 value map') === (B.insert time key2 value $ B.delete key1 map')
,
testProperty "member and insert" $ \ (list :: [(UTCTime, Int, Int)], time :: UTCTime, key1 :: Int, key2 :: Int, value :: Int) ->
let map' = B.fromList list
in if key1 == key2
then (B.member key1 $ B.insert time key1 value map') === True
else (B.member key1 $ B.insert time key2 value map') === (B.member key1 map')
,
testProperty "member and delete" $ \ (list :: [(UTCTime, Int, Int)], key1 :: Int, key2 :: Int) ->
let map' = B.fromList list
in if key1 == key2
then (B.member key1 $ B.delete key1 map') === False
else (B.member key1 $ B.delete key2 map') === (B.member key1 map')
,
testProperty "member and insert" $ \ (list :: [(UTCTime, Int, Int)], time :: UTCTime, key1 :: Int, key2 :: Int, value :: Int) ->
let map' = B.fromList list
in if key1 == key2
then (B.lookup key1 $ B.insert time key1 value map') === Just value
else (B.lookup key1 $ B.insert time key2 value map') === (B.lookup key1 map')
,
testProperty "lookup and delete" $ \ (list :: [(UTCTime, Int, Int)], key1 :: Int, key2 :: Int) ->
let map' = B.fromList list
in if key1 == key2
then (B.lookup key1 $ B.delete key1 map') === Nothing
else (B.lookup key1 $ B.delete key2 map') === (B.lookup key1 map')
,
testProperty "map" $ \ (list :: [(UTCTime, Int, Int)], value1 :: Int, value2 :: Int) ->
let map' = B.fromList list
in B.map id map' === id map'
,
testProperty "map insert" $ \ (list :: [(UTCTime, Int, Int)], time :: UTCTime, key :: Int, value1 :: Int, fun :: (Fun Int Char)) ->
let map' = B.fromList list
f = applyFun fun
in B.map f (B.insert time key value1 map') === B.insert time key (f value1) (B.map f map')
,
testProperty "map delete" $ \ (list :: [(UTCTime, Int, Int)], time :: UTCTime, key :: Int, value1 :: Int, fun :: (Fun Int Char)) ->
let map' = B.fromList list
f = applyFun fun
in B.map f (B.delete key map') === B.delete key (B.map f map')
,
testProperty "map lookup" $ \ (list :: [(UTCTime, Int, Int)], time :: UTCTime, key :: Int, value1 :: Int, fun :: (Fun Int Char)) ->
let map' = B.fromList list
f = applyFun fun
in fmap f (B.lookup key map') === B.lookup key (B.map f map')
,
-- testProperty "map" $ \ (list :: [(UTCTime, Int, Int)], time :: UTCTime, key :: Int, value :: Int) ->
-- let map' = B.fromList list
-- in fmap (\x -> B.insert time key value map') (B.lookup key map') === (map' <$ (B.lookup key map'))
-- ,
-- testProperty "clean" $ \ (list :: [(UTCTime, Int)], key :: UTCTime) ->
-- let (list1, expire) = A.clean key $ A.fromList list
-- in (D.fromList $ fmap (\(t,a) -> a) $ C.filter (\(t,a) -> t < key) list) === (D.fromList list1)
-- ,
testProperty "member" $ \ (list :: [(UTCTime, Int, Int)], time :: UTCTime, key :: Int, value :: Int) ->
(B.member key $ B.delete key $ B.insert time key value $ B.fromList list) === False
-- ,
-- testProperty "insert and delete" $ \ (list :: [(UTCTime, Int, Int)], time :: UTCTime, key :: Int, value :: Int) ->
-- let list2 = C.nubBy (\(t1,k1,v1) (t2,k2,v2) -> k1 == k2) list
-- in (D.fromList $ fmap (\(t,a,b) -> (,,) (timestampUtcTime $ utcTimeTimestamp t) a b) $
-- C.deleteBy (\(t1,k1,v1) (t2,k2,v2) -> k1 == k2) (time, key, value) list2) === (D.fromList $ B.toList $ B.delete key $ B.insert time key value $ B.fromList list)
]
testFunc :: (Show a) => a -> String
testFunc = show
testFuncL :: (Show a) => (UTCTime, a) -> (UTCTime, String)
testFuncL (a, b) = (a, show b)