hspec 2.7.10 → 2.8.0

raw patch · 4 files changed

+20/−6 lines, 4 filesdep ~hspec-coredep ~hspec-discoverPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: hspec-core, hspec-discover

API changes (from Hackage documentation)

- Test.Hspec.Discover: (!!) :: [a] -> Int -> a

- Test.Hspec.Discover: ($!) :: forall (r :: RuntimeRep) a (b :: TYPE r). (a -> b) -> a -> b

- Test.Hspec.Discover: ($) :: forall (r :: RuntimeRep) a (b :: TYPE r). (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 :: Type -> Type)

- 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 :: Type -> Type)

- Test.Hspec.Discover: class Num a => Fractional a

- Test.Hspec.Discover: class Functor (f :: Type -> Type)

- Test.Hspec.Discover: class (Real a, Enum a) => Integral a

- Test.Hspec.Discover: class Applicative m => Monad (m :: Type -> Type)

- Test.Hspec.Discover: class Monad m => MonadFail (m :: Type -> Type)

- 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 :: Type -> Type)

- 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 :: forall (r :: RuntimeRep) (a :: TYPE r). HasCallStack => [Char] -> a

- Test.Hspec.Discover: errorWithoutStackTrace :: forall (r :: RuntimeRep) (a :: TYPE r). [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 :: MonadFail 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 1 >>

- Test.Hspec.Discover: infixl 4 <$>

- Test.Hspec.Discover: infixl 6 +

- Test.Hspec.Discover: infixl 7 *

- 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 6 <>

- Test.Hspec.Discover: infixr 8 ^

- Test.Hspec.Discover: infixr 9 .

- Test.Hspec.Discover: init :: [a] -> [a]

- Test.Hspec.Discover: instance Test.Hspec.Discover.IsFormatter (GHC.Types.IO Test.Hspec.Core.Formatters.Monad.Formatter)

- Test.Hspec.Discover: instance Test.Hspec.Discover.IsFormatter Test.Hspec.Core.Formatters.Monad.Formatter

- 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 :: forall (r :: RuntimeRep) a (b :: TYPE r). 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 :: forall (r :: RuntimeRep) (a :: TYPE r). 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.Discover: instance Test.Hspec.Discover.IsFormatter (GHC.Types.IO Test.Hspec.Core.Formatters.V1.Formatter)

+ Test.Hspec.Discover: instance Test.Hspec.Discover.IsFormatter Test.Hspec.Core.Formatters.V1.Formatter

- Test.Hspec: afterAll :: ActionWith a -> SpecWith a -> SpecWith a

+ Test.Hspec: afterAll :: HasCallStack => ActionWith a -> SpecWith a -> SpecWith a

- Test.Hspec: afterAll_ :: IO () -> SpecWith a -> SpecWith a

+ Test.Hspec: afterAll_ :: HasCallStack => IO () -> SpecWith a -> SpecWith a

Files

CHANGES.markdown +16/−0
hspec.cabal +3/−3
src/Test/Hspec/Discover.hs +0/−2
version.yaml +1/−1

CHANGES.markdown view

@@ -1,3 +1,19 @@+## Changes in 2.8.0+  - Add `--times` to print times for individual spec items+  - Add `--print-slow-items`+  - Use `-XNoImplicitPrelude` and do not rely on `base` for `hspec-discover`+    generated test drivers. This ensures full compatibility with custom+    preludes.+  - Add new APIs for formatters `Test.Hspec.Core.Format` and+    `Test.Hspec.Core.Formatters.V2`+  - Add `getItemCount` to `Formatter` API+  - Add `--qc-max-shrinks` (see #380)+  - Add location information for failing `afterAll`-hooks+  - hspec-discover: Deprecate `--no-main` and `--formatter` (use+    `--module-name` instead) (#196)+  - Remove `--verbose` option (this has been a noop since at least 2013)+  - Remove `--out` option (use shell output redirection instead)+ ## Changes in 2.7.10   - Add a new formatter (can be used with `--format checks`)   - Add `exampleStarted` to `Formatter` API

hspec.cabal view

@@ -5,7 +5,7 @@ -- see: https://github.com/sol/hpack  name:             hspec-version:          2.7.10+version:          2.8.0 license:          MIT license-file:     LICENSE copyright:        (c) 2011-2021 Simon Hengel,@@ -45,8 +45,8 @@   build-depends:       QuickCheck >=2.12     , base ==4.*-    , hspec-core ==2.7.10-    , hspec-discover ==2.7.10+    , hspec-core ==2.8.0+    , hspec-discover ==2.8.0     , hspec-expectations ==0.8.2.*   exposed-modules:       Test.Hspec

src/Test/Hspec/Discover.hs view

@@ -11,8 +11,6 @@ , module Prelude ) where -import           Prelude hiding (mapM)- import           Test.Hspec.Core.Spec import           Test.Hspec.Core.Runner import           Test.Hspec.Formatters

version.yaml view

@@ -1,1 +1,1 @@-&version 2.7.10+&version 2.8.0