{-# LANGUAGE TemplateHaskell   #-}
{-# LANGUAGE TupleSections     #-}
{-# LANGUAGE TypeApplications  #-}

module Tests.IntMap (intMapTests) where

import           Control.Applicative
import           Data.Coerce
import           Data.Foldable
import           Data.Functor.Identity
import           Data.List.NonEmpty            (NonEmpty(..))
import           Data.Semigroup.Foldable
import           Data.Text                     (Text)
import           Hedgehog
import           Test.Tasty
import           Tests.Util
import qualified Data.IntMap                   as M
import qualified Data.IntMap.NonEmpty          as NEM
import qualified Data.IntMap.NonEmpty.Internal as NEM
import qualified Data.List.NonEmpty            as NE
import qualified Hedgehog.Gen                  as Gen
import qualified Hedgehog.Range                as Range

intMapTests :: TestTree
intMapTests = groupTree $$(discover)





prop_valid :: Property
prop_valid = property $
    assert . NEM.valid =<< forAll neIntMapGen

-- | We cannot implement these because there is no 'valid' for IntSet
-- prop_valid_toMap :: Property
-- prop_valid_toMap = property $
--     assert . M.valid . NEM.toMap =<< forAll neIntMapGen

-- prop_valid_insertMinIntMap :: Property
-- prop_valid_insertMinIntMap = property $ do
--     n  <- forAll $ do
--         m <- intMapGen
--         let k = maybe 0 (subtract 1 . fst) $ M.lookupMin m
--         v <- valGen
--         pure $ NEM.insertMinIntMap k v m
--     assert $ M.valid n

-- prop_valid_insertMaxIntMap :: Property
-- prop_valid_insertMaxIntMap = property $ do
--     n  <- forAll $ do
--         m <- intMapGen
--         let k = maybe 0 ((+ 1) . fst) $ M.lookupMax m
--         v <- valGen
--         pure $ NEM.insertMaxIntMap k v m
--     assert $ M.valid n

prop_valid_insertMapMin :: Property
prop_valid_insertMapMin = property $ do
    n  <- forAll $ do
        m <- intMapGen
        let k = maybe 0 (subtract 1 . fst) $ NEM.lookupMinMap m
        v <- valGen
        pure $ NEM.insertMapMin k v m
    assert $ NEM.valid n

prop_valid_insertMapMax :: Property
prop_valid_insertMapMax = property $ do
    n  <- forAll $ do
        m <- intMapGen
        let k = maybe 0 ((+ 1) . fst) $ NEM.lookupMaxMap m
        v <- valGen
        pure $ NEM.insertMapMax k v m
    assert $ NEM.valid n

prop_toMapIso1 :: Property
prop_toMapIso1 = property $ do
    m0 <- forAll intMapGen
    tripping m0 (NEM.nonEmptyMap)
                (Identity . maybe M.empty NEM.toMap)

prop_toMapIso2 :: Property
prop_toMapIso2 = property $ do
    m0 <- forAll $ Gen.maybe neIntMapGen
    tripping m0 (maybe M.empty NEM.toMap)
                (Identity . NEM.nonEmptyMap)

prop_read_show :: Property
prop_read_show = readShow neIntMapGen

prop_read1_show1 :: Property
prop_read1_show1 = readShow1 neIntMapGen

prop_show_show1 :: Property
prop_show_show1 = showShow1 neIntMapGen

prop_splitRoot :: Property
prop_splitRoot = property $ do
    n <- forAll neIntMapGen
    let rs = NEM.splitRoot n
        allItems = foldMap1 NEM.keys rs
        n' = NEM.unions rs
    assert $ ascending allItems
    mapM_ (assert . (`NEM.isSubmapOf` n)) rs
    length allItems === length n'
    n === n'
  where
    ascending (x :| xs) = case NE.nonEmpty xs of
      Nothing          -> True
      Just ys@(y :| _) -> x < y && ascending ys







prop_insertMapWithKey :: Property
prop_insertMapWithKey = ttProp (gf3 valGen :?> GTIntKey :-> GTVal :-> GTIntMap :-> TTNEIntMap)
    M.insertWithKey
    NEM.insertMapWithKey

prop_singleton :: Property
prop_singleton = ttProp (GTIntKey :-> GTVal :-> TTNEIntMap)
    M.singleton
    NEM.singleton

prop_fromSet :: Property
prop_fromSet = ttProp (gf1 valGen :?> GTNEIntSet :-> TTNEIntMap)
    M.fromSet
    NEM.fromSet

prop_fromAscList :: Property
prop_fromAscList = ttProp (GTSorted STAsc (GTNEList Nothing (GTIntKey :&: GTVal)) :-> TTNEIntMap)
    M.fromAscList
    NEM.fromAscList

prop_fromAscListWithKey :: Property
prop_fromAscListWithKey = ttProp (gf3 valGen :?> GTSorted STAsc (GTNEList Nothing (GTIntKey :&: GTVal)) :-> TTNEIntMap)
    M.fromAscListWithKey
    NEM.fromAscListWithKey

prop_fromDistinctAscList :: Property
prop_fromDistinctAscList = ttProp (GTSorted STDistinctAsc (GTNEList Nothing (GTIntKey :&: GTVal)) :-> TTNEIntMap)
    M.fromDistinctAscList
    NEM.fromDistinctAscList

prop_fromListWithKey :: Property
prop_fromListWithKey = ttProp (gf3 valGen :?> GTNEList Nothing (GTIntKey :&: GTVal) :-> TTNEIntMap)
    M.fromListWithKey
    NEM.fromListWithKey

prop_insert :: Property
prop_insert = ttProp (GTIntKey :-> GTVal :-> GTNEIntMap :-> TTNEIntMap)
    M.insert
    NEM.insert

prop_insertWithKey :: Property
prop_insertWithKey = ttProp (gf3 valGen :?> GTIntKey :-> GTVal :-> GTNEIntMap :-> TTNEIntMap)
    M.insertWithKey
    NEM.insertWithKey

prop_delete :: Property
prop_delete = ttProp (GTIntKey :-> GTNEIntMap :-> TTOther)
    M.delete
    NEM.delete

prop_adjustWithKey :: Property
prop_adjustWithKey = ttProp (gf2 valGen :?> GTIntKey :-> GTNEIntMap :-> TTNEIntMap)
    M.adjustWithKey
    NEM.adjustWithKey

prop_updateWithKey :: Property
prop_updateWithKey = ttProp (gf2 (Gen.maybe valGen) :?> GTIntKey :-> GTNEIntMap :-> TTOther)
    M.updateWithKey
    NEM.updateWithKey

prop_updateLookupWithKey :: Property
prop_updateLookupWithKey = ttProp (gf2 (Gen.maybe valGen) :?> GTIntKey :-> GTNEIntMap :-> TTMaybe TTVal :*: TTOther)
    M.updateLookupWithKey
    NEM.updateLookupWithKey

prop_alter :: Property
prop_alter = ttProp (gf1 (Gen.maybe valGen) :?> GTIntKey :-> GTNEIntMap :-> TTOther)
    M.alter
    NEM.alter

prop_alter' :: Property
prop_alter' = ttProp (gf1 valGen :?> GTIntKey :-> GTNEIntMap :-> TTNEIntMap)
    (M.alter . fmap Just)
    NEM.alter'

prop_alterF :: Property
prop_alterF = ttProp ( gf1 (Gen.maybe valGen)
                   :?> GTIntKey
                   :-> GTNEIntMap
                   :-> TTCtx (GTMaybe GTVal :-> TTOther) (TTMaybe TTVal)
                     )
    (M.alterF   . Context)
    (NEM.alterF . Context)

prop_alterF_rules_Const :: Property
prop_alterF_rules_Const = ttProp ( gf1 (Const <$> valGen)
                               :?> GTIntKey
                               :-> GTNEIntMap
                               :-> TTOther
                                 )
    (\f k m -> getConst (M.alterF   f k m))
    (\f k m -> getConst (NEM.alterF f k m))

prop_alterF_rules_Identity :: Property
prop_alterF_rules_Identity = ttProp ( gf1 (Identity <$> Gen.maybe valGen)
                                  :?> GTIntKey
                                  :-> GTNEIntMap
                                  :-> TTOther
                                    )
    (\f k m -> runIdentity (M.alterF   f k m))
    (\f k m -> runIdentity (NEM.alterF f k m))

prop_alterF' :: Property
prop_alterF' = ttProp (gf1 valGen :?> GTIntKey :-> GTNEIntMap :-> TTCtx (GTVal :-> TTNEIntMap) (TTMaybe TTVal))
    (M.alterF    . Context . fmap Just)
    (NEM.alterF' . Context)

prop_alterF'_rules_Const :: Property
prop_alterF'_rules_Const = ttProp ( gf1 (Const <$> valGen)
                                :?> GTIntKey
                                :-> GTNEIntMap
                                :-> TTOther
                                  )
    (\f k m -> let f' = fmap Just . f in getConst (M.alterF    f' k m))
    (\f k m -> getConst (NEM.alterF' f k m))

-- -- | This fails, but isn't possible to fix without copying-and-pasting more
-- -- in code from containers.
-- prop_alterF'_rules_Identity :: Property
-- prop_alterF'_rules_Identity = ttProp ( gf1 (Identity <$> valGen)
--                                    :?> GTIntKey
--                                    :-> GTNEIntMap
--                                    :-> TTNEIntMap
--                                      )
--     (\f k m -> let f' = fmap Just . f in runIdentity (M.alterF   f' k m))
--     (\f k m -> runIdentity (NEM.alterF' f k m))

prop_lookup :: Property
prop_lookup = ttProp (GTIntKey :-> GTNEIntMap :-> TTMaybe TTVal)
    M.lookup
    NEM.lookup

prop_findWithDefault :: Property
prop_findWithDefault = ttProp (GTVal :-> GTIntKey :-> GTNEIntMap :-> TTVal)
    M.findWithDefault
    NEM.findWithDefault

prop_member :: Property
prop_member = ttProp (GTIntKey :-> GTNEIntMap :-> TTOther)
    M.member
    NEM.member

prop_notMember :: Property
prop_notMember = ttProp (GTIntKey :-> GTNEIntMap :-> TTOther)
    M.notMember
    NEM.notMember

prop_lookupLT :: Property
prop_lookupLT = ttProp (GTIntKey :-> GTNEIntMap :-> TTMaybe (TTOther :*: TTVal))
    M.lookupLT
    NEM.lookupLT

prop_lookupGT :: Property
prop_lookupGT = ttProp (GTIntKey :-> GTNEIntMap :-> TTMaybe (TTOther :*: TTVal))
    M.lookupGT
    NEM.lookupGT

prop_lookupLE :: Property
prop_lookupLE = ttProp (GTIntKey :-> GTNEIntMap :-> TTMaybe (TTOther :*: TTVal))
    M.lookupLE
    NEM.lookupLE

prop_lookupGE :: Property
prop_lookupGE = ttProp (GTIntKey :-> GTNEIntMap :-> TTMaybe (TTOther :*: TTVal))
    M.lookupGE
    NEM.lookupGE

prop_size :: Property
prop_size = ttProp (GTNEIntMap :-> TTOther)
    M.size
    NEM.size

prop_union :: Property
prop_union = ttProp (GTNEIntMap :-> GTNEIntMap :-> TTNEIntMap)
    M.union
    NEM.union

prop_unionWith :: Property
prop_unionWith = ttProp (gf2 valGen :?> GTNEIntMap :-> GTNEIntMap :-> TTNEIntMap)
    M.unionWith
    NEM.unionWith

prop_unionWithKey :: Property
prop_unionWithKey = ttProp (gf3 valGen :?> GTNEIntMap :-> GTNEIntMap :-> TTNEIntMap)
    M.unionWithKey
    NEM.unionWithKey

prop_unions :: Property
prop_unions = ttProp (GTNEList (Just (Range.linear 2 5)) GTNEIntMap :-> TTNEIntMap)
    M.unions
    NEM.unions

prop_unionsWith :: Property
prop_unionsWith = ttProp (gf2 valGen :?> GTNEList (Just (Range.linear 2 5)) GTNEIntMap :-> TTNEIntMap)
    M.unionsWith
    NEM.unionsWith

prop_difference :: Property
prop_difference = ttProp (GTNEIntMap :-> GTNEIntMap :-> TTOther)
    M.difference
    NEM.difference

prop_differenceWithKey :: Property
prop_differenceWithKey = ttProp (gf3 (Gen.maybe valGen) :?> GTNEIntMap :-> GTNEIntMap :-> TTOther)
    M.differenceWithKey
    NEM.differenceWithKey

prop_intersection :: Property
prop_intersection = ttProp (GTNEIntMap :-> GTNEIntMap :-> TTOther)
    M.intersection
    NEM.intersection

prop_intersectionWithKey :: Property
prop_intersectionWithKey = ttProp (gf3 valGen :?> GTNEIntMap :-> GTNEIntMap :-> TTOther)
    M.intersectionWithKey
    NEM.intersectionWithKey

prop_map :: Property
prop_map = ttProp (gf1 valGen :?> GTNEIntMap :-> TTNEIntMap)
    M.map
    NEM.map

prop_map_rules_map :: Property
prop_map_rules_map = ttProp (gf1 valGen :?> gf1 valGen :?> GTNEIntMap :-> TTNEIntMap)
    (\f g xs -> M.map   f (M.map   g xs))
    (\f g xs -> NEM.map f (NEM.map g xs))

prop_map_rules_coerce :: Property
prop_map_rules_coerce = ttProp (GTNEIntMap :-> TTNEIntMap)
    (M.map   @Text @Text coerce)
    (NEM.map @Text @Text coerce)

prop_map_rules_mapWithKey :: Property
prop_map_rules_mapWithKey = ttProp (gf1 valGen :?> gf2 valGen :?> GTNEIntMap :-> TTNEIntMap)
    (\f g xs -> M.map f (M.mapWithKey   g xs))
    (\f g xs -> NEM.map f (NEM.mapWithKey g xs))

prop_mapWithKey :: Property
prop_mapWithKey = ttProp (gf2 valGen :?> GTNEIntMap :-> TTNEIntMap)
    M.mapWithKey
    NEM.mapWithKey

prop_mapWithKey_rules_mapWithKey :: Property
prop_mapWithKey_rules_mapWithKey = ttProp (gf2 valGen :?> gf2 valGen :?> GTNEIntMap :-> TTNEIntMap)
    (\f g xs -> M.mapWithKey   f (M.mapWithKey   g xs))
    (\f g xs -> NEM.mapWithKey f (NEM.mapWithKey g xs))

prop_mapWithKey_rules_map :: Property
prop_mapWithKey_rules_map = ttProp (gf2 valGen :?> gf1 valGen :?> GTNEIntMap :-> TTNEIntMap)
    (\f g xs -> M.mapWithKey   f (M.map   g xs))
    (\f g xs -> NEM.mapWithKey f (NEM.map g xs))

-- | These intentionally do not match, because Foldable for IntMap is
-- inconsistent
-- prop_traverseWithKey1 :: Property
-- prop_traverseWithKey1 = ttProp (gf1 valGen :?> GTNEIntMap :-> TTBazaar GTVal TTNEIntMap TTVal)
--     (\f -> M.traverseWithKey    (\k -> (`More` Done (f . (k,)))))
--     (\f -> NEM.traverseWithKey1 (\k -> (`More` Done (f . (k,)))))

-- prop_traverseWithKey :: Property
-- prop_traverseWithKey = ttProp (gf1 valGen :?> GTNEIntMap :-> TTBazaar GTVal TTNEIntMap TTVal)
--     (\f -> M.traverseWithKey   (\k -> (`More` Done (f . (k,)))))
--     (\f -> NEM.traverseWithKey (\k -> (`More` Done (f . (k,)))))

-- prop_sequence1 :: Property
-- prop_sequence1 = ttProp (GTNEIntMap :-> TTBazaar GTVal TTNEIntMap TTVal)
--     (sequenceA . fmap (`More` Done id))
--     (sequence1 . fmap (`More` Done id))

-- prop_sequenceA :: Property
-- prop_sequenceA = ttProp (GTNEIntMap :-> TTBazaar GTVal TTNEIntMap TTVal)
--     (sequenceA . fmap (`More` Done id))
--     (sequenceA . fmap (`More` Done id))

-- prop_mapAccumWithKey :: Property
-- prop_mapAccumWithKey = ttProp  ( gf3 ((,) <$> valGen <*> valGen)
--                              :?> GTOther valGen
--                              :-> GTNEIntMap
--                              :-> TTOther :*: TTNEIntMap
--                                )
--     M.mapAccumWithKey
--     NEM.mapAccumWithKey

-- prop_mapAccumRWithKey :: Property
-- prop_mapAccumRWithKey = ttProp  ( gf3 ((,) <$> valGen <*> valGen)
--                               :?> GTOther valGen
--                               :-> GTNEIntMap
--                               :-> TTOther :*: TTNEIntMap
--                                 )
--     M.mapAccumRWithKey
--     NEM.mapAccumRWithKey

prop_mapKeys :: Property
prop_mapKeys = ttProp (gf1 intKeyGen :?> GTNEIntMap :-> TTNEIntMap)
    M.mapKeys
    NEM.mapKeys

prop_mapKeysWith :: Property
prop_mapKeysWith = ttProp ( gf2 valGen
                        :?> gf1 intKeyGen
                        :?> GTNEIntMap
                        :-> TTNEIntMap
                          )
    M.mapKeysWith
    NEM.mapKeysWith

prop_mapKeysMonotonic :: Property
prop_mapKeysMonotonic = ttProp (GTNEIntMap :-> TTNEIntMap)
    (M.mapKeysMonotonic   (*2))
    (NEM.mapKeysMonotonic (*2))

prop_foldr :: Property
prop_foldr = ttProp ( gf2 valGen
                  :?> GTOther valGen
                  :-> GTNEIntMap
                  :-> TTOther
                    )
    M.foldr
    NEM.foldr

prop_foldl :: Property
prop_foldl = ttProp ( gf2 valGen
                  :?> GTOther valGen
                  :-> GTNEIntMap
                  :-> TTOther
                    )
    M.foldl
    NEM.foldl

prop_foldr1 :: Property
prop_foldr1 = ttProp ( gf2 valGen
                   :?> GTNEIntMap
                   :-> TTOther
                     )
    foldr1
    NEM.foldr1

prop_foldl1 :: Property
prop_foldl1 = ttProp ( gf2 valGen
                   :?> GTNEIntMap
                   :-> TTOther
                     )
    foldl1
    NEM.foldl1

prop_foldrWithKey :: Property
prop_foldrWithKey = ttProp ( gf3 valGen
                         :?> GTOther valGen
                         :-> GTNEIntMap
                         :-> TTOther
                           )
    M.foldrWithKey
    NEM.foldrWithKey

prop_foldlWithKey :: Property
prop_foldlWithKey = ttProp ( gf3 valGen
                         :?> GTOther valGen
                         :-> GTNEIntMap
                         :-> TTOther
                           )
    M.foldlWithKey
    NEM.foldlWithKey

prop_foldMapWithKey :: Property
prop_foldMapWithKey = ttProp (gf2 valGen :?> GTNEIntMap :-> TTOther)
    (\f -> foldMap (uncurry f) . M.toList)
    NEM.foldMapWithKey

prop_foldr' :: Property
prop_foldr' = ttProp ( gf2 valGen
                   :?> GTOther valGen
                   :-> GTNEIntMap
                   :-> TTOther
                     )
    M.foldr'
    NEM.foldr'

prop_foldl' :: Property
prop_foldl' = ttProp ( gf2 valGen
                   :?> GTOther valGen
                   :-> GTNEIntMap
                   :-> TTOther
                     )
    M.foldl'
    NEM.foldl'

prop_foldr1' :: Property
prop_foldr1' = ttProp ( gf2 valGen
                    :?> GTNEIntMap
                    :-> TTOther
                      )
    foldr1
    NEM.foldr1'

prop_foldl1' :: Property
prop_foldl1' = ttProp ( gf2 valGen
                    :?> GTNEIntMap
                    :-> TTOther
                      )
    foldl1
    NEM.foldl1'

