From: stevenknight Date: Fri, 24 Sep 2004 14:23:40 +0000 (+0000) Subject: Add validator functions for PathOption. (Steve Christensen) X-Git-Url: http://git.tremily.us/?a=commitdiff_plain;h=84f22a9edd0cc5552be66be7bdc223d2a07653ff;p=scons.git Add validator functions for PathOption. (Steve Christensen) git-svn-id: http://scons.tigris.org/svn/scons/trunk@1098 fdb21ef1-2011-0410-befe-b5e4ea1792b1 --- diff --git a/doc/man/scons.1 b/doc/man/scons.1 index 6399568f..5cad3f2a 100644 --- a/doc/man/scons.1 +++ b/doc/man/scons.1 @@ -7201,7 +7201,7 @@ or to disable use of the specified option. .TP -.RI PathOption( key ", " help ", " default ) +.RI PathOption( key ", " help ", " default ", [" validator ]) Return a tuple of arguments to set up an option whose value is expected to be a path name. @@ -7213,6 +7213,38 @@ have a default value of and display the specified .I help text. +An additional +.I validator +may be specified +that will be called to +verify that the specified path +is acceptable. +SCons supplies the +following ready-made validators: +.BR PathOption.PathExists +(the default), +which verifies that the specified path exists; +.BR PathOption.PathIsFile , +which verifies that the specified path is an existing file; +.BR PathOption.PathIsDir , +which verifies that the specified path is an existing directory; +and +.BR PathOption.PathIsDirCreate , +which verifies that the specified path is a directory, +and will create the specified directory if the path exist. +You may supply your own +.I validator +function, +which must take three arguments +.RI ( key , +the name of the options variable to be set; +.IR val , +the specified value being checked; +and +.IR env , +the construction environment) +and should raise an exception +if the specified value is not acceptable. .RE These functions make it @@ -7236,6 +7268,9 @@ opts.AddOptions( 'use X11 installed here (yes = search some places)', 'yes'), PathOption('qtdir', 'where the root of Qt is installed', qtdir), + PathOption('foopath', 'where the foo library is installed', foopath, + PathOption.PathIsDir), + ) .EE diff --git a/src/CHANGES.txt b/src/CHANGES.txt index 61fafaee..8e761e9e 100644 --- a/src/CHANGES.txt +++ b/src/CHANGES.txt @@ -17,7 +17,10 @@ RELEASE 0.97 - XXX From Steve Christensen: - - Handle exceptions from Python functions a build actions. + - Handle exceptions from Python functions as build actions. + + - Add a set of canned PathOption validators: PathExists (the default), + PathIsFile, PathIsDir and PathIsDirCreate. From Eric Frias: diff --git a/src/engine/SCons/Options/PathOption.py b/src/engine/SCons/Options/PathOption.py index cea47501..f4078649 100644 --- a/src/engine/SCons/Options/PathOption.py +++ b/src/engine/SCons/Options/PathOption.py @@ -55,31 +55,61 @@ Usage example: __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" -__all__ = ('PathOption',) - import os +import os.path import SCons.Errors -def _validator(key, val, env): - """ - """ - # todo: write validator, check for path - if not os.path.exists(val): - raise SCons.Errors.UserError( - 'Path does not exist for option %s: %s' % (key, val)) - - -def PathOption(key, help, default): - # NB: searchfunc is currenty undocumented and unsupported - """ - The input parameters describe a 'path list' option, thus they - are returned with the correct converter and validator appended. The - result is usable for input to opts.Add() . - - A 'package list' option may either be 'all', 'none' or a list of - package names (seperated by space). - """ - return (key, '%s ( /path/to/%s )' % (help, key), default, - _validator, None) - +class _PathOptionClass: + + def PathIsDir(self, key, val, env): + """Validator to check if Path is a directory.""" + if not os.path.isdir(val): + if os.path.isfile(val): + m = 'Directory path for option %s is a file: %s' + else: + m = 'Directory path for option %s does not exist: %s' + raise SCons.Errors.UserError(m % (key, val)) + + def PathIsDirCreate(self, key, val, env): + """Validator to check if Path is a directory, + creating it if it does not exist.""" + if os.path.isfile(val): + m = 'Path for option %s is a file, not a directory: %s' + raise SCons.Errors.UserError(m % (key, val)) + if not os.path.isdir(val): + os.makedirs(val) + + def PathIsFile(self, key, val, env): + """validator to check if Path is a file""" + if not os.path.isfile(val): + if os.path.isdir(val): + m = 'File path for option %s is a directory: %s' + else: + m = 'File path for option %s does not exist: %s' + raise SCons.Errors.UserError(m % (key, val)) + + def PathExists(self, key, val, env): + """validator to check if Path exists""" + if not os.path.exists(val): + m = 'Path for option %s does not exist: %s' + raise SCons.Errors.UserError(m % (key, val)) + + def __call__(self, key, help, default, validator=None): + # NB: searchfunc is currenty undocumented and unsupported + """ + The input parameters describe a 'path list' option, thus they + are returned with the correct converter and validator appended. The + result is usable for input to opts.Add() . + + A 'package list' option may either be 'all', 'none' or a list of + package names (seperated by space). + + validator is a validator, see this file for examples + """ + if validator is None: + validator = self.PathExists + return (key, '%s ( /path/to/%s )' % (help, key), default, + validator, None) + +PathOption = _PathOptionClass() diff --git a/src/engine/SCons/Options/PathOptionTests.py b/src/engine/SCons/Options/PathOptionTests.py index 358f8e70..9749ee7f 100644 --- a/src/engine/SCons/Options/PathOptionTests.py +++ b/src/engine/SCons/Options/PathOptionTests.py @@ -23,6 +23,7 @@ __revision__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" +import os.path import sys import unittest @@ -35,7 +36,9 @@ class PathOptionTestCase(unittest.TestCase): def test_PathOption(self): """Test PathOption creation""" opts = SCons.Options.Options() - opts.Add(SCons.Options.PathOption('test', 'test option help', '/default/path')) + opts.Add(SCons.Options.PathOption('test', + 'test option help', + '/default/path')) o = opts.options[0] assert o.key == 'test', o.key @@ -44,10 +47,124 @@ class PathOptionTestCase(unittest.TestCase): assert not o.validator is None, o.validator assert o.converter is None, o.converter + def test_PathExists(self): + """Test the PathExists validator""" + opts = SCons.Options.Options() + opts.Add(SCons.Options.PathOption('test', + 'test option help', + '/default/path', + SCons.Options.PathOption.PathExists)) + + test = TestCmd.TestCmd(workdir='') + test.write('exists', 'exists\n') + + o = opts.options[0] + + o.validator('X', test.workpath('exists'), {}) + + dne = test.workpath('does_not_exist') + try: + o.validator('X', dne, {}) + except SCons.Errors.UserError, e: + assert str(e) == 'Path for option X does not exist: %s' % dne, e + except: + raise "did not catch expected UserError" + + def test_PathIsDir(self): + """Test the PathIsDir validator""" + opts = SCons.Options.Options() + opts.Add(SCons.Options.PathOption('test', + 'test option help', + '/default/path', + SCons.Options.PathOption.PathIsDir)) + + test = TestCmd.TestCmd(workdir='') + test.subdir('dir') + test.write('file', "file\n") + + o = opts.options[0] + + o.validator('X', test.workpath('dir'), {}) + + f = test.workpath('file') + try: + o.validator('X', f, {}) + except SCons.Errors.UserError, e: + assert str(e) == 'Directory path for option X is a file: %s' % f, e + except: + raise "did not catch expected UserError" + + dne = test.workpath('does_not_exist') + try: + o.validator('X', dne, {}) + except SCons.Errors.UserError, e: + assert str(e) == 'Directory path for option X does not exist: %s' % dne, e + except: + raise "did not catch expected UserError" + + def test_PathIsDirCreate(self): + """Test the PathIsDirCreate validator""" + opts = SCons.Options.Options() + opts.Add(SCons.Options.PathOption('test', + 'test option help', + '/default/path', + SCons.Options.PathOption.PathIsDirCreate)) + + test = TestCmd.TestCmd(workdir='') + test.write('file', "file\n") + + o = opts.options[0] + + d = test.workpath('dir') + o.validator('X', d, {}) + assert os.path.isdir(d) + + f = test.workpath('file') + try: + o.validator('X', f, {}) + except SCons.Errors.UserError, e: + assert str(e) == 'Path for option X is a file, not a directory: %s' % f, e + except: + raise "did not catch expected UserError" + + def test_PathIsFile(self): + """Test the PathIsFile validator""" + opts = SCons.Options.Options() + opts.Add(SCons.Options.PathOption('test', + 'test option help', + '/default/path', + SCons.Options.PathOption.PathIsFile)) + + test = TestCmd.TestCmd(workdir='') + test.subdir('dir') + test.write('file', "file\n") + + o = opts.options[0] + + o.validator('X', test.workpath('file'), {}) + + d = test.workpath('d') + try: + o.validator('X', d, {}) + except SCons.Errors.UserError, e: + assert str(e) == 'File path for option X does not exist: %s' % d, e + except: + raise "did not catch expected UserError" + + dne = test.workpath('does_not_exist') + try: + o.validator('X', dne, {}) + except SCons.Errors.UserError, e: + assert str(e) == 'File path for option X does not exist: %s' % dne, e + except: + raise "did not catch expected UserError" + def test_validator(self): - """Test the PathOption validator""" + """Test the PathOption validator argument""" opts = SCons.Options.Options() - opts.Add(SCons.Options.PathOption('test', 'test option help', '/default/path')) + opts.Add(SCons.Options.PathOption('test', + 'test option help', + '/default/path')) test = TestCmd.TestCmd(workdir='') test.write('exists', 'exists\n') @@ -56,12 +173,34 @@ class PathOptionTestCase(unittest.TestCase): o.validator('X', test.workpath('exists'), {}) - caught = None + dne = test.workpath('does_not_exist') + try: + o.validator('X', dne, {}) + except SCons.Errors.UserError, e: + expect = 'Path for option X does not exist: %s' % dne + assert str(e) == expect, e + else: + raise "did not catch expected UserError" + + def my_validator(key, val, env): + raise Exception, "my_validator() got called for %s, %s!" % (key, val) + + opts = SCons.Options.Options() + opts.Add(SCons.Options.PathOption('test2', + 'more help', + '/default/path/again', + my_validator)) + + o = opts.options[0] + try: - o.validator('X', test.workpath('does_not_exist'), {}) - except SCons.Errors.UserError: - caught = 1 - assert caught, "did not catch expected UserError" + o.validator('Y', 'value', {}) + except Exception, e: + assert str(e) == 'my_validator() got called for Y, value!', e + else: + raise "did not catch expected exception from my_validator()" + + if __name__ == "__main__": diff --git a/test/Options/BoolOption.py b/test/Options/BoolOption.py new file mode 100644 index 00000000..ef6491db --- /dev/null +++ b/test/Options/BoolOption.py @@ -0,0 +1,77 @@ +#!/usr/bin/env python +# +# __COPYRIGHT__ +# +# 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__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" + +""" +Test the BoolOption canned Option type. +""" + +import os.path +import string + +import TestSCons + +test = TestSCons.TestSCons() + +def check(expect): + result = string.split(test.stdout(), '\n') + assert result[1:len(expect)+1] == expect, (result[1:len(expect)+1], expect) + + + +test.write('SConstruct', """ +from SCons.Options import BoolOption + +opts = Options(args=ARGUMENTS) +opts.AddOptions( + BoolOption('warnings', 'compilation with -Wall and similiar', 1), + BoolOption('profile', 'create profiling informations', 0), + ) + +env = Environment(options=opts) +Help(opts.GenerateHelpText(env)) + +print env['warnings'] +print env['profile'] + +Default(env.Alias('dummy', None)) +""") + +test.run() +check(['1', '0']) + +test.run(arguments='warnings=0 profile=no profile=true') +check(['0', '1']) + +test.run(arguments='warnings=irgendwas', + stderr = """ +scons: *** Error converting option: warnings +Invalid value for boolean option: irgendwas +File "SConstruct", line 10, in ? +""", status=2) + + + +test.pass_test() diff --git a/test/Options/EnumOption.py b/test/Options/EnumOption.py new file mode 100644 index 00000000..c47f7d5c --- /dev/null +++ b/test/Options/EnumOption.py @@ -0,0 +1,98 @@ +#!/usr/bin/env python +# +# __COPYRIGHT__ +# +# 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__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" + +""" +Test the EnumOption canned Option type. +""" + +import os.path +import string + +import TestSCons + +test = TestSCons.TestSCons() + +def check(expect): + result = string.split(test.stdout(), '\n') + assert result[1:len(expect)+1] == expect, (result[1:len(expect)+1], expect) + + + +test.write('SConstruct', """ +from SCons.Options import EnumOption + +list_of_libs = Split('x11 gl qt ical') + +opts = Options(args=ARGUMENTS) +opts.AddOptions( + EnumOption('debug', 'debug output and symbols', 'no', + allowed_values=('yes', 'no', 'full'), + map={}, ignorecase=0), # case sensitive + EnumOption('guilib', 'gui lib to use', 'gtk', + allowed_values=('motif', 'gtk', 'kde'), + map={}, ignorecase=1), # case insensitive + EnumOption('some', 'some option', 'xaver', + allowed_values=('xaver', 'eins'), + map={}, ignorecase=2), # make lowercase + ) + +env = Environment(options=opts) +Help(opts.GenerateHelpText(env)) + +print env['debug'] +print env['guilib'] +print env['some'] + +Default(env.Alias('dummy', None)) +""") + + +test.run(); check(['no', 'gtk', 'xaver']) +test.run(arguments='debug=yes guilib=Motif some=xAVER') +check(['yes', 'Motif', 'xaver']) +test.run(arguments='debug=full guilib=KdE some=EiNs') +check(['full', 'KdE', 'eins']) + +test.run(arguments='debug=FULL', + stderr = """ +scons: *** Invalid value for option debug: FULL +File "SConstruct", line 19, in ? +""", status=2) + +test.run(arguments='guilib=IrGeNdwas', + stderr = """ +scons: *** Invalid value for option guilib: irgendwas +File "SConstruct", line 19, in ? +""", status=2) + +test.run(arguments='some=IrGeNdwas', + stderr = """ +scons: *** Invalid value for option some: irgendwas +File "SConstruct", line 19, in ? +""", status=2) + + +test.pass_test() diff --git a/test/Options/ListOption.py b/test/Options/ListOption.py new file mode 100644 index 00000000..3f0c4263 --- /dev/null +++ b/test/Options/ListOption.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python +# +# __COPYRIGHT__ +# +# 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__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" + +""" +Test the ListOption canned Option type. +""" + +import os.path +import string + +import TestSCons + +test = TestSCons.TestSCons() + +def check(expect): + result = string.split(test.stdout(), '\n') + assert result[1:len(expect)+1] == expect, (result[1:len(expect)+1], expect) + + + +test.write('SConstruct', """ +from SCons.Options import ListOption + +list_of_libs = Split('x11 gl qt ical') + +opts = Options(args=ARGUMENTS) +opts.AddOptions( + ListOption('shared', + 'libraries to build as shared libraries', + 'all', + names = list_of_libs), + ) + +env = Environment(options=opts) +Help(opts.GenerateHelpText(env)) + +print env['shared'] +if 'ical' in env['shared']: print '1' +else: print '0' +for x in env['shared']: + print x, +print +print env.subst('$shared') +Default(env.Alias('dummy', None)) +""") + +test.run() +check(['all', '1', 'gl ical qt x11', 'gl ical qt x11']) +test.run(arguments='shared=none') +check(['none', '0', '', '']) +test.run(arguments='shared=') +check(['none', '0', '', '']) +test.run(arguments='shared=x11,ical') +check(['ical,x11', '1', 'ical x11', 'ical x11']) +test.run(arguments='shared=x11,,ical,,') +check(['ical,x11', '1', 'ical x11', 'ical x11']) + + +test.run(arguments='shared=foo', + stderr = """ +scons: *** Error converting option: shared +Invalid value(s) for option: foo +File "SConstruct", line 14, in ? +""", status=2) + +# be paranoid in testing some more combinations + +test.run(arguments='shared=foo,ical', + stderr = """ +scons: *** Error converting option: shared +Invalid value(s) for option: foo +File "SConstruct", line 14, in ? +""", status=2) + +test.run(arguments='shared=ical,foo', + stderr = """ +scons: *** Error converting option: shared +Invalid value(s) for option: foo +File "SConstruct", line 14, in ? +""", status=2) + +test.run(arguments='shared=ical,foo,x11', + stderr = """ +scons: *** Error converting option: shared +Invalid value(s) for option: foo +File "SConstruct", line 14, in ? +""", status=2) + +test.run(arguments='shared=foo,x11,,,bar', + stderr = """ +scons: *** Error converting option: shared +Invalid value(s) for option: foo,bar +File "SConstruct", line 14, in ? +""", status=2) + +test.write('SConstruct', """ +from SCons.Options import ListOption + +opts = Options(args=ARGUMENTS) +opts.AddOptions( + ListOption('gpib', + 'comment', + ['ENET', 'GPIB'], + names = ['ENET', 'GPIB', 'LINUX_GPIB', 'NO_GPIB']), + ) + +env = Environment(options=opts) +Help(opts.GenerateHelpText(env)) + +print env['gpib'] +Default(env.Alias('dummy', None)) +""") + +test.run(stdout=test.wrap_stdout(read_str="ENET,GPIB\n", build_str="""\ +scons: Nothing to be done for `dummy'. +""")) + + + +test.pass_test() diff --git a/test/Options/PackageOption.py b/test/Options/PackageOption.py new file mode 100644 index 00000000..ca8944d2 --- /dev/null +++ b/test/Options/PackageOption.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python +# +# __COPYRIGHT__ +# +# 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__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" + +""" +Test the PackageOption canned Option type. +""" + +import os.path +import string + +import TestSCons + +test = TestSCons.TestSCons() + +def check(expect): + result = string.split(test.stdout(), '\n') + assert result[1:len(expect)+1] == expect, (result[1:len(expect)+1], expect) + + + +test.write('SConstruct', """ +from SCons.Options import PackageOption + +opts = Options(args=ARGUMENTS) +opts.AddOptions( + PackageOption('x11', + 'use X11 installed here (yes = search some places', + 'yes'), + ) + +env = Environment(options=opts) +Help(opts.GenerateHelpText(env)) + +print env['x11'] +Default(env.Alias('dummy', None)) +""") + +test.run() +check(['1']) +test.run(arguments='x11=no'); check(['0']) +test.run(arguments='x11=0'); check(['0']) +test.run(arguments='"x11=%s"' % test.workpath()); check([test.workpath()]) + +test.run(arguments='x11=/non/existing/path/', + stderr = """ +scons: *** Path does not exist for option x11: /non/existing/path/ +File "SConstruct", line 11, in ? +""", status=2) + + + +test.pass_test() diff --git a/test/Options/PathOption.py b/test/Options/PathOption.py new file mode 100644 index 00000000..4366730c --- /dev/null +++ b/test/Options/PathOption.py @@ -0,0 +1,238 @@ +#!/usr/bin/env python +# +# __COPYRIGHT__ +# +# 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__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" + +""" +Test the PathOption canned option type, with tests for its +various canned validators. +""" + +import os.path +import string + +import TestSCons + +test = TestSCons.TestSCons() + +def check(expect): + result = string.split(test.stdout(), '\n') + assert result[1:len(expect)+1] == expect, (result[1:len(expect)+1], expect) + +#### test PathOption #### + +test.subdir('lib', 'qt', ['qt', 'lib'], 'nolib' ) +workpath = test.workpath() +libpath = os.path.join(workpath, 'lib') + +test.write('SConstruct', """ +from SCons.Options import PathOption + +qtdir = r'%s' + +opts = Options(args=ARGUMENTS) +opts.AddOptions( + PathOption('qtdir', 'where the root of Qt is installed', qtdir), + PathOption('qt_libraries', 'where the Qt library is installed', r'%s'), + ) + +env = Environment(options=opts) +Help(opts.GenerateHelpText(env)) + +print env['qtdir'] +print env['qt_libraries'] +print env.subst('$qt_libraries') + +Default(env.Alias('dummy', None)) +""" % (workpath, os.path.join('$qtdir', 'lib') )) + +qtpath = workpath +libpath = os.path.join(qtpath, 'lib') +test.run() +check([qtpath, os.path.join('$qtdir', 'lib'), libpath]) + +qtpath = os.path.join(workpath, 'qt') +libpath = os.path.join(qtpath, 'lib') +test.run(arguments='"qtdir=%s"' % qtpath) +check([qtpath, os.path.join('$qtdir', 'lib'), libpath]) + +qtpath = workpath +libpath = os.path.join(qtpath, 'nolib') +test.run(arguments='"qt_libraries=%s"' % libpath) +check([qtpath, libpath, libpath]) + +qtpath = os.path.join(workpath, 'qt') +libpath = os.path.join(workpath, 'nolib') +test.run(arguments='"qtdir=%s" "qt_libraries=%s"' % (qtpath, libpath)) +check([qtpath, libpath, libpath]) + +qtpath = os.path.join(workpath, 'non', 'existing', 'path') +test.run(arguments='"qtdir=%s"' % qtpath, + stderr = """ +scons: *** Path for option qtdir does not exist: %s +File "SConstruct", line 12, in ? +""" % qtpath, status=2) + +test.run(arguments='"qt_libraries=%s"' % qtpath, + stderr = """ +scons: *** Path for option qt_libraries does not exist: %s +File "SConstruct", line 12, in ? +""" % qtpath, status=2) + + + +default_file = test.workpath('default_file') +default_subdir = test.workpath('default_subdir') + +existing_subdir = test.workpath('existing_subdir') +test.subdir(existing_subdir) + +existing_file = test.workpath('existing_file') +test.write(existing_file, "existing_file\n") + +non_existing_subdir = test.workpath('non_existing_subdir') +non_existing_file = test.workpath('non_existing_file') + + + +test.write('SConstruct', """\ +opts = Options(args=ARGUMENTS) +opts.AddOptions( + PathOption('X', 'X variable', r'%s', validator=PathOption.PathIsFile), + ) + +env = Environment(options=opts) + +print env['X'] + +Default(env.Alias('dummy', None)) +""" % default_file) + +test.run(status=2, + stderr=""" +scons: *** File path for option X does not exist: %s +File "SConstruct", line 6, in ? +""" % default_file) + +test.write(default_file, "default_file\n") + +test.run() +check([default_file]) + +test.run(arguments='"X=%s"' % existing_subdir, + status=2, + stderr=""" +scons: *** File path for option X is a directory: %s +File "SConstruct", line 6, in ? +""" % existing_subdir) + +test.run(arguments='"X=%s"' % existing_file) +check([existing_file]) + +test.run(arguments='"X=%s"' % non_existing_file, + status=2, + stderr=""" +scons: *** File path for option X does not exist: %s +File "SConstruct", line 6, in ? +""" % non_existing_file) + + + +test.write('SConstruct', """\ +opts = Options(args=ARGUMENTS) +opts.AddOptions( + PathOption('X', 'X variable', r'%s', validator=PathOption.PathIsDir), + ) + +env = Environment(options=opts) + +print env['X'] + +Default(env.Alias('dummy', None)) +""" % default_subdir) + +test.run(status=2, + stderr=""" +scons: *** Directory path for option X does not exist: %s +File "SConstruct", line 6, in ? +""" % default_subdir) + +test.subdir(default_subdir) + +test.run() +check([default_subdir]) + +test.run(arguments='"X=%s"' % existing_file, + status=2, + stderr=""" +scons: *** Directory path for option X is a file: %s +File "SConstruct", line 6, in ? +""" % existing_file) + +test.run(arguments='"X=%s"' % existing_subdir) +check([existing_subdir]) + +test.run(arguments='"X=%s"' % non_existing_subdir, + status=2, + stderr=""" +scons: *** Directory path for option X does not exist: %s +File "SConstruct", line 6, in ? +""" % non_existing_subdir) + + + +test.write('SConstruct', """\ +opts = Options(args=ARGUMENTS) +opts.AddOptions( + PathOption('X', 'X variable', r'%s', validator=PathOption.PathIsDirCreate), + ) + +env = Environment(options=opts) + +print env['X'] + +Default(env.Alias('dummy', None)) +""" % default_subdir) + +test.run() +check([default_subdir]) + +test.run(arguments='"X=%s"' % existing_file, + status=2, + stderr=""" +scons: *** Path for option X is a file, not a directory: %s +File "SConstruct", line 6, in ? +""" % existing_file) + +test.run(arguments='"X=%s"' % existing_subdir) +check([existing_subdir]) + +test.run(arguments='"X=%s"' % non_existing_subdir) +check([non_existing_subdir]) + +test.must_exist(non_existing_subdir) + + + +test.pass_test() diff --git a/test/Options/help.py b/test/Options/help.py new file mode 100644 index 00000000..5ef56224 --- /dev/null +++ b/test/Options/help.py @@ -0,0 +1,143 @@ +#!/usr/bin/env python +# +# __COPYRIGHT__ +# +# 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__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" + +""" +Test the Options help messages. +""" + +import os.path +import string + +import TestSCons + +test = TestSCons.TestSCons() + + + +workpath = test.workpath() +qtpath = os.path.join(workpath, 'qt') +libpath = os.path.join(qtpath, 'lib') +libdirvar = os.path.join('$qtdir', 'lib') + +test.subdir(qtpath) +test.subdir(libpath) + +test.write('SConstruct', """ +from SCons.Options import BoolOption, EnumOption, ListOption, \ + PackageOption, PathOption + +list_of_libs = Split('x11 gl qt ical') +qtdir = r'%(qtdir)s' + +opts = Options(args=ARGUMENTS) +opts.AddOptions( + BoolOption('warnings', 'compilation with -Wall and similiar', 1), + BoolOption('profile', 'create profiling informations', 0), + EnumOption('debug', 'debug output and symbols', 'no', + allowed_values=('yes', 'no', 'full'), + map={}, ignorecase=0), # case sensitive + EnumOption('guilib', 'gui lib to use', 'gtk', + allowed_values=('motif', 'gtk', 'kde'), + map={}, ignorecase=1), # case insensitive + EnumOption('some', 'some option', 'xaver', + allowed_values=('xaver', 'eins'), + map={}, ignorecase=2), # make lowercase + ListOption('shared', + 'libraries to build as shared libraries', + 'all', + names = list_of_libs), + PackageOption('x11', + 'use X11 installed here (yes = search some places)', + 'yes'), + PathOption('qtdir', 'where the root of Qt is installed', qtdir), + PathOption('qt_libraries', + 'where the Qt library is installed', + r'%(libdirvar)s'), + ) + +env = Environment(options=opts) +Help(opts.GenerateHelpText(env)) + +print env['warnings'] +print env['profile'] + +Default(env.Alias('dummy', None)) +""" % {'qtdir': qtpath, 'libdirvar': libdirvar, 'libdir': libpath}) + + +test.run(arguments='-h', + stdout = """\ +scons: Reading SConscript files ... +1 +0 +scons: done reading SConscript files. + +warnings: compilation with -Wall and similiar (yes|no) + default: 1 + actual: 1 + +profile: create profiling informations (yes|no) + default: 0 + actual: 0 + +debug: debug output and symbols (yes|no|full) + default: no + actual: no + +guilib: gui lib to use (motif|gtk|kde) + default: gtk + actual: gtk + +some: some option (xaver|eins) + default: xaver + actual: xaver + +shared: libraries to build as shared libraries + (all|none|comma-separated list of names) + allowed names: x11 gl qt ical + default: all + actual: x11 gl qt ical + +x11: use X11 installed here (yes = search some places) + ( yes | no | /path/to/x11 ) + default: yes + actual: 1 + +qtdir: where the root of Qt is installed ( /path/to/qtdir ) + default: %(qtdir)s + actual: %(qtdir)s + +qt_libraries: where the Qt library is installed ( /path/to/qt_libraries ) + default: %(qtdir_lib)s + actual: %(libdir)s + +Use scons -H for help about command-line options. +""" % {'qtdir': qtpath, 'qtdir_lib' : os.path.join('$qtdir', 'lib'), + 'libdirvar': libdirvar, 'libdir': libpath}) + + + +test.pass_test() diff --git a/test/OptionsTypes.py b/test/OptionsTypes.py deleted file mode 100644 index 41829053..00000000 --- a/test/OptionsTypes.py +++ /dev/null @@ -1,420 +0,0 @@ -#!/usr/bin/env python -# -# __COPYRIGHT__ -# -# 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__ = "__FILE__ __REVISION__ __DATE__ __DEVELOPER__" - -import TestSCons, SCons.Errors -import string, os - -test = TestSCons.TestSCons() - -def check(expect): - result = string.split(test.stdout(), '\n') - assert result[1:len(expect)+1] == expect, (result[1:len(expect)+1], expect) - -#### test BoolOption ##### - -test.write('SConstruct', """ -from SCons.Options import BoolOption - -opts = Options(args=ARGUMENTS) -opts.AddOptions( - BoolOption('warnings', 'compilation with -Wall and similiar', 1), - BoolOption('profile', 'create profiling informations', 0), - ) - -env = Environment(options=opts) -Help(opts.GenerateHelpText(env)) - -print env['warnings'] -print env['profile'] - -Default(env.Alias('dummy', None)) -""") - -test.run() -check(['1', '0']) - -test.run(arguments='warnings=0 profile=no profile=true') -check(['0', '1']) - -test.run(arguments='warnings=irgendwas', - stderr = """ -scons: *** Error converting option: warnings -Invalid value for boolean option: irgendwas -File "SConstruct", line 10, in ? -""", status=2) - - -#### test EnumOption #### - -test.write('SConstruct', """ -from SCons.Options import EnumOption - -list_of_libs = Split('x11 gl qt ical') - -opts = Options(args=ARGUMENTS) -opts.AddOptions( - EnumOption('debug', 'debug output and symbols', 'no', - allowed_values=('yes', 'no', 'full'), - map={}, ignorecase=0), # case sensitive - EnumOption('guilib', 'gui lib to use', 'gtk', - allowed_values=('motif', 'gtk', 'kde'), - map={}, ignorecase=1), # case insensitive - EnumOption('some', 'some option', 'xaver', - allowed_values=('xaver', 'eins'), - map={}, ignorecase=2), # make lowercase - ) - -env = Environment(options=opts) -Help(opts.GenerateHelpText(env)) - -print env['debug'] -print env['guilib'] -print env['some'] - -Default(env.Alias('dummy', None)) -""") - - -test.run(); check(['no', 'gtk', 'xaver']) -test.run(arguments='debug=yes guilib=Motif some=xAVER') -check(['yes', 'Motif', 'xaver']) -test.run(arguments='debug=full guilib=KdE some=EiNs') -check(['full', 'KdE', 'eins']) - -test.run(arguments='debug=FULL', - stderr = """ -scons: *** Invalid value for option debug: FULL -File "SConstruct", line 19, in ? -""", status=2) - -test.run(arguments='guilib=IrGeNdwas', - stderr = """ -scons: *** Invalid value for option guilib: irgendwas -File "SConstruct", line 19, in ? -""", status=2) - -test.run(arguments='some=IrGeNdwas', - stderr = """ -scons: *** Invalid value for option some: irgendwas -File "SConstruct", line 19, in ? -""", status=2) - - - -#### test ListOption #### - -test.write('SConstruct', """ -from SCons.Options import ListOption - -list_of_libs = Split('x11 gl qt ical') - -opts = Options(args=ARGUMENTS) -opts.AddOptions( - ListOption('shared', - 'libraries to build as shared libraries', - 'all', - names = list_of_libs), - ) - -env = Environment(options=opts) -Help(opts.GenerateHelpText(env)) - -print env['shared'] -if 'ical' in env['shared']: print '1' -else: print '0' -for x in env['shared']: - print x, -print -print env.subst('$shared') -Default(env.Alias('dummy', None)) -""") - -test.run() -check(['all', '1', 'gl ical qt x11', 'gl ical qt x11']) -test.run(arguments='shared=none') -check(['none', '0', '', '']) -test.run(arguments='shared=') -check(['none', '0', '', '']) -test.run(arguments='shared=x11,ical') -check(['ical,x11', '1', 'ical x11', 'ical x11']) -test.run(arguments='shared=x11,,ical,,') -check(['ical,x11', '1', 'ical x11', 'ical x11']) - - -test.run(arguments='shared=foo', - stderr = """ -scons: *** Error converting option: shared -Invalid value(s) for option: foo -File "SConstruct", line 14, in ? -""", status=2) - -# be paranoid in testing some more combinations - -test.run(arguments='shared=foo,ical', - stderr = """ -scons: *** Error converting option: shared -Invalid value(s) for option: foo -File "SConstruct", line 14, in ? -""", status=2) - -test.run(arguments='shared=ical,foo', - stderr = """ -scons: *** Error converting option: shared -Invalid value(s) for option: foo -File "SConstruct", line 14, in ? -""", status=2) - -test.run(arguments='shared=ical,foo,x11', - stderr = """ -scons: *** Error converting option: shared -Invalid value(s) for option: foo -File "SConstruct", line 14, in ? -""", status=2) - -test.run(arguments='shared=foo,x11,,,bar', - stderr = """ -scons: *** Error converting option: shared -Invalid value(s) for option: foo,bar -File "SConstruct", line 14, in ? -""", status=2) - -test.write('SConstruct', """ -from SCons.Options import ListOption - -opts = Options(args=ARGUMENTS) -opts.AddOptions( - ListOption('gpib', - 'comment', - ['ENET', 'GPIB'], - names = ['ENET', 'GPIB', 'LINUX_GPIB', 'NO_GPIB']), - ) - -env = Environment(options=opts) -Help(opts.GenerateHelpText(env)) - -print env['gpib'] -Default(env.Alias('dummy', None)) -""") - -test.run(stdout=test.wrap_stdout(read_str="ENET,GPIB\n", build_str="""\ -scons: Nothing to be done for `dummy'. -""")) - -#### test PackageOption #### - -test.write('SConstruct', """ -from SCons.Options import PackageOption - -opts = Options(args=ARGUMENTS) -opts.AddOptions( - PackageOption('x11', - 'use X11 installed here (yes = search some places', - 'yes'), - ) - -env = Environment(options=opts) -Help(opts.GenerateHelpText(env)) - -print env['x11'] -Default(env.Alias('dummy', None)) -""") - -test.run() -check(['1']) -test.run(arguments='x11=no'); check(['0']) -test.run(arguments='x11=0'); check(['0']) -test.run(arguments='"x11=%s"' % test.workpath()); check([test.workpath()]) - -test.run(arguments='x11=/non/existing/path/', - stderr = """ -scons: *** Path does not exist for option x11: /non/existing/path/ -File "SConstruct", line 11, in ? -""", status=2) - - - -#### test PathOption #### - -test.subdir('lib', 'qt', ['qt', 'lib'], 'nolib' ) -workpath = test.workpath() -libpath = os.path.join(workpath, 'lib') - -test.write('SConstruct', """ -from SCons.Options import PathOption - -qtdir = r'%s' - -opts = Options(args=ARGUMENTS) -opts.AddOptions( - PathOption('qtdir', 'where the root of Qt is installed', qtdir), - PathOption('qt_libraries', 'where the Qt library is installed', r'%s'), - ) - -env = Environment(options=opts) -Help(opts.GenerateHelpText(env)) - -print env['qtdir'] -print env['qt_libraries'] -print env.subst('$qt_libraries') - -Default(env.Alias('dummy', None)) -""" % (workpath, os.path.join('$qtdir', 'lib') )) - -qtpath = workpath -libpath = os.path.join(qtpath, 'lib') -test.run() -check([qtpath, os.path.join('$qtdir', 'lib'), libpath]) - -qtpath = os.path.join(workpath, 'qt') -libpath = os.path.join(qtpath, 'lib') -test.run(arguments='"qtdir=%s"' % qtpath) -check([qtpath, os.path.join('$qtdir', 'lib'), libpath]) - -qtpath = workpath -libpath = os.path.join(qtpath, 'nolib') -test.run(arguments='"qt_libraries=%s"' % libpath) -check([qtpath, libpath, libpath]) - -qtpath = os.path.join(workpath, 'qt') -libpath = os.path.join(workpath, 'nolib') -test.run(arguments='"qtdir=%s" "qt_libraries=%s"' % (qtpath, libpath)) -check([qtpath, libpath, libpath]) - -qtpath = os.path.join(workpath, 'non', 'existing', 'path') -test.run(arguments='"qtdir=%s"' % qtpath, - stderr = """ -scons: *** Path does not exist for option qtdir: %s -File "SConstruct", line 12, in ? -""" % qtpath, status=2) - -test.run(arguments='"qt_libraries=%s"' % qtpath, - stderr = """ -scons: *** Path does not exist for option qt_libraries: %s -File "SConstruct", line 12, in ? -""" % qtpath, status=2) - - -### test help messages #### - -workpath = test.workpath() -qtpath = os.path.join(workpath, 'qt') -libpath = os.path.join(qtpath, 'lib') -libdirvar = os.path.join('$qtdir', 'lib') - -test.write('SConstruct', """ -from SCons.Options import BoolOption, EnumOption, ListOption, \ - PackageOption, PathOption - -list_of_libs = Split('x11 gl qt ical') -qtdir = r'%(qtdir)s' - -opts = Options(args=ARGUMENTS) -opts.AddOptions( - BoolOption('warnings', 'compilation with -Wall and similiar', 1), - BoolOption('profile', 'create profiling informations', 0), - EnumOption('debug', 'debug output and symbols', 'no', - allowed_values=('yes', 'no', 'full'), - map={}, ignorecase=0), # case sensitive - EnumOption('guilib', 'gui lib to use', 'gtk', - allowed_values=('motif', 'gtk', 'kde'), - map={}, ignorecase=1), # case insensitive - EnumOption('some', 'some option', 'xaver', - allowed_values=('xaver', 'eins'), - map={}, ignorecase=2), # make lowercase - ListOption('shared', - 'libraries to build as shared libraries', - 'all', - names = list_of_libs), - PackageOption('x11', - 'use X11 installed here (yes = search some places)', - 'yes'), PathOption('qtdir', 'where the root of Qt is installed', qtdir), - PathOption('qt_libraries', - 'where the Qt library is installed', - r'%(libdirvar)s'), - ) - -env = Environment(options=opts) -Help(opts.GenerateHelpText(env)) - -print env['warnings'] -print env['profile'] - -Default(env.Alias('dummy', None)) -""" % {'qtdir': qtpath, 'libdirvar': libdirvar, 'libdir': libpath}) - - -test.run(arguments='-h', - stdout = """\ -scons: Reading SConscript files ... -1 -0 -scons: done reading SConscript files. - -warnings: compilation with -Wall and similiar (yes|no) - default: 1 - actual: 1 - -profile: create profiling informations (yes|no) - default: 0 - actual: 0 - -debug: debug output and symbols (yes|no|full) - default: no - actual: no - -guilib: gui lib to use (motif|gtk|kde) - default: gtk - actual: gtk - -some: some option (xaver|eins) - default: xaver - actual: xaver - -shared: libraries to build as shared libraries - (all|none|comma-separated list of names) - allowed names: x11 gl qt ical - default: all - actual: x11 gl qt ical - -x11: use X11 installed here (yes = search some places) - ( yes | no | /path/to/x11 ) - default: yes - actual: 1 - -qtdir: where the root of Qt is installed ( /path/to/qtdir ) - default: %(qtdir)s - actual: %(qtdir)s - -qt_libraries: where the Qt library is installed ( /path/to/qt_libraries ) - default: %(qtdir_lib)s - actual: %(libdir)s - -Use scons -H for help about command-line options. -""" % {'qtdir': qtpath, 'qtdir_lib' : os.path.join('$qtdir', 'lib'), - 'libdirvar': libdirvar, 'libdir': libpath}) - - -test.pass_test()