Add -k support and more

1 files changed, 137 insertions, 23 deletions

diff --git a/src/engine/SCons/TaskmasterTests.py b/src/engine/SCons/TaskmasterTests.py
index 59f62bd..809df6a 100644
--- a/src/engine/SCons/TaskmasterTests.py
+++ b/src/engine/SCons/TaskmasterTests.py
@@ -36,7 +36,12 @@ class Node:
     def __init__(self, name, kids = []):
         self.name = name
 	self.kids = kids
-
+        self.state = None
+        self.parents = []
+        
+        for kid in kids:
+            kid.parents.append(self)
+            
     def build(self):
         global built
         built = self.name + " built"
@@ -44,18 +49,22 @@ class Node:
     def children(self):
 	return self.kids
 
+    def get_parents(self):
+        return self.parents
+    
     def get_state(self):
-        pass
+        return self.state
 
     def set_state(self, state):
-        pass
+        self.state = state
 
-class Task:
-    def __init__(self, target):
-        self.target = target
-
-    def set_state(self, state):
-        pass
+    def children_are_executed(self):
+        return reduce(lambda x,y: ((y.get_state() == SCons.Node.executed
+                                   or y.get_state() == SCons.Node.up_to_date)
+                                   and x),
+                      self.children(),
+                      1)
+    
 
 
 class TaskmasterTestCase(unittest.TestCase):
@@ -65,19 +74,36 @@ class TaskmasterTestCase(unittest.TestCase):
 	"""
 	global built
 
+        n1 = Node("n1")
+        tm = SCons.Taskmaster.Taskmaster([n1,n1])
+        t = tm.next_task()
+        tm.executed(t)
+        t = tm.next_task()
+        assert t == None
+
+        
 	n1 = Node("n1")
 	n2 = Node("n2")
         n3 = Node("n3", [n1, n2])
         
 	tm = SCons.Taskmaster.Taskmaster([n3])
-	tm.next_task().execute()
-	assert built == "n1 built"
 
-	tm.next_task().execute()
-	assert built == "n2 built"
+        t = tm.next_task()
+        t.execute()
+        assert built == "n1 built"
+        tm.executed(t)
+
+        t = tm.next_task()
+        t.execute()
+        assert built == "n2 built"
+        tm.executed(t)
 
-	tm.next_task().execute()
-	assert built == "n3 built"
+        t = tm.next_task()
+        t.execute()
+        assert built == "n3 built"
+        tm.executed(t)
+
+        assert tm.next_task() == None
 
 	def current(node):
 	    return 1
@@ -93,23 +119,68 @@ class TaskmasterTestCase(unittest.TestCase):
                 global built
                 built = built + " " + node.name
 
+
+        n1.set_state(None)
+        n2.set_state(None)
+        n3.set_state(None)
 	tm = MyTM(targets = [n3], current = current)
 	assert tm.next_task() == None
         print built
 	assert built == "up to date:  n1 n2 n3"
 
+
+        n1 = Node("n1")
+	n2 = Node("n2")
+        n3 = Node("n3", [n1, n2])
         n4 = Node("n4")
-        n4.get_state = lambda: SCons.Node.executed
-        tm = SCons.Taskmaster.Taskmaster([n4])
+        n5 = Node("n5", [n3, n4])
+        tm = SCons.Taskmaster.Taskmaster([n5])
+
+        assert not tm.is_blocked()
+        
+        t1 = tm.next_task()
+        assert t1.get_target() == n1
+        assert not tm.is_blocked()
+        
+        t2 = tm.next_task()
+        assert t2.get_target() == n2
+        assert not tm.is_blocked()
+
+        t4 = tm.next_task()
+        assert t4.get_target() == n4
+        assert tm.is_blocked()
+        tm.executed(t4)
+        assert tm.is_blocked()
+        
+        tm.executed(t1)
+        assert tm.is_blocked()
+        tm.executed(t2)
+        assert not tm.is_blocked()
+        t3 = tm.next_task()
+        assert t3.get_target() == n3
+        assert tm.is_blocked()
+
+        tm.executed(t3)
+        assert not tm.is_blocked()
+        t5 = tm.next_task()
+        assert t5.get_target() == n5
+        assert not tm.is_blocked()
+
         assert tm.next_task() == None
+
         
+        n4 = Node("n4")
+        n4.set_state(SCons.Node.executed)
+        tm = SCons.Taskmaster.Taskmaster([n4])
+        assert tm.next_task() == None
+
     def test_is_blocked(self):
         """Test whether a task is blocked
 
 	Both default and overridden in a subclass.
 	"""
 	tm = SCons.Taskmaster.Taskmaster()
-	assert tm.is_blocked() == 0
+	assert not tm.is_blocked()
 
 	class MyTM(SCons.Taskmaster.Taskmaster):
 	    def is_blocked(self):
@@ -123,7 +194,8 @@ class TaskmasterTestCase(unittest.TestCase):
 	Both default and overridden in a subclass.
 	"""
 	tm = SCons.Taskmaster.Taskmaster()
-	tm.executed(Task('foo'))
+        foo = Node('foo')
+	tm.executed(SCons.Taskmaster.Task(foo))
 
 	class MyTM(SCons.Taskmaster.Taskmaster):
 	    def executed(self, task):
@@ -131,15 +203,57 @@ class TaskmasterTestCase(unittest.TestCase):
 	tm = MyTM()
 	assert tm.executed('foo') == 'xfoo'
 
+    def test_ignore_errors(self):
+        n1 = Node("n1")
+        n2 = Node("n2")
+        n3 = Node("n3", [n1])
+        
+        tm = SCons.Taskmaster.Taskmaster([n3, n2],
+                                         SCons.Taskmaster.Task,
+                                         SCons.Taskmaster.current,
+                                         1)
+
+        t = tm.next_task()
+        assert t.get_target() == n1
+        tm.failed(t)
+        t = tm.next_task()
+        assert t.get_target() == n3
+        tm.failed(t)
+        t = tm.next_task()
+        assert t.get_target() == n2
+        
+
+    def test_keep_going(self):
+        n1 = Node("n1")
+        n2 = Node("n2")
+        n3 = Node("n3", [n1])
+        
+        tm = SCons.Taskmaster.Taskmaster([n3, n2],
+                                         SCons.Taskmaster.Task,
+                                         SCons.Taskmaster.current,
+                                         0,
+                                         1)
+
+        tm.failed(tm.next_task())
+        t = tm.next_task()
+        assert t.get_target() == n2
+        tm.executed(t)
+        assert not tm.is_blocked()
+        t = tm.next_task()
+        assert t == None
+
+
     def test_failed(self):
         """Test the failed() method
 
 	Both default and overridden in a subclass.
 	"""
-	tm = SCons.Taskmaster.Taskmaster()
-	#XXX
-	tm.failed(Task('foo'))
-
+        foo = Node('foo')
+        bar = Node('bar')
+        tm = SCons.Taskmaster.Taskmaster([foo,bar])
+        tm.failed(tm.next_task())
+        assert tm.next_task() == None
+        
 	class MyTM(SCons.Taskmaster.Taskmaster):
 	    def failed(self, task):
 	        return 'y' + task