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/SConfTests.py | 759 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 759 insertions(+) create mode 100644 src/engine/SCons/SConfTests.py (limited to 'src/engine/SCons/SConfTests.py') diff --git a/src/engine/SCons/SConfTests.py b/src/engine/SCons/SConfTests.py new file mode 100644 index 0000000..71bdb57 --- /dev/null +++ b/src/engine/SCons/SConfTests.py @@ -0,0 +1,759 @@ +# +# 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/SConfTests.py 4577 2009/12/27 19:44:43 scons" + +import os +import re +import string +import StringIO +import sys +from types import * +import unittest + +import TestCmd + +sys.stdout = StringIO.StringIO() + +if sys.platform == 'win32': + existing_lib = "msvcrt" +else: + existing_lib = "m" + +class SConfTestCase(unittest.TestCase): + + def setUp(self): + # we always want to start with a clean directory + self.save_cwd = os.getcwd() + self.test = TestCmd.TestCmd(workdir = '') + os.chdir(self.test.workpath('')) + + def tearDown(self): + self.test.cleanup() + import SCons.SConsign + SCons.SConsign.Reset() + os.chdir(self.save_cwd) + + def _resetSConfState(self): + # Ok, this is tricky, and i do not know, if everything is sane. + # We try to reset scons' state (including all global variables) + import SCons.SConsign + SCons.SConsign.write() # simulate normal scons-finish + for n in sys.modules.keys(): + if string.split(n, '.')[0] == 'SCons' and n[:12] != 'SCons.compat': + m = sys.modules[n] + if type(m) is ModuleType: + # if this is really a scons module, clear its namespace + del sys.modules[n] + m.__dict__.clear() + # we only use SCons.Environment and SCons.SConf for these tests. + import SCons.Environment + import SCons.SConf + self.Environment = SCons.Environment + self.SConf = SCons.SConf + # and we need a new environment, cause references may point to + # old modules (well, at least this is safe ...) + self.scons_env = self.Environment.Environment() + self.scons_env.AppendENVPath('PATH', os.environ['PATH']) + + # we want to do some autodetection here + # this stuff works with + # - cygwin on Windows (using cmd.exe, not bash) + # - posix + # - msvc on Windows (hopefully) + if (not self.scons_env.Detect( self.scons_env.subst('$CXX') ) or + not self.scons_env.Detect( self.scons_env.subst('$CC') ) or + not self.scons_env.Detect( self.scons_env.subst('$LINK') )): + raise Exception, "This test needs an installed compiler!" + if self.scons_env['CXX'] == 'g++': + global existing_lib + existing_lib = 'm' + + if sys.platform in ['cygwin', 'win32']: + # On Windows, SCons.Platform.win32 redefines the builtin + # file() and open() functions to close the file handles. + # This interferes with the unittest.py infrastructure in + # some way. Just sidestep the issue by restoring the + # original builtin functions whenever we have to reset + # all of our global state. + + import __builtin__ + import SCons.Platform.win32 + + __builtin__.file = SCons.Platform.win32._builtin_file + __builtin__.open = SCons.Platform.win32._builtin_open + + def _baseTryXXX(self, TryFunc): + # TryCompile and TryLink are much the same, so we can test them + # in one method, we pass the function as a string ('TryCompile', + # 'TryLink'), so we are aware of reloading modules. + + def checks(self, sconf, TryFuncString): + TryFunc = self.SConf.SConfBase.__dict__[TryFuncString] + res1 = TryFunc( sconf, "int main() { return 0; }\n", ".c" ) + res2 = TryFunc( sconf, + '#include "no_std_header.h"\nint main() {return 0; }\n', + '.c' ) + return (res1,res2) + + # 1. test initial behaviour (check ok / failed) + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + res = checks( self, sconf, TryFunc ) + assert res[0] and not res[1], res + finally: + sconf.Finish() + + # 2.1 test the error caching mechanism (no dependencies have changed) + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + res = checks( self, sconf, TryFunc ) + assert res[0] and not res[1], res + finally: + sconf.Finish() + # we should have exactly one one error cached + log = self.test.read( self.test.workpath('config.log') ) + expr = re.compile( ".*failed in a previous run and all", re.DOTALL ) + firstOcc = expr.match( log ) + assert firstOcc is not None, log + secondOcc = expr.match( log, firstOcc.end(0) ) + assert secondOcc is None, log + + # 2.2 test the error caching mechanism (dependencies have changed) + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + no_std_header_h = self.test.workpath('config.tests', 'no_std_header.h') + test_h = self.test.write( no_std_header_h, + "/* we are changing a dependency now */\n" ); + try: + res = checks( self, sconf, TryFunc ) + log = self.test.read( self.test.workpath('config.log') ) + assert res[0] and res[1], res + finally: + sconf.Finish() + + def test_TryBuild(self): + """Test SConf.TryBuild + """ + # 1 test that we can try a builder that returns a list of nodes + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + class MyBuilder: + def __init__(self): + self.prefix = '' + self.suffix = '' + def __call__(self, env, target, source): + class MyNode: + def __init__(self, name): + self.name = name + self.state = None + self.waiting_parents = set() + self.side_effects = [] + self.builder = None + self.prerequisites = [] + def disambiguate(self): + return self + def has_builder(self): + return 1 + def add_pre_action(self, *actions): + pass + def add_post_action(self, *actions): + pass + def children(self): + return [] + def get_state(self): + return self.state + def set_state(self, state): + self.state = state + def alter_targets(self): + return [], None + def depends_on(self, nodes): + return None + def postprocess(self): + pass + def clear(self): + pass + def is_up_to_date(self): + return None + def prepare(self): + pass + def push_to_cache(self): + pass + def retrieve_from_cache(self): + return 0 + def build(self, **kw): + return + def built(self): + pass + def get_stored_info(self): + pass + def do_not_store_info(self): + pass + def get_executor(self): + class Executor: + def __init__(self, targets): + self.targets = targets + def get_all_targets(self): + return self.targets + return Executor([self]) + return [MyNode('n1'), MyNode('n2')] + try: + self.scons_env.Append(BUILDERS = {'SConfActionBuilder' : MyBuilder()}) + sconf.TryBuild(self.scons_env.SConfActionBuilder) + finally: + sconf.Finish() + + def test_TryCompile(self): + """Test SConf.TryCompile + """ + self._baseTryXXX( "TryCompile" ) #self.SConf.SConf.TryCompile ) + + def test_TryLink(self): + """Test SConf.TryLink + """ + self._baseTryXXX( "TryLink" ) #self.SConf.SConf.TryLink ) + + def test_TryRun(self): + """Test SConf.TryRun + """ + def checks(sconf): + prog = """ +#include +int main() { + printf( "Hello" ); + return 0; +} +""" + res1 = sconf.TryRun( prog, ".c" ) + res2 = sconf.TryRun( "not a c program\n", ".c" ) + return (res1, res2) + + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + res = checks(sconf) + assert res[0][0] and res[0][1] == "Hello", res + assert not res[1][0] and res[1][1] == "", res + finally: + sconf.Finish() + log = self.test.read( self.test.workpath('config.log') ) + + # test the caching mechanism + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + res = checks(sconf) + assert res[0][0] and res[0][1] == "Hello", res + assert not res[1][0] and res[1][1] == "", res + finally: + sconf.Finish() + # we should have exactly one error cached + log = self.test.read( self.test.workpath('config.log') ) + expr = re.compile( ".*failed in a previous run and all", re.DOTALL ) + firstOcc = expr.match( log ) + assert firstOcc is not None, log + secondOcc = expr.match( log, firstOcc.end(0) ) + assert secondOcc is None, log + + + def test_TryAction(self): + """Test SConf.TryAction + """ + def actionOK(target, source, env): + open(str(target[0]), "w").write( "RUN OK\n" ) + return None + def actionFAIL(target, source, env): + return 1 + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + (ret, output) = sconf.TryAction(action=actionOK) + assert ret and output == "RUN OK" + os.linesep, (ret, output) + (ret, output) = sconf.TryAction(action=actionFAIL) + assert not ret and output == "", (ret, output) + finally: + sconf.Finish() + + def _test_check_compilers(self, comp, func, name): + """This is the implementation for CheckCC and CheckCXX tests.""" + from copy import deepcopy + + # Check that Check* works + r = func() + assert r, "could not find %s ?" % comp + + # Check that Check* does fail if comp is not available in env + oldcomp = deepcopy(self.scons_env[comp]) + del self.scons_env[comp] + r = func() + assert not r, "%s worked wo comp ?" % name + + # Check that Check* does fail if comp is set but empty + self.scons_env[comp] = '' + r = func() + assert not r, "%s worked with comp = '' ?" % name + + # Check that Check* does fail if comp is set to buggy executable + self.scons_env[comp] = 'thiscccompilerdoesnotexist' + r = func() + assert not r, "%s worked with comp = thiscompilerdoesnotexist ?" % name + + # Check that Check* does fail if CFLAGS is buggy + self.scons_env[comp] = oldcomp + self.scons_env['%sFLAGS' % comp] = '/WX qwertyuiop.c' + r = func() + assert not r, "%s worked with %sFLAGS = qwertyuiop ?" % (name, comp) + + def test_CheckCC(self): + """Test SConf.CheckCC() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + try: + self._test_check_compilers('CC', sconf.CheckCC, 'CheckCC') + except AssertionError: + sys.stderr.write(self.test.read('config.log')) + raise + finally: + sconf.Finish() + + def test_CheckSHCC(self): + """Test SConf.CheckSHCC() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + try: + self._test_check_compilers('SHCC', sconf.CheckSHCC, 'CheckSHCC') + except AssertionError: + sys.stderr.write(self.test.read('config.log')) + raise + finally: + sconf.Finish() + + def test_CheckCXX(self): + """Test SConf.CheckCXX() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + try: + self._test_check_compilers('CXX', sconf.CheckCXX, 'CheckCXX') + except AssertionError: + sys.stderr.write(self.test.read('config.log')) + raise + finally: + sconf.Finish() + + def test_CheckSHCXX(self): + """Test SConf.CheckSHCXX() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + try: + self._test_check_compilers('SHCXX', sconf.CheckSHCXX, 'CheckSHCXX') + except AssertionError: + sys.stderr.write(self.test.read('config.log')) + raise + finally: + sconf.Finish() + + + def test_CheckHeader(self): + """Test SConf.CheckHeader() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + # CheckHeader() + r = sconf.CheckHeader( "stdio.h", include_quotes="<>", language="C" ) + assert r, "did not find stdio.h" + r = sconf.CheckHeader( "HopefullyNoHeader.noh", language="C" ) + assert not r, "unexpectedly found HopefullyNoHeader.noh" + r = sconf.CheckHeader( "vector", include_quotes="<>", language="C++" ) + assert r, "did not find vector" + r = sconf.CheckHeader( "HopefullyNoHeader.noh", language="C++" ) + assert not r, "unexpectedly found HopefullyNoHeader.noh" + + finally: + sconf.Finish() + + def test_CheckCHeader(self): + """Test SConf.CheckCHeader() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + + try: + # CheckCHeader() + r = sconf.CheckCHeader( "stdio.h", include_quotes="<>" ) + assert r, "did not find stdio.h" + r = sconf.CheckCHeader( ["math.h", "stdio.h"], include_quotes="<>" ) + assert r, "did not find stdio.h, #include math.h first" + r = sconf.CheckCHeader( "HopefullyNoCHeader.noh" ) + assert not r, "unexpectedly found HopefullyNoCHeader.noh" + + finally: + sconf.Finish() + + def test_CheckCXXHeader(self): + """Test SConf.CheckCXXHeader() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + + try: + # CheckCXXHeader() + r = sconf.CheckCXXHeader( "vector", include_quotes="<>" ) + assert r, "did not find vector" + r = sconf.CheckCXXHeader( ["stdio.h", "vector"], include_quotes="<>" ) + assert r, "did not find vector, #include stdio.h first" + r = sconf.CheckCXXHeader( "HopefullyNoCXXHeader.noh" ) + assert not r, "unexpectedly found HopefullyNoCXXHeader.noh" + + finally: + sconf.Finish() + + def test_CheckLib(self): + """Test SConf.CheckLib() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + + try: + # CheckLib() + r = sconf.CheckLib( existing_lib, "main", autoadd=0 ) + assert r, "did not find %s" % existing_lib + r = sconf.CheckLib( "hopefullynolib", "main", autoadd=0 ) + assert not r, "unexpectedly found hopefullynolib" + + # CheckLib() with list of libs + r = sconf.CheckLib( [existing_lib], "main", autoadd=0 ) + assert r, "did not find %s" % existing_lib + r = sconf.CheckLib( ["hopefullynolib"], "main", autoadd=0 ) + assert not r, "unexpectedly found hopefullynolib" + # This is a check that a null list doesn't find functions + # that are in libraries that must be explicitly named. + # This works on POSIX systems where you have to -lm to + # get the math functions, but it fails on Visual Studio + # where you apparently get all those functions for free. + # Comment out this check until someone who understands + # Visual Studio better can come up with a corresponding + # test (if that ever really becomes necessary). + #r = sconf.CheckLib( [], "sin", autoadd=0 ) + #assert not r, "unexpectedly found nonexistent library" + r = sconf.CheckLib( [existing_lib,"hopefullynolib"], "main", autoadd=0 ) + assert r, "did not find %s,%s " % (existing_lib,r) + r = sconf.CheckLib( ["hopefullynolib",existing_lib], "main", autoadd=0 ) + assert r, "did not find %s " % existing_lib + + # CheckLib() with autoadd + def libs(env): + return env.get('LIBS', []) + + env = sconf.env.Clone() + + try: + r = sconf.CheckLib( existing_lib, "main", autoadd=1 ) + assert r, "did not find main in %s" % existing_lib + expect = libs(env) + [existing_lib] + got = libs(sconf.env) + assert got == expect, "LIBS: expected %s, got %s" % (expect, got) + + sconf.env = env.Clone() + r = sconf.CheckLib( existing_lib, "main", autoadd=0 ) + assert r, "did not find main in %s" % existing_lib + expect = libs(env) + got = libs(sconf.env) + assert got == expect, "before and after LIBS were not the same" + finally: + sconf.env = env + finally: + sconf.Finish() + + def test_CheckLibWithHeader(self): + """Test SConf.CheckLibWithHeader() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + + try: + # CheckLibWithHeader() + r = sconf.CheckLibWithHeader( existing_lib, "math.h", "C", autoadd=0 ) + assert r, "did not find %s" % existing_lib + r = sconf.CheckLibWithHeader( existing_lib, ["stdio.h", "math.h"], "C", autoadd=0 ) + assert r, "did not find %s, #include stdio.h first" % existing_lib + r = sconf.CheckLibWithHeader( "hopefullynolib", "math.h", "C", autoadd=0 ) + assert not r, "unexpectedly found hopefullynolib" + + # CheckLibWithHeader() with lists of libs + r = sconf.CheckLibWithHeader( [existing_lib], "math.h", "C", autoadd=0 ) + assert r, "did not find %s" % existing_lib + r = sconf.CheckLibWithHeader( [existing_lib], ["stdio.h", "math.h"], "C", autoadd=0 ) + assert r, "did not find %s, #include stdio.h first" % existing_lib + # This is a check that a null list doesn't find functions + # that are in libraries that must be explicitly named. + # This works on POSIX systems where you have to -lm to + # get the math functions, but it fails on Visual Studio + # where you apparently get all those functions for free. + # Comment out this check until someone who understands + # Visual Studio better can come up with a corresponding + # test (if that ever really becomes necessary). + #r = sconf.CheckLibWithHeader( [], "math.h", "C", call="sin(3);", autoadd=0 ) + #assert not r, "unexpectedly found non-existent library" + r = sconf.CheckLibWithHeader( ["hopefullynolib"], "math.h", "C", autoadd=0 ) + assert not r, "unexpectedly found hopefullynolib" + r = sconf.CheckLibWithHeader( ["hopefullynolib",existing_lib], ["stdio.h", "math.h"], "C", autoadd=0 ) + assert r, "did not find %s, #include stdio.h first" % existing_lib + r = sconf.CheckLibWithHeader( [existing_lib,"hopefullynolib"], ["stdio.h", "math.h"], "C", autoadd=0 ) + assert r, "did not find %s, #include stdio.h first" % existing_lib + + # CheckLibWithHeader with autoadd + def libs(env): + return env.get('LIBS', []) + + env = sconf.env.Clone() + + try: + r = sconf.CheckLibWithHeader( existing_lib, "math.h", "C", autoadd=1 ) + assert r, "did not find math.h with %s" % existing_lib + expect = libs(env) + [existing_lib] + got = libs(sconf.env) + assert got == expect, "LIBS: expected %s, got %s" % (expect, got) + + sconf.env = env.Clone() + r = sconf.CheckLibWithHeader( existing_lib, "math.h", "C", autoadd=0 ) + assert r, "did not find math.h with %s" % existing_lib + expect = libs(env) + got = libs(sconf.env) + assert got == expect, "before and after LIBS were not the same" + finally: + sconf.env = env + + finally: + sconf.Finish() + + def test_CheckFunc(self): + """Test SConf.CheckFunc() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + + try: + # CheckFunc() + r = sconf.CheckFunc('strcpy') + assert r, "did not find strcpy" + r = sconf.CheckFunc('strcpy', '/* header */ char strcpy();') + assert r, "did not find strcpy" + r = sconf.CheckFunc('hopefullynofunction') + assert not r, "unexpectedly found hopefullynofunction" + + finally: + sconf.Finish() + + def test_Define(self): + """Test SConf.Define() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log'), + config_h = self.test.workpath('config.h')) + try: + # XXX: we test the generated config.h string. This is not so good, + # ideally, we would like to test if the generated file included in + # a test program does what we want. + + # Test defining one symbol wo value + sconf.config_h_text = '' + sconf.Define('YOP') + assert sconf.config_h_text == '#define YOP\n' + + # Test defining one symbol with integer value + sconf.config_h_text = '' + sconf.Define('YOP', 1) + assert sconf.config_h_text == '#define YOP 1\n' + + # Test defining one symbol with string value + sconf.config_h_text = '' + sconf.Define('YOP', '"YIP"') + assert sconf.config_h_text == '#define YOP "YIP"\n' + + # Test defining one symbol with string value + sconf.config_h_text = '' + sconf.Define('YOP', "YIP") + assert sconf.config_h_text == '#define YOP YIP\n' + + finally: + sconf.Finish() + + def test_CheckTypeSize(self): + """Test SConf.CheckTypeSize() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + # CheckTypeSize() + + # In ANSI C, sizeof(char) == 1. + r = sconf.CheckTypeSize('char', expect = 1) + assert r == 1, "sizeof(char) != 1 ??" + r = sconf.CheckTypeSize('char', expect = 0) + assert r == 0, "sizeof(char) == 0 ??" + r = sconf.CheckTypeSize('char', expect = 2) + assert r == 0, "sizeof(char) == 2 ??" + r = sconf.CheckTypeSize('char') + assert r == 1, "sizeof(char) != 1 ??" + r = sconf.CheckTypeSize('const unsigned char') + assert r == 1, "sizeof(const unsigned char) != 1 ??" + + # Checking C++ + r = sconf.CheckTypeSize('const unsigned char', language = 'C++') + assert r == 1, "sizeof(const unsigned char) != 1 ??" + + # Checking Non-existing type + r = sconf.CheckTypeSize('thistypedefhasnotchancetosexist_scons') + assert r == 0, \ + "Checking size of thistypedefhasnotchancetosexist_scons succeeded ?" + + finally: + sconf.Finish() + + def test_CheckDeclaration(self): + """Test SConf.CheckDeclaration() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + # In ANSI C, malloc should be available in stdlib + r = sconf.CheckDeclaration('malloc', includes = "#include ") + assert r, "malloc not declared ??" + # For C++, __cplusplus should be declared + r = sconf.CheckDeclaration('__cplusplus', language = 'C++') + assert r, "__cplusplus not declared in C++ ??" + r = sconf.CheckDeclaration('__cplusplus', language = 'C') + assert not r, "__cplusplus declared in C ??" + finally: + sconf.Finish() + + def test_(self): + """Test SConf.CheckType() + """ + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + # CheckType() + r = sconf.CheckType('off_t', '#include \n') + assert r, "did not find off_t" + r = sconf.CheckType('hopefullynotypedef_not') + assert not r, "unexpectedly found hopefullynotypedef_not" + + finally: + sconf.Finish() + + def test_CustomChecks(self): + """Test Custom Checks + """ + def CheckCustom(test): + test.Message( "Checking UserTest ... " ) + prog = """ +#include + +int main() { + printf( "Hello" ); + return 0; +} +""" + (ret, output) = test.TryRun( prog, ".c" ) + test.Result( ret ) + assert ret and output == "Hello", (ret, output) + return ret + + + self._resetSConfState() + sconf = self.SConf.SConf(self.scons_env, + custom_tests={'CheckCustom': CheckCustom}, + conf_dir=self.test.workpath('config.tests'), + log_file=self.test.workpath('config.log')) + try: + ret = sconf.CheckCustom() + assert ret, ret + finally: + sconf.Finish() + + +if __name__ == "__main__": + suite = unittest.makeSuite(SConfTestCase, 'test_') + res = unittest.TextTestRunner().run(suite) + if not res.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