[haizea-commit] r803 - branches/1.1/tests
haizea-commit at mailman.cs.uchicago.edu
haizea-commit at mailman.cs.uchicago.edu
Tue Jun 22 12:01:20 CDT 2010
Author: borja
Date: 2010-06-22 12:01:20 -0500 (Tue, 22 Jun 2010)
New Revision: 803
Added:
branches/1.1/tests/piggybacking.lwf
Modified:
branches/1.1/tests/common.py
branches/1.1/tests/test_annotations.py
branches/1.1/tests/test_mapper.py
branches/1.1/tests/test_simul_transfers_noreuse.py
branches/1.1/tests/test_simul_transfers_reuse.py
branches/1.1/tests/test_slottable.py
Log:
- Changed unit tests to use test_* functions instead of Test* classes. Newer py.test is apparently not too happy about test classes having a constructor.
- Minor changes.
Modified: branches/1.1/tests/common.py
===================================================================
--- branches/1.1/tests/common.py 2010-06-22 15:01:11 UTC (rev 802)
+++ branches/1.1/tests/common.py 2010-06-22 17:01:20 UTC (rev 803)
@@ -7,101 +7,65 @@
from haizea.core.manager import Manager
from haizea.common.utils import reset_lease_id_counter
-class BaseTest(object):
- def __init__(self, config):
- self.config = config
- self.haizea = None
+PREEMPTION_TRACE = "preemption.lwf"
+PREEMPTION_PREMATUREEND_TRACE = "preemption_prematureend.lwf"
+PREEMPTION_PREMATUREEND2_TRACE = "preemption_prematureend2.lwf"
+RESERVATION_TRACE = "reservation.lwf"
+RESERVATION_PREMATUREEND_TRACE = "reservation_prematureend.lwf"
+MIGRATE_TRACE = "migrate.lwf"
+REUSE1_TRACE = "reuse1.lwf"
+REUSE2_TRACE = "reuse2.lwf"
+PIGGYBACKING_TRACE = "piggybacking.lwf"
+WAIT_TRACE = "wait.lwf"
- @staticmethod
- def load_configfile(configfile):
- f = open (configfile, "r")
- c = ConfigParser.ConfigParser()
- c.readfp(f)
- return c
-
- def _tracefile_test(self, tracefile):
- self.config.set("tracefile", "tracefile", tracefile)
- Manager.reset_singleton()
- reset_lease_id_counter()
- self.haizea = Manager(HaizeaConfig(self.config))
- self.haizea.start()
+def load_configfile(configfile):
+ f = open (configfile, "r")
+ c = ConfigParser.ConfigParser()
+ c.readfp(f)
+ return c
- def _verify_done(self, ids):
- for id in ids:
- lease = self.haizea.scheduler.completed_leases.get_lease(id)
-
- assert lease.get_state() == Lease.STATE_DONE
-
- if lease.deadline != None:
- assert lease.end <= lease.deadline
-
- if lease.duration.known != None:
- duration = lease.duration.known
- else:
- duration = lease.duration.requested
-
- assert duration == lease.duration.actual
+def load_tracefile(config, tracefile):
+ config.set("tracefile", "tracefile", tracefile)
+ Manager.reset_singleton()
+ reset_lease_id_counter()
+ return Manager(HaizeaConfig(config))
- def _verify_rejected(self, ids):
- for id in ids:
- lease = self.haizea.scheduler.completed_leases.get_lease(id)
+def verify_done(haizea, ids):
+ for id in ids:
+ lease = haizea.scheduler.completed_leases.get_lease(id)
+
+ assert lease.get_state() == Lease.STATE_DONE
+
+ if lease.deadline != None:
+ assert lease.end <= lease.deadline
- assert lease.get_state() == Lease.STATE_REJECTED
-
- def _verify_rejected_by_user(self, ids):
- for id in ids:
- lease = self.haizea.scheduler.completed_leases.get_lease(id)
+ if lease.duration.known != None:
+ duration = lease.duration.known
+ else:
+ duration = lease.duration.requested
- assert lease.get_state() == Lease.STATE_REJECTED_BY_USER
+ assert duration == lease.duration.actual
-class BaseSimulatorTest(BaseTest):
- def __init__(self, config):
- BaseTest.__init__(self, config)
-
- def test_preemption(self):
- self._tracefile_test("preemption.lwf")
+def verify_rejected(haizea, ids):
+ for id in ids:
+ lease = haizea.scheduler.completed_leases.get_lease(id)
- def test_preemption_prematureend(self):
- self._tracefile_test("preemption_prematureend.lwf")
+ assert lease.get_state() == Lease.STATE_REJECTED
+
+def verify_rejected_by_user(haizea, ids):
+ for id in ids:
+ lease = haizea.scheduler.completed_leases.get_lease(id)
- def test_preemption_prematureend2(self):
- self._tracefile_test("preemption_prematureend2.lwf")
-
- def test_reservation(self):
- self._tracefile_test("reservation.lwf")
-
- def test_reservation_prematureend(self):
- self._tracefile_test("reservation_prematureend.lwf")
-
- def test_migrate(self):
- self._tracefile_test("migrate.lwf")
-
- def test_reuse1(self):
- self._tracefile_test("reuse1.lwf")
-
- def test_reuse2(self):
- self._tracefile_test("reuse2.lwf")
-
- def test_wait(self):
- self._tracefile_test("wait.lwf")
-
+ assert lease.get_state() == Lease.STATE_REJECTED_BY_USER
-
-class BaseXMLRPCTest(BaseTest):
- def __init__(self, config):
- BaseTest.__init__(self, config)
- self.haizea = None
- self.haizea_thread = None
-
- def start(self):
- Manager.reset_singleton()
- self.haizea = Manager(HaizeaConfig(self.config))
- self.haizea_thread = threading.Thread(target=self.haizea.start)
- self.haizea_thread.start()
+def create_haizea_thread(config):
+ Manager.reset_singleton()
+ haizea = Manager(HaizeaConfig(self.config))
+ return haizea, threading.Thread(target=self.haizea.start)
- def stop(self):
- self.haizea.stop()
- self.haizea_thread.join()
+#def stop(self):
+# self.haizea.stop()
+# self.haizea_thread.join()
def create_ar_lease(lease_id, submit_time, start, end, preemptible, requested_resources):
Added: branches/1.1/tests/piggybacking.lwf
===================================================================
--- branches/1.1/tests/piggybacking.lwf (rev 0)
+++ branches/1.1/tests/piggybacking.lwf 2010-06-22 17:01:20 UTC (rev 803)
@@ -0,0 +1,54 @@
+<?xml version="1.0"?>
+<lease-workload name="reuse1">
+ <description>
+ Two lease requests, both requiring the same
+ disk image. The second (best-effort) should be able to avoid
+ doing an image transfer by reusing the cached image from the
+ first (AR) request.
+ </description>
+
+ <site>
+ <resource-types names="CPU Memory"/>
+ <nodes>
+ <node-set numnodes="4">
+ <res type="CPU" amount="100"/>
+ <res type="Memory" amount="1024"/>
+ </node-set>
+ </nodes>
+ </site>
+
+ <lease-requests>
+ <lease-request arrival="00:00:00.00">
+ <lease id="1" preemptible="false">
+ <nodes>
+ <node-set numnodes="4">
+ <res amount="100" type="CPU"/>
+ <res amount="1024" type="Memory"/>
+ </node-set>
+ </nodes>
+ <start>
+ <exact time="00:02:00.00"/>
+ </start>
+ <duration time="00:13:00.00"/>
+ <software>
+ <disk-image id="foobar.img" size="1024"/>
+ </software>
+ </lease>
+ </lease-request>
+ <lease-request arrival="00:00:00.00">
+ <lease id="2" preemptible="true">
+ <nodes>
+ <node-set numnodes="4">
+ <res amount="100" type="CPU"/>
+ <res amount="1024" type="Memory"/>
+ </node-set>
+ </nodes>
+ <start/>
+ <duration time="00:15:00.00"/>
+ <software>
+ <disk-image id="foobar.img" size="1024"/>
+ </software>
+ </lease>
+ </lease-request>
+ </lease-requests>
+</lease-workload>
Modified: branches/1.1/tests/test_annotations.py
===================================================================
--- branches/1.1/tests/test_annotations.py 2010-06-22 15:01:11 UTC (rev 802)
+++ branches/1.1/tests/test_annotations.py 2010-06-22 17:01:20 UTC (rev 803)
@@ -1,61 +1,57 @@
from haizea.core.leases import LeaseWorkload, LeaseAnnotation, LeaseAnnotations, UnmanagedSoftwareEnvironment, DiskImageSoftwareEnvironment, Timestamp
from mx.DateTime import Time, DateTime
-from common import BaseTest
+from common import *
from haizea.common.utils import reset_lease_id_counter
-class TestAnnotations(BaseTest):
- def __init__(self):
- config = BaseTest.load_configfile("base_config_simulator.conf")
- BaseTest.__init__(self, config)
+def get_config():
+ return load_configfile("base_config_simulator.conf")
- def test_annotation1(self):
- reset_lease_id_counter()
- lease_workload = LeaseWorkload.from_xml_file("preemption.lwf")
- annotations = LeaseAnnotations.from_xml_file("annotations1.lwfa")
- leases = lease_workload.get_leases()
+def test_annotation1():
+ reset_lease_id_counter()
+ lease_workload = LeaseWorkload.from_xml_file("preemption.lwf")
+ annotations = LeaseAnnotations.from_xml_file("annotations1.lwfa")
+ leases = lease_workload.get_leases()
- annotations.apply_to_leases(leases)
+ annotations.apply_to_leases(leases)
- lease1 = leases[0]
- lease2 = leases[1]
+ lease1 = leases[0]
+ lease2 = leases[1]
- assert lease1.start.requested == DateTime(0, 1, 1, 10)
- assert lease1.deadline == DateTime(0, 1, 1, 20)
- assert isinstance(lease1.software, UnmanagedSoftwareEnvironment)
- assert lease1.extras["one"] == "1"
- assert lease1.extras["two"] == "2"
-
- assert lease2.start.requested == Timestamp.UNSPECIFIED
- assert lease2.deadline == None
- assert isinstance(lease2.software, DiskImageSoftwareEnvironment)
- assert lease2.software.image_id == "annotation.img"
- assert lease2.software.image_size == 4096
- assert lease2.extras["three"] == "3"
- assert lease2.extras["four"] == "4"
+ assert lease1.start.requested == DateTime(0, 1, 1, 10)
+ assert lease1.deadline == DateTime(0, 1, 1, 20)
+ assert isinstance(lease1.software, UnmanagedSoftwareEnvironment)
+ assert lease1.extras["one"] == "1"
+ assert lease1.extras["two"] == "2"
-# def test_annotation2(self):
-# # TODO: Test multiple annotations
-# pass
+ assert lease2.start.requested == Timestamp.UNSPECIFIED
+ assert lease2.deadline == None
+ assert isinstance(lease2.software, DiskImageSoftwareEnvironment)
+ assert lease2.software.image_id == "annotation.img"
+ assert lease2.software.image_size == 4096
+ assert lease2.extras["three"] == "3"
+ assert lease2.extras["four"] == "4"
+
+def test_annotation_simul():
+ c= get_config()
+ c.set("tracefile", "annotationfile", "annotations2.lwfa")
+ h = load_tracefile(c, PREEMPTION_TRACE)
+ h.start()
- def test_annotation_simul(self):
- self.config.set("tracefile", "annotationfile", "annotations2.lwfa")
- self._tracefile_test("preemption.lwf")
-
- lease1 = self.haizea.scheduler.completed_leases.get_lease(1)
- lease2 = self.haizea.scheduler.completed_leases.get_lease(2)
+ lease1 = h.scheduler.completed_leases.get_lease(1)
+ lease2 = h.scheduler.completed_leases.get_lease(2)
+
+ assert lease1.start.requested == DateTime(2006, 11, 25, 14)
+ assert lease1.deadline == None
+ assert isinstance(lease1.software, DiskImageSoftwareEnvironment)
+ assert lease1.software.image_id == "annotation1.img"
+ assert lease1.software.image_size == 4096
+ assert lease1.extras["five"] == "5"
+ assert lease1.extras["six"] == "6"
- assert lease1.start.requested == DateTime(2006, 11, 25, 14)
- assert lease1.deadline == None
- assert isinstance(lease1.software, DiskImageSoftwareEnvironment)
- assert lease1.software.image_id == "annotation1.img"
- assert lease1.software.image_size == 4096
- assert lease1.extras["five"] == "5"
- assert lease1.extras["six"] == "6"
-
- assert lease2.start.requested == DateTime(2006, 11, 25, 15, 15)
- assert lease2.deadline == None
- assert isinstance(lease2.software, DiskImageSoftwareEnvironment)
- assert lease2.software.image_id == "annotation2.img"
- assert lease2.software.image_size == 4096
- assert lease2.extras["seven"] == "7"
- assert lease2.extras["eight"] == "8"
\ No newline at end of file
+ assert lease2.start.requested == DateTime(2006, 11, 25, 15, 15)
+ assert lease2.deadline == None
+ assert isinstance(lease2.software, DiskImageSoftwareEnvironment)
+ assert lease2.software.image_id == "annotation2.img"
+ assert lease2.software.image_size == 4096
+ assert lease2.extras["seven"] == "7"
+ assert lease2.extras["eight"] == "8"
\ No newline at end of file
Modified: branches/1.1/tests/test_mapper.py
===================================================================
--- branches/1.1/tests/test_mapper.py 2010-06-22 15:01:11 UTC (rev 802)
+++ branches/1.1/tests/test_mapper.py 2010-06-22 17:01:20 UTC (rev 803)
@@ -19,220 +19,237 @@
def accept_lease(self, lease):
return True
+
+def mapping_assertions(slottable, mapper, start, end, requested_resources, strictend, mustmap,
+ maxend = None, can_preempt = []):
+ lease = create_ar_lease(lease_id = 100,
+ submit_time = T1200,
+ start = start,
+ end = end,
+ preemptible = False,
+ requested_resources = requested_resources)
+ mapping, actualend, preemptions = mapper.map(lease, requested_resources,
+ start, end,
+ strictend = strictend,
+ allow_preemption = True)
+
+ if mustmap:
+ assert(mapping != None and actualend != None and preemptions != None)
+ if strictend:
+ assert(end == actualend)
+ else:
+ assert(actualend <= maxend)
+ assert(set(preemptions).issubset(set(can_preempt)))
-class TestMapper(object):
- def __init__(self):
- pass
-
- def mapping_assertions(self, start, end, requested_resources, strictend, mustmap,
- maxend = None, can_preempt = []):
- lease = create_ar_lease(lease_id = 100,
- submit_time = T1200,
- start = start,
- end = end,
- preemptible = False,
- requested_resources = requested_resources)
+ else:
+ assert(mapping == None and actualend == None and preemptions == None)
+ return
+
+ # Sanity check slottable
+ tmp_slottable = create_tmp_slottable(slottable)
+
+ # Add reservation
+ res = dict([(mapping[vnode],r) for vnode,r in requested_resources.items()])
+ rr = ResourceReservation(lease, start, actualend, res)
+ tmp_slottable.add_reservation(rr)
+
+ if len(preemptions) > 0:
+ passed, node, time, capacity = tmp_slottable.sanity_check()
+ assert(not passed)
- mapping, actualend, preemptions = self.mapper.map(lease, requested_resources,
- start, end,
- strictend = strictend,
- allow_preemption = True)
-
- if mustmap:
- assert(mapping != None and actualend != None and preemptions != None)
- if strictend:
- assert(end == actualend)
- else:
- assert(actualend <= maxend)
- assert(set(preemptions).issubset(set(can_preempt)))
+ # Remove preempted reservations
+ remove = set()
+ for rr in [x.value for x in tmp_slottable.reservations_by_start]:
+ if rr.lease in preemptions:
+ remove.add(rr)
- else:
- assert(mapping == None and actualend == None and preemptions == None)
- return
-
- # Sanity check slottable
- tmp_slottable = create_tmp_slottable(self.slottable)
-
- # Add reservation
- res = dict([(mapping[vnode],r) for vnode,r in requested_resources.items()])
- rr = ResourceReservation(lease, start, actualend, res)
- tmp_slottable.add_reservation(rr)
-
- if len(preemptions) > 0:
- passed, node, time, capacity = tmp_slottable.sanity_check()
- assert(not passed)
-
- # Remove preempted reservations
- remove = set()
- for rr in [x.value for x in tmp_slottable.reservations_by_start]:
- if rr.lease in preemptions:
- remove.add(rr)
+ for rr in remove:
+ tmp_slottable.remove_reservation(rr)
- for rr in remove:
- tmp_slottable.remove_reservation(rr)
+ passed, node, time, capacity = tmp_slottable.sanity_check()
+ assert(passed)
- passed, node, time, capacity = tmp_slottable.sanity_check()
- assert(passed)
-
- def test_mapping_nopreemption_strictend(self):
- self.slottable, leases = sample_slottable_2()
- FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(self.slottable)
- policy = SimplePolicy(self.slottable, preemption = False)
- self.mapper = GreedyMapper(self.slottable, policy)
-
- self.mapping_assertions(start = T1300,
- end = T1345,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE},
- strictend = True,
- mustmap = True)
+def test_mapping_nopreemption_strictend():
+ slottable, leases = sample_slottable_2()
+ FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(slottable)
+ policy = SimplePolicy(slottable, preemption = False)
+ mapper = GreedyMapper(slottable, policy)
+
+ mapping_assertions(slottable, mapper,
+ start = T1300,
+ end = T1345,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE},
+ strictend = True,
+ mustmap = True)
- self.mapping_assertions(start = T1300,
- end = T1330,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: HALF_NODE},
- strictend = True,
- mustmap = True)
+ mapping_assertions(slottable, mapper,
+ start = T1300,
+ end = T1330,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: HALF_NODE},
+ strictend = True,
+ mustmap = True)
- self.mapping_assertions(start = T1300,
- end = T1315,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
- strictend = True,
- mustmap = True)
+ mapping_assertions(slottable, mapper,
+ start = T1300,
+ end = T1315,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
+ strictend = True,
+ mustmap = True)
- self.mapping_assertions(start = T1330,
- end = T1345,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE},
- strictend = True,
- mustmap = True)
+ mapping_assertions(slottable, mapper,
+ start = T1330,
+ end = T1345,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE},
+ strictend = True,
+ mustmap = True)
- self.mapping_assertions(start = T1330,
- end = T1345,
- requested_resources = {1: HALF_NODE, 2: HALF_NODE, 3: HALF_NODE, 4: HALF_NODE},
- strictend = True,
- mustmap = True)
+ mapping_assertions(slottable, mapper,
+ start = T1330,
+ end = T1345,
+ requested_resources = {1: HALF_NODE, 2: HALF_NODE, 3: HALF_NODE, 4: HALF_NODE},
+ strictend = True,
+ mustmap = True)
- self.mapping_assertions(start = T1300,
- end = T1415,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE},
- strictend = True,
- mustmap = True)
+ mapping_assertions(slottable, mapper,
+ start = T1300,
+ end = T1415,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE},
+ strictend = True,
+ mustmap = True)
- self.mapping_assertions(start = T1300,
- end = T1415,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
- strictend = True,
- mustmap = False)
+ mapping_assertions(slottable, mapper,
+ start = T1300,
+ end = T1415,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
+ strictend = True,
+ mustmap = False)
- self.mapping_assertions(start = T1300,
- end = T1330,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
- strictend = True,
- mustmap = False)
+ mapping_assertions(slottable, mapper,
+ start = T1300,
+ end = T1330,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
+ strictend = True,
+ mustmap = False)
- self.mapping_assertions(start = T1330,
- end = T1345,
- requested_resources = {1: HALF_NODE, 2: HALF_NODE, 3: HALF_NODE, 4: HALF_NODE, 5: HALF_NODE},
- strictend = True,
- mustmap = False)
+ mapping_assertions(slottable, mapper,
+ start = T1330,
+ end = T1345,
+ requested_resources = {1: HALF_NODE, 2: HALF_NODE, 3: HALF_NODE, 4: HALF_NODE, 5: HALF_NODE},
+ strictend = True,
+ mustmap = False)
- def test_mapping_nopreemption_nostrictend(self):
- self.slottable, leases = sample_slottable_3()
- FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(self.slottable)
- policy = SimplePolicy(self.slottable, preemption = False)
- self.mapper = GreedyMapper(self.slottable, policy)
-
- self.mapping_assertions(start = T1315,
- end = T1415,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: HALF_NODE},
- strictend = False,
- mustmap = True,
- maxend = T1400)
-
- self.mapping_assertions(start = T1315,
- end = T1415,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
- strictend = False,
- mustmap = True,
- maxend = T1330)
+def test_mapping_nopreemption_nostrictend():
+ slottable, leases = sample_slottable_3()
+ FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(slottable)
+ policy = SimplePolicy(slottable, preemption = False)
+ mapper = GreedyMapper(slottable, policy)
+
+ mapping_assertions(slottable, mapper,
+ start = T1315,
+ end = T1415,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: HALF_NODE},
+ strictend = False,
+ mustmap = True,
+ maxend = T1400)
+
+ mapping_assertions(slottable, mapper,
+ start = T1315,
+ end = T1415,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
+ strictend = False,
+ mustmap = True,
+ maxend = T1330)
- self.mapping_assertions(start = T1315,
- end = T1415,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: HALF_NODE},
- strictend = False,
- mustmap = True,
- maxend = T1345)
-
- self.mapping_assertions(start = T1315,
- end = T1415,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: HALF_NODE, 4: HALF_NODE, 5: HALF_NODE, 6: HALF_NODE},
- strictend = False,
- mustmap = True,
- maxend = T1330)
+ mapping_assertions(slottable, mapper,
+ start = T1315,
+ end = T1415,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: HALF_NODE},
+ strictend = False,
+ mustmap = True,
+ maxend = T1345)
+
+ mapping_assertions(slottable, mapper,
+ start = T1315,
+ end = T1415,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: HALF_NODE, 4: HALF_NODE, 5: HALF_NODE, 6: HALF_NODE},
+ strictend = False,
+ mustmap = True,
+ maxend = T1330)
- self.mapping_assertions(start = T1330,
- end = T1415,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: HALF_NODE},
- strictend = False,
- mustmap = True,
- maxend = T1345)
+ mapping_assertions(slottable, mapper,
+ start = T1330,
+ end = T1415,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: HALF_NODE},
+ strictend = False,
+ mustmap = True,
+ maxend = T1345)
- self.mapping_assertions(start = T1345,
- end = T1415,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: HALF_NODE},
- strictend = False,
- mustmap = True,
- maxend = T1400)
+ mapping_assertions(slottable, mapper,
+ start = T1345,
+ end = T1415,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: HALF_NODE},
+ strictend = False,
+ mustmap = True,
+ maxend = T1400)
- self.mapping_assertions(start = T1330,
- end = T1415,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
- strictend = False,
- mustmap = False)
-
- self.mapping_assertions(start = T1400,
- end = T1415,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: HALF_NODE},
- strictend = False,
- mustmap = False)
-
- def test_mapping_preemption_strictend(self):
- self.slottable, leases = sample_slottable_3()
- FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(self.slottable)
- policy = SimplePolicy(self.slottable, preemption = True)
- self.mapper = GreedyMapper(self.slottable, policy)
+ mapping_assertions(slottable, mapper,
+ start = T1330,
+ end = T1415,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
+ strictend = False,
+ mustmap = False)
+
+ mapping_assertions(slottable, mapper,
+ start = T1400,
+ end = T1415,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: HALF_NODE},
+ strictend = False,
+ mustmap = False)
+
+def test_mapping_preemption_strictend():
+ slottable, leases = sample_slottable_3()
+ FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(slottable)
+ policy = SimplePolicy(slottable, preemption = True)
+ mapper = GreedyMapper(slottable, policy)
- self.mapping_assertions(start = T1315,
- end = T1345,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
- strictend = True,
- mustmap = True,
- can_preempt = [leases[1]])
+ mapping_assertions(slottable, mapper,
+ start = T1315,
+ end = T1345,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
+ strictend = True,
+ mustmap = True,
+ can_preempt = [leases[1]])
- self.mapping_assertions(start = T1330,
- end = T1345,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
- strictend = True,
- mustmap = True,
- can_preempt = [leases[1]])
+ mapping_assertions(slottable, mapper,
+ start = T1330,
+ end = T1345,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
+ strictend = True,
+ mustmap = True,
+ can_preempt = [leases[1]])
- self.mapping_assertions(start = T1345,
- end = T1400,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE},
- strictend = True,
- mustmap = True,
- can_preempt = [leases[0],leases[1]])
-
- self.mapping_assertions(start = T1315,
- end = T1415,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
- strictend = True,
- mustmap = True,
- can_preempt = leases)
-
- self.mapping_assertions(start = T1315,
- end = T1415,
- requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: HALF_NODE},
- strictend = True,
- mustmap = True,
- can_preempt = leases)
+ mapping_assertions(slottable, mapper,
+ start = T1345,
+ end = T1400,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE},
+ strictend = True,
+ mustmap = True,
+ can_preempt = [leases[0],leases[1]])
+
+ mapping_assertions(slottable, mapper,
+ start = T1315,
+ end = T1415,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: FULL_NODE, 4: FULL_NODE},
+ strictend = True,
+ mustmap = True,
+ can_preempt = leases)
+
+ mapping_assertions(slottable, mapper,
+ start = T1315,
+ end = T1415,
+ requested_resources = {1: FULL_NODE, 2: FULL_NODE, 3: HALF_NODE},
+ strictend = True,
+ mustmap = True,
+ can_preempt = leases)
Modified: branches/1.1/tests/test_simul_transfers_noreuse.py
===================================================================
--- branches/1.1/tests/test_simul_transfers_noreuse.py 2010-06-22 15:01:11 UTC (rev 802)
+++ branches/1.1/tests/test_simul_transfers_noreuse.py 2010-06-22 17:01:20 UTC (rev 803)
@@ -1,35 +1,46 @@
-from common import BaseSimulatorTest
+from common import *
-class TestSimulator(BaseSimulatorTest):
- def __init__(self):
- config = BaseSimulatorTest.load_configfile("base_config_simulator.conf")
- config.set("general", "lease-preparation", "imagetransfer")
- BaseSimulatorTest.__init__(self, config)
+def get_config():
+ c = load_configfile("base_config_simulator.conf")
+ c.set("general", "lease-preparation", "imagetransfer")
+ return c
- def test_preemption(self):
- BaseSimulatorTest.test_preemption(self)
+def test_preemption():
+ h = load_tracefile(get_config(), PREEMPTION_TRACE)
+ h.start()
+
+def test_preemption_prematureend():
+ h = load_tracefile(get_config(), PREEMPTION_PREMATUREEND_TRACE)
+ h.start()
- def test_preemption_prematureend(self):
- BaseSimulatorTest.test_preemption_prematureend(self)
+def test_preemption_prematureend2():
+ h = load_tracefile(get_config(), PREEMPTION_PREMATUREEND2_TRACE)
+ h.start()
- def test_preemption_prematureend2(self):
- BaseSimulatorTest.test_preemption_prematureend2(self)
-
- def test_reservation(self):
- BaseSimulatorTest.test_reservation(self)
+def test_reservation():
+ h = load_tracefile(get_config(), RESERVATION_TRACE)
+ h.start()
- def test_reservation_prematureend(self):
- BaseSimulatorTest.test_reservation_prematureend(self)
+def test_reservation_prematureend():
+ h = load_tracefile(get_config(), RESERVATION_PREMATUREEND_TRACE)
+ h.start()
- def test_migrate(self):
- BaseSimulatorTest.test_migrate(self)
+def test_migrate():
+ h = load_tracefile(get_config(), MIGRATE_TRACE)
+ h.start()
- def test_reuse1(self):
- BaseSimulatorTest.test_reuse1(self)
+def test_reuse1():
+ h = load_tracefile(get_config(), REUSE1_TRACE)
+ h.start()
- def test_reuse2(self):
- BaseSimulatorTest.test_reuse2(self)
-
- def test_wait(self):
- BaseSimulatorTest.test_wait(self)
-
\ No newline at end of file
+def test_reuse2():
+ h = load_tracefile(get_config(), REUSE2_TRACE)
+ h.start()
+
+def test_piggybacking():
+ h = load_tracefile(get_config(), PIGGYBACKING_TRACE)
+ h.start()
+
+def test_wait():
+ h = load_tracefile(get_config(), WAIT_TRACE)
+ h.start()
Modified: branches/1.1/tests/test_simul_transfers_reuse.py
===================================================================
--- branches/1.1/tests/test_simul_transfers_reuse.py 2010-06-22 15:01:11 UTC (rev 802)
+++ branches/1.1/tests/test_simul_transfers_reuse.py 2010-06-22 17:01:20 UTC (rev 803)
@@ -1,36 +1,47 @@
-from common import BaseSimulatorTest
+from common import *
-class TestSimulator(BaseSimulatorTest):
- def __init__(self):
- config = BaseSimulatorTest.load_configfile("base_config_simulator.conf")
- config.set("general", "lease-preparation", "imagetransfer")
- config.set("deploy-imagetransfer", "diskimage-reuse", "image-caches")
- BaseSimulatorTest.__init__(self, config)
+def get_config():
+ c = load_configfile("base_config_simulator.conf")
+ c.set("general", "lease-preparation", "imagetransfer")
+ c.set("deploy-imagetransfer", "diskimage-reuse", "image-caches")
+ return c
- def test_preemption(self):
- BaseSimulatorTest.test_preemption(self)
+def test_preemption():
+ h = load_tracefile(get_config(), PREEMPTION_TRACE)
+ h.start()
+
+def test_preemption_prematureend():
+ h = load_tracefile(get_config(), PREEMPTION_PREMATUREEND_TRACE)
+ h.start()
- def test_preemption_prematureend(self):
- BaseSimulatorTest.test_preemption_prematureend(self)
+def test_preemption_prematureend2():
+ h = load_tracefile(get_config(), PREEMPTION_PREMATUREEND2_TRACE)
+ h.start()
- def test_preemption_prematureend2(self):
- BaseSimulatorTest.test_preemption_prematureend2(self)
-
- def test_reservation(self):
- BaseSimulatorTest.test_reservation(self)
+def test_reservation():
+ h = load_tracefile(get_config(), RESERVATION_TRACE)
+ h.start()
- def test_reservation_prematureend(self):
- BaseSimulatorTest.test_reservation_prematureend(self)
+def test_reservation_prematureend():
+ h = load_tracefile(get_config(), RESERVATION_PREMATUREEND_TRACE)
+ h.start()
- def test_migrate(self):
- BaseSimulatorTest.test_migrate(self)
+def test_migrate():
+ h = load_tracefile(get_config(), MIGRATE_TRACE)
+ h.start()
- def test_reuse1(self):
- BaseSimulatorTest.test_reuse1(self)
+def test_reuse1():
+ h = load_tracefile(get_config(), REUSE1_TRACE)
+ h.start()
- def test_reuse2(self):
- BaseSimulatorTest.test_reuse2(self)
-
- def test_wait(self):
- BaseSimulatorTest.test_wait(self)
-
\ No newline at end of file
+def test_reuse2():
+ h = load_tracefile(get_config(), REUSE2_TRACE)
+ h.start()
+
+def test_piggybacking():
+ h = load_tracefile(get_config(), PIGGYBACKING_TRACE)
+ h.start()
+
+def test_wait():
+ h = load_tracefile(get_config(), WAIT_TRACE)
+ h.start()
\ No newline at end of file
Modified: branches/1.1/tests/test_slottable.py
===================================================================
--- branches/1.1/tests/test_slottable.py 2010-06-22 15:01:11 UTC (rev 802)
+++ branches/1.1/tests/test_slottable.py 2010-06-22 17:01:20 UTC (rev 803)
@@ -3,674 +3,669 @@
from sample_slottables import *
import haizea.common.constants as constants
-class TestSlotTable(object):
- def __init__(self):
- self.slottable = None
-
- def test_resource_tuple(self):
-
- multiinst = [(constants.RES_CPU,ResourceTuple.MULTI_INSTANCE),(constants.RES_MEM,ResourceTuple.SINGLE_INSTANCE)]
-
- self.slottable = SlotTable(multiinst)
-
- c1_100 = Capacity([constants.RES_CPU,constants.RES_MEM])
- c1_100.set_quantity(constants.RES_CPU, 100)
- c1_100.set_quantity(constants.RES_MEM, 1024)
- c1_100 = self.slottable.create_resource_tuple_from_capacity(c1_100)
+def test_resource_tuple():
+ multiinst = [(constants.RES_CPU,ResourceTuple.MULTI_INSTANCE),(constants.RES_MEM,ResourceTuple.SINGLE_INSTANCE)]
+
+ slottable = SlotTable(multiinst)
+
+ c1_100 = Capacity([constants.RES_CPU,constants.RES_MEM])
+ c1_100.set_quantity(constants.RES_CPU, 100)
+ c1_100.set_quantity(constants.RES_MEM, 1024)
+ c1_100 = slottable.create_resource_tuple_from_capacity(c1_100)
- c2_100 = Capacity([constants.RES_CPU,constants.RES_MEM])
- c2_100.set_ninstances(constants.RES_CPU, 2)
- c2_100.set_quantity_instance(constants.RES_CPU, 1, 100)
- c2_100.set_quantity_instance(constants.RES_CPU, 2, 100)
- c2_100.set_quantity(constants.RES_MEM, 1024)
- c2_100 = self.slottable.create_resource_tuple_from_capacity(c2_100)
+ c2_100 = Capacity([constants.RES_CPU,constants.RES_MEM])
+ c2_100.set_ninstances(constants.RES_CPU, 2)
+ c2_100.set_quantity_instance(constants.RES_CPU, 1, 100)
+ c2_100.set_quantity_instance(constants.RES_CPU, 2, 100)
+ c2_100.set_quantity(constants.RES_MEM, 1024)
+ c2_100 = slottable.create_resource_tuple_from_capacity(c2_100)
- c1_50 = Capacity([constants.RES_CPU,constants.RES_MEM])
- c1_50.set_quantity(constants.RES_CPU, 50)
- c1_50.set_quantity(constants.RES_MEM, 1024)
- c1_50 = self.slottable.create_resource_tuple_from_capacity(c1_50)
+ c1_50 = Capacity([constants.RES_CPU,constants.RES_MEM])
+ c1_50.set_quantity(constants.RES_CPU, 50)
+ c1_50.set_quantity(constants.RES_MEM, 1024)
+ c1_50 = slottable.create_resource_tuple_from_capacity(c1_50)
- c2_50 = Capacity([constants.RES_CPU,constants.RES_MEM])
- c2_50.set_ninstances(constants.RES_CPU, 2)
- c2_50.set_quantity_instance(constants.RES_CPU, 1, 50)
- c2_50.set_quantity_instance(constants.RES_CPU, 2, 50)
- c2_50.set_quantity(constants.RES_MEM, 1024)
- c2_50 = self.slottable.create_resource_tuple_from_capacity(c2_50)
+ c2_50 = Capacity([constants.RES_CPU,constants.RES_MEM])
+ c2_50.set_ninstances(constants.RES_CPU, 2)
+ c2_50.set_quantity_instance(constants.RES_CPU, 1, 50)
+ c2_50.set_quantity_instance(constants.RES_CPU, 2, 50)
+ c2_50.set_quantity(constants.RES_MEM, 1024)
+ c2_50 = slottable.create_resource_tuple_from_capacity(c2_50)
- assert c1_100.fits_in(c2_100)
- assert not c1_100.fits_in(c1_50)
- assert not c1_100.fits_in(c2_50)
+ assert c1_100.fits_in(c2_100)
+ assert not c1_100.fits_in(c1_50)
+ assert not c1_100.fits_in(c2_50)
- assert not c2_100.fits_in(c1_100)
- assert not c2_100.fits_in(c1_50)
- assert not c2_100.fits_in(c2_50)
+ assert not c2_100.fits_in(c1_100)
+ assert not c2_100.fits_in(c1_50)
+ assert not c2_100.fits_in(c2_50)
- assert c1_50.fits_in(c1_100)
- assert c1_50.fits_in(c2_100)
- assert c1_50.fits_in(c2_50)
+ assert c1_50.fits_in(c1_100)
+ assert c1_50.fits_in(c2_100)
+ assert c1_50.fits_in(c2_50)
- assert c2_50.fits_in(c1_100)
- assert c2_50.fits_in(c2_100)
- assert not c2_50.fits_in(c1_50)
+ assert c2_50.fits_in(c1_100)
+ assert c2_50.fits_in(c2_100)
+ assert not c2_50.fits_in(c1_50)
- empty = self.slottable.create_empty_resource_tuple()
- empty.incr(c2_100)
- assert empty._single_instance[0] == 1024
- assert empty._multi_instance[1] == [100,100]
+ empty = slottable.create_empty_resource_tuple()
+ empty.incr(c2_100)
+ assert empty._single_instance[0] == 1024
+ assert empty._multi_instance[1] == [100,100]
+
+ empty = slottable.create_empty_resource_tuple()
+ empty.incr(c1_100)
+ assert empty._single_instance[0] == 1024
+ assert empty._multi_instance[1] == [100]
+ empty.incr(c1_100)
+ assert empty._single_instance[0] == 2048
+ assert empty._multi_instance[1] == [100,100]
+
+ empty = slottable.create_empty_resource_tuple()
+ empty.incr(c1_100)
+ assert empty._single_instance[0] == 1024
+ assert empty._multi_instance[1] == [100]
+ empty.incr(c1_50)
+ assert empty._single_instance[0] == 2048
+ assert empty._multi_instance[1] == [100,50]
+
+ c1_100a = ResourceTuple.copy(c1_100)
+ c1_100a.decr(c1_50)
+ assert c1_100a._single_instance[0] == 0
+ assert c1_100a._multi_instance[1] == [50]
+
+ c2_100a = ResourceTuple.copy(c2_100)
+ c2_100a._single_instance[0] = 2048
+ c2_100a.decr(c1_50)
+
+ assert c2_100a._single_instance[0] == 1024
+ assert c2_100a._multi_instance[1] == [50,100]
+ c2_100a.decr(c1_50)
+ assert c2_100a._single_instance[0] == 0
+ assert c2_100a._multi_instance[1] == [0,100]
+
+ c2_100a = ResourceTuple.copy(c2_100)
+ c2_100a._single_instance[0] = 2048
+ c2_100a.decr(c2_50)
+ assert c2_100a._single_instance[0] == 1024
+ assert c2_100a._multi_instance[1] == [0,100]
+ c2_100a.decr(c2_50)
+ assert c2_100a._single_instance[0] == 0
+ assert c2_100a._multi_instance[1] == [0,0]
+
+def test_slottable():
+ def assert_capacity(node, percent):
+ assert node.capacity.get_by_type(constants.RES_CPU) == percent * 100
+ assert node.capacity.get_by_type(constants.RES_MEM) == percent * 1024
- empty = self.slottable.create_empty_resource_tuple()
- empty.incr(c1_100)
- assert empty._single_instance[0] == 1024
- assert empty._multi_instance[1] == [100]
- empty.incr(c1_100)
- assert empty._single_instance[0] == 2048
- assert empty._multi_instance[1] == [100,100]
+ def reservations_1_assertions():
+ assert not slottable.is_empty()
+ nodes = slottable.get_availability(T1300)
+ assert_capacity(nodes[1], 0.5)
+ assert_capacity(nodes[2], 0.5)
+ nodes = slottable.get_availability(T1330)
+ assert_capacity(nodes[1], 1.0)
+ assert_capacity(nodes[2], 1.0)
+
+ def reservations_2_assertions():
+ nodes = slottable.get_availability(T1300)
+ assert_capacity(nodes[1], 0.5)
+ assert_capacity(nodes[2], 0.5)
+ rrs = slottable.get_reservations_at(T1300)
+ assert len(rrs) == 1
+ assert rrs[0] == rr1
- empty = self.slottable.create_empty_resource_tuple()
- empty.incr(c1_100)
- assert empty._single_instance[0] == 1024
- assert empty._multi_instance[1] == [100]
- empty.incr(c1_50)
- assert empty._single_instance[0] == 2048
- assert empty._multi_instance[1] == [100,50]
-
- c1_100a = ResourceTuple.copy(c1_100)
- c1_100a.decr(c1_50)
- assert c1_100a._single_instance[0] == 0
- assert c1_100a._multi_instance[1] == [50]
+ nodes = slottable.get_availability(T1330)
+ assert_capacity(nodes[1], 0.75)
+ assert_capacity(nodes[2], 0.5)
+ rrs = slottable.get_reservations_at(T1330)
+ assert len(rrs) == 1
+ assert rrs[0] == rr2
- c2_100a = ResourceTuple.copy(c2_100)
- c2_100a._single_instance[0] = 2048
- c2_100a.decr(c1_50)
+ nodes = slottable.get_availability(T1400)
+ assert_capacity(nodes[1], 1.0)
+ assert_capacity(nodes[2], 1.0)
+ rrs = slottable.get_reservations_at(T1400)
+ assert len(rrs) == 0
- assert c2_100a._single_instance[0] == 1024
- assert c2_100a._multi_instance[1] == [50,100]
- c2_100a.decr(c1_50)
- assert c2_100a._single_instance[0] == 0
- assert c2_100a._multi_instance[1] == [0,100]
+ def reservations_3_assertions():
+ nodes = slottable.get_availability(T1300)
+ assert_capacity(nodes[1], 0.5)
+ assert_capacity(nodes[2], 0.5)
+ rrs = slottable.get_reservations_at(T1300)
+ assert len(rrs) == 1
+ assert rrs[0] == rr1
- c2_100a = ResourceTuple.copy(c2_100)
- c2_100a._single_instance[0] = 2048
- c2_100a.decr(c2_50)
- assert c2_100a._single_instance[0] == 1024
- assert c2_100a._multi_instance[1] == [0,100]
- c2_100a.decr(c2_50)
- assert c2_100a._single_instance[0] == 0
- assert c2_100a._multi_instance[1] == [0,0]
-
- def test_slottable(self):
- def assert_capacity(node, percent):
- assert node.capacity.get_by_type(constants.RES_CPU) == percent * 100
- assert node.capacity.get_by_type(constants.RES_MEM) == percent * 1024
-
- def reservations_1_assertions():
- assert not self.slottable.is_empty()
- nodes = self.slottable.get_availability(T1300)
- assert_capacity(nodes[1], 0.5)
- assert_capacity(nodes[2], 0.5)
- nodes = self.slottable.get_availability(T1330)
- assert_capacity(nodes[1], 1.0)
- assert_capacity(nodes[2], 1.0)
-
- def reservations_2_assertions():
- nodes = self.slottable.get_availability(T1300)
- assert_capacity(nodes[1], 0.5)
- assert_capacity(nodes[2], 0.5)
- rrs = self.slottable.get_reservations_at(T1300)
- assert len(rrs) == 1
- assert rrs[0] == rr1
-
- nodes = self.slottable.get_availability(T1330)
- assert_capacity(nodes[1], 0.75)
- assert_capacity(nodes[2], 0.5)
- rrs = self.slottable.get_reservations_at(T1330)
- assert len(rrs) == 1
- assert rrs[0] == rr2
-
- nodes = self.slottable.get_availability(T1400)
- assert_capacity(nodes[1], 1.0)
- assert_capacity(nodes[2], 1.0)
- rrs = self.slottable.get_reservations_at(T1400)
- assert len(rrs) == 0
-
- def reservations_3_assertions():
- nodes = self.slottable.get_availability(T1300)
- assert_capacity(nodes[1], 0.5)
- assert_capacity(nodes[2], 0.5)
- rrs = self.slottable.get_reservations_at(T1300)
- assert len(rrs) == 1
- assert rrs[0] == rr1
-
- nodes = self.slottable.get_availability(T1315)
- assert_capacity(nodes[1], 0.25)
- assert_capacity(nodes[2], 0.25)
- rrs = self.slottable.get_reservations_at(T1315)
- assert len(rrs) == 2
- assert rr1 in rrs and rr3 in rrs
+ nodes = slottable.get_availability(T1315)
+ assert_capacity(nodes[1], 0.25)
+ assert_capacity(nodes[2], 0.25)
+ rrs = slottable.get_reservations_at(T1315)
+ assert len(rrs) == 2
+ assert rr1 in rrs and rr3 in rrs
- nodes = self.slottable.get_availability(T1330)
- assert_capacity(nodes[1], 0.5)
- assert_capacity(nodes[2], 0.25)
- rrs = self.slottable.get_reservations_at(T1330)
- assert len(rrs) == 2
- assert rr2 in rrs and rr3 in rrs
+ nodes = slottable.get_availability(T1330)
+ assert_capacity(nodes[1], 0.5)
+ assert_capacity(nodes[2], 0.25)
+ rrs = slottable.get_reservations_at(T1330)
+ assert len(rrs) == 2
+ assert rr2 in rrs and rr3 in rrs
- nodes = self.slottable.get_availability(T1345)
- assert_capacity(nodes[1], 0.75)
- assert_capacity(nodes[2], 0.5)
- rrs = self.slottable.get_reservations_at(T1345)
- assert len(rrs) == 1
- assert rrs[0] == rr2
-
- nodes = self.slottable.get_availability(T1400)
- assert_capacity(nodes[1], 1.0)
- assert_capacity(nodes[2], 1.0)
- rrs = self.slottable.get_reservations_at(T1400)
- assert len(rrs) == 0
+ nodes = slottable.get_availability(T1345)
+ assert_capacity(nodes[1], 0.75)
+ assert_capacity(nodes[2], 0.5)
+ rrs = slottable.get_reservations_at(T1345)
+ assert len(rrs) == 1
+ assert rrs[0] == rr2
- def reservations_4_assertions():
- nodes = self.slottable.get_availability(T1300)
- assert_capacity(nodes[1], 0.5)
- assert_capacity(nodes[2], 0.5)
- rrs = self.slottable.get_reservations_at(T1300)
- assert len(rrs) == 1
- assert rrs[0] == rr1
-
- nodes = self.slottable.get_availability(T1315)
- assert_capacity(nodes[1], 0.25)
- assert_capacity(nodes[2], 0.25)
- rrs = self.slottable.get_reservations_at(T1315)
- assert len(rrs) == 2
- assert rr1 in rrs and rr3 in rrs
+ nodes = slottable.get_availability(T1400)
+ assert_capacity(nodes[1], 1.0)
+ assert_capacity(nodes[2], 1.0)
+ rrs = slottable.get_reservations_at(T1400)
+ assert len(rrs) == 0
- nodes = self.slottable.get_availability(T1330)
- assert_capacity(nodes[1], 0)
- assert_capacity(nodes[2], 0)
- rrs = self.slottable.get_reservations_at(T1330)
- assert len(rrs) == 3
- assert rr4 in rrs and rr2 in rrs and rr3 in rrs
+ def reservations_4_assertions():
+ nodes = slottable.get_availability(T1300)
+ assert_capacity(nodes[1], 0.5)
+ assert_capacity(nodes[2], 0.5)
+ rrs = slottable.get_reservations_at(T1300)
+ assert len(rrs) == 1
+ assert rrs[0] == rr1
- nodes = self.slottable.get_availability(T1345)
- assert_capacity(nodes[1], 0.25)
- assert_capacity(nodes[2], 0.25)
- rrs = self.slottable.get_reservations_at(T1345)
- assert len(rrs) == 2
- assert rr2 in rrs and rr4 in rrs
-
- nodes = self.slottable.get_availability(T1400)
- assert_capacity(nodes[1], 0.5)
- assert_capacity(nodes[2], 0.75)
- rrs = self.slottable.get_reservations_at(T1400)
- assert len(rrs) == 1
- assert rrs[0] == rr4
-
- nodes = self.slottable.get_availability(T1415)
- assert_capacity(nodes[1], 1.0)
- assert_capacity(nodes[2], 1.0)
- rrs = self.slottable.get_reservations_at(T1415)
- assert len(rrs) == 0
-
- def reservations_5_assertions():
- nodes = self.slottable.get_availability(T1300)
- assert_capacity(nodes[1], 0.5)
- assert_capacity(nodes[2], 0.5)
- rrs = self.slottable.get_reservations_at(T1300)
- assert len(rrs) == 1
- assert rrs[0] == rr1
-
- nodes = self.slottable.get_availability(T1315)
- assert_capacity(nodes[1], 0.25)
- assert_capacity(nodes[2], 0.25)
- rrs = self.slottable.get_reservations_at(T1315)
- assert len(rrs) == 2
- assert set(rrs) == set([rr1,rr3])
+ nodes = slottable.get_availability(T1315)
+ assert_capacity(nodes[1], 0.25)
+ assert_capacity(nodes[2], 0.25)
+ rrs = slottable.get_reservations_at(T1315)
+ assert len(rrs) == 2
+ assert rr1 in rrs and rr3 in rrs
- nodes = self.slottable.get_availability(T1330)
- assert_capacity(nodes[1], 0)
- assert_capacity(nodes[2], 0)
- rrs = self.slottable.get_reservations_at(T1330)
- assert len(rrs) == 3
- assert set(rrs) == set([rr2,rr3,rr4])
+ nodes = slottable.get_availability(T1330)
+ assert_capacity(nodes[1], 0)
+ assert_capacity(nodes[2], 0)
+ rrs = slottable.get_reservations_at(T1330)
+ assert len(rrs) == 3
+ assert rr4 in rrs and rr2 in rrs and rr3 in rrs
- nodes = self.slottable.get_availability(T1345)
- assert_capacity(nodes[1], 0.25)
- assert_capacity(nodes[2], 0)
- rrs = self.slottable.get_reservations_at(T1345)
- assert len(rrs) == 3
- assert set(rrs) == set([rr2,rr4,rr5])
+ nodes = slottable.get_availability(T1345)
+ assert_capacity(nodes[1], 0.25)
+ assert_capacity(nodes[2], 0.25)
+ rrs = slottable.get_reservations_at(T1345)
+ assert len(rrs) == 2
+ assert rr2 in rrs and rr4 in rrs
+
+ nodes = slottable.get_availability(T1400)
+ assert_capacity(nodes[1], 0.5)
+ assert_capacity(nodes[2], 0.75)
+ rrs = slottable.get_reservations_at(T1400)
+ assert len(rrs) == 1
+ assert rrs[0] == rr4
+
+ nodes = slottable.get_availability(T1415)
+ assert_capacity(nodes[1], 1.0)
+ assert_capacity(nodes[2], 1.0)
+ rrs = slottable.get_reservations_at(T1415)
+ assert len(rrs) == 0
- nodes = self.slottable.get_availability(T1400)
- assert_capacity(nodes[1], 0.5)
- assert_capacity(nodes[2], 0.5)
- rrs = self.slottable.get_reservations_at(T1400)
- assert len(rrs) == 2
- assert set(rrs) == set([rr4,rr5])
-
- nodes = self.slottable.get_availability(T1415)
- assert_capacity(nodes[1], 1.0)
- assert_capacity(nodes[2], 1.0)
- rrs = self.slottable.get_reservations_at(T1415)
- assert len(rrs) == 0
-
- rrs = self.slottable.get_reservations_starting_between(T1300, T1315)
- assert set(rrs) == set([rr1,rr3])
- rrs = self.slottable.get_reservations_starting_between(T1300, T1330)
- assert set(rrs) == set([rr1,rr2,rr3,rr4])
- rrs = self.slottable.get_reservations_starting_between(T1300, T1345)
- assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_starting_between(T1315, T1330)
- assert set(rrs) == set([rr2,rr3,rr4])
- rrs = self.slottable.get_reservations_starting_between(T1315, T1345)
- assert set(rrs) == set([rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_starting_between(T1330, T1345)
- assert set(rrs) == set([rr2,rr4,rr5])
- rrs = self.slottable.get_reservations_starting_between(T1400, T1415)
- assert len(rrs) == 0
- rrs = self.slottable.get_reservations_starting_between(T1305, T1335)
- assert set(rrs) == set([rr3,rr2,rr4])
+ def reservations_5_assertions():
+ nodes = slottable.get_availability(T1300)
+ assert_capacity(nodes[1], 0.5)
+ assert_capacity(nodes[2], 0.5)
+ rrs = slottable.get_reservations_at(T1300)
+ assert len(rrs) == 1
+ assert rrs[0] == rr1
- rrs = self.slottable.get_reservations_ending_between(T1300, T1305)
- assert len(rrs) == 0
- rrs = self.slottable.get_reservations_ending_between(T1300, T1315)
- assert len(rrs) == 0
- rrs = self.slottable.get_reservations_ending_between(T1300, T1330)
- assert set(rrs) == set([rr1])
- rrs = self.slottable.get_reservations_ending_between(T1300, T1335)
- assert set(rrs) == set([rr1])
- rrs = self.slottable.get_reservations_ending_between(T1300, T1345)
- assert set(rrs) == set([rr1,rr3])
- rrs = self.slottable.get_reservations_ending_between(T1300, T1400)
- assert set(rrs) == set([rr1,rr2,rr3])
- rrs = self.slottable.get_reservations_ending_between(T1300, T1415)
- assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_between(T1305, T1315)
- assert len(rrs) == 0
- rrs = self.slottable.get_reservations_ending_between(T1305, T1330)
- assert set(rrs) == set([rr1])
- rrs = self.slottable.get_reservations_ending_between(T1305, T1335)
- assert set(rrs) == set([rr1])
- rrs = self.slottable.get_reservations_ending_between(T1305, T1345)
- assert set(rrs) == set([rr1,rr3])
- rrs = self.slottable.get_reservations_ending_between(T1305, T1400)
- assert set(rrs) == set([rr1,rr2,rr3])
- rrs = self.slottable.get_reservations_ending_between(T1305, T1415)
- assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_between(T1315, T1330)
- assert set(rrs) == set([rr1])
- rrs = self.slottable.get_reservations_ending_between(T1315, T1335)
- assert set(rrs) == set([rr1])
- rrs = self.slottable.get_reservations_ending_between(T1315, T1345)
- assert set(rrs) == set([rr1,rr3])
- rrs = self.slottable.get_reservations_ending_between(T1315, T1400)
- assert set(rrs) == set([rr1,rr2,rr3])
- rrs = self.slottable.get_reservations_ending_between(T1315, T1415)
- assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_between(T1330, T1335)
- assert set(rrs) == set([rr1])
- rrs = self.slottable.get_reservations_ending_between(T1330, T1345)
- assert set(rrs) == set([rr1,rr3])
- rrs = self.slottable.get_reservations_ending_between(T1330, T1400)
- assert set(rrs) == set([rr1,rr2,rr3])
- rrs = self.slottable.get_reservations_ending_between(T1330, T1415)
- assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_between(T1335, T1345)
- assert set(rrs) == set([rr3])
- rrs = self.slottable.get_reservations_ending_between(T1335, T1400)
- assert set(rrs) == set([rr2,rr3])
- rrs = self.slottable.get_reservations_ending_between(T1335, T1415)
- assert set(rrs) == set([rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_between(T1345, T1400)
- assert set(rrs) == set([rr2,rr3])
- rrs = self.slottable.get_reservations_ending_between(T1345, T1415)
- assert set(rrs) == set([rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_between(T1400, T1415)
- assert set(rrs) == set([rr2,rr4,rr5])
-
- rrs = self.slottable.get_reservations_starting_on_or_after(T1300)
- assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_starting_on_or_after(T1305)
- assert set(rrs) == set([rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_starting_on_or_after(T1315)
- assert set(rrs) == set([rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_starting_on_or_after(T1330)
- assert set(rrs) == set([rr2,rr4,rr5])
- rrs = self.slottable.get_reservations_starting_on_or_after(T1335)
- assert set(rrs) == set([rr5])
- rrs = self.slottable.get_reservations_starting_on_or_after(T1345)
- assert set(rrs) == set([rr5])
- rrs = self.slottable.get_reservations_starting_on_or_after(T1400)
- assert len(rrs) == 0
- rrs = self.slottable.get_reservations_starting_on_or_after(T1415)
- assert len(rrs) == 0
-
- rrs = self.slottable.get_reservations_ending_on_or_after(T1300)
- assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_on_or_after(T1305)
- assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_on_or_after(T1315)
- assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_on_or_after(T1330)
- assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_on_or_after(T1335)
- assert set(rrs) == set([rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_on_or_after(T1345)
- assert set(rrs) == set([rr2,rr3,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_on_or_after(T1400)
- assert set(rrs) == set([rr2,rr4,rr5])
- rrs = self.slottable.get_reservations_ending_on_or_after(T1415)
- assert set(rrs) == set([rr4,rr5])
-
- assert self.slottable.get_next_changepoint(T1255) == T1300
- assert self.slottable.get_next_changepoint(T1300) == T1315
- assert self.slottable.get_next_changepoint(T1315) == T1330
- assert self.slottable.get_next_changepoint(T1330) == T1345
- assert self.slottable.get_next_changepoint(T1335) == T1345
- assert self.slottable.get_next_changepoint(T1345) == T1400
- assert self.slottable.get_next_changepoint(T1400) == T1415
- assert self.slottable.get_next_changepoint(T1415) == None
- assert self.slottable.get_next_changepoint(T1420) == None
+ nodes = slottable.get_availability(T1315)
+ assert_capacity(nodes[1], 0.25)
+ assert_capacity(nodes[2], 0.25)
+ rrs = slottable.get_reservations_at(T1315)
+ assert len(rrs) == 2
+ assert set(rrs) == set([rr1,rr3])
+
+ nodes = slottable.get_availability(T1330)
+ assert_capacity(nodes[1], 0)
+ assert_capacity(nodes[2], 0)
+ rrs = slottable.get_reservations_at(T1330)
+ assert len(rrs) == 3
+ assert set(rrs) == set([rr2,rr3,rr4])
+
+ nodes = slottable.get_availability(T1345)
+ assert_capacity(nodes[1], 0.25)
+ assert_capacity(nodes[2], 0)
+ rrs = slottable.get_reservations_at(T1345)
+ assert len(rrs) == 3
+ assert set(rrs) == set([rr2,rr4,rr5])
+
+ nodes = slottable.get_availability(T1400)
+ assert_capacity(nodes[1], 0.5)
+ assert_capacity(nodes[2], 0.5)
+ rrs = slottable.get_reservations_at(T1400)
+ assert len(rrs) == 2
+ assert set(rrs) == set([rr4,rr5])
+
+ nodes = slottable.get_availability(T1415)
+ assert_capacity(nodes[1], 1.0)
+ assert_capacity(nodes[2], 1.0)
+ rrs = slottable.get_reservations_at(T1415)
+ assert len(rrs) == 0
- self.slottable = SlotTable([(constants.RES_CPU,ResourceTuple.SINGLE_INSTANCE),(constants.RES_MEM,ResourceTuple.SINGLE_INSTANCE)])
- FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(self.slottable)
+ rrs = slottable.get_reservations_starting_between(T1300, T1315)
+ assert set(rrs) == set([rr1,rr3])
+ rrs = slottable.get_reservations_starting_between(T1300, T1330)
+ assert set(rrs) == set([rr1,rr2,rr3,rr4])
+ rrs = slottable.get_reservations_starting_between(T1300, T1345)
+ assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_starting_between(T1315, T1330)
+ assert set(rrs) == set([rr2,rr3,rr4])
+ rrs = slottable.get_reservations_starting_between(T1315, T1345)
+ assert set(rrs) == set([rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_starting_between(T1330, T1345)
+ assert set(rrs) == set([rr2,rr4,rr5])
+ rrs = slottable.get_reservations_starting_between(T1400, T1415)
+ assert len(rrs) == 0
+ rrs = slottable.get_reservations_starting_between(T1305, T1335)
+ assert set(rrs) == set([rr3,rr2,rr4])
+
+ rrs = slottable.get_reservations_ending_between(T1300, T1305)
+ assert len(rrs) == 0
+ rrs = slottable.get_reservations_ending_between(T1300, T1315)
+ assert len(rrs) == 0
+ rrs = slottable.get_reservations_ending_between(T1300, T1330)
+ assert set(rrs) == set([rr1])
+ rrs = slottable.get_reservations_ending_between(T1300, T1335)
+ assert set(rrs) == set([rr1])
+ rrs = slottable.get_reservations_ending_between(T1300, T1345)
+ assert set(rrs) == set([rr1,rr3])
+ rrs = slottable.get_reservations_ending_between(T1300, T1400)
+ assert set(rrs) == set([rr1,rr2,rr3])
+ rrs = slottable.get_reservations_ending_between(T1300, T1415)
+ assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_ending_between(T1305, T1315)
+ assert len(rrs) == 0
+ rrs = slottable.get_reservations_ending_between(T1305, T1330)
+ assert set(rrs) == set([rr1])
+ rrs = slottable.get_reservations_ending_between(T1305, T1335)
+ assert set(rrs) == set([rr1])
+ rrs = slottable.get_reservations_ending_between(T1305, T1345)
+ assert set(rrs) == set([rr1,rr3])
+ rrs = slottable.get_reservations_ending_between(T1305, T1400)
+ assert set(rrs) == set([rr1,rr2,rr3])
+ rrs = slottable.get_reservations_ending_between(T1305, T1415)
+ assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_ending_between(T1315, T1330)
+ assert set(rrs) == set([rr1])
+ rrs = slottable.get_reservations_ending_between(T1315, T1335)
+ assert set(rrs) == set([rr1])
+ rrs = slottable.get_reservations_ending_between(T1315, T1345)
+ assert set(rrs) == set([rr1,rr3])
+ rrs = slottable.get_reservations_ending_between(T1315, T1400)
+ assert set(rrs) == set([rr1,rr2,rr3])
+ rrs = slottable.get_reservations_ending_between(T1315, T1415)
+ assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_ending_between(T1330, T1335)
+ assert set(rrs) == set([rr1])
+ rrs = slottable.get_reservations_ending_between(T1330, T1345)
+ assert set(rrs) == set([rr1,rr3])
+ rrs = slottable.get_reservations_ending_between(T1330, T1400)
+ assert set(rrs) == set([rr1,rr2,rr3])
+ rrs = slottable.get_reservations_ending_between(T1330, T1415)
+ assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_ending_between(T1335, T1345)
+ assert set(rrs) == set([rr3])
+ rrs = slottable.get_reservations_ending_between(T1335, T1400)
+ assert set(rrs) == set([rr2,rr3])
+ rrs = slottable.get_reservations_ending_between(T1335, T1415)
+ assert set(rrs) == set([rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_ending_between(T1345, T1400)
+ assert set(rrs) == set([rr2,rr3])
+ rrs = slottable.get_reservations_ending_between(T1345, T1415)
+ assert set(rrs) == set([rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_ending_between(T1400, T1415)
+ assert set(rrs) == set([rr2,rr4,rr5])
- self.slottable.add_node(1, FULL_NODE)
- self.slottable.add_node(2, FULL_NODE)
+ rrs = slottable.get_reservations_starting_on_or_after(T1300)
+ assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_starting_on_or_after(T1305)
+ assert set(rrs) == set([rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_starting_on_or_after(T1315)
+ assert set(rrs) == set([rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_starting_on_or_after(T1330)
+ assert set(rrs) == set([rr2,rr4,rr5])
+ rrs = slottable.get_reservations_starting_on_or_after(T1335)
+ assert set(rrs) == set([rr5])
+ rrs = slottable.get_reservations_starting_on_or_after(T1345)
+ assert set(rrs) == set([rr5])
+ rrs = slottable.get_reservations_starting_on_or_after(T1400)
+ assert len(rrs) == 0
+ rrs = slottable.get_reservations_starting_on_or_after(T1415)
+ assert len(rrs) == 0
- assert self.slottable.get_total_capacity(constants.RES_CPU) == 200
- assert self.slottable.get_total_capacity(constants.RES_MEM) == 2048
- assert self.slottable.is_empty()
+ rrs = slottable.get_reservations_ending_on_or_after(T1300)
+ assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_ending_on_or_after(T1305)
+ assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_ending_on_or_after(T1315)
+ assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_ending_on_or_after(T1330)
+ assert set(rrs) == set([rr1,rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_ending_on_or_after(T1335)
+ assert set(rrs) == set([rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_ending_on_or_after(T1345)
+ assert set(rrs) == set([rr2,rr3,rr4,rr5])
+ rrs = slottable.get_reservations_ending_on_or_after(T1400)
+ assert set(rrs) == set([rr2,rr4,rr5])
+ rrs = slottable.get_reservations_ending_on_or_after(T1415)
+ assert set(rrs) == set([rr4,rr5])
+
+ assert slottable.get_next_changepoint(T1255) == T1300
+ assert slottable.get_next_changepoint(T1300) == T1315
+ assert slottable.get_next_changepoint(T1315) == T1330
+ assert slottable.get_next_changepoint(T1330) == T1345
+ assert slottable.get_next_changepoint(T1335) == T1345
+ assert slottable.get_next_changepoint(T1345) == T1400
+ assert slottable.get_next_changepoint(T1400) == T1415
+ assert slottable.get_next_changepoint(T1415) == None
+ assert slottable.get_next_changepoint(T1420) == None
- res1 = {1: HALF_NODE, 2: HALF_NODE}
- rr1 = ResourceReservation(None, T1300, T1330, res1)
- self.slottable.add_reservation(rr1)
- reservations_1_assertions()
+ slottable = SlotTable([(constants.RES_CPU,ResourceTuple.SINGLE_INSTANCE),(constants.RES_MEM,ResourceTuple.SINGLE_INSTANCE)])
+ FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(slottable)
+
+ slottable.add_node(1, FULL_NODE)
+ slottable.add_node(2, FULL_NODE)
+
+ assert slottable.get_total_capacity(constants.RES_CPU) == 200
+ assert slottable.get_total_capacity(constants.RES_MEM) == 2048
+ assert slottable.is_empty()
- res2 = {1: QRTR_NODE, 2: HALF_NODE}
- rr2 = ResourceReservation(None, T1330, T1400, res2)
- self.slottable.add_reservation(rr2)
- reservations_2_assertions()
+ res1 = {1: HALF_NODE, 2: HALF_NODE}
+ rr1 = ResourceReservation(None, T1300, T1330, res1)
+ slottable.add_reservation(rr1)
+ reservations_1_assertions()
- res3 = {1: QRTR_NODE, 2: QRTR_NODE}
- rr3 = ResourceReservation(None, T1315, T1345, res3)
- self.slottable.add_reservation(rr3)
- reservations_3_assertions()
+ res2 = {1: QRTR_NODE, 2: HALF_NODE}
+ rr2 = ResourceReservation(None, T1330, T1400, res2)
+ slottable.add_reservation(rr2)
+ reservations_2_assertions()
- res4 = {1: HALF_NODE, 2: QRTR_NODE}
- rr4 = ResourceReservation(None, T1330, T1415, res4)
- self.slottable.add_reservation(rr4)
- reservations_4_assertions()
+ res3 = {1: QRTR_NODE, 2: QRTR_NODE}
+ rr3 = ResourceReservation(None, T1315, T1345, res3)
+ slottable.add_reservation(rr3)
+ reservations_3_assertions()
- res5 = {2: QRTR_NODE}
- rr5 = ResourceReservation(None, T1345, T1415, res5)
- self.slottable.add_reservation(rr5)
- reservations_5_assertions()
+ res4 = {1: HALF_NODE, 2: QRTR_NODE}
+ rr4 = ResourceReservation(None, T1330, T1415, res4)
+ slottable.add_reservation(rr4)
+ reservations_4_assertions()
- self.slottable.remove_reservation(rr5)
- reservations_4_assertions()
- self.slottable.remove_reservation(rr4)
- reservations_3_assertions()
- self.slottable.remove_reservation(rr3)
- reservations_2_assertions()
- self.slottable.remove_reservation(rr2)
- reservations_1_assertions()
- self.slottable.remove_reservation(rr1)
+ res5 = {2: QRTR_NODE}
+ rr5 = ResourceReservation(None, T1345, T1415, res5)
+ slottable.add_reservation(rr5)
+ reservations_5_assertions()
+
+ slottable.remove_reservation(rr5)
+ reservations_4_assertions()
+ slottable.remove_reservation(rr4)
+ reservations_3_assertions()
+ slottable.remove_reservation(rr3)
+ reservations_2_assertions()
+ slottable.remove_reservation(rr2)
+ reservations_1_assertions()
+ slottable.remove_reservation(rr1)
+
+ assert slottable.is_empty()
+
+def test_availabilitywindow():
+ def avail_node_assertions(time, avail, node_id, leases, next_cp):
+ node = aw.changepoints[time].nodes[node_id]
+ nleases = len(leases)
+ assert(node.available == avail)
- assert self.slottable.is_empty()
-
- def test_availabilitywindow(self):
- def avail_node_assertions(time, avail, node_id, leases, next_cp):
- node = aw.changepoints[time].nodes[node_id]
- nleases = len(leases)
- assert(node.available == avail)
-
- assert(len(node.leases)==nleases)
- for l in leases:
- assert(l in node.leases)
- assert(len(node.available_if_preempting) == nleases)
- for l in leases:
- assert(node.available_if_preempting[l] == leases[l])
- assert(node.next_cp == next_cp)
- if next_cp != None:
- assert(node.next_nodeavail == aw.changepoints[next_cp].nodes[node_id])
-
- self.slottable, leases = sample_slottable_1()
- FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(self.slottable)
-
- lease1,lease2,lease3,lease4,lease5,lease6 = leases
-
- aw = self.slottable.get_availability_window(T1300)
-
- # TODO: Factor out data into a data structure so we can do more
- # elaborate assertions
-
- # 13:00
- avail_node_assertions(time = T1300, avail = EMPT_NODE, node_id = 1,
- leases = {lease6:FULL_NODE}, next_cp = T1305)
- avail_node_assertions(time = T1300, avail = FULL_NODE, node_id = 2,
- leases = {}, next_cp = T1315)
- avail_node_assertions(time = T1300, avail = FULL_NODE, node_id = 3,
- leases = {}, next_cp = T1330)
- avail_node_assertions(time = T1300, avail = FULL_NODE, node_id = 4,
- leases = {}, next_cp = T1330)
+ assert(len(node.leases)==nleases)
+ for l in leases:
+ assert(l in node.leases)
+ assert(len(node.available_if_preempting) == nleases)
+ for l in leases:
+ assert(node.available_if_preempting[l] == leases[l])
+ assert(node.next_cp == next_cp)
+ if next_cp != None:
+ assert(node.next_nodeavail == aw.changepoints[next_cp].nodes[node_id])
+
+ slottable, leases = sample_slottable_1()
+ FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(slottable)
+
+ lease1,lease2,lease3,lease4,lease5,lease6 = leases
+
+ aw = slottable.get_availability_window(T1300)
+
+ # TODO: Factor out data into a data structure so we can do more
+ # elaborate assertions
+
+ # 13:00
+ avail_node_assertions(time = T1300, avail = EMPT_NODE, node_id = 1,
+ leases = {lease6:FULL_NODE}, next_cp = T1305)
+ avail_node_assertions(time = T1300, avail = FULL_NODE, node_id = 2,
+ leases = {}, next_cp = T1315)
+ avail_node_assertions(time = T1300, avail = FULL_NODE, node_id = 3,
+ leases = {}, next_cp = T1330)
+ avail_node_assertions(time = T1300, avail = FULL_NODE, node_id = 4,
+ leases = {}, next_cp = T1330)
- # 13:05
- avail_node_assertions(time = T1305, avail = FULL_NODE, node_id = 1,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1305, avail = FULL_NODE, node_id = 2,
- leases = {}, next_cp = T1315)
- avail_node_assertions(time = T1305, avail = FULL_NODE, node_id = 3,
- leases = {}, next_cp = T1330)
- avail_node_assertions(time = T1305, avail = FULL_NODE, node_id = 4,
- leases = {}, next_cp = T1330)
+ # 13:05
+ avail_node_assertions(time = T1305, avail = FULL_NODE, node_id = 1,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1305, avail = FULL_NODE, node_id = 2,
+ leases = {}, next_cp = T1315)
+ avail_node_assertions(time = T1305, avail = FULL_NODE, node_id = 3,
+ leases = {}, next_cp = T1330)
+ avail_node_assertions(time = T1305, avail = FULL_NODE, node_id = 4,
+ leases = {}, next_cp = T1330)
- # 13:15
- avail_node_assertions(time = T1315, avail = FULL_NODE, node_id = 1,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1315, avail = HALF_NODE, node_id = 2,
- leases = {lease1:HALF_NODE}, next_cp = T1330)
- avail_node_assertions(time = T1315, avail = FULL_NODE, node_id = 3,
- leases = {}, next_cp = T1330)
- avail_node_assertions(time = T1315, avail = FULL_NODE, node_id = 4,
- leases = {}, next_cp = T1330)
+ # 13:15
+ avail_node_assertions(time = T1315, avail = FULL_NODE, node_id = 1,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1315, avail = HALF_NODE, node_id = 2,
+ leases = {lease1:HALF_NODE}, next_cp = T1330)
+ avail_node_assertions(time = T1315, avail = FULL_NODE, node_id = 3,
+ leases = {}, next_cp = T1330)
+ avail_node_assertions(time = T1315, avail = FULL_NODE, node_id = 4,
+ leases = {}, next_cp = T1330)
- # 13:25
- avail_node_assertions(time = T1325, avail = FULL_NODE, node_id = 1,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1325, avail = HALF_NODE, node_id = 2,
- leases = {lease1:HALF_NODE}, next_cp = T1330)
- avail_node_assertions(time = T1325, avail = FULL_NODE, node_id = 3,
- leases = {}, next_cp = T1330)
- avail_node_assertions(time = T1325, avail = FULL_NODE, node_id = 4,
- leases = {}, next_cp = T1330)
+ # 13:25
+ avail_node_assertions(time = T1325, avail = FULL_NODE, node_id = 1,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1325, avail = HALF_NODE, node_id = 2,
+ leases = {lease1:HALF_NODE}, next_cp = T1330)
+ avail_node_assertions(time = T1325, avail = FULL_NODE, node_id = 3,
+ leases = {}, next_cp = T1330)
+ avail_node_assertions(time = T1325, avail = FULL_NODE, node_id = 4,
+ leases = {}, next_cp = T1330)
- # 13:30
- avail_node_assertions(time = T1330, avail = FULL_NODE, node_id = 1,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1330, avail = EMPT_NODE, node_id = 2,
- leases = {lease2:FULL_NODE}, next_cp = T1345)
- avail_node_assertions(time = T1330, avail = EMPT_NODE, node_id = 3,
- leases = {lease2:FULL_NODE}, next_cp = T1345)
- avail_node_assertions(time = T1330, avail = EMPT_NODE, node_id = 4,
- leases = {lease3:FULL_NODE}, next_cp = T1400)
+ # 13:30
+ avail_node_assertions(time = T1330, avail = FULL_NODE, node_id = 1,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1330, avail = EMPT_NODE, node_id = 2,
+ leases = {lease2:FULL_NODE}, next_cp = T1345)
+ avail_node_assertions(time = T1330, avail = EMPT_NODE, node_id = 3,
+ leases = {lease2:FULL_NODE}, next_cp = T1345)
+ avail_node_assertions(time = T1330, avail = EMPT_NODE, node_id = 4,
+ leases = {lease3:FULL_NODE}, next_cp = T1400)
- # 13:45
- avail_node_assertions(time = T1345, avail = FULL_NODE, node_id = 1,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1345, avail = FULL_NODE, node_id = 2,
- leases = {}, next_cp = T1350)
- avail_node_assertions(time = T1345, avail = FULL_NODE, node_id = 3,
- leases = {}, next_cp = T1350)
- avail_node_assertions(time = T1345, avail = EMPT_NODE, node_id = 4,
- leases = {lease3:FULL_NODE}, next_cp = T1400)
+ # 13:45
+ avail_node_assertions(time = T1345, avail = FULL_NODE, node_id = 1,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1345, avail = FULL_NODE, node_id = 2,
+ leases = {}, next_cp = T1350)
+ avail_node_assertions(time = T1345, avail = FULL_NODE, node_id = 3,
+ leases = {}, next_cp = T1350)
+ avail_node_assertions(time = T1345, avail = EMPT_NODE, node_id = 4,
+ leases = {lease3:FULL_NODE}, next_cp = T1400)
- # 13:50
- avail_node_assertions(time = T1350, avail = FULL_NODE, node_id = 1,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1350, avail = HALF_NODE, node_id = 2,
- leases = {lease4:QRTR_NODE,lease5:QRTR_NODE}, next_cp = T1415)
- avail_node_assertions(time = T1350, avail = HALF_NODE, node_id = 3,
- leases = {lease4:HALF_NODE}, next_cp = T1415)
- avail_node_assertions(time = T1350, avail = EMPT_NODE, node_id = 4,
- leases = {lease3:FULL_NODE}, next_cp = T1400)
+ # 13:50
+ avail_node_assertions(time = T1350, avail = FULL_NODE, node_id = 1,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1350, avail = HALF_NODE, node_id = 2,
+ leases = {lease4:QRTR_NODE,lease5:QRTR_NODE}, next_cp = T1415)
+ avail_node_assertions(time = T1350, avail = HALF_NODE, node_id = 3,
+ leases = {lease4:HALF_NODE}, next_cp = T1415)
+ avail_node_assertions(time = T1350, avail = EMPT_NODE, node_id = 4,
+ leases = {lease3:FULL_NODE}, next_cp = T1400)
- # 13:55
- avail_node_assertions(time = T1355, avail = FULL_NODE, node_id = 1,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1355, avail = HALF_NODE, node_id = 2,
- leases = {lease4:QRTR_NODE,lease5:QRTR_NODE}, next_cp = T1415)
- avail_node_assertions(time = T1355, avail = HALF_NODE, node_id = 3,
- leases = {lease4:HALF_NODE}, next_cp = T1415)
- avail_node_assertions(time = T1355, avail = EMPT_NODE, node_id = 4,
- leases = {lease3:FULL_NODE}, next_cp = T1400)
+ # 13:55
+ avail_node_assertions(time = T1355, avail = FULL_NODE, node_id = 1,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1355, avail = HALF_NODE, node_id = 2,
+ leases = {lease4:QRTR_NODE,lease5:QRTR_NODE}, next_cp = T1415)
+ avail_node_assertions(time = T1355, avail = HALF_NODE, node_id = 3,
+ leases = {lease4:HALF_NODE}, next_cp = T1415)
+ avail_node_assertions(time = T1355, avail = EMPT_NODE, node_id = 4,
+ leases = {lease3:FULL_NODE}, next_cp = T1400)
- # 14:00
- avail_node_assertions(time = T1400, avail = FULL_NODE, node_id = 1,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1400, avail = HALF_NODE, node_id = 2,
- leases = {lease4:QRTR_NODE,lease5:QRTR_NODE}, next_cp = T1415)
- avail_node_assertions(time = T1400, avail = HALF_NODE, node_id = 3,
- leases = {lease4:HALF_NODE}, next_cp = T1415)
- avail_node_assertions(time = T1400, avail = FULL_NODE, node_id = 4,
- leases = {}, next_cp = None)
+ # 14:00
+ avail_node_assertions(time = T1400, avail = FULL_NODE, node_id = 1,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1400, avail = HALF_NODE, node_id = 2,
+ leases = {lease4:QRTR_NODE,lease5:QRTR_NODE}, next_cp = T1415)
+ avail_node_assertions(time = T1400, avail = HALF_NODE, node_id = 3,
+ leases = {lease4:HALF_NODE}, next_cp = T1415)
+ avail_node_assertions(time = T1400, avail = FULL_NODE, node_id = 4,
+ leases = {}, next_cp = None)
- # 14:15
- avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 1,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 2,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 3,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 4,
- leases = {}, next_cp = None)
-
- avail = aw.get_ongoing_availability(T1300, 1)
- assert(len(avail.avail_list)==1)
- assert(avail.avail_list[0].available == EMPT_NODE)
- assert(avail.avail_list[0].until == None)
+ # 14:15
+ avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 1,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 2,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 3,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 4,
+ leases = {}, next_cp = None)
+
+ avail = aw.get_ongoing_availability(T1300, 1)
+ assert(len(avail.avail_list)==1)
+ assert(avail.avail_list[0].available == EMPT_NODE)
+ assert(avail.avail_list[0].until == None)
- avail = aw.get_ongoing_availability(T1300, 2)
- assert(len(avail.avail_list)==3)
- assert(avail.avail_list[0].available == FULL_NODE)
- assert(avail.avail_list[0].until == T1315)
- assert(avail.avail_list[1].available == HALF_NODE)
- assert(avail.avail_list[1].until == T1330)
- assert(avail.avail_list[2].available == EMPT_NODE)
- assert(avail.avail_list[2].until == None)
+ avail = aw.get_ongoing_availability(T1300, 2)
+ assert(len(avail.avail_list)==3)
+ assert(avail.avail_list[0].available == FULL_NODE)
+ assert(avail.avail_list[0].until == T1315)
+ assert(avail.avail_list[1].available == HALF_NODE)
+ assert(avail.avail_list[1].until == T1330)
+ assert(avail.avail_list[2].available == EMPT_NODE)
+ assert(avail.avail_list[2].until == None)
- avail = aw.get_ongoing_availability(T1300, 3)
- assert(len(avail.avail_list)==2)
- assert(avail.avail_list[0].available == FULL_NODE)
- assert(avail.avail_list[0].until == T1330)
- assert(avail.avail_list[1].available == EMPT_NODE)
- assert(avail.avail_list[1].until == None)
+ avail = aw.get_ongoing_availability(T1300, 3)
+ assert(len(avail.avail_list)==2)
+ assert(avail.avail_list[0].available == FULL_NODE)
+ assert(avail.avail_list[0].until == T1330)
+ assert(avail.avail_list[1].available == EMPT_NODE)
+ assert(avail.avail_list[1].until == None)
- avail = aw.get_ongoing_availability(T1300, 4)
- assert(len(avail.avail_list)==2)
- assert(avail.avail_list[0].available == FULL_NODE)
- assert(avail.avail_list[0].until == T1330)
- assert(avail.avail_list[1].available == EMPT_NODE)
- assert(avail.avail_list[1].until == None)
+ avail = aw.get_ongoing_availability(T1300, 4)
+ assert(len(avail.avail_list)==2)
+ assert(avail.avail_list[0].available == FULL_NODE)
+ assert(avail.avail_list[0].until == T1330)
+ assert(avail.avail_list[1].available == EMPT_NODE)
+ assert(avail.avail_list[1].until == None)
- avail = aw.get_ongoing_availability(T1330, 1)
- assert(len(avail.avail_list)==1)
- assert(avail.avail_list[0].available == FULL_NODE)
- assert(avail.avail_list[0].until == None)
+ avail = aw.get_ongoing_availability(T1330, 1)
+ assert(len(avail.avail_list)==1)
+ assert(avail.avail_list[0].available == FULL_NODE)
+ assert(avail.avail_list[0].until == None)
- avail = aw.get_ongoing_availability(T1330, 2)
- assert(len(avail.avail_list)==1)
- assert(avail.avail_list[0].available == EMPT_NODE)
- assert(avail.avail_list[0].until == None)
+ avail = aw.get_ongoing_availability(T1330, 2)
+ assert(len(avail.avail_list)==1)
+ assert(avail.avail_list[0].available == EMPT_NODE)
+ assert(avail.avail_list[0].until == None)
- avail = aw.get_ongoing_availability(T1330, 3)
- assert(len(avail.avail_list)==1)
- assert(avail.avail_list[0].available == EMPT_NODE)
- assert(avail.avail_list[0].until == None)
+ avail = aw.get_ongoing_availability(T1330, 3)
+ assert(len(avail.avail_list)==1)
+ assert(avail.avail_list[0].available == EMPT_NODE)
+ assert(avail.avail_list[0].until == None)
- avail = aw.get_ongoing_availability(T1330, 4)
- assert(len(avail.avail_list)==1)
- assert(avail.avail_list[0].available == EMPT_NODE)
- assert(avail.avail_list[0].until == None)
-
-
- avail = aw.get_ongoing_availability(T1345, 1)
- assert(len(avail.avail_list)==1)
- assert(avail.avail_list[0].available == FULL_NODE)
- assert(avail.avail_list[0].until == None)
+ avail = aw.get_ongoing_availability(T1330, 4)
+ assert(len(avail.avail_list)==1)
+ assert(avail.avail_list[0].available == EMPT_NODE)
+ assert(avail.avail_list[0].until == None)
+
+
+ avail = aw.get_ongoing_availability(T1345, 1)
+ assert(len(avail.avail_list)==1)
+ assert(avail.avail_list[0].available == FULL_NODE)
+ assert(avail.avail_list[0].until == None)
- avail = aw.get_ongoing_availability(T1345, 2)
- assert(len(avail.avail_list)==2)
- assert(avail.avail_list[0].available == FULL_NODE)
- assert(avail.avail_list[0].until == T1350)
- assert(avail.avail_list[1].available == HALF_NODE)
- assert(avail.avail_list[1].until == None)
+ avail = aw.get_ongoing_availability(T1345, 2)
+ assert(len(avail.avail_list)==2)
+ assert(avail.avail_list[0].available == FULL_NODE)
+ assert(avail.avail_list[0].until == T1350)
+ assert(avail.avail_list[1].available == HALF_NODE)
+ assert(avail.avail_list[1].until == None)
- avail = aw.get_ongoing_availability(T1345, 3)
- assert(len(avail.avail_list)==2)
- assert(avail.avail_list[0].available == FULL_NODE)
- assert(avail.avail_list[0].until == T1350)
- assert(avail.avail_list[1].available == HALF_NODE)
- assert(avail.avail_list[1].until == None)
+ avail = aw.get_ongoing_availability(T1345, 3)
+ assert(len(avail.avail_list)==2)
+ assert(avail.avail_list[0].available == FULL_NODE)
+ assert(avail.avail_list[0].until == T1350)
+ assert(avail.avail_list[1].available == HALF_NODE)
+ assert(avail.avail_list[1].until == None)
- avail = aw.get_ongoing_availability(T1345, 4)
- assert(len(avail.avail_list)==1)
- assert(avail.avail_list[0].available == EMPT_NODE)
- assert(avail.avail_list[0].until == None)
+ avail = aw.get_ongoing_availability(T1345, 4)
+ assert(len(avail.avail_list)==1)
+ assert(avail.avail_list[0].available == EMPT_NODE)
+ assert(avail.avail_list[0].until == None)
- self.slottable.awcache = None
- aw = self.slottable.get_availability_window(T1415)
- # 14:15
- avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 1,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 2,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 3,
- leases = {}, next_cp = None)
- avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 4,
- leases = {}, next_cp = None)
+ slottable.awcache = None
+ aw = slottable.get_availability_window(T1415)
+ # 14:15
+ avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 1,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 2,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 3,
+ leases = {}, next_cp = None)
+ avail_node_assertions(time = T1415, avail = FULL_NODE, node_id = 4,
+ leases = {}, next_cp = None)
- avail = aw.get_ongoing_availability(T1415, 1)
- assert(len(avail.avail_list)==1)
- assert(avail.avail_list[0].available == FULL_NODE)
- assert(avail.avail_list[0].until == None)
-
- avail = aw.get_ongoing_availability(T1415, 2)
- assert(len(avail.avail_list)==1)
- assert(avail.avail_list[0].available == FULL_NODE)
- assert(avail.avail_list[0].until == None)
-
- avail = aw.get_ongoing_availability(T1415, 3)
- assert(len(avail.avail_list)==1)
- assert(avail.avail_list[0].available == FULL_NODE)
- assert(avail.avail_list[0].until == None)
-
- avail = aw.get_ongoing_availability(T1415, 4)
- assert(len(avail.avail_list)==1)
- assert(avail.avail_list[0].available == FULL_NODE)
- assert(avail.avail_list[0].until == None)
-
- self.slottable, leases = sample_slottable_4()
- FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(self.slottable)
-
- lease1,lease2,lease3 = leases
- aw = self.slottable.get_availability_window(T1300)
-
- # 13:30
- avail_node_assertions(time = T1300, avail = FULL_NODE, node_id = 1,
- leases = {}, next_cp = T1315)
- avail_node_assertions(time = T1315, avail = HALF_NODE, node_id = 1,
- leases = {lease1:HALF_NODE}, next_cp = T1330)
- avail_node_assertions(time = T1330, avail = QRTR_NODE, node_id = 1,
- leases = {lease1:HALF_NODE,lease2:QRTR_NODE}, next_cp = T1415)
-
- avail = aw.get_ongoing_availability(T1300, 1)
- assert(len(avail.avail_list)==3)
- assert(avail.avail_list[0].available == FULL_NODE)
- assert(avail.avail_list[0].until == T1315)
- assert(avail.avail_list[1].available == HALF_NODE)
- assert(avail.avail_list[1].until == T1330)
- assert(avail.avail_list[2].available == QRTR_NODE)
- assert(avail.avail_list[2].until == None)
-
+ avail = aw.get_ongoing_availability(T1415, 1)
+ assert(len(avail.avail_list)==1)
+ assert(avail.avail_list[0].available == FULL_NODE)
+ assert(avail.avail_list[0].until == None)
+
+ avail = aw.get_ongoing_availability(T1415, 2)
+ assert(len(avail.avail_list)==1)
+ assert(avail.avail_list[0].available == FULL_NODE)
+ assert(avail.avail_list[0].until == None)
+
+ avail = aw.get_ongoing_availability(T1415, 3)
+ assert(len(avail.avail_list)==1)
+ assert(avail.avail_list[0].available == FULL_NODE)
+ assert(avail.avail_list[0].until == None)
+
+ avail = aw.get_ongoing_availability(T1415, 4)
+ assert(len(avail.avail_list)==1)
+ assert(avail.avail_list[0].available == FULL_NODE)
+ assert(avail.avail_list[0].until == None)
+
+ slottable, leases = sample_slottable_4()
+ FULL_NODE, HALF_NODE, QRTR_NODE, EMPT_NODE = create_capacities(slottable)
+
+ lease1,lease2,lease3 = leases
+ aw = slottable.get_availability_window(T1300)
+
+ # 13:30
+ avail_node_assertions(time = T1300, avail = FULL_NODE, node_id = 1,
+ leases = {}, next_cp = T1315)
+ avail_node_assertions(time = T1315, avail = HALF_NODE, node_id = 1,
+ leases = {lease1:HALF_NODE}, next_cp = T1330)
+ avail_node_assertions(time = T1330, avail = QRTR_NODE, node_id = 1,
+ leases = {lease1:HALF_NODE,lease2:QRTR_NODE}, next_cp = T1415)
+
+ avail = aw.get_ongoing_availability(T1300, 1)
+ assert(len(avail.avail_list)==3)
+ assert(avail.avail_list[0].available == FULL_NODE)
+ assert(avail.avail_list[0].until == T1315)
+ assert(avail.avail_list[1].available == HALF_NODE)
+ assert(avail.avail_list[1].until == T1330)
+ assert(avail.avail_list[2].available == QRTR_NODE)
+ assert(avail.avail_list[2].until == None)
+
\ No newline at end of file
More information about the Haizea-commit
mailing list