From 72c578fd4b0b4a5a43e18594339ac4ff26c376dc Mon Sep 17 00:00:00 2001 From: Luca Falavigna Date: Sat, 2 Jan 2010 20:56:27 +0100 Subject: Imported Upstream version 1.2.0.d20091224 --- src/engine/SCons/UtilTests.py | 802 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 802 insertions(+) create mode 100644 src/engine/SCons/UtilTests.py (limited to 'src/engine/SCons/UtilTests.py') diff --git a/src/engine/SCons/UtilTests.py b/src/engine/SCons/UtilTests.py new file mode 100644 index 0000000..f14e7c3 --- /dev/null +++ b/src/engine/SCons/UtilTests.py @@ -0,0 +1,802 @@ +# +# Copyright (c) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 The SCons Foundation +# +# Permission is hereby granted, free of charge, to any person obtaining +# a copy of this software and associated documentation files (the +# "Software"), to deal in the Software without restriction, including +# without limitation the rights to use, copy, modify, merge, publish, +# distribute, sublicense, and/or sell copies of the Software, and to +# permit persons to whom the Software is furnished to do so, subject to +# the following conditions: +# +# The above copyright notice and this permission notice shall be included +# in all copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY +# KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE +# WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +# + +__revision__ = "src/engine/SCons/UtilTests.py 4577 2009/12/27 19:44:43 scons" + +import os +import os.path +import string +import StringIO +import sys +import types +import unittest + +from UserDict import UserDict + +import TestCmd + +import SCons.Errors + +from SCons.Util import * + +class OutBuffer: + def __init__(self): + self.buffer = "" + + def write(self, str): + self.buffer = self.buffer + str + +class dictifyTestCase(unittest.TestCase): + def test_dictify(self): + """Test the dictify() function""" + r = SCons.Util.dictify(['a', 'b', 'c'], [1, 2, 3]) + assert r == {'a':1, 'b':2, 'c':3}, r + + r = {} + SCons.Util.dictify(['a'], [1], r) + SCons.Util.dictify(['b'], [2], r) + SCons.Util.dictify(['c'], [3], r) + assert r == {'a':1, 'b':2, 'c':3}, r + +class UtilTestCase(unittest.TestCase): + def test_splitext(self): + assert splitext('foo') == ('foo','') + assert splitext('foo.bar') == ('foo','.bar') + assert splitext(os.path.join('foo.bar', 'blat')) == (os.path.join('foo.bar', 'blat'),'') + + class Node: + def __init__(self, name, children=[]): + self.children = children + self.name = name + self.nocache = None + def __str__(self): + return self.name + def exists(self): + return 1 + def rexists(self): + return 1 + def has_builder(self): + return 1 + def has_explicit_builder(self): + return 1 + def side_effect(self): + return 1 + def precious(self): + return 1 + def always_build(self): + return 1 + def is_up_to_date(self): + return 1 + def noclean(self): + return 1 + + def tree_case_1(self): + """Fixture for the render_tree() and print_tree() tests.""" + windows_h = self.Node("windows.h") + stdlib_h = self.Node("stdlib.h") + stdio_h = self.Node("stdio.h") + bar_c = self.Node("bar.c", [stdlib_h, windows_h]) + bar_o = self.Node("bar.o", [bar_c]) + foo_c = self.Node("foo.c", [stdio_h]) + foo_o = self.Node("foo.o", [foo_c]) + foo = self.Node("foo", [foo_o, bar_o]) + + expect = """\ ++-foo + +-foo.o + | +-foo.c + | +-stdio.h + +-bar.o + +-bar.c + +-stdlib.h + +-windows.h +""" + + lines = string.split(expect, '\n')[:-1] + lines = map(lambda l: '[E BSPACN ]'+l, lines) + withtags = string.join(lines, '\n') + '\n' + + return foo, expect, withtags + + def tree_case_2(self, prune=1): + """Fixture for the render_tree() and print_tree() tests.""" + + stdlib_h = self.Node("stdlib.h") + bar_h = self.Node('bar.h', [stdlib_h]) + blat_h = self.Node('blat.h', [stdlib_h]) + blat_c = self.Node('blat.c', [blat_h, bar_h]) + blat_o = self.Node('blat.o', [blat_c]) + + expect = """\ ++-blat.o + +-blat.c + +-blat.h + | +-stdlib.h + +-bar.h + +-[stdlib.h] +""" + + if not prune: + expect = string.replace(expect, '[', '') + expect = string.replace(expect, ']', '') + + lines = string.split(expect, '\n')[:-1] + lines = map(lambda l: '[E BSPACN ]'+l, lines) + withtags = string.join(lines, '\n') + '\n' + + return blat_o, expect, withtags + + def test_render_tree(self): + """Test the render_tree() function""" + def get_children(node): + return node.children + + node, expect, withtags = self.tree_case_1() + actual = render_tree(node, get_children) + assert expect == actual, (expect, actual) + + node, expect, withtags = self.tree_case_2() + actual = render_tree(node, get_children, 1) + assert expect == actual, (expect, actual) + + def test_print_tree(self): + """Test the print_tree() function""" + def get_children(node): + return node.children + + save_stdout = sys.stdout + + try: + node, expect, withtags = self.tree_case_1() + + sys.stdout = StringIO.StringIO() + print_tree(node, get_children) + actual = sys.stdout.getvalue() + assert expect == actual, (expect, actual) + + sys.stdout = StringIO.StringIO() + print_tree(node, get_children, showtags=1) + actual = sys.stdout.getvalue() + assert withtags == actual, (withtags, actual) + + node, expect, withtags = self.tree_case_2(prune=0) + + sys.stdout = StringIO.StringIO() + print_tree(node, get_children, 1) + actual = sys.stdout.getvalue() + assert expect == actual, (expect, actual) + + sys.stdout = StringIO.StringIO() + # The following call should work here: + # print_tree(node, get_children, 1, showtags=1) + # For some reason I don't understand, though, *this* + # time that we call print_tree, the visited dictionary + # is still populated with the values from the last call! + # I can't see why this would be, short of a bug in Python, + # and rather than continue banging my head against the + # brick wall for a *test*, we're going to going with + # the cheap, easy workaround: + print_tree(node, get_children, 1, showtags=1, visited={}) + actual = sys.stdout.getvalue() + assert withtags == actual, (withtags, actual) + finally: + sys.stdout = save_stdout + + def test_is_Dict(self): + assert is_Dict({}) + assert is_Dict(UserDict()) + try: + class mydict(dict): + pass + except TypeError: + pass + else: + assert is_Dict(mydict({})) + assert not is_Dict([]) + assert not is_Dict(()) + assert not is_Dict("") + if hasattr(types, 'UnicodeType'): + exec "assert not is_Dict(u'')" + + def test_is_List(self): + assert is_List([]) + import UserList + assert is_List(UserList.UserList()) + try: + class mylist(list): + pass + except TypeError: + pass + else: + assert is_List(mylist([])) + assert not is_List(()) + assert not is_List({}) + assert not is_List("") + if hasattr(types, 'UnicodeType'): + exec "assert not is_List(u'')" + + def test_is_String(self): + assert is_String("") + if hasattr(types, 'UnicodeType'): + exec "assert is_String(u'')" + try: + import UserString + except: + pass + else: + assert is_String(UserString.UserString('')) + try: + class mystr(str): + pass + except TypeError: + pass + else: + assert is_String(mystr('')) + assert not is_String({}) + assert not is_String([]) + assert not is_String(()) + + def test_is_Tuple(self): + assert is_Tuple(()) + try: + class mytuple(tuple): + pass + except TypeError: + pass + else: + assert is_Tuple(mytuple(())) + assert not is_Tuple([]) + assert not is_Tuple({}) + assert not is_Tuple("") + if hasattr(types, 'UnicodeType'): + exec "assert not is_Tuple(u'')" + + def test_to_String(self): + """Test the to_String() method.""" + assert to_String(1) == "1", to_String(1) + assert to_String([ 1, 2, 3]) == str([1, 2, 3]), to_String([1,2,3]) + assert to_String("foo") == "foo", to_String("foo") + + try: + import UserString + + s1=UserString.UserString('blah') + assert to_String(s1) == s1, s1 + assert to_String(s1) == 'blah', s1 + + class Derived(UserString.UserString): + pass + s2 = Derived('foo') + assert to_String(s2) == s2, s2 + assert to_String(s2) == 'foo', s2 + + if hasattr(types, 'UnicodeType'): + s3=UserString.UserString(unicode('bar')) + assert to_String(s3) == s3, s3 + assert to_String(s3) == unicode('bar'), s3 + assert type(to_String(s3)) is types.UnicodeType, \ + type(to_String(s3)) + except ImportError: + pass + + if hasattr(types, 'UnicodeType'): + s4 = unicode('baz') + assert to_String(s4) == unicode('baz'), to_String(s4) + assert type(to_String(s4)) is types.UnicodeType, \ + type(to_String(s4)) + + def test_WhereIs(self): + test = TestCmd.TestCmd(workdir = '') + + sub1_xxx_exe = test.workpath('sub1', 'xxx.exe') + sub2_xxx_exe = test.workpath('sub2', 'xxx.exe') + sub3_xxx_exe = test.workpath('sub3', 'xxx.exe') + sub4_xxx_exe = test.workpath('sub4', 'xxx.exe') + + test.subdir('subdir', 'sub1', 'sub2', 'sub3', 'sub4') + + if sys.platform != 'win32': + test.write(sub1_xxx_exe, "\n") + + os.mkdir(sub2_xxx_exe) + + test.write(sub3_xxx_exe, "\n") + os.chmod(sub3_xxx_exe, 0777) + + test.write(sub4_xxx_exe, "\n") + os.chmod(sub4_xxx_exe, 0777) + + env_path = os.environ['PATH'] + + try: + pathdirs_1234 = [ test.workpath('sub1'), + test.workpath('sub2'), + test.workpath('sub3'), + test.workpath('sub4'), + ] + string.split(env_path, os.pathsep) + + pathdirs_1243 = [ test.workpath('sub1'), + test.workpath('sub2'), + test.workpath('sub4'), + test.workpath('sub3'), + ] + string.split(env_path, os.pathsep) + + os.environ['PATH'] = string.join(pathdirs_1234, os.pathsep) + wi = WhereIs('xxx.exe') + assert wi == test.workpath(sub3_xxx_exe), wi + wi = WhereIs('xxx.exe', pathdirs_1243) + assert wi == test.workpath(sub4_xxx_exe), wi + wi = WhereIs('xxx.exe', string.join(pathdirs_1243, os.pathsep)) + assert wi == test.workpath(sub4_xxx_exe), wi + + wi = WhereIs('xxx.exe',reject = sub3_xxx_exe) + assert wi == test.workpath(sub4_xxx_exe), wi + wi = WhereIs('xxx.exe', pathdirs_1243, reject = sub3_xxx_exe) + assert wi == test.workpath(sub4_xxx_exe), wi + + os.environ['PATH'] = string.join(pathdirs_1243, os.pathsep) + wi = WhereIs('xxx.exe') + assert wi == test.workpath(sub4_xxx_exe), wi + wi = WhereIs('xxx.exe', pathdirs_1234) + assert wi == test.workpath(sub3_xxx_exe), wi + wi = WhereIs('xxx.exe', string.join(pathdirs_1234, os.pathsep)) + assert wi == test.workpath(sub3_xxx_exe), wi + + if sys.platform == 'win32': + wi = WhereIs('xxx', pathext = '') + assert wi is None, wi + + wi = WhereIs('xxx', pathext = '.exe') + assert wi == test.workpath(sub4_xxx_exe), wi + + wi = WhereIs('xxx', path = pathdirs_1234, pathext = '.BAT;.EXE') + assert string.lower(wi) == string.lower(test.workpath(sub3_xxx_exe)), wi + + # Test that we return a normalized path even when + # the path contains forward slashes. + forward_slash = test.workpath('') + '/sub3' + wi = WhereIs('xxx', path = forward_slash, pathext = '.EXE') + assert string.lower(wi) == string.lower(test.workpath(sub3_xxx_exe)), wi + + del os.environ['PATH'] + wi = WhereIs('xxx.exe') + assert wi is None, wi + + finally: + os.environ['PATH'] = env_path + + def test_get_env_var(self): + """Testing get_environment_var().""" + assert get_environment_var("$FOO") == "FOO", get_environment_var("$FOO") + assert get_environment_var("${BAR}") == "BAR", get_environment_var("${BAR}") + assert get_environment_var("$FOO_BAR1234") == "FOO_BAR1234", get_environment_var("$FOO_BAR1234") + assert get_environment_var("${BAR_FOO1234}") == "BAR_FOO1234", get_environment_var("${BAR_FOO1234}") + assert get_environment_var("${BAR}FOO") == None, get_environment_var("${BAR}FOO") + assert get_environment_var("$BAR ") == None, get_environment_var("$BAR ") + assert get_environment_var("FOO$BAR") == None, get_environment_var("FOO$BAR") + assert get_environment_var("$FOO[0]") == None, get_environment_var("$FOO[0]") + assert get_environment_var("${some('complex expression')}") == None, get_environment_var("${some('complex expression')}") + + def test_Proxy(self): + """Test generic Proxy class.""" + class Subject: + def foo(self): + return 1 + def bar(self): + return 2 + + s=Subject() + s.baz = 3 + + class ProxyTest(Proxy): + def bar(self): + return 4 + + p=ProxyTest(s) + + assert p.foo() == 1, p.foo() + assert p.bar() == 4, p.bar() + assert p.baz == 3, p.baz + + p.baz = 5 + s.baz = 6 + + assert p.baz == 5, p.baz + assert p.get() == s, p.get() + + def test_display(self): + old_stdout = sys.stdout + sys.stdout = OutBuffer() + display("line1") + display.set_mode(0) + display("line2") + display.set_mode(1) + display("line3") + display("line4\n", append_newline=0) + display.set_mode(0) + display("dont print1") + display("dont print2\n", append_newline=0) + display.set_mode(1) + assert sys.stdout.buffer == "line1\nline3\nline4\n" + sys.stdout = old_stdout + + def test_get_native_path(self): + """Test the get_native_path() function.""" + import tempfile + filename = tempfile.mktemp() + str = '1234567890 ' + filename + try: + open(filename, 'w').write(str) + assert open(get_native_path(filename)).read() == str + finally: + try: + os.unlink(filename) + except OSError: + pass + + def test_PrependPath(self): + """Test prepending to a path""" + p1 = r'C:\dir\num\one;C:\dir\num\two' + p2 = r'C:\mydir\num\one;C:\mydir\num\two' + # have to include the pathsep here so that the test will work on UNIX too. + p1 = PrependPath(p1,r'C:\dir\num\two',sep = ';') + p1 = PrependPath(p1,r'C:\dir\num\three',sep = ';') + p2 = PrependPath(p2,r'C:\mydir\num\three',sep = ';') + p2 = PrependPath(p2,r'C:\mydir\num\one',sep = ';') + assert(p1 == r'C:\dir\num\three;C:\dir\num\two;C:\dir\num\one') + assert(p2 == r'C:\mydir\num\one;C:\mydir\num\three;C:\mydir\num\two') + + def test_AppendPath(self): + """Test appending to a path.""" + p1 = r'C:\dir\num\one;C:\dir\num\two' + p2 = r'C:\mydir\num\one;C:\mydir\num\two' + # have to include the pathsep here so that the test will work on UNIX too. + p1 = AppendPath(p1,r'C:\dir\num\two',sep = ';') + p1 = AppendPath(p1,r'C:\dir\num\three',sep = ';') + p2 = AppendPath(p2,r'C:\mydir\num\three',sep = ';') + p2 = AppendPath(p2,r'C:\mydir\num\one',sep = ';') + assert(p1 == r'C:\dir\num\one;C:\dir\num\two;C:\dir\num\three') + assert(p2 == r'C:\mydir\num\two;C:\mydir\num\three;C:\mydir\num\one') + + def test_PrependPathPreserveOld(self): + """Test prepending to a path while preserving old paths""" + p1 = r'C:\dir\num\one;C:\dir\num\two' + # have to include the pathsep here so that the test will work on UNIX too. + p1 = PrependPath(p1,r'C:\dir\num\two',sep = ';', delete_existing=0) + p1 = PrependPath(p1,r'C:\dir\num\three',sep = ';') + assert(p1 == r'C:\dir\num\three;C:\dir\num\one;C:\dir\num\two') + + def test_AppendPathPreserveOld(self): + """Test appending to a path while preserving old paths""" + p1 = r'C:\dir\num\one;C:\dir\num\two' + # have to include the pathsep here so that the test will work on UNIX too. + p1 = AppendPath(p1,r'C:\dir\num\one',sep = ';', delete_existing=0) + p1 = AppendPath(p1,r'C:\dir\num\three',sep = ';') + assert(p1 == r'C:\dir\num\one;C:\dir\num\two;C:\dir\num\three') + + def test_CLVar(self): + """Test the command-line construction variable class""" + f = SCons.Util.CLVar('a b') + + r = f + 'c d' + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a', 'b', 'c', 'd'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + ' c d' + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a', 'b', 'c', 'd'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + ['c d'] + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a', 'b', 'c d'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + [' c d'] + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a', 'b', ' c d'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + ['c', 'd'] + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a', 'b', 'c', 'd'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + [' c', 'd'] + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a', 'b', ' c', 'd'], r.data + assert str(r) == 'a b c d', str(r) + + f = SCons.Util.CLVar(['a b']) + + r = f + 'c d' + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a b', 'c', 'd'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + ' c d' + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a b', 'c', 'd'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + ['c d'] + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a b', 'c d'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + [' c d'] + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a b', ' c d'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + ['c', 'd'] + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a b', 'c', 'd'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + [' c', 'd'] + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a b', ' c', 'd'], r.data + assert str(r) == 'a b c d', str(r) + + f = SCons.Util.CLVar(['a', 'b']) + + r = f + 'c d' + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a', 'b', 'c', 'd'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + ' c d' + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a', 'b', 'c', 'd'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + ['c d'] + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a', 'b', 'c d'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + [' c d'] + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a', 'b', ' c d'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + ['c', 'd'] + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a', 'b', 'c', 'd'], r.data + assert str(r) == 'a b c d', str(r) + + r = f + [' c', 'd'] + assert isinstance(r, SCons.Util.CLVar), type(r) + assert r.data == ['a', 'b', ' c', 'd'], r.data + assert str(r) == 'a b c d', str(r) + + def test_Selector(self): + """Test the Selector class""" + + class MyNode: + def __init__(self, name): + self.name = name + self.suffix = os.path.splitext(name)[1] + + def __str__(self): + return self.name + + s = Selector({'a' : 'AAA', 'b' : 'BBB'}) + assert s['a'] == 'AAA', s['a'] + assert s['b'] == 'BBB', s['b'] + exc_caught = None + try: + x = s['c'] + except KeyError: + exc_caught = 1 + assert exc_caught, "should have caught a KeyError" + s['c'] = 'CCC' + assert s['c'] == 'CCC', s['c'] + + class DummyEnv(UserDict): + def subst(self, key): + if key[0] == '$': + return self[key[1:]] + return key + + env = DummyEnv() + + s = Selector({'.d' : 'DDD', '.e' : 'EEE'}) + ret = s(env, []) + assert ret is None, ret + ret = s(env, [MyNode('foo.d')]) + assert ret == 'DDD', ret + ret = s(env, [MyNode('bar.e')]) + assert ret == 'EEE', ret + ret = s(env, [MyNode('bar.x')]) + assert ret is None, ret + s[None] = 'XXX' + ret = s(env, [MyNode('bar.x')]) + assert ret == 'XXX', ret + + env = DummyEnv({'FSUFF' : '.f', 'GSUFF' : '.g'}) + + s = Selector({'$FSUFF' : 'FFF', '$GSUFF' : 'GGG'}) + ret = s(env, [MyNode('foo.f')]) + assert ret == 'FFF', ret + ret = s(env, [MyNode('bar.g')]) + assert ret == 'GGG', ret + + def test_adjustixes(self): + """Test the adjustixes() function""" + r = adjustixes('file', 'pre-', '-suf') + assert r == 'pre-file-suf', r + r = adjustixes('pre-file', 'pre-', '-suf') + assert r == 'pre-file-suf', r + r = adjustixes('file-suf', 'pre-', '-suf') + assert r == 'pre-file-suf', r + r = adjustixes('pre-file-suf', 'pre-', '-suf') + assert r == 'pre-file-suf', r + r = adjustixes('pre-file.xxx', 'pre-', '-suf') + assert r == 'pre-file.xxx', r + r = adjustixes('dir/file', 'pre-', '-suf') + assert r == os.path.join('dir', 'pre-file-suf'), r + + def test_containsAny(self): + """Test the containsAny() function""" + assert containsAny('*.py', '*?[]') + assert not containsAny('file.txt', '*?[]') + + def test_containsAll(self): + """Test the containsAll() function""" + assert containsAll('43221', '123') + assert not containsAll('134', '123') + + def test_containsOnly(self): + """Test the containsOnly() function""" + assert containsOnly('.83', '0123456789.') + assert not containsOnly('43221', '123') + + def test_LogicalLines(self): + """Test the LogicalLines class""" + fobj = StringIO.StringIO(r""" +foo \ +bar \ +baz +foo +bling \ +bling \ bling +bling +""") + + lines = LogicalLines(fobj).readlines() + assert lines == [ + '\n', + 'foo bar baz\n', + 'foo\n', + 'bling bling \\ bling\n', + 'bling\n', + ], lines + + def test_intern(self): + s1 = silent_intern("spam") + # Python 1.5 and 3.x do not have a unicode() built-in + if sys.version[0] == '2': + s2 = silent_intern(unicode("unicode spam")) + s3 = silent_intern(42) + s4 = silent_intern("spam") + assert id(s1) == id(s4) + + +class MD5TestCase(unittest.TestCase): + + def test_collect(self): + """Test collecting a list of signatures into a new signature value + """ + s = map(MD5signature, ('111', '222', '333')) + + assert '698d51a19d8a121ce581499d7b701668' == MD5collect(s[0:1]) + assert '8980c988edc2c78cc43ccb718c06efd5' == MD5collect(s[0:2]) + assert '53fd88c84ff8a285eb6e0a687e55b8c7' == MD5collect(s) + + def test_MD5signature(self): + """Test generating a signature""" + s = MD5signature('111') + assert '698d51a19d8a121ce581499d7b701668' == s, s + + s = MD5signature('222') + assert 'bcbe3365e6ac95ea2c0343a2395834dd' == s, s + +class NodeListTestCase(unittest.TestCase): + def test_simple_attributes(self): + """Test simple attributes of a NodeList class""" + class TestClass: + def __init__(self, name, child=None): + self.child = child + self.bar = name + + t1 = TestClass('t1', TestClass('t1child')) + t2 = TestClass('t2', TestClass('t2child')) + t3 = TestClass('t3') + + nl = NodeList([t1, t2, t3]) + assert nl.bar == [ 't1', 't2', 't3' ], nl.bar + assert nl[0:2].child.bar == [ 't1child', 't2child' ], \ + nl[0:2].child.bar + + def test_callable_attributes(self): + """Test callable attributes of a NodeList class""" + class TestClass: + def __init__(self, name, child=None): + self.child = child + self.bar = name + def foo(self): + return self.bar + "foo" + def getself(self): + return self + + t1 = TestClass('t1', TestClass('t1child')) + t2 = TestClass('t2', TestClass('t2child')) + t3 = TestClass('t3') + + nl = NodeList([t1, t2, t3]) + assert nl.foo() == [ 't1foo', 't2foo', 't3foo' ], nl.foo() + assert nl.bar == [ 't1', 't2', 't3' ], nl.bar + assert nl.getself().bar == [ 't1', 't2', 't3' ], nl.getself().bar + assert nl[0:2].child.foo() == [ 't1childfoo', 't2childfoo' ], \ + nl[0:2].child.foo() + assert nl[0:2].child.bar == [ 't1child', 't2child' ], \ + nl[0:2].child.bar + + def test_null(self): + """Test a null NodeList""" + nl = NodeList([]) + r = str(nl) + assert r == '', r + for node in nl: + raise Exception, "should not enter this loop" + + +class flattenTestCase(unittest.TestCase): + + def test_scalar(self): + """Test flattening a scalar""" + result = flatten('xyz') + assert result == ['xyz'], result + +if __name__ == "__main__": + suite = unittest.TestSuite() + tclasses = [ dictifyTestCase, + flattenTestCase, + MD5TestCase, + NodeListTestCase, + UtilTestCase, + ] + for tclass in tclasses: + names = unittest.getTestCaseNames(tclass, 'test_') + suite.addTests(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: -- cgit v1.2.3