prop_foldrWithKey' :: Property
prop_foldrWithKey' = ttProp ( gf3 valGen
                          :?> GTOther valGen
                          :-> GTNEIntMap
                          :-> TTOther
                            )
    M.foldrWithKey'
    NEM.foldrWithKey'

prop_foldlWithKey' :: Property
prop_foldlWithKey' = ttProp ( gf3 valGen
                          :?> GTOther valGen
                          :-> GTNEIntMap
                          :-> TTOther
                            )
    M.foldlWithKey'
    NEM.foldlWithKey'

prop_elems :: Property
prop_elems = ttProp (GTNEIntMap :-> TTNEList TTVal)
    M.elems
    NEM.elems

prop_keys :: Property
prop_keys = ttProp (GTNEIntMap :-> TTNEList TTOther)
    M.keys
    NEM.keys

prop_assocs :: Property
prop_assocs = ttProp (GTNEIntMap :-> TTNEList (TTOther :*: TTVal))
    M.assocs
    NEM.assocs

prop_keysSet :: Property
prop_keysSet = ttProp (GTNEIntMap :-> TTNEIntSet)
    M.keysSet
    NEM.keysSet

prop_toList :: Property
prop_toList = ttProp (GTNEIntMap :-> TTNEList (TTOther :*: TTVal))
    M.toList
    NEM.toList

