def update_lease_wrapper(self, reservation: ReservationClient, rtype: ResourceType, units: int, cs: ABCConcreteSet, term: Term): if reservation.state == ReservationStates.Ticketed: reservation.leased_resources = reservation.resources.abstract_clone( ) reservation.leased_resources.units = units reservation.leased_resources.type = rtype reservation.leased_resources.set_resources(cset=cs) reservation.previous_lease_term = None reservation.previous_term = reservation.term reservation.lease_term = term.clone() reservation.term = reservation.lease_term reservation.transition(prefix="redeem", state=ReservationStates.Active, pending=ReservationPendingStates.None_) else: reservation.leased_resources.units = units reservation.leased_resources.type = rtype reservation.leased_resources.resources.change(concrete_set=cs, configure=False) reservation.previous_lease_term = reservation.requested_term reservation.previous_term = reservation.term reservation.lease_term = term.clone() reservation.term = reservation.lease_term reservation.transition(prefix="redeem", state=ReservationStates.Active, pending=ReservationPendingStates.None_)
def update_ticket_wrapper(self, reservation: ReservationClient, rtype: ResourceType, units: int, ticket: Ticket, term: Term): if reservation.state == ReservationStates.Nascent: reservation.resources = reservation.get_approved_resources( ).abstract_clone() reservation.resources.units = units reservation.resources.type = rtype reservation.resources.set_resources(cset=ticket) reservation.previous_ticket_term = None reservation.previous_term = None reservation.term = term.clone() reservation.ticket_term = reservation.term reservation.transition(prefix="ticket", state=ReservationStates.Ticketed, pending=ReservationPendingStates.None_) else: reservation.resources.units = units reservation.resources.type = rtype reservation.resources.resources.change(concrete_set=ticket, configure=False) reservation.previous_term = reservation.term reservation.previous_ticket_term = reservation.ticket_term reservation.term = term.clone() reservation.ticket_term = reservation.term reservation.transition(prefix="extendticket", state=ReservationStates.ActiveTicketed, pending=ReservationPendingStates.None_)
def get_authority(self, name: str = BaseTestCase.authority_name, guid: ID = BaseTestCase.authority_guid): authority = self.get_registered_new_actor() authority.set_recovered(value=True) Term.set_clock(clock=authority.get_actor_clock()) return authority
def get_authority(self, name: str = BaseTestCase.authority_name, guid: ID = BaseTestCase.authority_guid): db = self.get_container_database() db.reset_db() authority = super().get_authority() authority.set_recovered(value=True) authority.set_aggregate_resource_model(aggregate_resource_model=self.arm) authority.get_plugin().handler_processor.add_config_mapping(mapping=self.get_config_map()) Term.set_clock(authority.get_actor_clock()) return authority
def check_not_valid(self, *, term: Term): failed = False try: term.validate() except Exception: failed = True self.assertTrue(failed)
def get_broker(self, *, name: str = BaseTestCase.broker_name, guid: ID = BaseTestCase.broker_guid) -> ABCBrokerMixin: db = self.get_container_database() db.reset_db() self.broker = super().get_broker() self.broker.set_recovered(value=True) Term.set_clock(self.broker.get_actor_clock()) return self.broker
def test_equals(self): start = 1000 end = 1499 length = 500 t = Term(start=ActorClock.from_milliseconds(milli_seconds=start), end=ActorClock.from_milliseconds(milli_seconds=end)) self.check(term=t, start=start, new_start=start, end=end) self.assertEqual(length, t.get_length()) self.assertTrue(t == t) t1 = Term(start=ActorClock.from_milliseconds(milli_seconds=start), end=ActorClock.from_milliseconds(milli_seconds=end)) self.check(term=t1, start=start, new_start=start, end=end) self.assertEqual(length, t1.get_length()) t2 = Term(start=ActorClock.from_milliseconds(milli_seconds=start + 100), end=ActorClock.from_milliseconds(milli_seconds=end)) self.check(term=t2, start=start + 100, new_start=start + 100, end=end) self.assertEqual(length - 100, t2.get_length()) self.assertTrue(t == t1) self.assertFalse(t == t2) self.assertFalse(t == 11) class Abc: def __init__(self): self.num = 1 self.assertFalse(t == Abc())
def test_change(self): start = 1000 end = 1499 length = 500 t = Term(start=ActorClock.from_milliseconds(milli_seconds=start), end=ActorClock.from_milliseconds(milli_seconds=end)) self.check(term=t, start=start, new_start=start, end=end) self.assertEqual(length, t.get_length()) t1 = t.change_length(length=2 * length) self.check(term=t1, start=start, new_start=start, end=end+length) self.assertEqual(length * 2, t1.get_length()) t1 = t.change_length(length=int(length/2)) self.check(term=t1, start=start, new_start=start, end=int(end - length/2)) self.assertEqual(length / 2, t1.get_length())
def test_c_fail(self): controller = self.get_controller() clock = controller.get_actor_clock() Term.clock = clock resources = ResourceSet(units=1, rtype=ResourceType(resource_type="1")) slice_obj = SliceFactory.create(slice_id=ID(), name="fail") controller.register_slice(slice_object=slice_obj) start = 5 end = 10 term = Term(start=clock.cycle_start_date(cycle=start), end=clock.cycle_end_date(cycle=end)) r1 = ClientReservationFactory.create(rid=ID(), resources=resources, term=term, slice_object=slice_obj) r1.set_renewable(renewable=False) controller.register(reservation=r1) controller.demand(rid=r1.get_reservation_id()) r2 = ClientReservationFactory.create(rid=ID(), resources=resources, term=term, slice_object=slice_obj) r2.set_renewable(renewable=False) controller.register(reservation=r2) controller.demand(rid=r2.get_reservation_id()) for i in range(1, end + 3): controller.external_tick(cycle=i) while controller.get_current_cycle() != i: time.sleep(0.001) if i >= start and (i < (end - 1)): self.assertTrue(r1.is_closed()) self.assertTrue(r2.is_closed()) self.assertTrue(r2.get_notices().__contains__(Constants.CLOSURE_BY_TICKET_REVIEW_POLICY))
def ticket(self, *, reservation: ABCBrokerReservation, node_id_to_reservations: dict) -> Tuple[bool, dict, Any]: self.logger.debug( f"cycle: {self.actor.get_current_cycle()} new ticket request: " f"{reservation}/{type(reservation).__name__}") error_msg = None start = self.align_start( when=reservation.get_requested_term().get_new_start_time()) end = self.align_end( when=reservation.get_requested_term().get_end_time()) resource_type = reservation.get_requested_resources().get_type() if resource_type is None or not self.inventory.contains_type( resource_type=resource_type): resource_type = self.get_default_resource_type() if resource_type is not None: inv = self.inventory.get(resource_type=resource_type) if inv is not None: self.logger.debug(f"Inventory type: {type(inv)}") term = Term(start=start, end=end) return self.ticket_inventory( reservation=reservation, inv=inv, term=term, node_id_to_reservations=node_id_to_reservations) else: reservation.fail(message=Constants.NO_POOL) else: reservation.fail(message=Constants.NO_POOL) return False, node_id_to_reservations, error_msg
def test_extend(self): start_ms = 1000 end_ms = 1499 length_ms = 500 t = Term(start=ActorClock.from_milliseconds(milli_seconds=start_ms), end=ActorClock.from_milliseconds(milli_seconds=end_ms)) self.assertEqual(length_ms, t.get_length()) self.check(term=t, start=start_ms, new_start=start_ms, end=end_ms) # extend with same length t1 = t.extend() self.check(term=t1, start=start_ms, new_start=end_ms + 1, end=end_ms + length_ms) self.assertEqual(length_ms, t1.get_length()) self.assertEqual(2 * length_ms, t1.get_full_length()) self.assertTrue(t1.extends_term(old_term=t)) # extend multiple times for i in range(10): t2 = t1.extend() self.check(start=ActorClock.to_milliseconds(when=t1.get_start_time()), new_start=ActorClock.to_milliseconds(when=t1.get_end_time()) + 1, end=ActorClock.to_milliseconds(when=t1.get_end_time()) + length_ms, term=t2) self.assertEqual(length_ms, t2.get_length()) self.assertEqual(t1.get_full_length() + length_ms, t2.get_full_length()) self.assertTrue(t2.extends_term(old_term=t1)) t1 = t2 # extend with 1000 l = 1000 t1 = t.extend(length=l) self.check(start=start_ms, new_start=end_ms+1, end=end_ms+l, term=t1) self.assertEqual(l, t1.get_length()) self.assertEqual(l + length_ms, t1.get_full_length()) # extend multiple times for i in range(10): t2 = t1.extend() self.check(start=ActorClock.to_milliseconds(when=t1.get_start_time()), new_start=ActorClock.to_milliseconds(when=t1.get_end_time()) + 1, end=ActorClock.to_milliseconds(when=t1.get_end_time()) + l, term=t2) self.assertEqual(l, t2.get_length()) self.assertEqual(t1.get_full_length() + l, t2.get_full_length()) self.assertTrue(t2.extends_term(old_term=t2)) t1 = t2
def get_extend_lease_request(self, authority: ABCAuthority, delegation: ABCDelegation, request: ABCAuthorityReservation): req_start = authority.get_actor_clock().cycle_start_date(cycle=self.TicketStartCycle) req_new_start = authority.get_actor_clock().cycle_start_date(cycle=self.TicketEndCycle + 1) req_end = authority.get_actor_clock().cycle_end_date(cycle=self.TicketNewEndCycle) req_term = Term(start=req_start, end=req_end, new_start=req_new_start) rtype = ResourceType(resource_type=request.get_requested_resources().get_sliver().resource_type.name) ticket = self.get_ticket(self.TicketUnits, rtype, req_term, delegation, authority) new_request = self.get_request_from_request(request, req_term, ticket) return new_request
def add_reservation_private(self, *, reservation: TicketReservationAvro): result = ResultAvro() slice_id = ID(uid=reservation.get_slice_id()) rset = Converter.get_resource_set(res_mng=reservation) term = Term(start=ActorClock.from_milliseconds( milli_seconds=reservation.get_start()), end=ActorClock.from_milliseconds( milli_seconds=reservation.get_end())) broker = None if reservation.get_broker() is not None: broker = ID(uid=reservation.get_broker()) rid = None if reservation.get_reservation_id() is not None: rid = ID(uid=reservation.get_reservation_id()) else: rid = ID() rc = ClientReservationFactory.create(rid=rid, resources=rset, term=term) rc.set_renewable(renewable=reservation.is_renewable()) if rc.get_state() != ReservationStates.Nascent or rc.get_pending_state( ) != ReservationPendingStates.None_: result.set_code(ErrorCodes.ErrorInvalidReservation.value) result.set_message( "Only reservations in Nascent.None can be added") return None, result slice_obj = self.client.get_slice(slice_id=slice_id) if slice_obj is None: result.set_code(ErrorCodes.ErrorNoSuchSlice.value) result.set_message(ErrorCodes.ErrorNoSuchSlice.interpret()) return None, result rc.set_slice(slice_object=slice_obj) proxy = None if broker is None: proxy = self.client.get_default_broker() else: proxy = self.client.get_broker(guid=broker) if proxy is None: result.set_code(ErrorCodes.ErrorNoSuchBroker.value) result.set_message(ErrorCodes.ErrorNoSuchBroker.interpret()) return None, result rc.set_broker(broker=proxy) self.client.register(reservation=rc) return rc.get_reservation_id(), result
def get_redeem_request(self, authority: ABCAuthority, delegation: ABCDelegation): req_start = authority.get_actor_clock().cycle_start_date(cycle=self.TicketStartCycle) req_end = authority.get_actor_clock().cycle_end_date(cycle=self.TicketEndCycle) req_term = Term(start=req_start, end=req_end) sliver = self.build_sliver() ticket = self.get_ticket(units=self.TicketUnits, rtype=ResourceType(resource_type=sliver.resource_type.name), term=req_term, source=delegation, actor=authority) request = self.get_request(req_term, ticket, sliver) return request
def get_reservation_for_network_node(self, start: datetime, end: datetime, sliver: NodeSliver): slice_obj = SliceFactory.create(slice_id=ID(), name="test-slice") rtype = ResourceType(resource_type=sliver.resource_type.name) rset = ResourceSet(units=1, rtype=rtype, sliver=sliver) term = Term(start=start, end=end) request = BrokerReservationFactory.create(rid=ID(), resources=rset, term=term, slice_obj=slice_obj) return request
def get_close(self, *, term: Term) -> int: """ Return the cycle when a term closes @params term: the term @returns the cycle of the end of a term """ if self.lazy_close: return -1 else: return self.clock.cycle(when=term.get_end_time()) + 1
def translate_term(*, term: Term) -> TermAvro: avro_term = TermAvro() if term.get_start_time() is not None: avro_term.start_time = ActorClock.to_milliseconds(when=term.get_start_time()) else: term.start_time = 0 if term.get_end_time() is not None: avro_term.end_time = ActorClock.to_milliseconds(when=term.get_end_time()) else: term.end_time = 0 if term.get_new_start_time() is not None: avro_term.new_start_time = ActorClock.to_milliseconds(when=term.get_new_start_time()) else: avro_term.new_start_time = 0 return avro_term
def check(self, *, term: Term, start: int = None, new_start: int = None, end: int = None): if start is not None and new_start is not None and end is not None: self.assertIsNotNone(term.start_time) self.assertIsNotNone(term.new_start_time) self.assertIsNotNone(term.end_time) self.assertIsNotNone(term.get_start_time()) self.assertIsNotNone(term.get_new_start_time()) self.assertIsNotNone(term.get_end_time()) self.assertEqual(start, ActorClock.to_milliseconds(when=term.get_start_time())) self.assertEqual(new_start, ActorClock.to_milliseconds(when=term.get_new_start_time())) self.assertEqual(end, ActorClock.to_milliseconds(when=term.get_end_time())) else: self.assertIsNone(term.start_time) self.assertIsNone(term.new_start_time) self.assertIsNone(term.end_time) self.assertIsNone(term.get_start_time()) self.assertIsNone(term.get_new_start_time()) self.assertIsNone(term.get_end_time())
def translate_term_from_avro(*, term: TermAvro) -> Term: start_time = None end_time = None new_start_time = None if term.start_time > 0: start_time = ActorClock.from_milliseconds(milli_seconds=term.start_time) if term.end_time > 0: end_time = ActorClock.from_milliseconds(milli_seconds=term.end_time) if term.new_start_time > 0: new_start_time = ActorClock.from_milliseconds(milli_seconds=term.new_start_time) return Term(start=start_time, end=end_time, new_start=new_start_time)
def get_request_from_request(self, request: ABCBrokerReservation, units: int, rtype: ResourceType, start: datetime, end: datetime): rset = ResourceSet(units=units, rtype=rtype) term = Term(start=request.get_term().get_start_time(), end=end, new_start=start) result = BrokerReservationFactory.create( rid=request.get_reservation_id(), resources=rset, term=term, slice_obj=request.get_slice()) result.set_sequence_in(sequence=request.get_sequence_in() + 1) return result
def test_d_nascent(self): controller = self.get_controller() clock = controller.get_actor_clock() Term.clock = clock resources = ResourceSet(units=1, rtype=ResourceType(resource_type="1")) slice_obj = SliceFactory.create(slice_id=ID(), name="nascent") controller.register_slice(slice_object=slice_obj) start = 5 end = 10 term = Term(start=clock.cycle_start_date(cycle=start), end=clock.cycle_end_date(cycle=end)) r1 = ClientReservationFactory.create(rid=ID(), resources=resources, term=term, slice_object=slice_obj) r1.set_renewable(renewable=False) controller.register(reservation=r1) controller.demand(rid=r1.get_reservation_id()) r2 = ClientReservationFactory.create(rid=ID(), resources=resources, term=term, slice_object=slice_obj) r2.set_renewable(renewable=False) controller.register(reservation=r2) r2demanded = False for i in range(1, end + 3): controller.external_tick(cycle=i) while controller.get_current_cycle() != i: time.sleep(0.001) if i == (start -3) and not r2demanded: self.assertTrue(r1.is_ticketed()) self.assertTrue(r2.is_nascent()) controller.demand(rid=r2.get_reservation_id()) r2demanded = True if i >= start and (i < end - 1): self.assertTrue(r1.is_active()) self.assertTrue(r2.is_active()) if i > end: self.assertTrue(r1.is_closed()) self.assertTrue(r2.is_closed())
def test_d_add_update_get_unit(self): actor = self.prepare_actor_database() db = actor.get_plugin().get_database() slice_obj = SliceFactory.create(slice_id=ID(), name="slice-1") db.add_slice(slice_object=slice_obj) rset = ResourceSet() term = Term(start=datetime.now(), end=datetime.now().replace(minute=20)) res = AuthorityReservationFactory.create(resources=rset, term=term, slice_obj=slice_obj, rid=ID()) db.add_reservation(reservation=res) rtype = ResourceType(resource_type="12") u = Unit(rid=res.get_reservation_id(), slice_id=slice_obj.get_slice_id(), actor_id=actor.get_guid()) u.set_resource_type(rtype=rtype) db.add_unit(u=u) self.assertIsNotNone(db.get_unit(uid=u.get_id()))
def test_validate(self): with self.assertRaises(Exception): self.check_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=10), new_start=ActorClock.from_milliseconds(milli_seconds=100), end=ActorClock.from_milliseconds(milli_seconds=10))) self.check_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=10), new_start=ActorClock.from_milliseconds(milli_seconds=100), end=ActorClock.from_milliseconds(milli_seconds=99))) self.check_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=10), new_start=ActorClock.from_milliseconds(milli_seconds=1000), end=ActorClock.from_milliseconds(milli_seconds=1000))) self.check_not_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=100), end=ActorClock.from_milliseconds(milli_seconds=10))) self.check_not_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=100), end=ActorClock.from_milliseconds(milli_seconds=100))) self.check_not_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=100), end=ActorClock.from_milliseconds(milli_seconds=1000), new_start=ActorClock.from_milliseconds(milli_seconds=10))) self.check_not_valid(term=Term(start=ActorClock.from_milliseconds(milli_seconds=100), end=ActorClock.from_milliseconds(milli_seconds=10), new_start=ActorClock.from_milliseconds(milli_seconds=10000)))
def allocate_extending_reservation_set(self, *, requests: ReservationSet): if requests is not None: for reservation in requests.values(): if reservation.is_extending_ticket( ) and not reservation.is_closed(): start = reservation.get_requested_term( ).get_new_start_time() end = self.align_end( when=reservation.get_requested_term().get_end_time()) resource_type = reservation.get_resources().get_type() inv = self.inventory.get(resource_type=resource_type) if inv is not None: ext_term = Term( start=reservation.get_term().get_start_time(), end=end, new_start=start) self.extend_private(reservation=reservation, inv=inv, term=ext_term) else: reservation.fail(message=Constants.NO_POOL)
def test_shift(self): start = 1000 end = 1499 length = 500 t = Term(start=ActorClock.from_milliseconds(milli_seconds=start), end=ActorClock.from_milliseconds(milli_seconds=end)) self.check(term=t, start=start, new_start=start, end=end) self.assertEqual(length, t.get_length()) t1 = t.shift(date=ActorClock.from_milliseconds(milli_seconds=start-500)) self.check(term=t1, start=start-500, new_start=start-500, end=end-500) self.assertEqual(length, t1.get_length()) t1 = t.shift(date=ActorClock.from_milliseconds(milli_seconds=start)) self.check(term=t1, start=start, new_start=start, end=end) self.assertEqual(length, t1.get_length()) t1 = t.shift(date=ActorClock.from_milliseconds(milli_seconds=start+500)) self.check(term=t1, start=start + 500, new_start=start + 500, end=end + 500) self.assertEqual(length, t1.get_length())
def test_contains(self): start = 1000 end = 1499 length = 500 t = Term(start=ActorClock.from_milliseconds(milli_seconds=start), end=ActorClock.from_milliseconds(milli_seconds=end)) self.check(term=t, start=start, new_start=start, end=end) self.assertEqual(length, t.get_length()) # self -> true self.assertTrue(t.contains(term=t)) # self - 1 from the right self.assertTrue(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start), length=length-1))) # self + 1 from the left self.assertTrue(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start), end=ActorClock.from_milliseconds(milli_seconds=end)))) # self +1 from the left, -1 from the right self.assertTrue(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start), end=ActorClock.from_milliseconds(milli_seconds=end - 1)))) self.assertFalse(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start -1), end=ActorClock.from_milliseconds(milli_seconds=end)))) self.assertFalse(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start -100), end=ActorClock.from_milliseconds(milli_seconds=start)))) self.assertFalse(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start), end=ActorClock.from_milliseconds(milli_seconds=end + 1)))) self.assertFalse(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start), end=ActorClock.from_milliseconds(milli_seconds=end + 100)))) self.assertFalse(t.contains(term=Term(start=ActorClock.from_milliseconds(milli_seconds=start - 100), end=ActorClock.from_milliseconds(milli_seconds=end + 100)))) self.assertTrue(t.contains(date=ActorClock.from_milliseconds(milli_seconds=start))) self.assertTrue(t.contains(date=ActorClock.from_milliseconds(milli_seconds=end))) self.assertTrue(t.contains(date=ActorClock.from_milliseconds(milli_seconds=int((start + end)/2)))) self.assertFalse(t.contains(date=ActorClock.from_milliseconds(milli_seconds=start -1))) self.assertFalse(t.contains(date=ActorClock.from_milliseconds(milli_seconds=end + 1)))
def get_approved_term(*, reservation: ABCBrokerReservation) -> Term: return Term( start=reservation.get_requested_term().get_start_time(), end=reservation.get_requested_term().get_end_time(), new_start=reservation.get_requested_term().get_new_start_time())
def test_ends(self): start = 1000 end = 1499 length = 500 t = Term(start=ActorClock.from_milliseconds(milli_seconds=start), end=ActorClock.from_milliseconds(milli_seconds=end)) self.check(term=t, start=start, new_start=start, end=end) self.assertEqual(length, t.get_length()) # term cannot end before it started self.assertFalse(t.ends_before(date=t.get_start_time())) self.assertFalse(t.expired(date=t.get_start_time())) self.assertTrue(t.ends_after(date=t.get_start_time())) self.assertFalse(t.ends_before(date=t.get_end_time())) self.assertFalse(t.ends_after(date=t.get_end_time())) self.assertFalse(t.expired(date=t.get_end_time())) self.assertFalse(t.ends_before(date=ActorClock.from_milliseconds(milli_seconds=start - 100))) self.assertTrue(t.ends_after(date=ActorClock.from_milliseconds(milli_seconds=start - 100))) self.assertFalse(t.expired(date=ActorClock.from_milliseconds(milli_seconds=start - 100))) self.assertTrue(t.ends_before(date=ActorClock.from_milliseconds(milli_seconds=end + 1))) self.assertTrue(t.expired(date=ActorClock.from_milliseconds(milli_seconds=end + 1))) self.assertFalse(t.ends_after(date=ActorClock.from_milliseconds(milli_seconds=end + 1)))
def check_valid(term: Term): term.validate()
def test_create(self): length = 500 start = 1000 new_start = 1500 end = 1999 old_end = 1499 with self.assertRaises(Exception): Term() with self.assertRaises(Exception): t2 = Term(start=ActorClock.from_milliseconds(milli_seconds=start)) # Term(start, length) t3 = Term(start=ActorClock.from_milliseconds(milli_seconds=start), length=length) self.check(term=t3, start=start, new_start=start, end=old_end) self.assertEqual(length, t3.get_length()) # Term(start, end) t4 = Term(start=ActorClock.from_milliseconds(milli_seconds=start), end=ActorClock.from_milliseconds(milli_seconds=old_end)) self.check(term=t4, start=start, new_start=start, end=old_end) self.assertEqual(length, t4.get_length()) # Term(start, end, new_start) t5 = Term(start=ActorClock.from_milliseconds(milli_seconds=start), new_start=ActorClock.from_milliseconds(milli_seconds=new_start), end=ActorClock.from_milliseconds(milli_seconds=end)) self.check(term=t5, start=start, new_start=new_start, end=end) # NOTE: length is measured only relative to newStartTime!!! self.assertEqual(length, t5.get_length())