module Saturn.Unstable.MatchSpec where

import qualified Data.Fixed as Fixed
import qualified Data.Time as Time
import qualified Data.Time.Calendar.WeekDate as Time
import qualified Saturn.Unstable.Match as Match
import qualified Saturn.Unstable.Type.ScheduleSpec as ScheduleSpec
import qualified Test.Hspec as Hspec
import qualified Test.QuickCheck as QuickCheck

spec :: Hspec.Spec
spec :: Spec
spec = forall a. HasCallStack => String -> SpecWith a -> SpecWith a
Hspec.describe String
"Saturn.Unstable.Match" forall a b. (a -> b) -> a -> b
$ do
  forall a. HasCallStack => String -> SpecWith a -> SpecWith a
Hspec.describe String
"isMatch" forall a b. (a -> b) -> a -> b
$ do
    forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true with all wildcards"
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
      forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
        Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] []
        Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
utcTime

    forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when day or weekday matches" forall a b. (a -> b) -> a -> b
$ do
      Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
5]] [] [[Word8
5]]
      UTCTime
t1 <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
5 MonthOfYear
0 MonthOfYear
0 Pico
0
      Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t1
      UTCTime
t2 <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
2 MonthOfYear
0 MonthOfYear
0 Pico
0
      Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t2

    forall a. HasCallStack => String -> SpecWith a -> SpecWith a
Hspec.describe String
"minute" forall a b. (a -> b) -> a -> b
$ do
      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a number matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
5]] [] [] [] []
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (MonthOfYear -> UTCTime -> UTCTime
withMinute MonthOfYear
5 UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a range matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
4, Word8
5]] [] [] [] []
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (MonthOfYear -> UTCTime -> UTCTime
withMinute MonthOfYear
5 UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a choice matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
4], [Word8
5]] [] [] [] []
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (MonthOfYear -> UTCTime -> UTCTime
withMinute MonthOfYear
5 UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a number matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
0 MonthOfYear
5 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
5]] [] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a number does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
0 MonthOfYear
6 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
5]] [] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a range matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
0 MonthOfYear
5 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
4, Word8
5]] [] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a range does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
0 MonthOfYear
6 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
4, Word8
5]] [] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a choice matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
0 MonthOfYear
5 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
4], [Word8
5]] [] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a choice does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
0 MonthOfYear
6 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
4], [Word8
5]] [] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any second" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
0 MonthOfYear
5 Pico
6
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
5]] [] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any hour" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
6 MonthOfYear
5 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
5]] [] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any day" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
6 MonthOfYear
0 MonthOfYear
5 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
5]] [] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any month" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
6 MonthOfYear
1 MonthOfYear
0 MonthOfYear
5 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
5]] [] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

    forall a. HasCallStack => String -> SpecWith a -> SpecWith a
Hspec.describe String
"hour" forall a b. (a -> b) -> a -> b
$ do
      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a number matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
5]] [] [] []
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (MonthOfYear -> UTCTime -> UTCTime
withHour MonthOfYear
5 UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a range matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
4, Word8
5]] [] [] []
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (MonthOfYear -> UTCTime -> UTCTime
withHour MonthOfYear
5 UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a choice matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
4], [Word8
5]] [] [] []
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (MonthOfYear -> UTCTime -> UTCTime
withHour MonthOfYear
5 UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a number matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
5 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
5]] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a number does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
6 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
5]] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a range matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
5 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
4, Word8
5]] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a range does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
6 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
4, Word8
5]] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a choice matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
5 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
4], [Word8
5]] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a choice does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
6 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
4], [Word8
5]] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any second" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
5 MonthOfYear
0 Pico
6
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
5]] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any minute" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
5 MonthOfYear
6 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
5]] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any day" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
6 MonthOfYear
5 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
5]] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any month" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
6 MonthOfYear
1 MonthOfYear
5 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [[Word8
5]] [] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

    forall a. HasCallStack => String -> SpecWith a -> SpecWith a
Hspec.describe String
"day" forall a b. (a -> b) -> a -> b
$ do
      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a number matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