prop_toDescList :: Property
prop_toDescList = ttProp (GTNEIntMap :-> TTNEList (TTOther :*: TTVal))
    M.toDescList
    NEM.toDescList

prop_filter :: Property
prop_filter = ttProp (gf1 Gen.bool :?> GTNEIntMap :-> TTOther)
    M.filter
    NEM.filter

prop_filterWithKey :: Property
prop_filterWithKey = ttProp (gf2 Gen.bool :?> GTNEIntMap :-> TTOther)
    M.filterWithKey
    NEM.filterWithKey

prop_restrictKeys :: Property
prop_restrictKeys = ttProp (GTNEIntMap :-> GTIntSet :-> TTOther)
    M.restrictKeys
    NEM.restrictKeys

prop_withoutKeys :: Property
prop_withoutKeys = ttProp (GTNEIntMap :-> GTIntSet :-> TTOther)
    M.withoutKeys
    NEM.withoutKeys

prop_partitionWithKey :: Property
prop_partitionWithKey = ttProp (gf2 Gen.bool :?> GTNEIntMap :-> TTThese TTNEIntMap TTNEIntMap)
    M.partitionWithKey
    NEM.partitionWithKey

prop_mapMaybeWithKey :: Property
prop_mapMaybeWithKey = ttProp (gf2 (Gen.maybe valGen) :?> GTNEIntMap :-> TTOther)
    M.mapMaybeWithKey
    NEM.mapMaybeWithKey

