hspec 2.5.2 → 2.5.3
raw patch · 2 files changed
+11/−6 lines, 2 filesdep ~hspec-coredep ~hspec-discoverPVP: major bump suggested
API removals or changes: PVP suggests a major version bump
Dependency ranges changed: hspec-core, hspec-discover
API changes (from Hackage documentation)
- Test.Hspec: type family Arg e :: *;
- Test.Hspec: }
+ Test.Hspec.Core: Error :: Maybe String -> SomeException -> FailureReason
+ Test.Hspec.Core: ExpectedButGot :: Maybe String -> String -> String -> FailureReason
+ Test.Hspec.Core: Failure :: Maybe Location -> FailureReason -> ResultStatus
+ Test.Hspec.Core: Item :: String -> Maybe Location -> Maybe Bool -> Params -> ActionWith a -> IO () -> ProgressCallback -> IO Result -> Item a
+ Test.Hspec.Core: Leaf :: a -> Tree c a
+ Test.Hspec.Core: Location :: FilePath -> Int -> Int -> Location
+ Test.Hspec.Core: NoReason :: FailureReason
+ Test.Hspec.Core: Node :: String -> [Tree c a] -> Tree c a
+ Test.Hspec.Core: NodeWithCleanup :: c -> [Tree c a] -> Tree c a
+ Test.Hspec.Core: Params :: Args -> Int -> Params
+ Test.Hspec.Core: Pending :: Maybe Location -> Maybe String -> ResultStatus
+ Test.Hspec.Core: Reason :: String -> FailureReason
+ Test.Hspec.Core: Result :: String -> ResultStatus -> Result
+ Test.Hspec.Core: SpecM :: WriterT [SpecTree a] IO r -> SpecM a r
+ Test.Hspec.Core: Success :: ResultStatus
+ Test.Hspec.Core: [itemExample] :: Item a -> Params -> ActionWith a -> IO () -> ProgressCallback -> IO Result
+ Test.Hspec.Core: [itemIsParallelizable] :: Item a -> Maybe Bool
+ Test.Hspec.Core: [itemLocation] :: Item a -> Maybe Location
+ Test.Hspec.Core: [itemRequirement] :: Item a -> String
+ Test.Hspec.Core: [locationColumn] :: Location -> Int
+ Test.Hspec.Core: [locationFile] :: Location -> FilePath
+ Test.Hspec.Core: [locationLine] :: Location -> Int
+ Test.Hspec.Core: [paramsQuickCheckArgs] :: Params -> Args
+ Test.Hspec.Core: [paramsSmallCheckDepth] :: Params -> Int
+ Test.Hspec.Core: [resultInfo] :: Result -> String
+ Test.Hspec.Core: [resultStatus] :: Result -> ResultStatus
+ Test.Hspec.Core: class Example e where {
+ Test.Hspec.Core: context :: HasCallStack => String -> SpecWith a -> SpecWith a
+ Test.Hspec.Core: data FailureReason
+ Test.Hspec.Core: data Item a
+ Test.Hspec.Core: data Location
+ Test.Hspec.Core: data Params
+ Test.Hspec.Core: data Result
+ Test.Hspec.Core: data ResultStatus
+ Test.Hspec.Core: data Tree c a
+ Test.Hspec.Core: defaultParams :: Params
+ Test.Hspec.Core: evaluateExample :: Example e => e -> Params -> ActionWith Arg e -> IO () -> ProgressCallback -> IO Result
+ Test.Hspec.Core: fromSpecList :: () => [SpecTree a] -> SpecWith a
+ Test.Hspec.Core: location :: HasCallStack -> Maybe Location
+ Test.Hspec.Core: mapSpecItem :: () => ActionWith a -> ActionWith b -> Item a -> Item b -> SpecWith a -> SpecWith b
+ Test.Hspec.Core: mapSpecItem_ :: () => Item a -> Item a -> SpecWith a -> SpecWith a
+ Test.Hspec.Core: modifyParams :: () => Params -> Params -> SpecWith a -> SpecWith a
+ Test.Hspec.Core: newtype SpecM a r
+ Test.Hspec.Core: parallel :: () => SpecWith a -> SpecWith a
+ Test.Hspec.Core: pending :: HasCallStack -> Expectation
+ Test.Hspec.Core: pendingWith :: HasCallStack -> String -> Expectation
+ Test.Hspec.Core: runIO :: () => IO r -> SpecM a r
+ Test.Hspec.Core: runSpecM :: () => SpecWith a -> IO [SpecTree a]
+ Test.Hspec.Core: safeEvaluateExample :: Example e => e -> Params -> ActionWith Arg e -> IO () -> ProgressCallback -> IO Result
+ Test.Hspec.Core: sequential :: () => SpecWith a -> SpecWith a
+ Test.Hspec.Core: specGroup :: HasCallStack => String -> [SpecTree a] -> SpecTree a
+ Test.Hspec.Core: specItem :: (HasCallStack, Example a) => String -> a -> SpecTree Arg a
+ Test.Hspec.Core: specify :: (HasCallStack, Example a) => String -> a -> SpecWith Arg a
+ Test.Hspec.Core: type ActionWith a = a -> IO ()
+ Test.Hspec.Core: type Progress = (Int, Int)
+ Test.Hspec.Core: type ProgressCallback = Progress -> IO ()
+ Test.Hspec.Core: type Spec = SpecWith ()
+ Test.Hspec.Core: type SpecTree a = Tree ActionWith a Item a
+ Test.Hspec.Core: type SpecWith a = SpecM a ()
+ Test.Hspec.Core: type family Arg e :: *;
+ Test.Hspec.Core: xcontext :: HasCallStack => String -> SpecWith a -> SpecWith a
+ Test.Hspec.Core: xdescribe :: HasCallStack => String -> SpecWith a -> SpecWith a
+ Test.Hspec.Core: xit :: (HasCallStack, Example a) => String -> a -> SpecWith Arg a
+ Test.Hspec.Core: xspecify :: (HasCallStack, Example a) => String -> a -> SpecWith Arg a
+ Test.Hspec.Core: }
+ Test.Hspec.Discover: (!!) :: () => [a] -> Int -> a
+ Test.Hspec.Discover: ($!) :: () => a -> b -> a -> b
+ Test.Hspec.Discover: ($) :: () => a -> b -> a -> b
+ Test.Hspec.Discover: (&&) :: Bool -> Bool -> Bool
+ Test.Hspec.Discover: (*) :: Num a => a -> a -> a
+ Test.Hspec.Discover: (**) :: Floating a => a -> a -> a
+ Test.Hspec.Discover: (*>) :: Applicative f => f a -> f b -> f b
+ Test.Hspec.Discover: (+) :: Num a => a -> a -> a
+ Test.Hspec.Discover: (++) :: () => [a] -> [a] -> [a]
+ Test.Hspec.Discover: (-) :: Num a => a -> a -> a
+ Test.Hspec.Discover: (.) :: () => b -> c -> a -> b -> a -> c
+ Test.Hspec.Discover: (/) :: Fractional a => a -> a -> a
+ Test.Hspec.Discover: (/=) :: Eq a => a -> a -> Bool
+ Test.Hspec.Discover: (<$) :: Functor f => a -> f b -> f a
+ Test.Hspec.Discover: (<$>) :: Functor f => a -> b -> f a -> f b
+ Test.Hspec.Discover: (<) :: Ord a => a -> a -> Bool
+ Test.Hspec.Discover: (<*) :: Applicative f => f a -> f b -> f a
+ Test.Hspec.Discover: (<*>) :: Applicative f => f a -> b -> f a -> f b
+ Test.Hspec.Discover: (<=) :: Ord a => a -> a -> Bool
+ Test.Hspec.Discover: (<>) :: Semigroup a => a -> a -> a
+ Test.Hspec.Discover: (=<<) :: Monad m => a -> m b -> m a -> m b
+ Test.Hspec.Discover: (==) :: Eq a => a -> a -> Bool
+ Test.Hspec.Discover: (>) :: Ord a => a -> a -> Bool
+ Test.Hspec.Discover: (>=) :: Ord a => a -> a -> Bool
+ Test.Hspec.Discover: (>>) :: Monad m => m a -> m b -> m b
+ Test.Hspec.Discover: (>>=) :: Monad m => m a -> a -> m b -> m b
+ Test.Hspec.Discover: (^) :: (Num a, Integral b) => a -> b -> a
+ Test.Hspec.Discover: (^^) :: (Fractional a, Integral b) => a -> b -> a
+ Test.Hspec.Discover: (||) :: Bool -> Bool -> Bool
+ Test.Hspec.Discover: EQ :: Ordering
+ Test.Hspec.Discover: False :: Bool
+ Test.Hspec.Discover: GT :: Ordering
+ Test.Hspec.Discover: Just :: a -> Maybe a
+ Test.Hspec.Discover: LT :: Ordering
+ Test.Hspec.Discover: Left :: a -> Either a b
+ Test.Hspec.Discover: Nothing :: Maybe a
+ Test.Hspec.Discover: Right :: b -> Either a b
+ Test.Hspec.Discover: True :: Bool
+ Test.Hspec.Discover: abs :: Num a => a -> a
+ Test.Hspec.Discover: acos :: Floating a => a -> a
+ Test.Hspec.Discover: acosh :: Floating a => a -> a
+ Test.Hspec.Discover: all :: Foldable t => a -> Bool -> t a -> Bool
+ Test.Hspec.Discover: and :: Foldable t => t Bool -> Bool
+ Test.Hspec.Discover: any :: Foldable t => a -> Bool -> t a -> Bool
+ Test.Hspec.Discover: appendFile :: FilePath -> String -> IO ()
+ Test.Hspec.Discover: asTypeOf :: () => a -> a -> a
+ Test.Hspec.Discover: asin :: Floating a => a -> a
+ Test.Hspec.Discover: asinh :: Floating a => a -> a
+ Test.Hspec.Discover: atan :: Floating a => a -> a
+ Test.Hspec.Discover: atan2 :: RealFloat a => a -> a -> a
+ Test.Hspec.Discover: atanh :: Floating a => a -> a
+ Test.Hspec.Discover: break :: () => a -> Bool -> [a] -> ([a], [a])
+ Test.Hspec.Discover: ceiling :: (RealFrac a, Integral b) => a -> b
+ Test.Hspec.Discover: class Functor f => Applicative (f :: * -> *)
+ Test.Hspec.Discover: class Bounded a
+ Test.Hspec.Discover: class Enum a
+ Test.Hspec.Discover: class Eq a
+ Test.Hspec.Discover: class Fractional a => Floating a
+ Test.Hspec.Discover: class Foldable (t :: * -> *)
+ Test.Hspec.Discover: class Num a => Fractional a
+ Test.Hspec.Discover: class Functor (f :: * -> *)
+ Test.Hspec.Discover: class (Real a, Enum a) => Integral a
+ Test.Hspec.Discover: class Applicative m => Monad (m :: * -> *)
+ Test.Hspec.Discover: class Semigroup a => Monoid a
+ Test.Hspec.Discover: class Num a
+ Test.Hspec.Discover: class Eq a => Ord a
+ Test.Hspec.Discover: class Read a
+ Test.Hspec.Discover: class (Num a, Ord a) => Real a
+ Test.Hspec.Discover: class (RealFrac a, Floating a) => RealFloat a
+ Test.Hspec.Discover: class (Real a, Fractional a) => RealFrac a
+ Test.Hspec.Discover: class Semigroup a
+ Test.Hspec.Discover: class Show a
+ Test.Hspec.Discover: class (Functor t, Foldable t) => Traversable (t :: * -> *)
+ Test.Hspec.Discover: compare :: Ord a => a -> a -> Ordering
+ Test.Hspec.Discover: concat :: Foldable t => t [a] -> [a]
+ Test.Hspec.Discover: concatMap :: Foldable t => a -> [b] -> t a -> [b]
+ Test.Hspec.Discover: const :: () => a -> b -> a
+ Test.Hspec.Discover: cos :: Floating a => a -> a
+ Test.Hspec.Discover: cosh :: Floating a => a -> a
+ Test.Hspec.Discover: curry :: () => (a, b) -> c -> a -> b -> c
+ Test.Hspec.Discover: cycle :: () => [a] -> [a]
+ Test.Hspec.Discover: data Bool
+ Test.Hspec.Discover: data Char
+ Test.Hspec.Discover: data Double
+ Test.Hspec.Discover: data Either a b
+ Test.Hspec.Discover: data Float
+ Test.Hspec.Discover: data IO a
+ Test.Hspec.Discover: data Int
+ Test.Hspec.Discover: data Integer
+ Test.Hspec.Discover: data Maybe a
+ Test.Hspec.Discover: data Ordering
+ Test.Hspec.Discover: data Word
+ Test.Hspec.Discover: decodeFloat :: RealFloat a => a -> (Integer, Int)
+ Test.Hspec.Discover: div :: Integral a => a -> a -> a
+ Test.Hspec.Discover: divMod :: Integral a => a -> a -> (a, a)
+ Test.Hspec.Discover: drop :: () => Int -> [a] -> [a]
+ Test.Hspec.Discover: dropWhile :: () => a -> Bool -> [a] -> [a]
+ Test.Hspec.Discover: either :: () => a -> c -> b -> c -> Either a b -> c
+ Test.Hspec.Discover: elem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Test.Hspec.Discover: encodeFloat :: RealFloat a => Integer -> Int -> a
+ Test.Hspec.Discover: enumFrom :: Enum a => a -> [a]
+ Test.Hspec.Discover: enumFromThen :: Enum a => a -> a -> [a]
+ Test.Hspec.Discover: enumFromThenTo :: Enum a => a -> a -> a -> [a]
+ Test.Hspec.Discover: enumFromTo :: Enum a => a -> a -> [a]
+ Test.Hspec.Discover: error :: HasCallStack => [Char] -> a
+ Test.Hspec.Discover: errorWithoutStackTrace :: () => [Char] -> a
+ Test.Hspec.Discover: even :: Integral a => a -> Bool
+ Test.Hspec.Discover: exp :: Floating a => a -> a
+ Test.Hspec.Discover: exponent :: RealFloat a => a -> Int
+ Test.Hspec.Discover: fail :: Monad m => String -> m a
+ Test.Hspec.Discover: filter :: () => a -> Bool -> [a] -> [a]
+ Test.Hspec.Discover: flip :: () => a -> b -> c -> b -> a -> c
+ Test.Hspec.Discover: floatDigits :: RealFloat a => a -> Int
+ Test.Hspec.Discover: floatRadix :: RealFloat a => a -> Integer
+ Test.Hspec.Discover: floatRange :: RealFloat a => a -> (Int, Int)
+ Test.Hspec.Discover: floor :: (RealFrac a, Integral b) => a -> b
+ Test.Hspec.Discover: fmap :: Functor f => a -> b -> f a -> f b
+ Test.Hspec.Discover: foldMap :: (Foldable t, Monoid m) => a -> m -> t a -> m
+ Test.Hspec.Discover: foldl :: Foldable t => b -> a -> b -> b -> t a -> b
+ Test.Hspec.Discover: foldl1 :: Foldable t => a -> a -> a -> t a -> a
+ Test.Hspec.Discover: foldr :: Foldable t => a -> b -> b -> b -> t a -> b
+ Test.Hspec.Discover: foldr1 :: Foldable t => a -> a -> a -> t a -> a
+ Test.Hspec.Discover: fromEnum :: Enum a => a -> Int
+ Test.Hspec.Discover: fromInteger :: Num a => Integer -> a
+ Test.Hspec.Discover: fromIntegral :: (Integral a, Num b) => a -> b
+ Test.Hspec.Discover: fromRational :: Fractional a => Rational -> a
+ Test.Hspec.Discover: fst :: () => (a, b) -> a
+ Test.Hspec.Discover: gcd :: Integral a => a -> a -> a
+ Test.Hspec.Discover: getChar :: IO Char
+ Test.Hspec.Discover: getContents :: IO String
+ Test.Hspec.Discover: getLine :: IO String
+ Test.Hspec.Discover: head :: () => [a] -> a
+ Test.Hspec.Discover: id :: () => a -> a
+ Test.Hspec.Discover: infix 4 `notElem`
+ Test.Hspec.Discover: infixl 4 <$>
+ Test.Hspec.Discover: infixl 9 !!
+ Test.Hspec.Discover: infixr 0 $!
+ Test.Hspec.Discover: infixr 1 =<<
+ Test.Hspec.Discover: infixr 2 ||
+ Test.Hspec.Discover: infixr 3 &&
+ Test.Hspec.Discover: infixr 5 ++
+ Test.Hspec.Discover: infixr 8 ^
+ Test.Hspec.Discover: infixr 9 .
+ Test.Hspec.Discover: init :: () => [a] -> [a]
+ Test.Hspec.Discover: interact :: String -> String -> IO ()
+ Test.Hspec.Discover: ioError :: () => IOError -> IO a
+ Test.Hspec.Discover: isDenormalized :: RealFloat a => a -> Bool
+ Test.Hspec.Discover: isIEEE :: RealFloat a => a -> Bool
+ Test.Hspec.Discover: isInfinite :: RealFloat a => a -> Bool
+ Test.Hspec.Discover: isNaN :: RealFloat a => a -> Bool
+ Test.Hspec.Discover: isNegativeZero :: RealFloat a => a -> Bool
+ Test.Hspec.Discover: iterate :: () => a -> a -> a -> [a]
+ Test.Hspec.Discover: last :: () => [a] -> a
+ Test.Hspec.Discover: lcm :: Integral a => a -> a -> a
+ Test.Hspec.Discover: length :: Foldable t => t a -> Int
+ Test.Hspec.Discover: lex :: ReadS String
+ Test.Hspec.Discover: lines :: String -> [String]
+ Test.Hspec.Discover: log :: Floating a => a -> a
+ Test.Hspec.Discover: logBase :: Floating a => a -> a -> a
+ Test.Hspec.Discover: lookup :: Eq a => a -> [(a, b)] -> Maybe b
+ Test.Hspec.Discover: map :: () => a -> b -> [a] -> [b]
+ Test.Hspec.Discover: mapM_ :: (Foldable t, Monad m) => a -> m b -> t a -> m ()
+ Test.Hspec.Discover: mappend :: Monoid a => a -> a -> a
+ Test.Hspec.Discover: max :: Ord a => a -> a -> a
+ Test.Hspec.Discover: maxBound :: Bounded a => a
+ Test.Hspec.Discover: maximum :: (Foldable t, Ord a) => t a -> a
+ Test.Hspec.Discover: maybe :: () => b -> a -> b -> Maybe a -> b
+ Test.Hspec.Discover: mconcat :: Monoid a => [a] -> a
+ Test.Hspec.Discover: mempty :: Monoid a => a
+ Test.Hspec.Discover: min :: Ord a => a -> a -> a
+ Test.Hspec.Discover: minBound :: Bounded a => a
+ Test.Hspec.Discover: minimum :: (Foldable t, Ord a) => t a -> a
+ Test.Hspec.Discover: mod :: Integral a => a -> a -> a
+ Test.Hspec.Discover: negate :: Num a => a -> a
+ Test.Hspec.Discover: not :: Bool -> Bool
+ Test.Hspec.Discover: notElem :: (Foldable t, Eq a) => a -> t a -> Bool
+ Test.Hspec.Discover: null :: Foldable t => t a -> Bool
+ Test.Hspec.Discover: odd :: Integral a => a -> Bool
+ Test.Hspec.Discover: or :: Foldable t => t Bool -> Bool
+ Test.Hspec.Discover: otherwise :: Bool
+ Test.Hspec.Discover: pi :: Floating a => a
+ Test.Hspec.Discover: pred :: Enum a => a -> a
+ Test.Hspec.Discover: print :: Show a => a -> IO ()
+ Test.Hspec.Discover: product :: (Foldable t, Num a) => t a -> a
+ Test.Hspec.Discover: properFraction :: (RealFrac a, Integral b) => a -> (b, a)
+ Test.Hspec.Discover: pure :: Applicative f => a -> f a
+ Test.Hspec.Discover: putChar :: Char -> IO ()
+ Test.Hspec.Discover: putStr :: String -> IO ()
+ Test.Hspec.Discover: putStrLn :: String -> IO ()
+ Test.Hspec.Discover: quot :: Integral a => a -> a -> a
+ Test.Hspec.Discover: quotRem :: Integral a => a -> a -> (a, a)
+ Test.Hspec.Discover: read :: Read a => String -> a
+ Test.Hspec.Discover: readFile :: FilePath -> IO String
+ Test.Hspec.Discover: readIO :: Read a => String -> IO a
+ Test.Hspec.Discover: readList :: Read a => ReadS [a]
+ Test.Hspec.Discover: readLn :: Read a => IO a
+ Test.Hspec.Discover: readParen :: () => Bool -> ReadS a -> ReadS a
+ Test.Hspec.Discover: reads :: Read a => ReadS a
+ Test.Hspec.Discover: readsPrec :: Read a => Int -> ReadS a
+ Test.Hspec.Discover: realToFrac :: (Real a, Fractional b) => a -> b
+ Test.Hspec.Discover: recip :: Fractional a => a -> a
+ Test.Hspec.Discover: rem :: Integral a => a -> a -> a
+ Test.Hspec.Discover: repeat :: () => a -> [a]
+ Test.Hspec.Discover: replicate :: () => Int -> a -> [a]
+ Test.Hspec.Discover: return :: Monad m => a -> m a
+ Test.Hspec.Discover: reverse :: () => [a] -> [a]
+ Test.Hspec.Discover: round :: (RealFrac a, Integral b) => a -> b
+ Test.Hspec.Discover: scaleFloat :: RealFloat a => Int -> a -> a
+ Test.Hspec.Discover: scanl :: () => b -> a -> b -> b -> [a] -> [b]
+ Test.Hspec.Discover: scanl1 :: () => a -> a -> a -> [a] -> [a]
+ Test.Hspec.Discover: scanr :: () => a -> b -> b -> b -> [a] -> [b]
+ Test.Hspec.Discover: scanr1 :: () => a -> a -> a -> [a] -> [a]
+ Test.Hspec.Discover: seq :: () => a -> b -> b
+ Test.Hspec.Discover: sequence :: (Traversable t, Monad m) => t m a -> m t a
+ Test.Hspec.Discover: sequenceA :: (Traversable t, Applicative f) => t f a -> f t a
+ Test.Hspec.Discover: sequence_ :: (Foldable t, Monad m) => t m a -> m ()
+ Test.Hspec.Discover: show :: Show a => a -> String
+ Test.Hspec.Discover: showChar :: Char -> ShowS
+ Test.Hspec.Discover: showList :: Show a => [a] -> ShowS
+ Test.Hspec.Discover: showParen :: Bool -> ShowS -> ShowS
+ Test.Hspec.Discover: showString :: String -> ShowS
+ Test.Hspec.Discover: shows :: Show a => a -> ShowS
+ Test.Hspec.Discover: showsPrec :: Show a => Int -> a -> ShowS
+ Test.Hspec.Discover: significand :: RealFloat a => a -> a
+ Test.Hspec.Discover: signum :: Num a => a -> a
+ Test.Hspec.Discover: sin :: Floating a => a -> a
+ Test.Hspec.Discover: sinh :: Floating a => a -> a
+ Test.Hspec.Discover: snd :: () => (a, b) -> b
+ Test.Hspec.Discover: span :: () => a -> Bool -> [a] -> ([a], [a])
+ Test.Hspec.Discover: splitAt :: () => Int -> [a] -> ([a], [a])
+ Test.Hspec.Discover: sqrt :: Floating a => a -> a
+ Test.Hspec.Discover: subtract :: Num a => a -> a -> a
+ Test.Hspec.Discover: succ :: Enum a => a -> a
+ Test.Hspec.Discover: sum :: (Foldable t, Num a) => t a -> a
+ Test.Hspec.Discover: tail :: () => [a] -> [a]
+ Test.Hspec.Discover: take :: () => Int -> [a] -> [a]
+ Test.Hspec.Discover: takeWhile :: () => a -> Bool -> [a] -> [a]
+ Test.Hspec.Discover: tan :: Floating a => a -> a
+ Test.Hspec.Discover: tanh :: Floating a => a -> a
+ Test.Hspec.Discover: toEnum :: Enum a => Int -> a
+ Test.Hspec.Discover: toInteger :: Integral a => a -> Integer
+ Test.Hspec.Discover: toRational :: Real a => a -> Rational
+ Test.Hspec.Discover: traverse :: (Traversable t, Applicative f) => a -> f b -> t a -> f t b
+ Test.Hspec.Discover: truncate :: (RealFrac a, Integral b) => a -> b
+ Test.Hspec.Discover: type FilePath = String
+ Test.Hspec.Discover: type IOError = IOException
+ Test.Hspec.Discover: type Rational = Ratio Integer
+ Test.Hspec.Discover: type ReadS a = String -> [(a, String)]
+ Test.Hspec.Discover: type ShowS = String -> String
+ Test.Hspec.Discover: type String = [Char]
+ Test.Hspec.Discover: uncurry :: () => a -> b -> c -> (a, b) -> c
+ Test.Hspec.Discover: undefined :: HasCallStack => a
+ Test.Hspec.Discover: unlines :: [String] -> String
+ Test.Hspec.Discover: until :: () => a -> Bool -> a -> a -> a -> a
+ Test.Hspec.Discover: unwords :: [String] -> String
+ Test.Hspec.Discover: unzip :: () => [(a, b)] -> ([a], [b])
+ Test.Hspec.Discover: unzip3 :: () => [(a, b, c)] -> ([a], [b], [c])
+ Test.Hspec.Discover: userError :: String -> IOError
+ Test.Hspec.Discover: words :: String -> [String]
+ Test.Hspec.Discover: writeFile :: FilePath -> String -> IO ()
+ Test.Hspec.Discover: zip :: () => [a] -> [b] -> [(a, b)]
+ Test.Hspec.Discover: zip3 :: () => [a] -> [b] -> [c] -> [(a, b, c)]
+ Test.Hspec.Discover: zipWith :: () => a -> b -> c -> [a] -> [b] -> [c]
+ Test.Hspec.Discover: zipWith3 :: () => a -> b -> c -> d -> [a] -> [b] -> [c] -> [d]
- Test.Hspec: around :: () => (ActionWith a -> IO ()) -> SpecWith a -> Spec
+ Test.Hspec: around :: () => ActionWith a -> IO () -> SpecWith a -> Spec
- Test.Hspec: aroundWith :: () => (ActionWith a -> ActionWith b) -> SpecWith a -> SpecWith b
+ Test.Hspec: aroundWith :: () => ActionWith a -> ActionWith b -> SpecWith a -> SpecWith b
- Test.Hspec: around_ :: () => (IO () -> IO ()) -> SpecWith a -> SpecWith a
+ Test.Hspec: around_ :: () => IO () -> IO () -> SpecWith a -> SpecWith a
- Test.Hspec: beforeWith :: () => (b -> IO a) -> SpecWith a -> SpecWith b
+ Test.Hspec: beforeWith :: () => b -> IO a -> SpecWith a -> SpecWith b
- Test.Hspec: class Example e where {
+ Test.Hspec: class Example e
- Test.Hspec.QuickCheck: modifyMaxDiscardRatio :: () => (Int -> Int) -> SpecWith a -> SpecWith a
+ Test.Hspec.QuickCheck: modifyMaxDiscardRatio :: () => Int -> Int -> SpecWith a -> SpecWith a
- Test.Hspec.QuickCheck: modifyMaxSize :: () => (Int -> Int) -> SpecWith a -> SpecWith a
+ Test.Hspec.QuickCheck: modifyMaxSize :: () => Int -> Int -> SpecWith a -> SpecWith a
- Test.Hspec.QuickCheck: modifyMaxSuccess :: () => (Int -> Int) -> SpecWith a -> SpecWith a
+ Test.Hspec.QuickCheck: modifyMaxSuccess :: () => Int -> Int -> SpecWith a -> SpecWith a
Files
- CHANGES.markdown +5/−0
- hspec.cabal +6/−6
CHANGES.markdown view
@@ -1,3 +1,8 @@+## Changes in 2.5.3+ - Treat character escapes like `\NUL` as single tokens on `--diff` (see #351)+ - Allow a `/` at the beginning and at the end of an absolute path that is+ passed to `--match` or `--skip`+ ## Changes in 2.5.2 - Use module:line:column as default label for describe/it (see #250) - Warn if user is affected by https://ghc.haskell.org/trac/ghc/ticket/13285 (see #329)
hspec.cabal view
@@ -2,10 +2,10 @@ -- -- see: https://github.com/sol/hpack ----- hash: 6935b231b0ab39d6cd6cec5c3e1a562188afb8399a3c60e2be17d1fb7cb8ff1b+-- hash: 45d945a4e3d6d2f79063973b4940202e9a88a0a9bd716c7844e05001829003ef name: hspec-version: 2.5.2+version: 2.5.3 license: MIT license-file: LICENSE copyright: (c) 2011-2018 Simon Hengel,@@ -48,8 +48,8 @@ , QuickCheck >=2.10 , base ==4.* , call-stack- , hspec-core ==2.5.2- , hspec-discover ==2.5.2+ , hspec-core ==2.5.3+ , hspec-discover ==2.5.3 , hspec-expectations ==0.8.2.* , transformers >=0.2.2.0 exposed-modules:@@ -76,8 +76,8 @@ , call-stack , directory , hspec- , hspec-core ==2.5.2- , hspec-discover ==2.5.2+ , hspec-core ==2.5.3+ , hspec-discover ==2.5.3 , hspec-expectations ==0.8.2.* , hspec-meta >=2.3.2 , stringbuilder