5]] [] []
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (MonthOfYear -> UTCTime -> UTCTime
withDayOfMonth MonthOfYear
5 UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a range matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
4, Word8
5]] [] []
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (MonthOfYear -> UTCTime -> UTCTime
withDayOfMonth MonthOfYear
5 UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a choice matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
4], [Word8
5]] [] []
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (MonthOfYear -> UTCTime -> UTCTime
withDayOfMonth MonthOfYear
5 UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a number matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
5 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
5]] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a number does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
6 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
5]] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a range matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
5 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
4, Word8
5]] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a range does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
6 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
4, Word8
5]] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a choice matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
5 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
4], [Word8
5]] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a choice does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
6 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
4], [Word8
5]] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any second" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
5 MonthOfYear
0 MonthOfYear
0 Pico
6
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
5]] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any minute" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
5 MonthOfYear
0 MonthOfYear
6 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
5]] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any hour" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
5 MonthOfYear
6 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
5]] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any month" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
6 MonthOfYear
5 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [[Word8
5]] [] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

    forall a. HasCallStack => String -> SpecWith a -> SpecWith a
Hspec.describe String
"month" forall a b. (a -> b) -> a -> b
$ do
      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a number matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
5]] []
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (MonthOfYear -> UTCTime -> UTCTime
withMonthOfYear MonthOfYear
5 UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a range matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
4, Word8
5]] []
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (MonthOfYear -> UTCTime -> UTCTime
withMonthOfYear MonthOfYear
5 UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a choice matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
4], [Word8
5]] []
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (MonthOfYear -> UTCTime -> UTCTime
withMonthOfYear MonthOfYear
5 UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a number matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
5 MonthOfYear
1 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
5]] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a number does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
6 MonthOfYear
1 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
5]] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a range matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
5 MonthOfYear
1 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
4, Word8
5]] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a range does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
6 MonthOfYear
1 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
4, Word8
5]] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a choice matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
5 MonthOfYear
1 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
4], [Word8
5]] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a choice does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
6 MonthOfYear
1 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
4], [Word8
5]] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any second" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
5 MonthOfYear
1 MonthOfYear
0 MonthOfYear
0 Pico
6
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
5]] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any minute" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
5 MonthOfYear
1 MonthOfYear
0 MonthOfYear
6 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
5]] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any hour" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
5 MonthOfYear
1 MonthOfYear
6 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
5]] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any day" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
5 MonthOfYear
6 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [[Word8
5]] []
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

    forall a. HasCallStack => String -> SpecWith a -> SpecWith a
Hspec.describe String
"weekday" forall a b. (a -> b) -> a -> b
$ do
      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a number matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
5]]
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (DayOfWeek -> UTCTime -> UTCTime
withDayOfWeek DayOfWeek
Time.Friday UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a range matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
4, Word8
5]]
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (DayOfWeek -> UTCTime -> UTCTime
withDayOfWeek DayOfWeek
Time.Friday UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always true when a choice matches"
        forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
        forall a b. (a -> b) -> a -> b
$ \UTCTime
utcTime -> do
          Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
4], [Word8
5]]
          Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch (DayOfWeek -> UTCTime -> UTCTime
withDayOfWeek DayOfWeek
Time.Friday UTCTime
utcTime)

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a number matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
2 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
5]]
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a number does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
3 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
5]]
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a range matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
2 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
4, Word8
5]]
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a range does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
3 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
4, Word8
5]]
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is true when a choice matches" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
2 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
4], [Word8
5]]
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is false when a choice does not match" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
3 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
4], [Word8
5]]
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldNotSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any second" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
2 MonthOfYear
0 MonthOfYear
0 Pico
6
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
5]]
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any minute" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
2 MonthOfYear
0 MonthOfYear
6 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
5]]
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any hour" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
2 MonthOfYear
6 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
5]]
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

      forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"accepts any day" forall a b. (a -> b) -> a -> b
$ do
        UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
9 MonthOfYear
0 MonthOfYear
0 Pico
0
        Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] [[Word8
5]]
        Schedule
s forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t

  forall a. HasCallStack => String -> SpecWith a -> SpecWith a