prop_mapEitherWithKey :: Property
prop_mapEitherWithKey = ttProp ( gf2 (Gen.choice [Left <$> valGen, Right <$> valGen])
                             :?> GTNEIntMap
                             :-> TTThese TTNEIntMap TTNEIntMap
                               )
    M.mapEitherWithKey
    NEM.mapEitherWithKey

prop_split :: Property
prop_split = ttProp (GTIntKey :-> GTNEIntMap :-> TTMThese TTNEIntMap TTNEIntMap)
    M.split
    NEM.split

prop_splitLookup :: Property
prop_splitLookup = ttProp (GTIntKey :-> GTNEIntMap :-> TTMaybe TTVal :*: TTMThese TTNEIntMap TTNEIntMap)
    (\k -> (\(x,y,z) -> (y,(x,z))) . M.splitLookup k)
    NEM.splitLookup

prop_isSubmapOfBy :: Property
prop_isSubmapOfBy = ttProp (gf2 Gen.bool :?> GTNEIntMap :-> GTNEIntMap :-> TTOther)
    M.isSubmapOfBy
    NEM.isSubmapOfBy

prop_isProperSubmapOfBy :: Property
prop_isProperSubmapOfBy = ttProp (gf2 Gen.bool :?> GTNEIntMap :-> GTNEIntMap :-> TTOther)
    M.isProperSubmapOfBy
    NEM.isProperSubmapOfBy

