[haizea-commit] r594 - branches/TP2.0/tests

[haizea-commit at mailman.cs.uchicago.edu]

Author: borja
Date: 2009-06-19 05:40:00 -0500 (Fri, 19 Jun 2009)
New Revision: 594

Modified:
   branches/TP2.0/tests/test_mapper.py
Log:
Added more mapper tests

Modified: branches/TP2.0/tests/test_mapper.py
===================================================================
--- branches/TP2.0/tests/test_mapper.py	2009-06-18 17:29:21 UTC (rev 593)
+++ branches/TP2.0/tests/test_mapper.py	2009-06-19 10:40:00 UTC (rev 594)
@@ -50,6 +50,7 @@
 
         else:
             assert(mapping == None and actualend == None and preemptions == None)
+            return
         
         # Sanity check slottable
         tmp_slottable = create_tmp_slottable(self.slottable)
@@ -85,9 +86,56 @@
                                 end = T1345,
                                 requested_resources = {1: FULL_NODE, 2: FULL_NODE},
                                 strictend = True,
-                                mustmap = True,
-                                maxend = T1345)
+                                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)
+
+        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)
+
+        self.mapping_assertions(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)
+
+        self.mapping_assertions(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)
+
+        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)
+
+        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)
+
     def test_mapping_nopreemption_nostrictend(self):
         self.slottable, leases = sample_slottable_3()
         policy = SimplePolicy(self.slottable, preemption = False)
@@ -120,18 +168,69 @@
                                 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)
+
+        self.mapping_assertions(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()
         policy = SimplePolicy(self.slottable, preemption = True)        
         self.mapper = GreedyMapper(self.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]])
+
+        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]])
+
+        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,
-                                maxend = T1415,
                                 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)