Hspec.describe String
"nextMatch" forall a b. (a -> b) -> a -> b
$ do
    forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"succeeds with a leap day" forall a b. (a -> b) -> a -> b
$ do
      Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
0]] [[Word8
0]] [[Word8
29]] [[Word8
2]] []
      UTCTime
t1 <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
0 MonthOfYear
0 Pico
0
      UTCTime
t2 <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1972 MonthOfYear
2 MonthOfYear
29 MonthOfYear
0 MonthOfYear
0 Pico
0
      UTCTime -> Schedule -> Maybe UTCTime
Match.nextMatch UTCTime
t1 Schedule
s forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`Hspec.shouldBe` forall a. a -> Maybe a
Just UTCTime
t2

    forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"succeeds with the next leap day" forall a b. (a -> b) -> a -> b
$ do
      Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
0]] [[Word8
0]] [[Word8
29]] [[Word8
2]] []
      UTCTime
t1 <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1972 MonthOfYear
2 MonthOfYear
29 MonthOfYear
0 MonthOfYear
0 Pico
0
      UTCTime
t2 <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1976 MonthOfYear
2 MonthOfYear
29 MonthOfYear
0 MonthOfYear
0 Pico
0
      UTCTime -> Schedule -> Maybe UTCTime
Match.nextMatch UTCTime
t1 Schedule
s forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`Hspec.shouldBe` forall a. a -> Maybe a
Just UTCTime
t2

    forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"succeeds with the furthest leap day" forall a b. (a -> b) -> a -> b
$ do
      Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
0]] [[Word8
0]] [[Word8
29]] [[Word8
2]] []
      UTCTime
t1 <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1896 MonthOfYear
2 MonthOfYear
29 MonthOfYear
0 MonthOfYear
0 Pico
0
      UTCTime
t2 <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1904 MonthOfYear
2 MonthOfYear
29 MonthOfYear
0 MonthOfYear
0 Pico
0
      UTCTime -> Schedule -> Maybe UTCTime
Match.nextMatch UTCTime
t1 Schedule
s forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`Hspec.shouldBe` forall a. a -> Maybe a
Just UTCTime
t2

    forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"fails with an impossible date" forall a b. (a -> b) -> a -> b
$ do
      Schedule
s <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [[Word8
0]] [[Word8
0]] [[Word8
30]] [[Word8
2]] []
      UTCTime
t <- forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
1970 MonthOfYear
1 MonthOfYear
1 MonthOfYear
0 MonthOfYear
0 Pico
0
      UTCTime -> Schedule -> Maybe UTCTime
Match.nextMatch UTCTime
t Schedule
s forall a. (HasCallStack, Show a, Eq a) => a -> a -> IO ()
`Hspec.shouldBe` forall a. Maybe a
Nothing

    forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"is always in the future"
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
      forall a b. (a -> b) -> a -> b
$ \UTCTime
t1 -> do
        Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] []
        UTCTime
t2 <- forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"impossible") forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ UTCTime -> Schedule -> Maybe UTCTime
Match.nextMatch UTCTime
t1 Schedule
schedule
        UTCTime