prop_findMin :: Property
prop_findMin = ttProp (GTNEIntMap :-> TTOther :*: TTVal)
    M.findMin
    NEM.findMin

prop_findMax :: Property
prop_findMax = ttProp (GTNEIntMap :-> TTOther :*: TTVal)
    M.findMax
    NEM.findMax

prop_deleteMin :: Property
prop_deleteMin = ttProp (GTNEIntMap :-> TTOther)
    M.deleteMin
    NEM.deleteMin

prop_deleteMax :: Property
prop_deleteMax = ttProp (GTNEIntMap :-> TTOther)
    M.deleteMax
    NEM.deleteMax

prop_deleteFindMin :: Property
prop_deleteFindMin = ttProp (GTNEIntMap :-> (TTOther :*: TTVal) :*: TTOther)
    M.deleteFindMin
    NEM.deleteFindMin

prop_deleteFindMax :: Property
prop_deleteFindMax = ttProp (GTNEIntMap :-> (TTOther :*: TTVal) :*: TTOther)
    M.deleteFindMax
    NEM.deleteFindMax

prop_updateMinWithKey :: Property
prop_updateMinWithKey = ttProp (gf2 (Gen.maybe valGen) :?> GTNEIntMap :-> TTOther)
    M.updateMinWithKey
    NEM.updateMinWithKey

