summaryrefslogtreecommitdiff
path: root/src/engine/SCons/UtilTests.py
diff options
context:
space:
mode:
Diffstat (limited to 'src/engine/SCons/UtilTests.py')
-rw-r--r--src/engine/SCons/UtilTests.py338
1 files changed, 235 insertions, 103 deletions
diff --git a/src/engine/SCons/UtilTests.py b/src/engine/SCons/UtilTests.py
index 1df4069..41a1647 100644
--- a/src/engine/SCons/UtilTests.py
+++ b/src/engine/SCons/UtilTests.py
@@ -1,5 +1,5 @@
#
-# Copyright (c) 2001 - 2017 The SCons Foundation
+# Copyright (c) 2001 - 2019 The SCons Foundation
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
@@ -21,7 +21,7 @@
# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#
-__revision__ = "src/engine/SCons/UtilTests.py rel_3.0.0:4395:8972f6a2f699 2017/09/18 12:59:24 bdbaddog"
+__revision__ = "src/engine/SCons/UtilTests.py e724ae812eb96f4858a132f5b8c769724744faf6 2019-07-21 00:04:47 bdeegan"
import SCons.compat
@@ -32,15 +32,18 @@ import unittest
from collections import UserDict, UserList, UserString
import TestCmd
-import TestUnit
import SCons.Errors
from SCons.Util import *
-try: eval('unicode')
-except NameError: HasUnicode = False
-else: HasUnicode = True
+try:
+ eval('unicode')
+except NameError:
+ HasUnicode = False
+else:
+ HasUnicode = True
+
class OutBuffer(object):
def __init__(self):
@@ -49,47 +52,59 @@ class OutBuffer(object):
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
+ 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
+ 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'),'')
+ 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(object):
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
@@ -116,7 +131,7 @@ class UtilTestCase(unittest.TestCase):
"""
lines = expect.split('\n')[:-1]
- lines = ['[E BSPACN ]'+l for l in lines]
+ lines = ['[E BSPACN ]' + l for l in lines]
withtags = '\n'.join(lines) + '\n'
return foo, expect, withtags
@@ -151,13 +166,14 @@ class UtilTestCase(unittest.TestCase):
"""
lines = expect.split('\n')[:-1]
- lines = ['[E BSPACN ]'+l for l in lines]
+ lines = ['[E BSPACN ]' + l for l in lines]
withtags = '\n'.join(lines) + '\n'
return blat_o, expect, withtags
def test_render_tree(self):
"""Test the render_tree() function"""
+
def get_children(node):
return node.children
@@ -178,6 +194,7 @@ class UtilTestCase(unittest.TestCase):
def test_print_tree(self):
"""Test the print_tree() function"""
+
def get_children(node):
return node.children
@@ -244,7 +261,7 @@ class UtilTestCase(unittest.TestCase):
assert is_Dict(UserDict())
# os.environ is not a dictionary in python 3
- if sys.version_info < (3,0):
+ if sys.version_info < (3, 0):
assert is_Dict(os.environ)
try:
@@ -258,7 +275,7 @@ class UtilTestCase(unittest.TestCase):
assert not is_Dict(())
assert not is_Dict("")
if HasUnicode:
- exec("assert not is_Dict(u'')")
+ exec ("assert not is_Dict(u'')")
def test_is_List(self):
assert is_List([])
@@ -274,12 +291,12 @@ class UtilTestCase(unittest.TestCase):
assert not is_List({})
assert not is_List("")
if HasUnicode:
- exec("assert not is_List(u'')")
+ exec ("assert not is_List(u'')")
def test_is_String(self):
assert is_String("")
if HasUnicode:
- exec("assert is_String(u'')")
+ exec ("assert is_String(u'')")
assert is_String(UserString(''))
try:
class mystr(str):
@@ -305,39 +322,51 @@ class UtilTestCase(unittest.TestCase):
assert not is_Tuple({})
assert not is_Tuple("")
if HasUnicode:
- exec("assert not is_Tuple(u'')")
+ exec ("assert not is_Tuple(u'')")
+
+ def test_to_Bytes(self):
+ """ Test the to_Bytes method"""
+ if not PY3:
+ self.assertEqual(to_bytes(UnicodeType('Hello')),
+ bytearray(u'Hello', 'utf-8'),
+ "Check that to_bytes creates byte array when presented with unicode string. PY2 only")
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([1, 2, 3]) == str([1, 2, 3]), to_String([1, 2, 3])
assert to_String("foo") == "foo", to_String("foo")
+ assert to_String(None) == 'None'
+ # test low level string converters too
+ assert to_str(None) == 'None'
+ assert to_bytes(None) == b'None'
- s1=UserString('blah')
+ s1 = UserString('blah')
assert to_String(s1) == s1, s1
assert to_String(s1) == 'blah', s1
class Derived(UserString):
pass
+
s2 = Derived('foo')
assert to_String(s2) == s2, s2
assert to_String(s2) == 'foo', s2
if HasUnicode:
- s3=UserString(unicode('bar'))
+ s3 = UserString(unicode('bar'))
assert to_String(s3) == s3, s3
assert to_String(s3) == unicode('bar'), s3
assert isinstance(to_String(s3), unicode), \
- type(to_String(s3))
+ type(to_String(s3))
if HasUnicode:
s4 = unicode('baz')
assert to_String(s4) == unicode('baz'), to_String(s4)
assert isinstance(to_String(s4), unicode), \
- type(to_String(s4))
+ type(to_String(s4))
def test_WhereIs(self):
- test = TestCmd.TestCmd(workdir = '')
+ test = TestCmd.TestCmd(workdir='')
sub1_xxx_exe = test.workpath('sub1', 'xxx.exe')
sub2_xxx_exe = test.workpath('sub2', 'xxx.exe')
@@ -360,17 +389,17 @@ class UtilTestCase(unittest.TestCase):
env_path = os.environ['PATH']
try:
- pathdirs_1234 = [ test.workpath('sub1'),
- test.workpath('sub2'),
- test.workpath('sub3'),
- test.workpath('sub4'),
- ] + env_path.split(os.pathsep)
-
- pathdirs_1243 = [ test.workpath('sub1'),
- test.workpath('sub2'),
- test.workpath('sub4'),
- test.workpath('sub3'),
- ] + env_path.split(os.pathsep)
+ pathdirs_1234 = [test.workpath('sub1'),
+ test.workpath('sub2'),
+ test.workpath('sub3'),
+ test.workpath('sub4'),
+ ] + env_path.split(os.pathsep)
+
+ pathdirs_1243 = [test.workpath('sub1'),
+ test.workpath('sub2'),
+ test.workpath('sub4'),
+ test.workpath('sub3'),
+ ] + env_path.split(os.pathsep)
os.environ['PATH'] = os.pathsep.join(pathdirs_1234)
wi = WhereIs('xxx.exe')
@@ -380,9 +409,9 @@ class UtilTestCase(unittest.TestCase):
wi = WhereIs('xxx.exe', os.pathsep.join(pathdirs_1243))
assert wi == test.workpath(sub4_xxx_exe), wi
- wi = WhereIs('xxx.exe',reject = sub3_xxx_exe)
+ 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)
+ wi = WhereIs('xxx.exe', pathdirs_1243, reject=sub3_xxx_exe)
assert wi == test.workpath(sub4_xxx_exe), wi
os.environ['PATH'] = os.pathsep.join(pathdirs_1243)
@@ -394,19 +423,19 @@ class UtilTestCase(unittest.TestCase):
assert wi == test.workpath(sub3_xxx_exe), wi
if sys.platform == 'win32':
- wi = WhereIs('xxx', pathext = '')
+ wi = WhereIs('xxx', pathext='')
assert wi is None, wi
- wi = WhereIs('xxx', pathext = '.exe')
+ wi = WhereIs('xxx', pathext='.exe')
assert wi == test.workpath(sub4_xxx_exe), wi
- wi = WhereIs('xxx', path = pathdirs_1234, pathext = '.BAT;.EXE')
+ wi = WhereIs('xxx', path=pathdirs_1234, pathext='.BAT;.EXE')
assert wi.lower() == test.workpath(sub3_xxx_exe).lower(), 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')
+ wi = WhereIs('xxx', path=forward_slash, pathext='.EXE')
assert wi.lower() == test.workpath(sub3_xxx_exe).lower(), wi
del os.environ['PATH']
@@ -426,24 +455,27 @@ class UtilTestCase(unittest.TestCase):
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')}")
+ assert get_environment_var("${some('complex expression')}") == None, get_environment_var(
+ "${some('complex expression')}")
def test_Proxy(self):
"""Test generic Proxy class."""
+
class Subject(object):
def foo(self):
return 1
+
def bar(self):
return 2
- s=Subject()
+ s = Subject()
s.baz = 3
class ProxyTest(Proxy):
def bar(self):
return 4
- p=ProxyTest(s)
+ p = ProxyTest(s)
assert p.foo() == 1, p.foo()
assert p.bar() == 4, p.bar()
@@ -477,8 +509,10 @@ class UtilTestCase(unittest.TestCase):
filename = tempfile.mktemp()
str = '1234567890 ' + filename
try:
- open(filename, 'w').write(str)
- assert open(get_native_path(filename)).read() == str
+ with open(filename, 'w') as f:
+ f.write(str)
+ with open(get_native_path(filename)) as f:
+ assert f.read() == str
finally:
try:
os.unlink(filename)
@@ -490,49 +524,49 @@ class UtilTestCase(unittest.TestCase):
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')
+ 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')
+ 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')
+ 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')
+ 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_addPathIfNotExists(self):
"""Test the AddPathIfNotExists() function"""
- env_dict = { 'FOO' : os.path.normpath('/foo/bar') + os.pathsep + \
- os.path.normpath('/baz/blat'),
- 'BAR' : os.path.normpath('/foo/bar') + os.pathsep + \
- os.path.normpath('/baz/blat'),
- 'BLAT' : [ os.path.normpath('/foo/bar'),
- os.path.normpath('/baz/blat') ] }
+ env_dict = {'FOO': os.path.normpath('/foo/bar') + os.pathsep + \
+ os.path.normpath('/baz/blat'),
+ 'BAR': os.path.normpath('/foo/bar') + os.pathsep + \
+ os.path.normpath('/baz/blat'),
+ 'BLAT': [os.path.normpath('/foo/bar'),
+ os.path.normpath('/baz/blat')]}
AddPathIfNotExists(env_dict, 'FOO', os.path.normpath('/foo/bar'))
AddPathIfNotExists(env_dict, 'BAR', os.path.normpath('/bar/foo'))
AddPathIfNotExists(env_dict, 'BAZ', os.path.normpath('/foo/baz'))
@@ -545,9 +579,9 @@ class UtilTestCase(unittest.TestCase):
os.path.normpath('/foo/bar') + os.pathsep + \
os.path.normpath('/baz/blat'), env_dict['BAR']
assert env_dict['BAZ'] == os.path.normpath('/foo/baz'), env_dict['BAZ']
- assert env_dict['BLAT'] == [ os.path.normpath('/baz/foo'),
- os.path.normpath('/foo/bar'),
- os.path.normpath('/baz/blat') ], env_dict['BLAT' ]
+ assert env_dict['BLAT'] == [os.path.normpath('/baz/foo'),
+ os.path.normpath('/foo/bar'),
+ os.path.normpath('/baz/blat')], env_dict['BLAT']
def test_CLVar(self):
"""Test the command-line construction variable class"""
@@ -656,10 +690,11 @@ class UtilTestCase(unittest.TestCase):
def __str__(self):
return self.name
+
def get_suffix(self):
return os.path.splitext(self.name)[1]
- s = Selector({'a' : 'AAA', 'b' : 'BBB'})
+ s = Selector({'a': 'AAA', 'b': 'BBB'})
assert s['a'] == 'AAA', s['a']
assert s['b'] == 'BBB', s['b']
exc_caught = None
@@ -679,7 +714,7 @@ class UtilTestCase(unittest.TestCase):
env = DummyEnv()
- s = Selector({'.d' : 'DDD', '.e' : 'EEE'})
+ s = Selector({'.d': 'DDD', '.e': 'EEE'})
ret = s(env, [])
assert ret is None, ret
ret = s(env, [MyNode('foo.d')])
@@ -692,9 +727,9 @@ class UtilTestCase(unittest.TestCase):
ret = s(env, [MyNode('bar.x')])
assert ret == 'XXX', ret
- env = DummyEnv({'FSUFF' : '.f', 'GSUFF' : '.g'})
+ env = DummyEnv({'FSUFF': '.f', 'GSUFF': '.g'})
- s = Selector({'$FSUFF' : 'FFF', '$GSUFF' : 'GGG'})
+ s = Selector({'$FSUFF': 'FFF', '$GSUFF': 'GGG'})
ret = s(env, [MyNode('foo.f')])
assert ret == 'FFF', ret
ret = s(env, [MyNode('bar.g')])
@@ -733,12 +768,12 @@ class UtilTestCase(unittest.TestCase):
def test_LogicalLines(self):
"""Test the LogicalLines class"""
content = u"""
-foo \
-bar \
+foo \\
+bar \\
baz
foo
-bling \
-bling \ bling
+bling \\
+bling \\ bling
bling
"""
fobj = io.StringIO(content)
@@ -780,9 +815,11 @@ class MD5TestCase(unittest.TestCase):
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(object):
def __init__(self, name, child=None):
self.child = child
@@ -793,18 +830,21 @@ class NodeListTestCase(unittest.TestCase):
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
+ 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(object):
def __init__(self, name, child=None):
self.child = child
self.bar = name
+
def foo(self):
return self.bar + "foo"
+
def getself(self):
return self
@@ -813,13 +853,13 @@ class NodeListTestCase(unittest.TestCase):
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
+ 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"""
@@ -835,21 +875,113 @@ class flattenTestCase(unittest.TestCase):
def test_scalar(self):
"""Test flattening a scalar"""
result = flatten('xyz')
- assert result == ['xyz'], result
+ self.assertEqual(result, ['xyz'], result)
+
+ def test_dictionary_values(self):
+ """Test flattening the dictionary values"""
+ items = {"a": 1, "b": 2, "c": 3}
+ result = flatten(items.values())
+ self.assertEqual(sorted(result), [1, 2, 3])
+
+
+class OsEnviron(object):
+ """Used to temporarily mock os.environ"""
+
+ def __init__(self, environ):
+ self._environ = environ
+
+ def start(self):
+ self._stored = os.environ
+ os.environ = self._environ
+
+ def stop(self):
+ os.environ = self._stored
+ del self._stored
+
+ def __enter__(self):
+ self.start()
+ return os.environ
+
+ def __exit__(self, *args):
+ self.stop()
+
+
+class get_env_boolTestCase(unittest.TestCase):
+ def test_missing(self):
+ env = dict()
+ var = get_env_bool(env, 'FOO')
+ assert var is False, "var should be False, not %s" % repr(var)
+ env = {'FOO': '1'}
+ var = get_env_bool(env, 'BAR')
+ assert var is False, "var should be False, not %s" % repr(var)
+
+ def test_true(self):
+ for foo in ['TRUE', 'True', 'true',
+ 'YES', 'Yes', 'yes',
+ 'Y', 'y',
+ 'ON', 'On', 'on',
+ '1', '20', '-1']:
+ env = {'FOO': foo}
+ var = get_env_bool(env, 'FOO')
+ assert var is True, 'var should be True, not %s' % repr(var)
+
+ def test_false(self):
+ for foo in ['FALSE', 'False', 'false',
+ 'NO', 'No', 'no',
+ 'N', 'n',
+ 'OFF', 'Off', 'off',
+ '0']:
+ env = {'FOO': foo}
+ var = get_env_bool(env, 'FOO', True)
+ assert var is False, 'var should be True, not %s' % repr(var)
+
+ def test_default(self):
+ env = {'FOO': 'other'}
+ var = get_env_bool(env, 'FOO', True)
+ assert var is True, 'var should be True, not %s' % repr(var)
+ var = get_env_bool(env, 'FOO', False)
+ assert var is False, 'var should be False, not %s' % repr(var)
+
+
+class get_os_env_boolTestCase(unittest.TestCase):
+ def test_missing(self):
+ with OsEnviron(dict()):
+ var = get_os_env_bool('FOO')
+ assert var is False, "var should be False, not %s" % repr(var)
+ with OsEnviron({'FOO': '1'}):
+ var = get_os_env_bool('BAR')
+ assert var is False, "var should be False, not %s" % repr(var)
+
+ def test_true(self):
+ for foo in ['TRUE', 'True', 'true',
+ 'YES', 'Yes', 'yes',
+ 'Y', 'y',
+ 'ON', 'On', 'on',
+ '1', '20', '-1']:
+ with OsEnviron({'FOO': foo}):
+ var = get_os_env_bool('FOO')
+ assert var is True, 'var should be True, not %s' % repr(var)
+
+ def test_false(self):
+ for foo in ['FALSE', 'False', 'false',
+ 'NO', 'No', 'no',
+ 'N', 'n',
+ 'OFF', 'Off', 'off',
+ '0']:
+ with OsEnviron({'FOO': foo}):
+ var = get_os_env_bool('FOO', True)
+ assert var is False, 'var should be True, not %s' % repr(var)
+
+ def test_default(self):
+ with OsEnviron({'FOO': 'other'}):
+ var = get_os_env_bool('FOO', True)
+ assert var is True, 'var should be True, not %s' % repr(var)
+ var = get_os_env_bool('FOO', False)
+ assert var is False, 'var should be False, not %s' % repr(var)
if __name__ == "__main__":
- suite = unittest.TestSuite()
- tclasses = [ dictifyTestCase,
- flattenTestCase,
- MD5TestCase,
- NodeListTestCase,
- UtilTestCase,
- ]
- for tclass in tclasses:
- names = unittest.getTestCaseNames(tclass, 'test_')
- suite.addTests(list(map(tclass, names)))
- TestUnit.run(suite)
+ unittest.main()
# Local Variables:
# tab-width:4