t2 forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` (forall a. Ord a => a -> a -> Bool
>= UTCTime
t1)

    forall a.
(HasCallStack, Example a) =>
String -> a -> SpecWith (Arg a)
Hspec.it String
"always matches"
      forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a prop.
(Show a, Testable prop) =>
Gen a -> (a -> [a]) -> (a -> prop) -> Property
QuickCheck.forAllShrink Gen UTCTime
arbitraryUtcTime UTCTime -> [UTCTime]
shrinkUtcTime
      forall a b. (a -> b) -> a -> b
$ \UTCTime
t1 -> do
        Schedule
schedule <- forall (m :: * -> *).
MonadFail m =>
[[Word8]]
-> [[Word8]] -> [[Word8]] -> [[Word8]] -> [[Word8]] -> m Schedule
ScheduleSpec.new [] [] [] [] []
        UTCTime
t2 <- forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"impossible") forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ UTCTime -> Schedule -> Maybe UTCTime
Match.nextMatch UTCTime
t1 Schedule
schedule
        Schedule
schedule forall a. (HasCallStack, Show a) => a -> (a -> Bool) -> IO ()
`Hspec.shouldSatisfy` UTCTime -> Schedule -> Bool
Match.isMatch UTCTime
t2

withMinute :: Int -> Time.UTCTime -> Time.UTCTime
withMinute :: MonthOfYear -> UTCTime -> UTCTime
withMinute MonthOfYear
minute = (TimeOfDay -> TimeOfDay) -> UTCTime -> UTCTime
overTimeOfDay forall a b. (a -> b) -> a -> b
$ \TimeOfDay
timeOfDay -> TimeOfDay
timeOfDay {todMin :: MonthOfYear
Time.todMin = MonthOfYear
minute}

withHour :: Int -> Time.UTCTime -> Time.UTCTime
withHour :: MonthOfYear -> UTCTime -> UTCTime
withHour MonthOfYear
hour = (TimeOfDay -> TimeOfDay) -> UTCTime -> UTCTime
overTimeOfDay forall a b. (a -> b) -> a -> b
$ \TimeOfDay
timeOfDay -> TimeOfDay
timeOfDay {todHour :: MonthOfYear
Time.todHour = MonthOfYear
hour}

overTimeOfDay :: (Time.TimeOfDay -> Time.TimeOfDay) -> Time.UTCTime -> Time.UTCTime
overTimeOfDay :: (TimeOfDay -> TimeOfDay) -> UTCTime -> UTCTime
overTimeOfDay TimeOfDay -> TimeOfDay
f UTCTime
utcTime =
  UTCTime
utcTime
    { utctDayTime :: DiffTime
Time.utctDayTime =
        TimeOfDay -> DiffTime
Time.sinceMidnight forall b c a. (b -> c) -> (a -> b) -> a -> c
. TimeOfDay -> TimeOfDay
f forall b c a. (b -> c) -> (a -> b) -> a -> c
. DiffTime -> TimeOfDay
Time.pastMidnight forall a b. (a -> b) -> a -> b
$ UTCTime -> DiffTime
Time.utctDayTime UTCTime
utcTime
    }

withDayOfMonth :: Time.DayOfMonth -> Time.UTCTime -> Time.UTCTime
withDayOfMonth :: MonthOfYear -> UTCTime -> UTCTime
withDayOfMonth MonthOfYear
dayOfMonth = (Day -> Day) -> UTCTime -> UTCTime
overDay forall a b. (a -> b) -> a -> b
$ \Day
day ->
  let (Integer
year, MonthOfYear
monthOfYear, MonthOfYear
_) = Day -> (Integer, MonthOfYear, MonthOfYear)
Time.toGregorian Day
day
   in Integer -> MonthOfYear -> MonthOfYear -> Day
Time.fromGregorian Integer
year MonthOfYear
monthOfYear MonthOfYear
dayOfMonth

withMonthOfYear :: Time.MonthOfYear -> Time.UTCTime -> Time.UTCTime
withMonthOfYear :: MonthOfYear -> UTCTime -> UTCTime
withMonthOfYear MonthOfYear
monthOfYear = (Day -> Day) -> UTCTime -> UTCTime
overDay forall a b. (a -> b) -> a -> b
$ \Day
day ->
  let (Integer
year, MonthOfYear
_, MonthOfYear
dayOfMonth) = Day -> (Integer, MonthOfYear, MonthOfYear)
Time.toGregorian Day
day
   in Integer -> MonthOfYear -> MonthOfYear -> Day
Time.fromGregorian Integer
year MonthOfYear
monthOfYear MonthOfYear
dayOfMonth

withDayOfWeek :: Time.DayOfWeek -> Time.UTCTime -> Time.UTCTime
withDayOfWeek :: DayOfWeek -> UTCTime -> UTCTime
withDayOfWeek DayOfWeek
dayOfWeek = (Day -> Day) -> UTCTime -> UTCTime
overDay forall a b. (a -> b) -> a -> b
$ \Day
day ->
  let fwt :: FirstWeekType
fwt = FirstWeekType
Time.FirstWholeWeek
      dow :: DayOfWeek
dow = DayOfWeek
Time.Sunday
      (Integer
year, MonthOfYear
weekOfYear, DayOfWeek
_) = FirstWeekType
-> DayOfWeek -> Day -> (Integer, MonthOfYear, DayOfWeek)
Time.toWeekCalendar FirstWeekType
fwt DayOfWeek
dow Day
day
   in FirstWeekType
-> DayOfWeek -> Integer -> MonthOfYear -> DayOfWeek -> Day
Time.fromWeekCalendar FirstWeekType
fwt DayOfWeek
dow Integer
year MonthOfYear
weekOfYear DayOfWeek
dayOfWeek

overDay :: (Time.Day -> Time.Day) -> Time.UTCTime -> Time.UTCTime
overDay :: (Day -> Day) -> UTCTime -> UTCTime
overDay Day -> Day
f UTCTime
utcTime = UTCTime
utcTime {utctDay :: Day
Time.utctDay = Day -> Day
f forall a b. (a -> b) -> a -> b
$ UTCTime -> Day
Time.utctDay UTCTime
utcTime}

newUtcTime ::
  (MonadFail m) =>
  Time.Year ->
  Time.MonthOfYear ->
  Time.DayOfMonth ->
  Int ->
  Int ->
  Fixed.Pico ->
  m Time.UTCTime
newUtcTime :: forall (m :: * -> *).
MonadFail m =>
Integer
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> MonthOfYear
-> Pico
-> m UTCTime
newUtcTime Integer
year MonthOfYear
monthOfYear MonthOfYear
dayOfMonth MonthOfYear
hour MonthOfYear
minute Pico
second = do
  Day
day <-
    forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"invalid Day") forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$
      Integer -> MonthOfYear -> MonthOfYear -> Maybe Day
Time.fromGregorianValid Integer
year MonthOfYear
monthOfYear MonthOfYear
dayOfMonth
  TimeOfDay
timeOfDay <-
    forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"invalid TimeOfDay") forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$
      MonthOfYear -> MonthOfYear -> Pico -> Maybe TimeOfDay
Time.makeTimeOfDayValid MonthOfYear
hour MonthOfYear
minute Pico
second
  forall (f :: * -> *) a. Applicative f => a -> f a
pure
    Time.UTCTime
      { utctDay :: Day
Time.utctDay = Day
day,
        utctDayTime :: DiffTime
Time.utctDayTime = TimeOfDay -> DiffTime
Time.sinceMidnight TimeOfDay
timeOfDay
      }

arbitraryUtcTime :: QuickCheck.Gen Time.UTCTime
arbitraryUtcTime :: Gen UTCTime
arbitraryUtcTime =
  Day -> DiffTime -> UTCTime
Time.UTCTime
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Integer -> Day
Time.ModifiedJulianDay forall a. Arbitrary a => Gen a
QuickCheck.arbitrary
    forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Integer -> DiffTime
Time.picosecondsToDiffTime ((Integer, Integer) -> Gen Integer
QuickCheck.chooseInteger (Integer
0, Integer
86400000000000000 forall a. Num a => a -> a -> a
- Integer
1))

shrinkUtcTime :: Time.UTCTime -> [Time.UTCTime]
shrinkUtcTime :: UTCTime -> [UTCTime]
shrinkUtcTime =
  forall a b. Arbitrary a => (a -> b) -> (b -> a) -> b -> [b]
QuickCheck.shrinkMap
    ( \(Integer
d, Integer
t) ->
        Time.UTCTime
          { utctDay :: Day
Time.utctDay = Integer -> Day
Time.ModifiedJulianDay Integer
d,
            utctDayTime :: DiffTime
Time.utctDayTime = Integer -> DiffTime
Time.picosecondsToDiffTime Integer
t
          }
    )
    ( \UTCTime
x ->
        ( Day -> Integer
Time.toModifiedJulianDay forall a b. (a -> b) -> a -> b
$ UTCTime -> Day
Time.utctDay UTCTime
x,
          DiffTime -> Integer
Time.diffTimeToPicoseconds forall a b. (a -> b) -> a -> b
$ UTCTime -> DiffTime
Time.utctDayTime UTCTime
x
        )
    )