prop_updateMaxWithKey :: Property
prop_updateMaxWithKey = ttProp (gf2 (Gen.maybe valGen) :?> GTNEIntMap :-> TTOther)
    M.updateMaxWithKey
    NEM.updateMaxWithKey

prop_adjustMinWithKey :: Property
prop_adjustMinWithKey = ttProp (gf2 valGen :?> GTNEIntMap :-> TTNEIntMap)
    (M.updateMinWithKey  . (fmap . fmap) Just)
    NEM.adjustMinWithKey

prop_adjustMaxWithKey :: Property
prop_adjustMaxWithKey = ttProp (gf2 valGen :?> GTNEIntMap :-> TTNEIntMap)
    (M.updateMaxWithKey  . (fmap . fmap) Just)
    NEM.adjustMaxWithKey

prop_minView :: Property
prop_minView = ttProp (GTNEIntMap :-> TTMaybe (TTVal :*: TTOther))
    M.minView
    (Just . NEM.minView)

prop_maxView :: Property
prop_maxView = ttProp (GTNEIntMap :-> TTMaybe (TTVal :*: TTOther))
    M.maxView
    (Just . NEM.maxView)

prop_elem :: Property
prop_elem = ttProp (GTVal :-> GTNEIntMap :-> TTOther)
    elem
    elem

prop_fold1 :: Property
prop_fold1 = ttProp (GTNEIntMap :-> TTVal)
    (fold . toList)
    fold1

prop_fold :: Property
prop_fold = ttProp (GTNEIntMap :-> TTVal)
    (fold . toList)
    fold

prop_foldMap1 :: Property
prop_foldMap1 = ttProp (gf1 valGen :?> GTNEIntMap :-> TTOther)
    (\f -> foldMap  ((:[]) . f) . toList)
    (\f -> foldMap1 ((:[]) . f))

prop_foldMap :: Property
prop_foldMap = ttProp (gf1 valGen :?> GTNEIntMap :-> TTOther)
    (\f -> foldMap ((:[]) . f) . toList)
    (\f -> foldMap ((:[]) . f))