X-Git-Url: http://git.tremily.us/?a=blobdiff_plain;f=src%2Fengine%2FSCons%2FNode%2FNodeTests.py;h=8c3dbe855ac53a8b563fd91e83905ddced3fe8e3;hb=11fb24c74fcbebe232bffbb4d30b002d51201106;hp=7d737bec581acb2051dbca67d6a2bd7aa8123efc;hpb=0c87c9435f6fdf1c6d89303f5c52aada2413c8b1;p=scons.git diff --git a/src/engine/SCons/Node/NodeTests.py b/src/engine/SCons/Node/NodeTests.py index 7d737bec..8c3dbe85 100644 --- a/src/engine/SCons/Node/NodeTests.py +++ b/src/engine/SCons/Node/NodeTests.py @@ -20,19 +20,19 @@ # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. # +from __future__ import generators ### KEEP FOR COMPATIBILITY FIXERS __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" +import collections import os import re -import string import sys -import types import unittest -import UserList import SCons.Errors import SCons.Node +import SCons.Util @@ -49,7 +49,7 @@ def _actionAppend(a1, a2): all.append(curr_a) elif isinstance(curr_a, MyListAction): all.extend(curr_a.list) - elif type(curr_a) == type([1,2]): + elif isinstance(curr_a, list): all.extend(curr_a) else: raise 'Cannot Combine Actions' @@ -66,8 +66,11 @@ class MyAction(MyActionBase): def __init__(self): self.order = 0 - def __call__(self, target, source, env, errfunc): + def __call__(self, target, source, env, executor=None): global built_it, built_target, built_source, built_args, built_order + if executor: + target = executor.get_all_targets() + source = executor.get_all_sources() built_it = 1 built_target = target built_source = source @@ -76,30 +79,39 @@ class MyAction(MyActionBase): self.order = built_order return 0 + def get_implicit_deps(self, target, source, env): + return [] + +class MyExecutor: + def __init__(self, env=None, targets=[], sources=[]): + self.env = env + self.targets = targets + self.sources = sources + def get_build_env(self): + return self.env + def get_build_scanner_path(self, scanner): + return 'executor would call %s' % scanner + def cleanup(self): + self.cleaned_up = 1 + def scan_targets(self, scanner): + if not scanner: + return + d = scanner(self.targets) + for t in self.targets: + t.implicit.extend(d) + def scan_sources(self, scanner): + if not scanner: + return + d = scanner(self.sources) + for t in self.targets: + t.implicit.extend(d) + class MyListAction(MyActionBase): def __init__(self, list): self.list = list - def __call__(self, target, source, env, errfunc): + def __call__(self, target, source, env): for A in self.list: - A(target, source, env, errfunc) - -class MyNonGlobalAction(MyActionBase): - def __init__(self): - self.order = 0 - self.built_it = None - self.built_target = None - self.built_source = None - - def __call__(self, target, source, env, errfunc): - # Okay, so not ENTIRELY non-global... - global built_order - self.built_it = 1 - self.built_target = target - self.built_source = source - self.built_args = env - built_order = built_order + 1 - self.order = built_order - return 0 + A(target, source, env) class Environment: def __init__(self, **kw): @@ -112,11 +124,11 @@ class Environment: def Override(self, overrides): d = self._dict.copy() d.update(overrides) - return apply(Environment, (), d) + return Environment(**d) def _update(self, dict): self._dict.update(dict) - def get_calculator(self): - return SCons.Sig.default_calc + def get_factory(self, factory): + return factory or MyNode def get_scanner(self, scanner_key): return self._dict['SCANNERS'][0] @@ -128,6 +140,8 @@ class Builder: self.action = MyAction() self.source_factory = MyNode self.is_explicit = is_explicit + self.target_scanner = None + self.source_scanner = None def targets(self, t): return [t] def get_actions(self): @@ -173,6 +187,8 @@ class Scanner: return () def select(self, node): return self + def recurse_nodes(self, nodes): + return nodes class MyNode(SCons.Node.Node): """The base Node class contains a number of do-nothing methods that @@ -202,6 +218,72 @@ class Calculator: +class NodeInfoBaseTestCase(unittest.TestCase): + + def test_merge(self): + """Test merging NodeInfoBase attributes""" + ni1 = SCons.Node.NodeInfoBase(SCons.Node.Node()) + ni2 = SCons.Node.NodeInfoBase(SCons.Node.Node()) + + ni1.a1 = 1 + ni1.a2 = 2 + + ni2.a2 = 222 + ni2.a3 = 333 + + ni1.merge(ni2) + expect = {'a1':1, 'a2':222, 'a3':333, '_version_id':1} + assert ni1.__dict__ == expect, ni1.__dict__ + + def test_update(self): + """Test the update() method""" + ni = SCons.Node.NodeInfoBase(SCons.Node.Node()) + ni.update(SCons.Node.Node()) + + def test_format(self): + """Test the NodeInfoBase.format() method""" + ni1 = SCons.Node.NodeInfoBase(SCons.Node.Node()) + ni1.xxx = 'x' + ni1.yyy = 'y' + ni1.zzz = 'z' + + f = ni1.format() + assert f == ['1', 'x', 'y', 'z'], f + + ni1.field_list = ['xxx', 'zzz', 'aaa'] + + f = ni1.format() + assert f == ['x', 'z', 'None'], f + + + +class BuildInfoBaseTestCase(unittest.TestCase): + + def test___init__(self): + """Test BuildInfoBase initialization""" + n = SCons.Node.Node() + bi = SCons.Node.BuildInfoBase(n) + assert bi + + def test_merge(self): + """Test merging BuildInfoBase attributes""" + n1 = SCons.Node.Node() + bi1 = SCons.Node.BuildInfoBase(n1) + n2 = SCons.Node.Node() + bi2 = SCons.Node.BuildInfoBase(n2) + + bi1.a1 = 1 + bi1.a2 = 2 + + bi2.a2 = 222 + bi2.a3 = 333 + + bi1.merge(bi2) + assert bi1.a1 == 1, bi1.a1 + assert bi1.a2 == 222, bi1.a2 + assert bi1.a3 == 333, bi1.a3 + + class NodeTestCase(unittest.TestCase): def test_build(self): @@ -212,9 +294,9 @@ class NodeTestCase(unittest.TestCase): # Make sure it doesn't blow up if no builder is set. node = MyNode("www") node.build() - assert built_it == None + assert built_it is None node.build(extra_kw_argument = 1) - assert built_it == None + assert built_it is None node = MyNode("xxx") node.builder_set(Builder()) @@ -280,43 +362,9 @@ class NodeTestCase(unittest.TestCase): assert built_args["on"] == 3, built_args assert built_args["off"] == 4, built_args - built_it = None - built_order = 0 - node = MyNode("xxx") - node.builder_set(Builder()) - node.env_set(Environment()) - node.sources = ["yyy", "zzz"] - pre1 = MyNonGlobalAction() - pre2 = MyNonGlobalAction() - post1 = MyNonGlobalAction() - post2 = MyNonGlobalAction() - node.add_pre_action(pre1) - node.add_pre_action(pre2) - node.add_post_action(post1) - node.add_post_action(post2) - node.build() - assert built_it - assert pre1.built_it - assert pre2.built_it - assert post1.built_it - assert post2.built_it - assert pre1.order == 1, pre1.order - assert pre2.order == 2, pre1.order - # The action of the builder itself is order 3... - assert post1.order == 4, pre1.order - assert post2.order == 5, pre1.order - - for act in [ pre1, pre2, post1, post2 ]: - assert type(act.built_target[0]) == type(MyNode("bar")), type(act.built_target[0]) - assert str(act.built_target[0]) == "xxx", str(act.built_target[0]) - assert act.built_source == ["yyy", "zzz"], act.built_source - def test_get_build_scanner_path(self): """Test the get_build_scanner_path() method""" n = SCons.Node.Node() - class MyExecutor: - def get_build_scanner_path(self, scanner): - return 'executor would call %s' % scanner x = MyExecutor() n.set_executor(x) p = n.get_build_scanner_path('fake_scanner') @@ -355,6 +403,14 @@ class NodeTestCase(unittest.TestCase): n.set_executor(1) assert n.executor == 1, n.executor + def test_executor_cleanup(self): + """Test letting the executor cleanup its cache""" + n = SCons.Node.Node() + x = MyExecutor() + n.set_executor(x) + n.executor_cleanup() + assert x.cleaned_up + def test_reset_executor(self): """Test the reset_executor() method""" n = SCons.Node.Node() @@ -365,13 +421,24 @@ class NodeTestCase(unittest.TestCase): def test_built(self): """Test the built() method""" + class SubNodeInfo(SCons.Node.NodeInfoBase): + def update(self, node): + self.updated = 1 class SubNode(SCons.Node.Node): def clear(self): self.cleared = 1 n = SubNode() + n.ninfo = SubNodeInfo(n) n.built() assert n.cleared, n.cleared + assert n.ninfo.updated, n.ninfo.cleared + + def test_push_to_cache(self): + """Test the base push_to_cache() method""" + n = SCons.Node.Node() + r = n.push_to_cache() + assert r is None, r def test_retrieve_from_cache(self): """Test the base retrieve_from_cache() method""" @@ -387,14 +454,6 @@ class NodeTestCase(unittest.TestCase): n = SCons.Node.Node() n.visited() - def test_depends_on(self): - """Test the depends_on() method - """ - parent = SCons.Node.Node() - child = SCons.Node.Node() - parent.add_dependency([child]) - assert parent.depends_on([child]) - def test_builder_set(self): """Test setting a Node's Builder """ @@ -462,13 +521,13 @@ class NodeTestCase(unittest.TestCase): n = SCons.Node.Node() t, m = n.alter_targets() assert t == [], t - assert m == None, m + assert m is None, m - def test_current(self): - """Test the default current() method + def test_is_up_to_date(self): + """Test the default is_up_to_date() method """ node = SCons.Node.Node() - assert node.current() is None + assert node.is_up_to_date() is None def test_children_are_up_to_date(self): """Test the children_are_up_to_date() method used by subclasses @@ -476,16 +535,14 @@ class NodeTestCase(unittest.TestCase): n1 = SCons.Node.Node() n2 = SCons.Node.Node() - calc = Calculator(111) - - n1.add_source(n2) - assert n1.children_are_up_to_date(calc), "expected up to date" + n1.add_source([n2]) + assert n1.children_are_up_to_date(), "expected up to date" n2.set_state(SCons.Node.executed) - assert not n1.children_are_up_to_date(calc), "expected not up to date" + assert not n1.children_are_up_to_date(), "expected not up to date" n2.set_state(SCons.Node.up_to_date) - assert n1.children_are_up_to_date(calc), "expected up to date" + assert n1.children_are_up_to_date(), "expected up to date" n1.always_build = 1 - assert not n1.children_are_up_to_date(calc), "expected not up to date" + assert not n1.children_are_up_to_date(), "expected not up to date" def test_env_set(self): """Test setting a Node's Environment @@ -503,37 +560,46 @@ class NodeTestCase(unittest.TestCase): a = node.builder.get_actions() assert isinstance(a[0], MyAction), a[0] - def test_calc_bsig(self): - """Test generic build signature calculation + def test_get_csig(self): + """Test generic content signature calculation """ node = SCons.Node.Node() - result = node.calc_bsig(Calculator(222)) - assert result == 222, result - result = node.calc_bsig(Calculator(333)) - assert result == 222, result + node.get_contents = lambda: 444 + result = node.get_csig() + assert result == '550a141f12de6341fba65b0ad0433500', result - def test_calc_csig(self): - """Test generic content signature calculation + def test_get_cachedir_csig(self): + """Test content signature calculation for CacheDir """ node = SCons.Node.Node() - result = node.calc_csig(Calculator(444)) - assert result == 444, result - result = node.calc_csig(Calculator(555)) - assert result == 444, result + node.get_contents = lambda: 555 + result = node.get_cachedir_csig() + assert result == '15de21c670ae7c3f6f3f1f37029303c9', result - def test_gen_binfo(self): - """Test generating a build information structure + def test_get_binfo(self): + """Test fetching/creating a build information structure """ node = SCons.Node.Node() - binfo = node.gen_binfo(Calculator(666)) - assert isinstance(binfo, SCons.Node.BuildInfo), binfo + + binfo = node.get_binfo() + assert isinstance(binfo, SCons.Node.BuildInfoBase), binfo + + node = SCons.Node.Node() + d = SCons.Node.Node() + d.get_ninfo().csig = 777 + i = SCons.Node.Node() + i.get_ninfo().csig = 888 + node.depends = [d] + node.implicit = [i] + + binfo = node.get_binfo() + assert isinstance(binfo, SCons.Node.BuildInfoBase), binfo assert hasattr(binfo, 'bsources') assert hasattr(binfo, 'bsourcesigs') - assert hasattr(binfo, 'bdepends') + assert binfo.bdepends == [d] assert hasattr(binfo, 'bdependsigs') - assert hasattr(binfo, 'bimplicit') + assert binfo.bimplicit == [i] assert hasattr(binfo, 'bimplicitsigs') - assert binfo.bsig == 666, binfo.bsig def test_explain(self): """Test explaining why a Node must be rebuilt @@ -549,36 +615,42 @@ class NodeTestCase(unittest.TestCase): class testNode2(SCons.Node.Node): def __str__(self): return 'null_binfo' + class FS: + pass node = testNode2() + node.fs = FS() + node.fs.Top = SCons.Node.Node() result = node.explain() - assert result == None, result + assert result is None, result - class Null_BInfo: - def __init__(self): - pass + def get_null_info(): + class Null_SConsignEntry: + class Null_BuildInfo: + def prepare_dependencies(self): + pass + binfo = Null_BuildInfo() + return Null_SConsignEntry() - node.get_stored_info = Null_BInfo + node.get_stored_info = get_null_info #see above: node.__str__ = lambda: 'null_binfo' result = node.explain() assert result == "Cannot explain why `null_binfo' is being rebuilt: No previous build information found\n", result # XXX additional tests for the guts of the functionality some day - def test_del_binfo(self): - """Test deleting the build information from a Node - """ - node = SCons.Node.Node() - node.binfo = None - node.del_binfo() - assert not hasattr(node, 'binfo'), node + #def test_del_binfo(self): + # """Test deleting the build information from a Node + # """ + # node = SCons.Node.Node() + # node.binfo = None + # node.del_binfo() + # assert not hasattr(node, 'binfo'), node def test_store_info(self): """Test calling the method to store build information """ - class Entry: - pass node = SCons.Node.Node() - node.store_info(Entry()) + node.store_info() def test_get_stored_info(self): """Test calling the method to fetch stored build information @@ -596,6 +668,19 @@ class NodeTestCase(unittest.TestCase): node.set_always_build(3) assert node.always_build == 3 + def test_set_noclean(self): + """Test setting a Node's noclean value + """ + node = SCons.Node.Node() + node.set_noclean() + assert node.noclean == 1, node.noclean + node.set_noclean(7) + assert node.noclean == 1, node.noclean + node.set_noclean(0) + assert node.noclean == 0, node.noclean + node.set_noclean(None) + assert node.noclean == 0, node.noclean + def test_set_precious(self): """Test setting a Node's precious value """ @@ -629,29 +714,31 @@ class NodeTestCase(unittest.TestCase): def test_prepare(self): """Test preparing a node to be built + + By extension, this also tests the missing() method. """ node = SCons.Node.Node() n1 = SCons.Node.Node() n1.builder_set(Builder()) node.implicit = [] - node.implicit_dict = {} - node._add_child(node.implicit, node.implicit_dict, [n1]) + node.implicit_set = set() + node._add_child(node.implicit, node.implicit_set, [n1]) node.prepare() # should not throw an exception n2 = SCons.Node.Node() n2.linked = 1 node.implicit = [] - node.implicit_dict = {} - node._add_child(node.implicit, node.implicit_dict, [n2]) + node.implicit_set = set() + node._add_child(node.implicit, node.implicit_set, [n2]) node.prepare() # should not throw an exception n3 = SCons.Node.Node() node.implicit = [] - node.implicit_dict = {} - node._add_child(node.implicit, node.implicit_dict, [n3]) + node.implicit_set = set() + node._add_child(node.implicit, node.implicit_set, [n3]) node.prepare() # should not throw an exception @@ -660,8 +747,8 @@ class NodeTestCase(unittest.TestCase): return None n4 = MyNode() node.implicit = [] - node.implicit_dict = {} - node._add_child(node.implicit, node.implicit_dict, [n4]) + node.implicit_set = set() + node._add_child(node.implicit, node.implicit_set, [n4]) exc_caught = 0 try: node.prepare() @@ -684,7 +771,7 @@ class NodeTestCase(unittest.TestCase): five = SCons.Node.Node() six = SCons.Node.Node() - node.add_dependency(zero) + node.add_dependency([zero]) assert node.depends == [zero] node.add_dependency([one]) assert node.depends == [zero, one] @@ -716,7 +803,7 @@ class NodeTestCase(unittest.TestCase): five = SCons.Node.Node() six = SCons.Node.Node() - node.add_source(zero) + node.add_source([zero]) assert node.sources == [zero] node.add_source([one]) assert node.sources == [zero, one] @@ -731,7 +818,7 @@ class NodeTestCase(unittest.TestCase): pass else: raise "did not catch expected exception" - assert node.sources == [zero, one, two, three, four] + assert node.sources == [zero, one, two, three, four], node.sources def test_add_ignore(self): """Test adding files whose dependencies should be ignored. @@ -747,7 +834,7 @@ class NodeTestCase(unittest.TestCase): five = SCons.Node.Node() six = SCons.Node.Node() - node.add_ignore(zero) + node.add_ignore([zero]) assert node.ignore == [zero] node.add_ignore([one]) assert node.ignore == [zero, one] @@ -785,35 +872,62 @@ class NodeTestCase(unittest.TestCase): assert deps == [], deps s = Scanner() - d = MyNode("ddd") - node.found_includes = [d] + d1 = MyNode("d1") + d2 = MyNode("d2") + node.found_includes = [d1, d2] # Simple return of the found includes deps = node.get_implicit_deps(env, s, target) - assert deps == [d], deps + assert deps == [d1, d2], deps - # No "recursive" attribute on scanner doesn't recurse + # By default, our fake scanner recurses e = MyNode("eee") - d.found_includes = [e] + f = MyNode("fff") + g = MyNode("ggg") + d1.found_includes = [e, f] + d2.found_includes = [e, f] + f.found_includes = [g] deps = node.get_implicit_deps(env, s, target) - assert deps == [d], map(str, deps) + assert deps == [d1, d2, e, f, g], list(map(str, deps)) - # Explicit "recursive" attribute on scanner doesn't recurse - s.recursive = None + # Recursive scanning eliminates duplicates + e.found_includes = [f] deps = node.get_implicit_deps(env, s, target) - assert deps == [d], map(str, deps) + assert deps == [d1, d2, e, f, g], list(map(str, deps)) - # Explicit "recursive" attribute on scanner which does recurse - s.recursive = 1 + # Scanner method can select specific nodes to recurse + def no_fff(nodes): + return [n for n in nodes if str(n)[0] != 'f'] + s.recurse_nodes = no_fff deps = node.get_implicit_deps(env, s, target) - assert deps == [d, e], map(str, deps) + assert deps == [d1, d2, e, f], list(map(str, deps)) - # Recursive scanning eliminates duplicates - f = MyNode("fff") - d.found_includes = [e, f] - e.found_includes = [f] + # Scanner method can short-circuit recursing entirely + s.recurse_nodes = lambda nodes: [] deps = node.get_implicit_deps(env, s, target) - assert deps == [d, e, f], map(str, deps) + assert deps == [d1, d2], list(map(str, deps)) + + def test_get_env_scanner(self): + """Test fetching the environment scanner for a Node + """ + node = SCons.Node.Node() + scanner = Scanner() + env = Environment(SCANNERS = [scanner]) + s = node.get_env_scanner(env) + assert s == scanner, s + s = node.get_env_scanner(env, {'X':1}) + assert s == scanner, s + + def test_get_target_scanner(self): + """Test fetching the target scanner for a Node + """ + s = Scanner() + b = Builder() + b.target_scanner = s + n = SCons.Node.Node() + n.builder = b + x = n.get_target_scanner() + assert x is s, x def test_get_source_scanner(self): """Test fetching the source scanner for a Node @@ -821,7 +935,7 @@ class NodeTestCase(unittest.TestCase): target = SCons.Node.Node() source = SCons.Node.Node() s = target.get_source_scanner(source) - assert s is None, s + assert isinstance(s, SCons.Util.Null), s ts1 = Scanner() ts2 = Scanner() @@ -858,11 +972,13 @@ class NodeTestCase(unittest.TestCase): def test_scan(self): """Test Scanner functionality """ + env = Environment() node = MyNode("nnn") node.builder = Builder() - node.env_set(Environment()) - s = Scanner() + node.env_set(env) + x = MyExecutor(env, [node]) + s = Scanner() d = MyNode("ddd") node.found_includes = [d] @@ -878,21 +994,11 @@ class NodeTestCase(unittest.TestCase): # if the stored dependencies need recalculation. class StoredNode(MyNode): def get_stored_implicit(self): - return ['implicit1', 'implicit2'] + return [MyNode('implicit1'), MyNode('implicit2')] - class NotCurrent: - def current(self, node, sig): - return None - def bsig(self, node): - return 0 - - import SCons.Sig - - save_default_calc = SCons.Sig.default_calc save_implicit_cache = SCons.Node.implicit_cache save_implicit_deps_changed = SCons.Node.implicit_deps_changed save_implicit_deps_unchanged = SCons.Node.implicit_deps_unchanged - SCons.Sig.default_calc = NotCurrent() SCons.Node.implicit_cache = 1 SCons.Node.implicit_deps_changed = None SCons.Node.implicit_deps_unchanged = None @@ -907,14 +1013,13 @@ class NodeTestCase(unittest.TestCase): assert sn.children() == [], sn.children() finally: - SCons.Sig.default_calc = save_default_calc SCons.Node.implicit_cache = save_implicit_cache SCons.Node.implicit_deps_changed = save_implicit_deps_changed SCons.Node.implicit_deps_unchanged = save_implicit_deps_unchanged def test_scanner_key(self): """Test that a scanner_key() method exists""" - assert SCons.Node.Node().scanner_key() == None + assert SCons.Node.Node().scanner_key() is None def test_children(self): """Test fetching the non-ignored "children" of a Node. @@ -936,9 +1041,9 @@ class NodeTestCase(unittest.TestCase): node.add_source([n1, n2, n3]) node.add_dependency([n4, n5, n6]) node.implicit = [] - node.implicit_dict = {} - node._add_child(node.implicit, node.implicit_dict, [n7, n8, n9]) - node._add_child(node.implicit, node.implicit_dict, [n10, n11, n12]) + node.implicit_set = set() + node._add_child(node.implicit, node.implicit_set, [n7, n8, n9]) + node._add_child(node.implicit, node.implicit_set, [n10, n11, n12]) node.add_ignore([n2, n5, n8, n11]) kids = node.children() @@ -967,9 +1072,9 @@ class NodeTestCase(unittest.TestCase): node.add_source([n1, n2, n3]) node.add_dependency([n4, n5, n6]) node.implicit = [] - node.implicit_dict = {} - node._add_child(node.implicit, node.implicit_dict, [n7, n8, n9]) - node._add_child(node.implicit, node.implicit_dict, [n10, n11, n12]) + node.implicit_set = set() + node._add_child(node.implicit, node.implicit_set, [n7, n8, n9]) + node._add_child(node.implicit, node.implicit_set, [n10, n11, n12]) node.add_ignore([n2, n5, n8, n11]) kids = node.all_children() @@ -980,7 +1085,7 @@ class NodeTestCase(unittest.TestCase): """Test setting and getting the state of a node """ node = SCons.Node.Node() - assert node.get_state() == None + assert node.get_state() == SCons.Node.no_state node.set_state(SCons.Node.executing) assert node.get_state() == SCons.Node.executing assert SCons.Node.pending < SCons.Node.executing @@ -996,23 +1101,23 @@ class NodeTestCase(unittest.TestCase): nw = SCons.Node.Walker(n1) assert not nw.is_done() - assert nw.next().name == "n1" + assert nw.get_next().name == "n1" assert nw.is_done() - assert nw.next() == None + assert nw.get_next() is None n2 = MyNode("n2") n3 = MyNode("n3") n1.add_source([n2, n3]) nw = SCons.Node.Walker(n1) - n = nw.next() + n = nw.get_next() assert n.name == "n2", n.name - n = nw.next() + n = nw.get_next() assert n.name == "n3", n.name - n = nw.next() + n = nw.get_next() assert n.name == "n1", n.name - n = nw.next() - assert n == None, n + n = nw.get_next() + assert n is None, n n4 = MyNode("n4") n5 = MyNode("n5") @@ -1022,17 +1127,17 @@ class NodeTestCase(unittest.TestCase): n3.add_dependency([n6, n7]) nw = SCons.Node.Walker(n1) - assert nw.next().name == "n4" - assert nw.next().name == "n5" - assert nw.history.has_key(n2) - assert nw.next().name == "n2" - assert nw.next().name == "n6" - assert nw.next().name == "n7" - assert nw.history.has_key(n3) - assert nw.next().name == "n3" - assert nw.history.has_key(n1) - assert nw.next().name == "n1" - assert nw.next() == None + assert nw.get_next().name == "n4" + assert nw.get_next().name == "n5" + assert n2 in nw.history + assert nw.get_next().name == "n2" + assert nw.get_next().name == "n6" + assert nw.get_next().name == "n7" + assert n3 in nw.history + assert nw.get_next().name == "n3" + assert n1 in nw.history + assert nw.get_next().name == "n1" + assert nw.get_next() is None n8 = MyNode("n8") n8.add_dependency([n3]) @@ -1045,16 +1150,16 @@ class NodeTestCase(unittest.TestCase): global cycle_detected nw = SCons.Node.Walker(n3, cycle_func = cycle) - n = nw.next() + n = nw.get_next() assert n.name == "n6", n.name - n = nw.next() + n = nw.get_next() assert n.name == "n8", n.name assert cycle_detected cycle_detected = None - n = nw.next() + n = nw.get_next() assert n.name == "n7", n.name - n = nw.next() - assert nw.next() == None + n = nw.get_next() + assert nw.get_next() is None def test_abspath(self): """Test the get_abspath() method.""" @@ -1113,15 +1218,14 @@ class NodeTestCase(unittest.TestCase): n.includes = 'testincludes' n.found_include = {'testkey':'testvalue'} n.implicit = 'testimplicit' - n.waiting_parents = ['foo', 'bar'] + + x = MyExecutor() + n.set_executor(x) n.clear() - assert not hasattr(n, 'binfo'), n.bsig assert n.includes is None, n.includes - assert n.found_includes == {}, n.found_includes - assert n.implicit is None, n.implicit - assert n.waiting_parents == [], n.waiting_parents + assert x.cleaned_up def test_get_subst_proxy(self): """Test the get_subst_proxy method.""" @@ -1133,7 +1237,7 @@ class NodeTestCase(unittest.TestCase): """Test the new_binfo() method""" n = SCons.Node.Node() result = n.new_binfo() - assert isinstance(result, SCons.Node.BuildInfo), result + assert isinstance(result, SCons.Node.BuildInfoBase), result def test_get_suffix(self): """Test the base Node get_suffix() method""" @@ -1144,26 +1248,22 @@ class NodeTestCase(unittest.TestCase): def test_postprocess(self): """Test calling the base Node postprocess() method""" n = SCons.Node.Node() + n.waiting_parents = set( ['foo','bar'] ) + n.postprocess() + assert n.waiting_parents == set(), n.waiting_parents def test_add_to_waiting_parents(self): """Test the add_to_waiting_parents() method""" n1 = SCons.Node.Node() n2 = SCons.Node.Node() - assert n1.waiting_parents == [], n1.waiting_parents - n1.add_to_waiting_parents(n2) - assert n1.waiting_parents == [n2], n1.waiting_parents + assert n1.waiting_parents == set(), n1.waiting_parents + r = n1.add_to_waiting_parents(n2) + assert r == 1, r + assert n1.waiting_parents == set((n2,)), n1.waiting_parents + r = n1.add_to_waiting_parents(n2) + assert r == 0, r - def test_call_for_all_waiting_parents(self): - """Test the call_for_all_waiting_parents() method""" - n1 = SCons.Node.Node() - n2 = SCons.Node.Node() - n1.add_to_waiting_parents(n2) - result = [] - def func(node, result=result): - result.append(node) - n1.call_for_all_waiting_parents(func) - assert result == [n1, n2], result class NodeListTestCase(unittest.TestCase): def test___str__(self): @@ -1174,7 +1274,7 @@ class NodeListTestCase(unittest.TestCase): nl = SCons.Node.NodeList([n3, n2, n1]) l = [1] - ul = UserList.UserList([2]) + ul = collections.UserList([2]) try: l.extend(ul) except TypeError: @@ -1192,17 +1292,25 @@ class NodeListTestCase(unittest.TestCase): # New-style classes report as "object"; classic classes report # as "instance"... r = re.sub("object", "instance", r) - l = string.join([""]*3, ", ") + l = ", ".join([""]*3) assert r == '[%s]' % l, r if __name__ == "__main__": suite = unittest.TestSuite() - tclasses = [ NodeTestCase, + tclasses = [ BuildInfoBaseTestCase, + NodeInfoBaseTestCase, + NodeTestCase, NodeListTestCase ] for tclass in tclasses: names = unittest.getTestCaseNames(tclass, 'test_') - suite.addTests(map(tclass, names)) + suite.addTests(list(map(tclass, names))) if not unittest.TextTestRunner().run(suite).wasSuccessful(): sys.exit(1) + +# Local Variables: +# tab-width:4 +# indent-tabs-mode:nil +# End: +# vim: set expandtab tabstop=4 shiftwidth=4: