示例#1
0
 async def test_decrease(self):
     resources = Resources(a=40, b=40)
     async with resources.borrow(a=20, b=20):
         await resources.decrease(a=10, b=10)
         async with until(time == 10):
             async with resources.borrow(a=20, b=20):
                 assert False
         assert time == 10
     async with resources.borrow(a=30, b=30):
         assert True
     async with until(time == 20):
         async with resources.borrow(a=40, b=40):
             assert False
     assert time == 20
示例#2
0
async def test_for_interval():
    expected_time = 5
    async with until(time == 60):
        async for _ in interval(5):
            assert time.now == expected_time
            expected_time += 5
    assert time.now == 60
示例#3
0
 async def test_release_self(self):
     """Condition is set synchronously"""
     flag = Flag()
     entered, exited = False, False
     async with until(flag):
         entered = True
         await flag.set()  # get interrupted immediately
         exited = True
     assert entered and not exited
示例#4
0
 async def test_before(self):
     start = time.now
     assert not (time < time.now)
     assert (time < time.now + 20)
     assert ~(time < time.now)
     assert not ~(time < time.now + 20)
     await (time < time.now + 20)
     async with until(time + 20):
         await (time < time.now)
     assert time.now == start + 20
示例#5
0
 async def test_release_early(self):
     """Condition is set before entering interrupt scope"""
     flag = Flag()
     await flag.set()
     entered, exited = False, False
     async with until(flag):
         entered = True
         await instant
         exited = True
     assert entered and not exited
示例#6
0
async def car(end: float):
    async with until(time == end):
        while True:
            print('Start parking at %d' % time.now)
            parking_duration = 5
            await (time + parking_duration)

            print('Start driving at %d' % time.now)
            trip_duration = 2
            await (time + trip_duration)
示例#7
0
 async def test_release_concurrent(self):
     """Condition is set concurrently"""
     flag = Flag()
     entered, exited = False, False
     async with until(flag) as scope:
         scope.do(flag.set())
         await instant  # start task
         entered = True
         await instant
         exited = True
     assert entered and not exited
示例#8
0
 async def _simulate(self, end):
     print(f"Starting simulation at {time.now}")
     async with until(time == end) if end else Scope() as while_running:
         for pool in self.pools:
             while_running.do(pool.run(), volatile=True)
         for job_input, job_reader in self._job_generators:
             while_running.do(self._queue_jobs(job_input, job_reader))
         while_running.do(self.job_scheduler.run())
         for controller in self.controllers:
             while_running.do(controller.run(), volatile=True)
         while_running.do(self.monitoring.run(), volatile=True)
     self.duration = time.now
     print(f"Finished simulation at {self.duration}")
示例#9
0
async def test_reuse():
    async def make_job():
        async with Scope() as scope:
            running_job = scope.do(run_job())
            running_job.cancel()
            await running_job.done

    async def run_job():
        await (time + 100)

    async with until(time == 500) as running:
        activity = running.do(make_job())
    await activity
示例#10
0
async def test_until():
    async def scheduler():
        async with Scope() as scope:
            while True:
                scope.do(run_job())
                await (time + 500)

    async def run_job():
        await (time + 1000)

    async with until(time == 500) as running:
        activity = running.do(scheduler())

    assert time.now == 500
    with pytest.raises(TaskClosed):
        await activity
示例#11
0
 async def test_previous_before(self):
     start, delay = time.now, 20
     async with until(time == start + delay):
         await (time < start - 5)  # await moment in the past
         assert False, "Before in the past should never pass"
     assert start + delay == time.now
示例#12
0
 async def test_previous_after(self):
     start, delay = time.now, 20
     async with until(time == start + delay):
         await (time >= start - 5)  # await moment in the past
         assert True, "After in the past should always pass"
     assert start == time.now
示例#13
0
async def test_representable():
    async with Scope() as scope:
        str(scope), repr(scope)
    async with until(time == 200) as scope:
        str(scope), repr(scope)