def test_forward_non_recurrent_random(unit, overlap, trim):
"""`forward()` method of non-recurrent time intervals with and without
overlapping `start` date."""
correction = BASE[unit]
max_ = add_delta(MAX, -1 * N, unit)
unit_maximum = delta(MIN, max_, unit)
interval = sorted(randuniq(2, correction, unit_maximum))
if overlap:
start = add_delta(
MIN,
rnd.randrange(int(interval[0]), int(interval[1])) - correction,
unit
)
else:
start = add_delta(MIN, int(interval[0]) - correction, unit)
if trim:
expected_start = start
else:
expected_start = add_delta(MIN, int(interval[0]) - correction, unit)
stop = add_delta(MIN, int(interval[1]) - correction, unit)
expected = [(expected_start, stop)]
recurrentevent = RecurrentEvent(interval[0], interval[1], unit, None)
actual = list(islice(recurrentevent.forward(start, trim), None, N))
assert actual == expected
def test_forward_non_recurrent_random(unit, overlap):
"""`forward()` method of non-recurrent time intervals with and without
overlapping `start` date."""
correction = BASE[unit]
max_ = add_delta(MAX, -1 * N, unit)
unit_maximum = delta(MIN, max_, unit)
interval = Interval(*sorted(randuniq(2, correction, unit_maximum)))
if overlap:
start = add_delta(
MIN,
rnd.randrange(
int(interval.start), int(interval.stop)
) - correction,
unit
)
else:
start = add_delta(MIN,
int(interval.start) - correction,
unit)
stop = add_delta(MIN, int(interval.stop) - correction + 1, unit)
expected = [Interval(start, stop)]
timeinterval = TimeInterval(interval, unit, None)
actual = list(islice(timeinterval.forward(start), None, N))
assert actual == expected
def test_forward_recurrent_random(unit, recurrence, overlap, trim):
"""`forward()` method of recurrent time intervals with and without
overlapping `start` date."""
correction = BASE[unit]
max_ = add_delta(MAX, -1 * N, recurrence)
unit_maximum = delta(MIN, add_delta(MIN, 1, recurrence), unit)
from_, to = sorted(randuniq(2, correction, unit_maximum))
expected = []
initial = start = floor(
add_delta(MIN, rnd.randrange(delta(MIN, max_, unit)), unit),
recurrence
)
if overlap:
initial = start = add_delta(
initial,
rnd.randrange(
int(from_), int(to)
) - correction,
unit
)
for i in range(N):
recurrence_start = floor(start, recurrence)
recurrence_stop = floor(add_delta(recurrence_start, 1, recurrence),
recurrence)
first = floor(add_delta(recurrence_start,
from_ - correction,
unit), unit)
second = floor(add_delta(recurrence_start, to - correction, unit),
unit)
first = max(recurrence_start, min(first, recurrence_stop))
second = min(recurrence_stop, second)
assert first <= second
assert start <= second
if start > first and trim:
first = start
expected.append((first, second))
start = floor(add_delta(recurrence_start, 1, recurrence), recurrence)
recurrentevent = RecurrentEvent(from_, to, unit, recurrence)
actual = list(islice(recurrentevent.forward(initial, trim), None, N))
assert actual == expected
def test_forward_recurrent_random(unit, recurrence, overlap):
"""`forward()` method of recurrent time intervals with and without
overlapping `start` date."""
correction = BASE[unit]
max_ = add_delta(MAX, -1 * N, recurrence)
unit_maximum = delta(MIN, add_delta(MIN, 1, recurrence), unit)
interval = Interval(*sorted(randuniq(2, correction, unit_maximum)))
expected = []
initial = start = floor(
add_delta(MIN, rnd.randrange(delta(MIN, max_, unit)), unit),
recurrence
)
if overlap:
initial = start = add_delta(
initial,
rnd.randrange(
int(interval.start), int(interval.stop)
) - correction,
unit
)
for i in range(N):
recurrence_start = floor(start, recurrence)
first = floor(add_delta(recurrence_start,
interval.start - correction,
unit), unit)
second = add_delta(floor(add_delta(recurrence_start,
interval.stop - correction,
unit),
unit), 1, unit)
assert first < second
assert start < second
if start > first:
first = start
expected.append(Interval(first, second))
start = floor(add_delta(recurrence_start, 1, recurrence), recurrence)
timeinterval = TimeInterval(interval, unit, recurrence)
actual = list(islice(timeinterval.forward(initial), None, N))
assert actual == expected
